docs: def sequence_equal(self, second_iterable, equality_comparer=operator.eq):
          '''
          Determine whether two sequences are equal by elementwise comparison.
  
          Sequence equality is defined as the two sequences being equal length
          and corresponding elements being equal as determined by the equality
          comparer.
  
          Note: This method uses immediate execution.
  
          Args:
              second_iterable: The sequence which will be compared with the
                  source sequence.
  
              equality_comparer: An optional binary predicate function which is
                  used to compare corresponding elements. Should return True if
                  the elements are equal, otherwise False.  The default equality
                  comparer is operator.eq which calls __eq__ on elements of the
                  source sequence with the corresponding element of the second
                  sequence as a parameter.
  
          Returns:
              True if the sequences are equal, otherwise False.
  
          Raises:
              ValueError: If the Queryable is closed.
              TypeError: If second_iterable is not in fact iterable.
              TypeError: If equality_comparer is not callable.
  
          '''
          if self.closed():
              raise ValueError("Attempt to call to_tuple() on a closed Queryable.")
  
          if not is_iterable(second_iterable):
              raise TypeError("Cannot compute sequence_equal() with second_iterable of non-iterable {type}".format(
                      type=str(type(second_iterable))[7: -1]))
  
          if not is_callable(equality_comparer):
              raise TypeError("aggregate() parameter equality_comparer={equality_comparer} is not callable".format(
                      equality_comparer=repr(equality_comparer)))
  
          # Try to check the lengths directly as an optimization
          try:
              if len(self._iterable) != len(second_iterable):
                  return False
          except TypeError:
              pass
  
          sentinel = object()
          for first, second in izip_longest(self, second_iterable, fillvalue=sentinel):
              if first is sentinel or second is sentinel:
                  return False
              if not equality_comparer(first, second):
                  return False
          return True