code: public <V, R> StreamEx<R> zipWith(Stream<V> other, BiFunction<? super T, ? super V, ? extends R> mapper) {
          return zipWith((BaseStream<V, ?>) other, mapper);
      }
docs: Creates a new {@link StreamEx} which is the result of applying of the
  mapper {@code BiFunction} to the corresponding elements of this stream
  and the supplied other stream. The resulting stream is ordered if both of
  the input streams are ordered, and parallel if either of the input
  streams is parallel. When the resulting stream is closed, the close
  handlers for both input streams are invoked.
  
  <p>
  This is a <a href="package-summary.html#StreamOps">quasi-intermediate
  operation</a>.
  
  <p>
  The resulting stream finishes when either of the input streams finish:
  the rest of the longer stream is discarded. It's unspecified whether the
  rest elements of the longer stream are actually consumed.
  
  <p>
  The stream created by this operation may have poor characteristics and
  parallelize badly, so it should be used only when there's no other
  choice. If both input streams are random-access lists or arrays, consider
  using {@link #zip(List, List, BiFunction)} or
  {@link #zip(Object[], Object[], BiFunction)} respectively. If you want to
  zip the stream with the stream of indices, consider using
  {@link EntryStream#of(List)} instead.
  
  @param <V> the type of the other stream elements
  @param <R> the type of the resulting stream elements
  @param other the stream to zip this stream with
  @param mapper a non-interfering, stateless function to apply to the
  corresponding pairs of this stream and other stream elements
  @return the new stream
  @since 0.5.5
  @see #zipWith(Stream)