zip([[1, 2, 3], [4, 5, 6]]) = [[1, 4], [2, 5], [3, 6]].
972529
function zip(arrayOfArrays) {
  return arrayOfArrays[0].map(function(_, secondIndex) {
    return arrayOfArrays.map(function(_, firstIndex) {
      return arrayOfArrays[firstIndex][secondIndex];
    });
  });
}
1012458
def cartesian_lists(d):
    
    return [{k: v for k, v in zip(d.keys(), args)}
            for args in itertools.product(*d.values())]
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)
36644
def zip_and_tuple(self, x):
        
        return tuple(self.space.zip_inputs(np.atleast_2d(x)).flatten())
998882
def pairs(iterable):
    
    a, b = itertools.tee(iterable)
    next(b, None)
    return zip(a, b)
1284105
def flatten(list_of_lists):
    """"""
    flat_list = []
    for sublist in list_of_lists:
        if isinstance(sublist, string_types) or isinstance(sublist, int):
            flat_list.append(sublist)
        elif sublist is None:
            continue
        elif not isinstance(sublist, string_types) and len(sublist) == 1:
            flat_list.append(sublist[0])
        else:
            flat_list.append(tuple(sublist))
    return flat_list
63063
public static <X, Y> Iterable<ZipPair<X, Y>> zip(final Iterable<X> iter1,
      final Iterable<Y> iter2) {
    return new ZipIterable<X, Y>(iter1, iter2);
  }
633332
def ziptake(items_list, indexes_list):
    
    return [take(list_, index_list)
            for list_, index_list in zip(items_list, indexes_list)]
770990
def p_expr_list_assign(p):
    ''
    p[0] = ast.ListAssignment(p[3], p[6], lineno=p.lineno(1))
357050
def p_concatlist(self, p):
        ''
        p[0] = p[1] + (p[3],)
        p.set_lineno(0, p.lineno(1))
854522
function $zip(params) {
    if (
        Array.isArray(params) &&
        params.every(p => Array.isArray(p) && p.length === 2)
    ) {
        return params.reduce((o, p) => Object.assign(o, { [p[0]]: p[1] }), {});
    }
    throw new Error('$zip expects an array of two-element-array');
}
348486
public static function zip()
    {
        $args = func_get_args();
        $count = count($args);

        $out = [];

        for ($i = 0; $i < $count; $i++) {
            $out[$i] = self::pluck($i, $args);
        }

        return $out;
    }
892025
def _pairwise(iterable):
    
    a, b = itertools.tee(iterable)
    next(b, None)
    if sys.version_info.major == 2:
        return itertools.izip(a, b)
    else:
        return zip(a, b)
75530
def flatten_list(l):
    
    if (l == []) or (l is None):
        return l
    if isinstance(l[0], list):
        return flatten_list(l[0]) + flatten_list(l[1:])
    return l[:1] + flatten_list(l[1:])
1279320
def chunked(l, n):
    """"""
    return [l[i:i + n] for i in range(0, len(l), n)]
536711
def pairwise(iterable):
    ""
    a, b = tee(iterable)
    next(b, None)
    return izip(a, b)
781715
def seven_zip(archive, items, self_extracting=False):
    """"""
    if not isinstance(items, (list, tuple)):
        items = [items]
    if self_extracting:
        return er(_get_sz(), "a", "-ssw", "-sfx", archive, *items)
    else:
        return er(_get_sz(), "a", "-ssw", archive, *items)