Clojure coalesce function

Question

SQL offre una funzione denominata coalesce(a, b, c, ...) che restituisce null se tutti i suoi argomenti sono nulli, altrimenti restituisce il primo argomento non null.

Come andresti a scrivere qualcosa del genere in Clojure?

Si chiamerà così: (coalesce f1 f2 f3 ...) dove il fi sono forme che dovrebbero essere valutati solo se necessario. Se f1 non è zero, non è necessario valutare f2 - potrebbe avere effetti collaterali.

Forse Clojure offre già una tale funzione (o macro).

EDIT: Ecco una soluzione che mi è venuta (modificata dalla programmazione di Stuart Halloway Clojure, (and ...) macro a pagina 206):

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

sembra funzionare.

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

Risolto.

Answer 1

in base alla risposta del nickik e "o" macro clojure:

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

Answer 2

Quello che vuoi è la "o" macro.

Valuta expr uno alla volta, da sinistra a destra. Se un modulo restituisce un valore true logico o restituisce tale valore e non valuta nessuna delle altre espressioni, altrimenti restituisce il valore dell'ultima espressione. (o) restituisce nil.

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

Se desideri solo nil e non falsa fare una riscrittura e di fondersi e il nome.

Edit:

Questo non poteva essere fatto in funzione perché le funzioni valutare tutti i loro argomenti prima. Questo potrebbe essere fatto in Haskell perché le funzioni sono pigre (non sicuro al 100% della cosa di Haskell).

Answer 3

Si potrebbe utilizzare tenere introdotto in 1.2:

EDIT: esteso rispondere un po '. Macro per invocazioni dirette. Helper per es. applica + pigro seq producendo i valori.

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

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

Tuttavia per evitare la valutazione dei valori è necessario un percorso interno.

Ugly:

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

Un po 'più coinvolto, ma più bella nel codice:

(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

Forse sto capendo male la domanda, ma questo non è solo il primo elemento filtrato?

Esempio:

 
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 

Potrebbe essere ridotto fino a:

 
(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

Alcune versioni di funzione del fondono, se si preferisce evitare le macro:

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

Uso:

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

A differenza delle specifiche, questo valuterà tutti gli argomenti. Utilizzare or o un'altra soluzione macro appropriata se si desidera una valutazione del cortocircuito.