Teste se uma lista contém um valor específico no Clojure

Qual é a melhor maneira de testar se uma lista contém um determinado valor no Clojure?

Em particular, o comportamento de contains?está atualmente me confundindo:

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

Obviamente, eu poderia escrever uma função simples para percorrer a lista e testar a igualdade, mas certamente deve haver uma maneira padrão de fazer isso?

Ah, contains?... supostamente uma das cinco principais perguntas frequentes sobre: ​​Clojure.

Ele não verifica se uma coleção contém um valor; verifica se um item pode ser recuperado com getou, em outras palavras, se uma coleção contém uma chave. Isso faz sentido para conjuntos (que podem ser considerados como não fazendo distinção entre chaves e valores), mapas (como (contains? {:foo 1} :foo)é true) e vetores (mas note que (contains? [:foo :bar] 0)é trueporque as chaves aqui são índices e o vetor em questão "contém" o índice 0!).

Para aumentar a confusão, nos casos em que não faz sentido ligar contains?, basta retornar false; é isso que acontece (contains? :foo 1) e também (contains? '(100 101 102) 101) . Atualização: No Clojure, contains?lançamentos ≥ 1,5 quando entregue um objeto de um tipo que não suporta o teste de "associação de chave" pretendido.

A maneira correta de fazer o que você está tentando fazer é a seguinte:

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

Ao procurar um de vários itens, você pode usar um conjunto maior; Ao procurar por false/ nil, você pode usar false?/ nil?- porque (#{x} x)retorna x, assim (#{nil} nil)é nil; ao procurar um dos vários itens, alguns dos quais podem ser falseou nil, você pode usar

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

(Observe que os itens podem ser passados ​​para zipmapqualquer tipo de coleção.)

Aqui está o meu utilitário padrão para o mesmo objetivo:

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

Você sempre pode chamar métodos java com a sintaxe .methodName.

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

Sei que estou um pouco atrasado, mas e quanto a:

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

Finalmente, no clojure 1.4, as saídas são verdadeiras :)

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

Funciona, mas abaixo é melhor:

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

Pelo que vale a pena, esta é minha implementação simples de uma função contém para listas:

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

Se você tem um vetor ou lista e deseja verificar se um valor está contido nele, verá que contains?isso não funciona. Michał já explicou o porquê .

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

Há quatro coisas que você pode tentar neste caso:

1. Considere se você realmente precisa de um vetor ou lista. Se você usar um conjunto , contains?funcionará.

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

2. Usesome , agrupando o destino em um conjunto, da seguinte maneira:

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

3. O atalho de configuração como função não funcionará se você estiver procurando por um valor falso ( falseou nil).

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

   Nesses casos, você deve usar a função de predicado interno para esse valor false?ou nil?:

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

4. Se você precisar fazer muito esse tipo de pesquisa, escreva uma função para ele :

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

Além disso, consulte a resposta de Michał para obter formas de verificar se algum dos vários destinos está contido em uma sequência.

Aqui está uma função rápida dos meus utilitários padrão que eu uso para esse fim:

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

Aqui está a solução clássica do Lisp:

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

Eu desenvolvi a versão jg-faustus de "list-contains?". Agora é preciso qualquer número de argumentos.

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

É tão simples quanto usar um conjunto - semelhante aos mapas, você pode simplesmente deixá-lo na posição de função. Ele avalia o valor se no conjunto (que é verdade) ou nil(que é falsey):

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

Se você estiver verificando um vetor / lista de tamanho razoável que não terá até o tempo de execução, também poderá usar a setfunção:

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

A maneira recomendada é usar somecom um conjunto - consulte a documentação para clojure.core/some.

Você pode usar somedentro de um predicado verdadeiro / falso real, por exemplo

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

exemplo de uso (qual? ​​[1 2 3] 3) ou (qual? ​​# {1 2 3} 4 5 3)

Como o Clojure é construído em Java, você também pode chamar facilmente a .indexOffunção Java. Essa função retorna o índice de qualquer elemento em uma coleção e, se não conseguir encontrar esse elemento, retorna -1.

Fazendo uso disso, poderíamos simplesmente dizer:

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

O problema com a solução 'recomendada' é que ela quebra quando o valor que você procura é 'nulo'. Eu prefiro esta solução:

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

Existem funções convenientes para esse fim na biblioteca Tupelo . Em particular, as funções contains-elem?, contains-key?e contains-val?são muito úteis. A documentação completa está presente nos documentos da API .

contains-elem?é o mais genérico e destina-se a vetores ou qualquer outro 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))))

Aqui vemos que, para um intervalo inteiro ou um vetor misto, contains-elem?funciona como esperado para elementos existentes e inexistentes na coleção. Para mapas, também podemos procurar qualquer par de valores-chave (expresso como um vetor 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] ))))

Também é simples pesquisar um conjunto:

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

Para mapas e conjuntos, é mais simples (e mais eficiente) usar contains-key?para encontrar uma entrada de mapa ou um elemento de conjunto:

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

E, para mapas, você também pode procurar valores com 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)))

Como visto no teste, cada uma dessas funções funciona corretamente ao pesquisar nilvalores.

Outra opção:

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

Use java.util.Collection # contains ():

(.contains '(100 101 102) 101)