Clojure coalesce function

Question

SQL предлагает функцию с именем coalesce(a, b, c, ...), которая возвращает значение null, если все его аргументы равны нулю, в противном случае он возвращает первый ненулевой аргумент.

Как вы собираетесь писать что-то подобное в Clojure?

Он будет называться так: (coalesce f1 f2 f3 ...) где fi являются формами , которые должны быть оценены только в случае необходимости. Если f1 не равен нулю, то f2 не следует оценивать - он может иметь побочные эффекты.

Возможно, Clojure уже предлагает такую ​​функцию (или макрос).

EDIT: Вот решение, которое я придумал (редактировался программирования Стюарта Халлоуэй в Clojure, (and ...) макросъемки на странице 206):

(defmacro coalesce 
    ([] nil) 
    ([x] x) 
    ([x & rest] `(let [c# ~x] (if c# c# (coalesce ~@rest))))) 

похоже на работу.

(defmacro coalesce 
    ([] nil) 
    ([x] x) 
    ([x & rest] `(let [c# ~x] (if (not (nil? c#)) c# (coalesce ~@rest))))) 

Исправлено.

Answer 1

На основании ответа nickik и "или" Clojure макрос:

(defmacro coalesce 
    ([] nil) 
    ([x] x) 
    ([x & next] 
     `(let [v# ~x] 
      (if (not (nil? v#)) v# (coalesce ~@next))))) 

Answer 2

Что вы хотите, это макрос или.

Оценки exprs по одному, слева направо. Если форма возвращает логическое истинное значение или возвращает это значение, а не оценивает любое из других выражений, в противном случае оно возвращает значение последнего выражения. (или) возвращает нуль.

http://clojuredocs.org/clojure_core/clojure.core/or

Если вы хотите только ноль и не ложь делать перезапись и и назовите его слипаются.

Edit:

Это не может быть сделано в качестве функции, поскольку функции оценить все их аргументы первой. Это можно сделать в Haskell, потому что функции ленивы (не на 100% уверены в вещи Haskell).

Answer 3

Вы можете использовать снова введены в 1.2:

EDIT: расширенный ответ немного. Макрос для прямых вызовов. Помощник, например. Примените + lazy seq, производя значения.

(defn coalesce* 
    [values] 
    (first (keep identity values))) 

(defmacro coalesce 
    [& values] 
    `(coalesce* (lazy-list ~@values))) 

Однако для предотвращения оценки ценностей необходим какой-то домашний образ жизни.

Гадкий:

(lazy-cat [e1] [e2] [e3])

Немного сложнее, но симпатичнее в коде:

(defn lazy-list* 
    [& delayed-values] 
    (when-let [delayed-values (seq delayed-values)] 
    (reify 
     clojure.lang.ISeq 
     (first [this] @(first delayed-values)) 
     (next [this] (lazy-list* (next delayed-values))) 
     (more [this] (or (next this)()))))) 

(defmacro lazy-list 
    [& values] 
    `(lazy-list* ~@(map (fn [v] `(delay ~v)) values)) 

Answer 4

Возможно, я 'mis misprehending вопрос, но разве это не только первый фильтрованный элемент?

Например:

 
user=> (first (filter (complement nil?) [nil false :foo])) 
false 
user=> (first (filter (complement nil?) [nil :foo])) 
:foo 
user=> (first (filter (complement nil?) [])) 
nil 
user=> (first (filter (complement nil?) nil)) 
nil 

Это может быть сокращен до:

 
(defn coalesce [& vals] 
    (first (filter (complement nil?) vals))) 

 
user=> (coalesce nil false :foo) 
false 
user=> (coalesce nil :foo) 
:foo 
user=> (coalesce nil) 
nil 
user=> (coalesce) 
nil 

Answer 5

Некоторые функции версии сливаются, если вы не хотите избежать макросов:

(defn coalesce 
    "Returns first non-nil argument." 
    [& args] 
    (first (keep identity args))) 

(defn coalesce-with 
    "Returns first argument which passes f." 
    [f & args] 
    (first (filter f args))) 

Использование:

=> (coalesce nil "a" "b") 
"a" 
=> (coalesce-with not-empty nil "" "123") 
"123" 

В отличие от спецификации, это будет оценивать все аргументы. Используйте or или другое подходящее решение для макросов, если вы хотите получить оценку короткого замыкания.