Est-il un équivalent pour le Zip de la fonction en Clojure de Base ou Contrib?

En Clojure, je tiens à combiner les deux listes de donner une liste de paires, 

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

En Haskell ou Ruby la fonction est appelée zip. Mise en œuvre il n'est pas difficile, mais je voulais m'assurer que je n'étais pas manquer une fonction de Base ou Contrib.

Il y a un zip espace de noms dans le coeur, mais il est décrit que de l'accès à la fermeture à Glissière fonctionnelle technique, qui ne semble pas être ce que je suis après.

Est-il une fonction équivalente pour la combinaison de 2 ou plusieurs listes, de cette façon, dans le Core?

Si il ne l'est pas, est-ce parce qu'il y a un idiomatiques approche qui rend la fonction inutiles?

InformationsquelleAutor John Kane | 2010-04-06
  1. 201
    (map vector '(1 2 3) '(4 5 6))

    fait ce que vous voulez:

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

    Haskell a besoin d'une collection de zipWith (zipWith3, zipWith4, ...) des fonctions, parce qu'ils ont tous besoin d'avoir une certaine type; en particulier, le nombre d'entrées des listes qu'ils acceptent doit être corrigé. (Le zip, zip2, zip3, ... de la famille peut être considérée comme une spécialisation de la zipWith de la famille pour le cas d'utilisation de tupling).

    En revanche, Clojure et d'autres Lisps ont un bon support pour la variable d'arité de fonctions; map est l'un d'entre eux et peut être utilisé pour "tupling" une manière similaire à Haskell

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

    La idiomatiques façon de construire un "tuple" en Clojure est de construire un court vecteur, comme affiché ci-dessus.

    (Juste pour être complet, notons que Haskell avec certaines extensions de base ne permettent variable arité de fonctions; leur utilisation nécessite une bonne compréhension de la langue, mais, et la vanille Haskell 98 probablement ne les supporte pas du tout, donc fixe arité de fonctions sont à préférer pour la bibliothèque standard.)

    • C'est exactement ce que je recherchais. Des acclamations.
    • Wow, c'était une bonne explication. Exactement ce que je cherchais comme bien, merci!
    • Notez que cela se comporte différemment que zip lorsque les collections sont pas de la même longueur. Ruby continuera de traiter et de fournir nils pour la plus courte de la collection, tandis que Clojure va arrêter le traitement une fois que l'une de ces collections est épuisé.
    • C'est bon de noter, merci. En Haskell zip se comporte comme Clojure est map à cet égard.
    • Puis-je demander une référence sur la variable d'arité de Haskell fonctions?
    InformationsquelleAutor Michał Marczyk
  2. 15
    (partition 2 (interleave '(1 2 3) '(4 5 6))) 
=> ((1 4) (2 5) (3 6))

    ou plus généralement

    (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))
    InformationsquelleAutor Lambder
  3. 12
    (map vector [1 2 3] [4 5 6])
    • Oups, Michał déjà répondu à cette question.
    InformationsquelleAutor danlei
  4. 10

    pour vous donner exactement ce que tu voulais, cartographie list entre les deux listes vous donnera une liste de listes, comme dans votre exemple. Je pense que beaucoup de Clojurians aurait tendance à utiliser des vecteurs cependant, il va fonctionner avec n'importe quoi. et les entrées n'ont pas besoin d'être du même type. carte crée seqs d'eux et puis les cartes de la seqs de sorte que toute seq'able entrée, beau travail. 

    (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))
    • Je pense que vous voulez dire de hachage de la carte et de hachage de jeu au lieu de la map et set.
    • merci pour ça 🙂 fixe.
    InformationsquelleAutor Arthur Ulfeldt
  5. 3

    Le moyen intégré serait tout simplement la fonction "interleave':

    (interleave [1 2 3 4] [5 6 7 8]) => [1 5 2 6 3 7 4 8]
    • pour atteindre l'objectif de l'OP, vous devez ajouter (partition 2 (interleave [1 2 3 4][5 6 7 8]))
    • oui, Il semble que je ne regarde pas le cas des OP de sortie désiré de trop près.
    InformationsquelleAutor lsh
  6. -1

    Il y a une fonction appelée zipmap, qui peuvent avoir le même effet,
    (zipmap (1 2 3)(4 5 6))
    La sortie est comme fllows:
    {3 6, 2 5, 1 4}

    • zipmap vous donne une carte, ce qui ne garantit pas l'ordre
    InformationsquelleAutor 温发琥
  7. -2

    #(demande de carte liste %) transpose une matrice comme le Python zip* fonction. Comme une définition de macro:

    utilisateur=> (defmacro py-zip [lst] `(appliquer la liste des cartes ~lst))

    #'utilisateur/py-zip

    utilisateur=> (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))

    utilisateur=> (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))

    • Comment est-ce mieux que de simplement à l'aide de "carte"? Et quel est l'intérêt d'une macro ici?
    InformationsquelleAutor dhr bibberknie