adding a future_factory argument to Thread/ProcessPoolExecutor to control which type of Future should be created by Executor.submit

What is your use case?

I'd like to know about the use case too :-)

It would allow to use Futures with a customized interface for a specific domain.
e.g. to not only save the result of a task but also some context informations
or provide properties/methods which are result specific.

But when subclassing Future the builtin Thread/ProcessExecutor cannot be reused anymore, because
the returned class on submit cannot be customized to be the subclassed Future.

With my change it would be possible to customize the Future object returned by the Executor.

As it is now the Future class has to be wrapped and the Executor subclassed
to return a wrapped Future object. 
The Future object cannot be extended without completely wrapping it.

This change would make the Executor class more versatile.

It would allow something like this:

class CustomExecutor:
	...

custom_executor = CustomExecutor()
custom_future = custom_executor.submit(workload, context=context_information)
...
assert custom_future.context_has_some_property()
assert custom_future.result_has_some_property()


factories are also used in other places in standard library:
logging.setLogFactory
asyncio.loop.set_task_factory

Sorry, but in the provided snippet I see a class with an interface which looks close to executor.

There is no clear relationship with standard executors (e.g. is it inherited from ThreadExecutor?). Proposed `future_factory` is also absent.

Please, provide a real example if you want to convince us that the requested feature is important and desired.

Here is a complete example.
Please consider this is a very simple example just to demonstrate what would be possible with my proposed changes.

In the following example you can see two things:
 * saving informations about the context in which a workload was submitted to the Executor in the Future
 * having a custom methods on the Future returned by the Executor

from concurrent.futures import Future, ThreadPoolExecutor


def workload(n):
    # does some heavy calculations
    return n


class Context:
    def __init__(self, name):
        self.name = name


class CustomFactory(Future):
    def __init__(self):
        super().__init__()
        self.context = None

    def is_from_context(self, ctx):
        return self.context.name == ctx

    def processed_result(self):
        # processes the result
        return self.result()


class ContextExecutor(ThreadPoolExecutor):
    def __init__(self):
        super().__init__(future_factory=CustomFactory)

    def submit(self, workload, arg, context):
        future = super().submit(workload, arg)
        future.context = context
        return future


context_executor = ContextExecutor()
futures = [
    context_executor.submit(workload, 0, context=Context("A")),
    context_executor.submit(workload, 1, context=Context("B")),
    context_executor.submit(workload, 2, context=Context("A")),
]

futures_from_context_a = [f for f in futures if f.is_from_context("A")]
if all(f.done() for f in futures_from_context_a):
    print("All Futures in context A are done")
    processed_results = [f.processed_result() for f in futures_from_context_a]
    print("Results:", processed_results)