Tester si une liste contient une valeur spécifique dans Clojure

Quelle est la meilleure façon de tester si une liste contient une valeur donnée dans Clojure?

En particulier, le comportement de contains?me déroute actuellement:

(contains? '(100 101 102) 101) => false

Je pourrais évidemment écrire une fonction simple pour parcourir la liste et tester l'égalité, mais il doit sûrement y avoir un moyen standard de le faire?

Ah, contains?... soi-disant l'une des cinq principales FAQ concernant Clojure.

Il ne vérifie pas si une collection contient une valeur; il vérifie si un élément peut être récupéré avec getou, en d'autres termes, si une collection contient une clé. Cela a du sens pour les ensembles (qui peuvent être considérés comme ne faisant aucune distinction entre les clés et les valeurs), les cartes (ainsi (contains? {:foo 1} :foo)est true) et les vecteurs (mais notez que (contains? [:foo :bar] 0)c'est true, parce que les clés ici sont des indices et le vecteur en question "contient" le index 0!).

Pour ajouter à la confusion, dans les cas où cela n'a pas de sens d'appeler contains?, il revient simplement false; c'est ce qui se passe dans (contains? :foo 1) et aussi (contains? '(100 101 102) 101) . Mise à jour: Dans Clojure ≥ 1.5 contains?lance quand on lui donne un objet d'un type qui ne prend pas en charge le test "d'appartenance clé" prévu.

La bonne façon de faire ce que vous essayez de faire est la suivante:

; most of the time this works
(some #{101} '(100 101 102))

Lorsque vous recherchez l'un des nombreux éléments, vous pouvez utiliser un ensemble plus grand; lors de la recherche false/ nil, vous pouvez utiliser false?/ nil?- parce que les (#{x} x)rendements x, ce qui (#{nil} nil)est nil; lors de la recherche d'un élément parmi plusieurs, dont certains peuvent être falseou nil, vous pouvez utiliser

(some (zipmap [...the items...] (repeat true)) the-collection)

(Notez que les éléments peuvent être transmis zipmapdans n'importe quel type de collection.)

Voici mon utilitaire standard dans le même but:

(defn in? 
  "true if coll contains elm"
  [coll elm]  
  (some #(= elm %) coll))

Vous pouvez toujours appeler des méthodes java avec la syntaxe .methodName.

(.contains [100 101 102] 101) => true

Je sais que je suis un peu en retard, mais qu'en est-il:

(contains? (set '(101 102 103)) 102)

Enfin dans clojure 1.4 sort vrai :)

(not= -1 (.indexOf '(101 102 103) 102))

Fonctionne, mais ci-dessous est mieux:

(some #(= 102 %) '(101 102 103)) 

Pour ce que cela vaut, voici ma simple implémentation d'une fonction contient pour les listes:

(defn list-contains? [coll value]
  (let [s (seq coll)]
    (if s
      (if (= (first s) value) true (recur (rest s) value))
      false)))

Si vous avez un vecteur ou une liste et que vous souhaitez vérifier si une valeur y est contenue, vous constaterez que contains?cela ne fonctionne pas. Michał a déjà expliqué pourquoi .

; does not work as you might expect
(contains? [:a :b :c] :b) ; = false

Il y a quatre choses que vous pouvez essayer dans ce cas:

1. Demandez-vous si vous avez vraiment besoin d'un vecteur ou d'une liste. Si vous utilisez un ensemble à la place , contains?cela fonctionnera.

   (contains? #{:a :b :c} :b) ; = true

2. Utilisezsome , enveloppant la cible dans un ensemble, comme suit:

   (some #{:b} [:a :b :c]) ; = :b, which is truthy

3. Le raccourci définir en tant que fonction ne fonctionnera pas si vous recherchez une valeur erronée ( falseou nil).

   ; will not work
   (some #{false} [true false true]) ; = nil

   Dans ces cas, vous devez utiliser la fonction de prédicat intégrée pour cette valeur, false?ou nil?:

   (some false? [true false true]) ; = true

4. Si vous devez souvent effectuer ce type de recherche, écrivez une fonction pour cela :

   (defn seq-contains? [coll target] (some #(= target %) coll))
   (seq-contains? [true false true] false) ; = true

Voir également la réponse de Michał pour savoir si l'une des cibles multiples est contenue dans une séquence.

Voici une fonction rapide de mes utilitaires standard que j'utilise à cet effet:

(defn seq-contains?
  "Determine whether a sequence contains a given item"
  [sequence item]
  (if (empty? sequence)
    false
    (reduce #(or %1 %2) (map #(= %1 item) sequence))))

Voici la solution Lisp classique:

(defn member? [list elt]
    "True if list contains at least one instance of elt"
    (cond 
        (empty? list) false
        (= (first list) elt) true
        true (recur (rest list) elt)))

J'ai construit sur la version jg-faustus de "list-contains?". Il prend maintenant n'importe quel nombre d'arguments.

(defn list-contains?
([collection value]
    (let [sequence (seq collection)]
        (if sequence (some #(= value %) sequence))))
([collection value & next]
    (if (list-contains? collection value) (apply list-contains? collection next))))

C'est aussi simple que d'utiliser un ensemble - semblable aux cartes, vous pouvez simplement le déposer dans la position de fonction. Il évalue à la valeur si dans l'ensemble (qui est vrai) ou nil(qui est faux):

(#{100 101 102} 101) ; 101
(#{100 101 102} 99) ; nil

Si vous comparez un vecteur / une liste de taille raisonnable que vous n'aurez pas avant l'exécution, vous pouvez également utiliser la setfonction:

; (def nums '(100 101 102))
((set nums) 101) ; 101

La méthode recommandée est de l'utiliser someavec un ensemble - voir la documentation pour clojure.core/some.

Vous pouvez alors utiliser somedans un vrai prédicat vrai / faux, par exemple

(defn in? [coll x] (if (some #{x} coll) true false))

(defn in?
  [needle coll]
  (when (seq coll)
    (or (= needle (first coll))
        (recur needle (next coll)))))

(defn first-index
  [needle coll]
  (loop [index 0
         needle needle
         coll coll]
    (when (seq coll)
      (if (= needle (first coll))
        index
        (recur (inc index) needle (next coll))))))

(defn which?
 "Checks if any of elements is included in coll and says which one
  was found as first. Coll can be map, list, vector and set"
 [ coll & rest ]
 (let [ncoll (if (map? coll) (keys coll) coll)]
    (reduce
     #(or %1  (first (filter (fn[a] (= a %2))
                           ncoll))) nil rest )))

exemple d'utilisation (laquelle? [1 2 3] 3) ou (laquelle? # {1 2 3} 4 5 3)

Puisque Clojure est construit sur Java, vous pouvez tout aussi facilement appeler la .indexOffonction Java. Cette fonction renvoie l'index de tout élément d'une collection et, si elle ne trouve pas cet élément, renvoie -1.

En utilisant cela, nous pourrions simplement dire:

(not= (.indexOf [1 2 3 4] 3) -1)
=> true

Le problème avec la solution «recommandée» est qu'elle est interrompue lorsque la valeur que vous recherchez est «nulle». Je préfère cette solution:

(defn member?
  "I'm still amazed that Clojure does not provide a simple member function.
   Returns true if `item` is a member of `series`, else nil."
  [item series]
  (and (some #(= item %) series) true))

Il existe des fonctions pratiques à cet effet dans la bibliothèque Tupelo . En particulier, les fonctions contains-elem?, contains-key?et contains-val?sont très utiles. Une documentation complète est présente dans la documentation de l'API .

contains-elem?est le plus générique et est destiné aux vecteurs ou à tout autre clojure seq:

  (testing "vecs"
    (let [coll (range 3)]
      (isnt (contains-elem? coll -1))
      (is   (contains-elem? coll  0))
      (is   (contains-elem? coll  1))
      (is   (contains-elem? coll  2))
      (isnt (contains-elem? coll  3))
      (isnt (contains-elem? coll  nil)))

    (let [coll [ 1 :two "three" \4]]
      (isnt (contains-elem? coll  :no-way))
      (isnt (contains-elem? coll  nil))
      (is   (contains-elem? coll  1))
      (is   (contains-elem? coll  :two))
      (is   (contains-elem? coll  "three"))
      (is   (contains-elem? coll  \4)))

    (let [coll [:yes nil 3]]
      (isnt (contains-elem? coll  :no-way))
      (is   (contains-elem? coll  :yes))
      (is   (contains-elem? coll  nil))))

Ici, nous voyons que pour une plage d'entiers ou un vecteur mixte, contains-elem?fonctionne comme prévu pour les éléments existants et inexistants dans la collection. Pour les cartes, nous pouvons également rechercher n'importe quelle paire clé-valeur (exprimée sous forme de vecteur len-2):

 (testing "maps"
    (let [coll {1 :two "three" \4}]
      (isnt (contains-elem? coll nil ))
      (isnt (contains-elem? coll [1 :no-way] ))
      (is   (contains-elem? coll [1 :two]))
      (is   (contains-elem? coll ["three" \4])))
    (let [coll {1 nil "three" \4}]
      (isnt (contains-elem? coll [nil 1] ))
      (is   (contains-elem? coll [1 nil] )))
    (let [coll {nil 2 "three" \4}]
      (isnt (contains-elem? coll [1 nil] ))
      (is   (contains-elem? coll [nil 2] ))))

Il est également simple de rechercher un ensemble:

  (testing "sets"
    (let [coll #{1 :two "three" \4}]
      (isnt (contains-elem? coll  :no-way))
      (is   (contains-elem? coll  1))
      (is   (contains-elem? coll  :two))
      (is   (contains-elem? coll  "three"))
      (is   (contains-elem? coll  \4)))

    (let [coll #{:yes nil}]
      (isnt (contains-elem? coll  :no-way))
      (is   (contains-elem? coll  :yes))
      (is   (contains-elem? coll  nil)))))

Pour les cartes et les ensembles, il est plus simple (et plus efficace) d'utiliser contains-key?pour trouver une entrée de carte ou un élément d'ensemble:

(deftest t-contains-key?
  (is   (contains-key?  {:a 1 :b 2} :a))
  (is   (contains-key?  {:a 1 :b 2} :b))
  (isnt (contains-key?  {:a 1 :b 2} :x))
  (isnt (contains-key?  {:a 1 :b 2} :c))
  (isnt (contains-key?  {:a 1 :b 2}  1))
  (isnt (contains-key?  {:a 1 :b 2}  2))

  (is   (contains-key?  {:a 1 nil   2} nil))
  (isnt (contains-key?  {:a 1 :b  nil} nil))
  (isnt (contains-key?  {:a 1 :b    2} nil))

  (is   (contains-key? #{:a 1 :b 2} :a))
  (is   (contains-key? #{:a 1 :b 2} :b))
  (is   (contains-key? #{:a 1 :b 2}  1))
  (is   (contains-key? #{:a 1 :b 2}  2))
  (isnt (contains-key? #{:a 1 :b 2} :x))
  (isnt (contains-key? #{:a 1 :b 2} :c))

  (is   (contains-key? #{:a 5 nil   "hello"} nil))
  (isnt (contains-key? #{:a 5 :doh! "hello"} nil))

  (throws? (contains-key? [:a 1 :b 2] :a))
  (throws? (contains-key? [:a 1 :b 2]  1)))

Et, pour les cartes, vous pouvez également rechercher des valeurs avec contains-val?:

(deftest t-contains-val?
  (is   (contains-val? {:a 1 :b 2} 1))
  (is   (contains-val? {:a 1 :b 2} 2))
  (isnt (contains-val? {:a 1 :b 2} 0))
  (isnt (contains-val? {:a 1 :b 2} 3))
  (isnt (contains-val? {:a 1 :b 2} :a))
  (isnt (contains-val? {:a 1 :b 2} :b))

  (is   (contains-val? {:a 1 :b nil} nil))
  (isnt (contains-val? {:a 1 nil  2} nil))
  (isnt (contains-val? {:a 1 :b   2} nil))

  (throws? (contains-val?  [:a 1 :b 2] 1))
  (throws? (contains-val? #{:a 1 :b 2} 1)))

Comme vu dans le test, chacune de ces fonctions fonctionne correctement lors de la recherche de nilvaleurs.

Une autre option:

((set '(100 101 102)) 101)

Utilisez java.util.Collection # contains ():

(.contains '(100 101 102) 101)