/* (non-Javadoc)
@see cyclops2.monads.transformers.values.ValueTransformer#zip(java.lang.Iterable, java.util.function.BiFunction)
502042
@Override
    public <T2, R> CompletableFutureT<W, R> zip(Iterable<? extends T2> iterable,
                                                BiFunction<? super T, ? super T2, ? extends R> fn) {

        return (CompletableFutureT<W, R>)super.zip(iterable, fn);
    }
956176
@SuppressWarnings("resource")
    public static <R> Stream<R> zip(final Collection<? extends ShortStream> c, final ShortNFunction<R> zipFunction) {
        if (N.isNullOrEmpty(c)) {
            return Stream.empty();
        }

        final int len = c.size();
        final ShortIterator[] iters = new ShortIterator[len];
        int i = 0;

        for (ShortStream s : c) {
            iters[i++] = s.iteratorEx();
        }

        return new IteratorStream<>(new ObjIteratorEx<R>() {
            @Override
            public boolean hasNext() {
                for (int i = 0; i < len; i++) {
                    if (iters[i].hasNext() == false) {
                        return false;
                    }
                }

                return true;
            }

            @Override
            public R next() {
                final short[] args = new short[len];

                for (int i = 0; i < len; i++) {
                    args[i] = iters[i].nextShort();
                }

                return zipFunction.apply(args);
            }
        }).onClose(newCloseHandler(c));
    }
368563
public static <T1, T2> ReactiveSeq<Tuple2<T1, T2>> zip(final Stream<T1> left, final Stream<? extends T2> right) {
        return zip(left, right, Tuple::tuple);
    }
1033709
def zip(self, *args):
        
        args = list(args)
        args.insert(0, self.obj)
        maxLen = _(args).chain().collect(lambda x, *args: len(x)).max().value()
        for i, v in enumerate(args):
            l = len(args[i])
            if l < maxLen:
                args[i]
            for x in range(maxLen - l):
                args[i].append(None)
        return self._wrap(zip(*args))
275981
public Iterable<DContact> queryByZipCode(Object parent, java.lang.String zipCode) {
    return queryByField(parent, DContactMapper.Field.ZIPCODE.getFieldName(), zipCode);
  }
363270
function zipObject(keys, values) {
  return keys.reduce(function(object, currentValue, currentIndex) {
    object[currentValue] = values[currentIndex];

    return object;
  }, {});
}
485814
public static <K, V> Map<K, V> zipMapPartial(Iterable<K> keys, Iterable<V> values)
  {
    Map<K, V> retVal = new LinkedHashMap<>();

    Iterator<K> keysIter = keys.iterator();
    Iterator<V> valsIter = values.iterator();

    while (keysIter.hasNext()) {
      final K key = keysIter.next();

      if(valsIter.hasNext()) retVal.put(key, valsIter.next());
      else break;
    }

    return retVal;
  }
111100
func Zip(slice1 interface{}, slice2 interface{}) []Tuple {
	inValue1 := reflect.ValueOf(slice1)
	inValue2 := reflect.ValueOf(slice2)
	kind1 := inValue1.Type().Kind()
	kind2 := inValue2.Type().Kind()

	result := []Tuple{}
	for _, kind := range []reflect.Kind{kind1, kind2} {
		if kind != reflect.Slice && kind != reflect.Array {
			return result
		}
	}

	var minLength int
	length1 := inValue1.Len()
	length2 := inValue2.Len()
	if length1 <= length2 {
		minLength = length1
	} else {
		minLength = length2
	}

	for i := 0; i < minLength; i++ {
		newTuple := Tuple{
			Element1: inValue1.Index(i).Interface(),
			Element2: inValue2.Index(i).Interface(),
		}
		result = append(result, newTuple)
	}
	return result
}
882773
public static <R> Stream<R> zip(final FloatStream a, final FloatStream b, final FloatStream c, final FloatTriFunction<R> zipFunction) {
        return zip(a.iteratorEx(), b.iteratorEx(), c.iteratorEx(), zipFunction).onClose(newCloseHandler(N.asList(a, b, c)));
    }
555570
@Override
    public <T2, R> Future<R> zip(final Iterable<? extends T2> app, final BiFunction<? super T, ? super T2, ? extends R> fn) {

      return Future.of(future.thenCombine(Future.fromIterable(app).getFuture(), fn));
    }
644244
public static <R> Stream<R> zip(final int[] a, final int[] b, final int[] c, final IntTriFunction<R> zipFunction) {
        return zip(IntIteratorEx.of(a), IntIteratorEx.of(b), IntIteratorEx.of(c), zipFunction);
    }
523452
public static <R> Stream<R> zip(final long[] a, final long[] b, final long[] c, final LongTriFunction<R> zipFunction) {
        return zip(LongIteratorEx.of(a), LongIteratorEx.of(b), LongIteratorEx.of(c), zipFunction);
    }
228277
function zip(keys, values) {
  if (keys.length !== values.length) {
    throw Error(`Incorrect number of arguments, expected: ${keys.length}, arguments received: ${values.join(', ')}`)
  }

  return keys.reduce((all, key, idx) => ({...all, [key]: values[idx]}), {})
}
1216258
@SuppressWarnings("unchecked")
    public static <T1, T2> Tuple2<T1, T2>[] zip(T1[] arr1, T2[] arr2) {
        int resultSize = _max(arr1.length, arr2.length);
        Tuple2[] result = new Tuple2[resultSize];

        for (int i = 0; i < resultSize; i++)
            result[i] = tuple(next(arr1, i), next(arr2, i));

        return result;
    }
879862
public <U> ValueTransformer<W,Tuple2<T,U>> zip(Iterable<? extends U> other) {

        return unitAnyM(this.transformerStream().map(v->v.zip(other)));
    }
313685
@Override
    public <T2, R> Future<R> zip(final BiFunction<? super T, ? super T2, ? extends R> fn, final Publisher<? extends T2> app) {
        return Future.of(future.thenCombine(Future.fromPublisher(app).getFuture(), fn));
    }
1229498
def zipObject(self, values):
        
        result = {}
        keys = self.obj
        i = 0
        l = len(keys)
        while i < l:
            result[keys[i]] = values[i]
            l = len(keys)
            i += 1

        return self._wrap(result)