docs: def select_many(self, projector, selector=identity):
          '''Projects each element of a sequence to an intermediate new sequence,
          flattens the resulting sequence into one sequence and optionally
          transforms the flattened sequence using a selector function.
  
          Args:
              projector: A unary function mapping each element of the source
                  sequence into an intermediate sequence. If no projection
                  function is provided, the intermediate sequence will consist of
                  the single corresponding element from the source sequence. The
                  projector function argument (which can have any name) and
                  return values are,
  
                  Args:
                      element: The value of the element
  
                  Returns:
                      An iterable derived from the element value
  
              selector: An optional unary function mapping the elements in the
                  flattened intermediate sequence to corresponding elements of
                  the result sequence. If no selector function is provided, the
                  identity function is used.  The selector function argument and
                  return values are,
  
                  Args:
                      element: The value of the intermediate element from the
                          concatenated sequences arising from the projector
                          function.
  
                  Returns:
                      The selected value derived from the element value
          Returns:
              A generated sequence whose elements are the result of projecting
              each element of the source sequence using projector function and
              then mapping each element through an optional selector function.
          '''
          sequences = (self._create(item).select(projector) for item in iter(self))
          # TODO: [asq 2.0] Without the list() to force evaluation
          # multiprocessing deadlocks...
          chained_sequence = list(itertools.chain.from_iterable(sequences))
          return self._create(self._pool.imap_unordered(selector,
                                              chained_sequence, self._chunksize))