Clojure coalesce function

Question

SQL ofrece una función llamada coalesce(a, b, c, ...) que devuelve null si todos sus argumentos son nulos, de lo contrario, devuelve el primer argumento no nulo.

¿Cómo harías para escribir algo así en Clojure?

Se llamará así: (coalesce f1 f2 f3 ...) donde el fi son formas que sólo se deben evaluar si se requiere. Si f1 no es nulo, entonces no se debe evaluar f2, puede tener efectos secundarios.

Quizás Clojure ya ofrezca dicha función (o macro).

EDITAR: Aquí una solución que se me ocurrió (modificado de Programación de Stuart Halloway Clojure, (and ...) macro en la página 206):

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

parece funcionar.

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

Fijo.

Answer 1

Sobre la base de la respuesta de nickik y "o" macro clojure:

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

Answer 2

Lo que desea es la macro "o".

Evalúa exprs de a una por vez, de izquierda a derecha. Si un formulario devuelve un valor verdadero lógico, o devuelve ese valor y no evalúa cualquiera de las otras expresiones, de lo contrario, devuelve el valor de la última expresión. (o) devuelve nil.

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

Si sólo desea nula y no falsas hacer una reescritura de e y el nombre que se aglutinan.

Editar:

Esto no podría hacerse como una función porque las funciones evalúan todos sus argumentos en primer lugar. Esto podría hacerse en Haskell porque las funciones son flojas (no es 100% seguro de lo de Haskell).

Answer 3

Usted podría utilizar Mantener introducido en 1.2:

EDITAR: extensión contestar un poco. Macro para invociones directas. Ayudante por ej. aplicar + lazy seq produciendo los valores.

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

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

Sin embargo, para evitar la evaluación de los valores, se necesita una forma tradicional.

feo:

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

un poco más complicado, pero más bonita en el código:

(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

Tal vez Estoy malinterpretando la pregunta, pero ¿no es este solo el primer elemento filtrado?

Ej:

 
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 

Podría ser acortado hasta:

 
(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

Algunas versiones de la función de coalescencia, si usted prefiere evitar las macros:

(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 diferencia de la especificación, esto evaluará todos los argumentos. Use or u otra solución de macro apropiada si desea una evaluación de cortocircuito.