Перевірте, чи містить список певне значення у Clojure

Який найкращий спосіб перевірити, чи містить список задане значення в Clojure?

Зокрема, поведінка компанії contains?зараз мене бентежить:

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

Я, очевидно, міг написати просту функцію, щоб пройти список і перевірити рівність, але, безумовно, повинен бути стандартний спосіб це зробити?

Ах, contains?... нібито один із п’ятірки найпоширеніших запитань про: Clojure.

Він не перевіряє, чи містить колекція значення; він перевіряє, чи можна отримати елемент за допомогою, getабо іншими словами, чи містить у колекції ключ. Це має сенс для наборів (які можна вважати такими, що не роблять різниці між ключами та значеннями), карт (так (contains? {:foo 1} :foo)це true) і векторів (але зауважте, що (contains? [:foo :bar] 0)тому true, що тут ключі є індексами, а відповідний вектор "містить" покажчик 0!).

Щоб додати плутанину, у випадках, коли не має сенсу телефонувати contains?, просто повертаються false; це те, що відбувається (contains? :foo 1) і в (contains? '(100 101 102) 101) . Оновлення: у Clojure ≥ 1,5 contains?кидка при передачі об'єкта типу, який не підтримує призначений тест на "ключове членство".

Правильний спосіб зробити те, що ви намагаєтесь зробити, полягає в наступному:

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

Під час пошуку одного з букетів предметів можна використовувати більший набір; під час пошуку false/ nilви можете використовувати false?/ nil?- тому що (#{x} x)повертається x, таким чином, (#{nil} nil)є nil; під час пошуку одного з декількох предметів, деякими з яких можуть бути falseабо nilви можете користуватися

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

(Зверніть увагу, що елементи можуть бути передані zipmapв будь-який тип колекції.)

Ось мій стандартний утиліт для тієї ж мети:

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

Ви завжди можете викликати методи Java з синтаксисом .methodName.

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

Я знаю, що я трохи запізнююся, але як бути:

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

Нарешті, в clojure 1.4 виходить правда :)

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

Працює, але нижче краще:

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

Оскільки це варто, це моя проста реалізація функції містить список для списків:

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

Якщо у вас є вектор або список і хочете перевірити , є чи значення міститься в ньому, ви побачите , що contains?не працює. Міхал уже пояснив, чому .

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

У цьому випадку ви можете спробувати чотири речі:

1. Поміркуйте, чи дійсно вам потрібен вектор чи список. Якщо ви замість цього використовуєте набір , contains?буде працювати.

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

2. Використовуйтеsome , загортаючи ціль у набір таким чином:

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

3. Ярлик на встановлення функції не працюватиме, якщо ви шукаєте помилкове значення ( falseабо nil).

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

   У цих випадках слід використовувати вбудовану функцію предиката для цього значення false?або nil?:

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

4. Якщо вам доведеться багато робити такий пошук, напишіть для нього функцію :

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

Також див . Відповідь Міхала щодо способів перевірити, чи міститься якась із кількох цілей у послідовності.

Ось швидка функція моїх стандартних утиліт, які я використовую для цієї мети:

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

Ось класичне рішення 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)))

Я створив jg-faustus версію "список-містить?". Тепер він бере будь-яку кількість аргументів.

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

Це так само просто, як використання набору - подібний до карт, ви можете просто опустити його у функціональне положення. Він оцінюється за значенням, якщо в наборі (який є трикутним) або nil(який є фальси):

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

Якщо ви перевіряєте наявність вектора / списку досить розумного розміру у вас не буде до виконання, ви також можете скористатися setфункцією

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

Рекомендований спосіб використання someз набором - див. Документацію для clojure.core/some.

Потім ви можете використовувати someв реальному істинному / хибному присудку, наприклад

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

приклад використання (який? [1 2 3] 3) або (який? # {1 2 3} 4 5 3)

Оскільки Clojure побудований на Java, ви можете так само легко викликати функцію .indexOfJava. Ця функція повертає індекс будь-якого елемента в колекції, і якщо він не може знайти цей елемент, повертає -1.

Скориставшись цим, ми могли б просто сказати:

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

Проблема з "рекомендованим" рішенням полягає в перервах, коли значення, яке ви шукаєте, "нульове". Я вважаю за краще таке рішення:

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

Для цієї мети в бібліотеці Тупело є зручні функції . Зокрема, функція contains-elem?, contains-key?і contains-val?дуже корисна. Повна документація присутня в документах API .

contains-elem?є найбільш загальним і призначений для векторів або будь-якого іншого клоджура 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))))

Тут ми бачимо, що для цілого діапазону або змішаного вектора contains-elem?працює, як очікувалося, і для існуючих, і для неіснуючих елементів колекції. Для карт ми також можемо шукати будь-яку пару ключ-значення (виражається у вигляді вектора 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] ))))

Шукати набір також просто:

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

Для карт і наборів простіше (і ефективніше) використовувати contains-key?для пошуку записи на карті чи елемента набору:

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

А для карт ви також можете шукати значення за допомогою 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)))

Як видно з тесту, кожна з цих функцій працює правильно при пошуку nilзначень.

Ще один варіант:

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

Використовуйте java.util.Collection # містить ():

(.contains '(100 101 102) 101)