Sprawdź, czy lista zawiera określoną wartość w Clojure

Jaki jest najlepszy sposób sprawdzenia, czy lista zawiera daną wartość w Clojure?

W szczególności contains?wprawia mnie w zakłopotanie zachowanie :

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

Mógłbym oczywiście napisać prostą funkcję, aby przejść przez listę i przetestować pod kątem równości, ale z pewnością musi istnieć standardowy sposób zrobienia tego?

Ach, contains?podobno jedno z pięciu najczęściej zadawanych pytań dotyczących Clojure.

To ma nie sprawdzić, czy kolekcja zawiera wartość; sprawdza, czy element można pobrać za pomocą getlub, innymi słowy, czy kolekcja zawiera klucz. Ma to sens w przypadku zbiorów (które można uważać za nie rozróżniające kluczy i wartości), map (tak samo (contains? {:foo 1} :foo)jest true) i wektorów (ale zauważ, że (contains? [:foo :bar] 0)to jest true, ponieważ klucze są tutaj indeksami, a dany wektor „zawiera” indeks 0!).

Aby dodać do zamieszania, w przypadkach, gdy dzwonienie nie ma sensu contains?, po prostu wraca false; to się dzieje w (contains? :foo 1) i także (contains? '(100 101 102) 101) . Aktualizacja: W Clojure ≥ 1,5 contains?wyrzuca, gdy wręczany jest obiekt typu, który nie obsługuje zamierzonego testu „kluczowego członkostwa”.

Prawidłowy sposób na zrobienie tego, co próbujesz zrobić, jest następujący:

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

Szukając jednego z kilku przedmiotów, możesz użyć większego zestawu; szukając false/ nil, możesz użyć false?/ nil?- ponieważ (#{x} x)zwraca x, więc (#{nil} nil)jest nil; podczas wyszukiwania jednej z wielu pozycji, z których niektóre mogą być falselub nilktórych możesz użyć

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

(Zwróć uwagę, że elementy można przekazywać do zipmapdowolnego typu kolekcji).

Oto moje standardowe narzędzie do tego samego celu:

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

Zawsze możesz wywołać metody Java za pomocą składni .methodName.

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

Wiem, że jestem trochę spóźniony, ale co z:

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

W końcu w clojure 1.4 wyświetla prawdę :)

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

Działa, ale poniżej jest lepiej:

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

Warto, oto moja prosta implementacja funkcji zawiera dla list:

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

Jeśli masz wektor lub listę i chcesz sprawdzić, czy dana wartość jest zawarta w nim, okaże się, że contains?nie działa. Michał już wyjaśnił, dlaczego .

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

W tym przypadku możesz wypróbować cztery rzeczy:

1. Zastanów się, czy naprawdę potrzebujesz wektora czy listy. Jeśli zamiast tego użyjesz zestawu , contains?zadziała.

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

2. Użyjsome , owijając cel w zestaw w następujący sposób:

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

3. Skrót ustaw jako funkcję nie będzie działał, jeśli szukasz fałszywej wartości ( falselub nil).

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

   W takich przypadkach należy użyć wbudowanej funkcji predykatu dla tej wartości false?lub nil?:

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

4. Jeśli będziesz musiał często przeprowadzać tego rodzaju wyszukiwanie, napisz dla niego funkcję :

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

Zobacz także odpowiedź Michała, aby dowiedzieć się, jak sprawdzić, czy któryś z wielu celów znajduje się w sekwencji.

Oto szybka funkcja z moich standardowych narzędzi, których używam do tego celu:

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

Oto klasyczne rozwiązanie 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)))

Zbudowałem na podstawie jg-faustus wersji „list-zawiera?”. Teraz wymaga dowolnej liczby argumentów.

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

Jest to tak proste, jak użycie zestawu - podobnie jak mapy, możesz po prostu upuścić go w pozycji funkcji. Zwraca wartość if w zestawie (co jest prawdą) lub nil(co jest błędne):

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

Jeśli porównujesz wektor / listę o rozsądnych rozmiarach, których nie będziesz mieć przed uruchomieniem, możesz również użyć setfunkcji:

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

Zalecanym sposobem jest użycie somez zestawem - patrz dokumentacja clojure.core/some.

Możesz wtedy użyć somerzeczywistego predykatu prawda / fałsz, np

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

przykładowe użycie (które? [1 2 3] 3) lub (które? # {1 2 3} 4 5 3)

Ponieważ Clojure jest zbudowany na Javie, równie łatwo możesz wywołać funkcję .indexOfJava. Ta funkcja zwraca indeks dowolnego elementu w kolekcji, a jeśli nie może znaleźć tego elementu, zwraca -1.

Korzystając z tego moglibyśmy po prostu powiedzieć:

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

Problem z „zalecanym” rozwiązaniem polega na tym, że łamie się, gdy szukana wartość wynosi „zero”. Wolę takie rozwiązanie:

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

W bibliotece Tupelo dostępne są wygodne funkcje służące do tego celu . W szczególności, funkcje contains-elem?, contains-key?i contains-val?są bardzo przydatne. Pełna dokumentacja znajduje się w dokumentacji API .

contains-elem?jest najbardziej ogólny i jest przeznaczony dla wektorów lub innych klastrów 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))))

Tutaj widzimy, że dla zakresu liczb całkowitych lub wektora mieszanego contains-elem?działa zgodnie z oczekiwaniami zarówno dla istniejących, jak i nieistniejących elementów w kolekcji. W przypadku map możemy również wyszukać dowolną parę klucz-wartość (wyrażoną jako wektor 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] ))))

Przeszukiwanie zbioru jest również proste:

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

W przypadku map i zestawów prostsze (i wydajniejsze) jest użycie contains-key?do znalezienia wpisu mapy lub elementu zestawu:

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

W przypadku map możesz również wyszukiwać wartości za pomocą 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)))

Jak widać w teście, każda z tych funkcji działa poprawnie podczas wyszukiwania nilwartości.

Inna opcja:

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

Użyj java.util.Collection # zawiera ():

(.contains '(100 101 102) 101)