docs: def select_many_with_correspondence(
              self,
              collection_selector=identity,
              result_selector=KeyedElement):
          '''Projects each element of a sequence to an intermediate new sequence,
          and flattens the resulting sequence, into one sequence and uses a
          selector function to incorporate the corresponding source for each item
          in the result sequence.
  
          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 binary function mapping the elements in the
                  flattened intermediate sequence together with their
                  corresponding source elements to elements of the result
                  sequence. The two positional arguments of the result_selector
                  are, first the source element corresponding to an element from
                  the intermediate sequence, and second the actual element from
                  the intermediate sequence. The return value should be the
                  corresponding value in the result sequence. If no
                  result_selector function is provided, the elements of the
                  result sequence are KeyedElement namedtuples.
  
          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 which incorporates the corresponding source element
              into the result sequence.
  
          Raises:
              ValueError: If this Queryable has been closed.
              TypeError: If projector or selector are not callable.
          '''
  
          if self.closed():
              raise ValueError("Attempt to call "
                  "select_many_with_correspondence() on a closed Queryable.")
  
          if not is_callable(collection_selector):
              raise TypeError("select_many_with_correspondence() parameter "
               "projector={0} is not callable".format(repr(collection_selector)))
  
          if not is_callable(result_selector):
              raise TypeError("select_many_with_correspondence() parameter "
                  "selector={0} is not callable".format(repr(result_selector)))
  
          return self._create(
              self._generate_select_many_with_correspondence(collection_selector,
                                                             result_selector))