docs: def select_with_correspondence(
              self,
              selector,
              result_selector=KeyedElement):
          '''Apply a callable to each element in an input sequence, generating a new
          sequence of 2-tuples where the first element is the input value and the
          second is the transformed input value.
  
          The generated sequence is lazily evaluated.
  
          Note: This method uses deferred execution.
  
          Args:
              selector: A unary function mapping a value in the source sequence
                  to the second argument of the result selector.
  
              result_selector: A binary callable mapping the of a value in
                  the source sequence and the transformed value to the
                  corresponding value in the generated sequence. The two
                  positional arguments of the selector function are the original
                  source element and the transformed value. The return value
                  should be the corresponding value in the result sequence. The
                  default selector produces a KeyedElement containing the index
                  and the element giving this function similar behaviour to the
                  built-in enumerate().
  
          Returns:
              When using the default selector, a Queryable whose elements are
              KeyedElements where the first element is from the input sequence
              and the second is the result of invoking the transform function on
              the first value.
  
          Raises:
              ValueError: If this Queryable has been closed.
              TypeError: If transform is not callable.
  
          '''
          if self.closed():
              raise ValueError("Attempt to call select_with_correspondence() on a "
                               "closed Queryable.")
  
          if not is_callable(selector):
              raise TypeError("select_with_correspondence() parameter selector={0} is "
                              "not callable".format(repr(selector)))
  
          if not is_callable(result_selector):
              raise TypeError("select_with_correspondence() parameter result_selector={0} is "
                              "not callable".format(repr(result_selector)))
  
          return self._create(result_selector(elem, selector(elem)) for elem in iter(self))