docs: def zip(self, second_iterable, result_selector=lambda x, y: (x, y)):
          '''Elementwise combination of two sequences.
  
          The source sequence and the second iterable are merged element-by-
          element using a function to combine them into the single corresponding
          element of the result sequence. The length of the result sequence is
          equal to the length of the shorter of the two input sequences.
  
          Note: This method uses deferred execution.
  
          Args:
              second_iterable: The second sequence to be combined with the source
                  sequence.
  
              result_selector: An optional binary function for combining
                  corresponding elements of the source sequences into an
                  element of the result sequence. The first and second positional
                  arguments are the elements from the source sequences. The
                  result should be the result sequence element. If omitted, the
                  result sequence will consist of 2-tuple pairs of corresponding
                  elements from the source sequences.
  
          Returns:
              A Queryable over the merged elements.
  
          Raises:
              ValueError: If the Queryable is closed.
              TypeError: If result_selector is not callable.
          '''
          if self.closed():
              raise ValueError("Attempt to call zip() on a closed Queryable.")
  
          if not is_iterable(second_iterable):
              raise TypeError("Cannot compute zip() with second_iterable of "
                    "non-iterable {0}".format(str(type(second_iterable))[7: -1]))
  
          if not is_callable(result_selector):
              raise TypeError("zip() parameter result_selector={0} is "
                              "not callable".format(repr(result_selector)))
  
          return self._create(result_selector(*t) for t in izip(self, second_iterable))