docs: def select_many(
              self,
              collection_selector=identity,
              result_selector=identity):
          '''Projects each element of a sequence to an intermediate new sequence,
          flattens the resulting sequences into one sequence and optionally
          transforms the flattened sequence using a selector function.
  
          Note: This method uses deferred execution.
  
          Args:
              collection_selector: A unary function mapping each element of the
                  source iterable into an intermediate sequence. The single
                  argument of the collection_selector is the value of an element
                  from the source sequence. The return value should be an
                  iterable derived from that element value. The default
                  collection_selector, which is the identity function, assumes
                  that each element of the source sequence is itself iterable.
  
              result_selector: An optional unary function mapping the elements in
                  the flattened intermediate sequence to corresponding elements
                  of the result sequence. The single argument of the
                  result_selector is the value of an element from the flattened
                  intermediate sequence. The return value should be the
                  corresponding value in the result sequence. The default
                  result_selector is the identity function.
  
          Returns:
              A Queryable over a generated sequence whose elements are the result
              of applying the one-to-many collection_selector to each element of
              the source sequence, concatenating the results into an intermediate
              sequence, and then mapping each of those elements through the
              result_selector into the result sequence.
  
          Raises:
              ValueError: If this Queryable has been closed.
              TypeError: If either collection_selector or result_selector are not
                  callable.
          '''
          if self.closed():
              raise ValueError("Attempt to call select_many() on a closed "
                               "Queryable.")
  
          if not is_callable(collection_selector):
              raise TypeError("select_many() parameter projector={0} is not "
                              "callable".format(repr(collection_selector)))
  
          if not is_callable(result_selector):
              raise TypeError("select_many() parameter selector={selector} is "
                          " not callable".format(selector=repr(result_selector)))
  
          sequences = self.select(collection_selector)
          chained_sequence = itertools.chain.from_iterable(sequences)
          return self._create(chained_sequence).select(result_selector)