Есть ли эквивалент функции Zip в Clojure Core или Contrib?

В Clojure я хочу объединить два списка, чтобы получить список пар,

> (zip '(1 2 3) '(4 5 6))  
((1 4) (2 5) (3 6))

В Haskell или Ruby функция называется zip . Реализовать это несложно, но я хотел убедиться, что не пропустил ни одной функции в Core или Contrib.

Есть молния Core пространство имен , но оно описано как обеспечивающее доступ к функциональной технике Zipper, которая, похоже, не то, что мне нужно.

Есть ли в Core эквивалентная функция для объединения 2 или более списков таким образом?

Если нет, то это потому, что существует идиоматический подход, который делает функцию ненужной?

(map vector '(1 2 3) '(4 5 6))

делает то, что вы хотите:

=> ([1 4] [2 5] [3 6])

Haskell необходим набор zipWith( zipWith3, zipWith4, ...) функции, потому что они все должны быть определенного типа ; в частности, необходимо зафиксировать количество принимаемых списков ввода. (The zip, zip2, zip3... семья может рассматриваться как специализацияzipWith семьи для общего пользования случае кортежей).

Напротив, Clojure и другие Lisp хорошо поддерживают функции переменной арности; mapявляется одним из них и может использоваться для "кортежа" аналогично Haskell's

zipWith (\x y -> (x, y))

Идиоматический способ создания «кортежа» в Clojure - это построить короткий вектор, как показано выше.

(Для полноты картины обратите внимание, что Haskell с некоторыми базовыми расширениями действительно допускает функции переменной арности; однако их использование требует хорошего понимания языка, а ванильный Haskell 98, вероятно, не поддерживает их вообще, поэтому функции с фиксированной арностью предпочтительнее для стандартной библиотеки.)

(partition 2 (interleave '(1 2 3) '(4 5 6))) 
=> ((1 4) (2 5) (3 6))

или в более общем смысле

(defn zip [& colls]
  (partition (count colls) (apply interleave colls)))

(zip '( 1 2 3) '(4 5 6))           ;=> ((1 4) (2 5) (3 6))

(zip '( 1 2 3) '(4 5 6) '(2 4 8))  ;=> ((1 4 2) (2 5 4) (3 6 8))

(map vector [1 2 3] [4 5 6])

чтобы дать вам именно то, что вы хотели, сопоставление listдвух списков даст вам список списков, как в вашем примере. Я думаю, что многие клоджурцы склонны использовать для этого векторы, хотя это будет работать с чем угодно. и входы не обязательно должны быть одного типа. map создает из них последовательности, а затем сопоставляет их, поэтому любой ввод с последовательностью будет работать нормально.

(map list '(1 2 3) '(4 5 6))
(map list  [1 2 3] '(4 5 6))
(map hash-map  '(1 2 3) '(4 5 6))
(map hash-set  '(1 2 3) '(4 5 6))

Встроенный способ - это просто функция interleave:

(interleave [1 2 3 4] [5 6 7 8]) => [1 5 2 6 3 7 4 8]

Существует функция под названием zipmap, которая может иметь аналогичный эффект (zipmap (1 2 3)(4 5 6)). Вывод выглядит следующим образом: {3 6, 2 5, 1 4}

# (применить список карт%) транспонирует матрицу точно так же, как функция Python zip *. Как определение макроса:

user => (defmacro py-zip [lst] `(применить список карт ~ lst))

# 'Пользователь / ая-молния

user => (py-zip '((1 2 3 4) (9 9 9 9) (5 6 7 8)))

((1 9 5) (2 9 6) (3 9 7) (4 9 8))

user => (py-zip '((1 9 5) (2 9 6) (3 9 7) (4 9 8)))

((1 2 3 4) (9 9 9 9) (5 6 7 8))