elementos condicionales en -/-> >> tuberías

Question

Dado un oleoducto ->> así:

(defn my-fn [] 
    (->> (get-data) 
     (do-foo) 
     (do-bar) 
     (do-baz))) 

Deseo hacer que las diferentes etapas condicional.

La primera forma de escribir esto que vino a la mente fue como tal:

(defn my-fn [{:keys [foo bar baz]}] 
    (->> (get-data) 
     (if foo (do-foo) identity) 
     (if bar (do-bar) identity) 
     (if baz (do-baz) identity)) 

Sin embargo, como los ->> macro intenta insertar en la forma if, esto no sólo se ve desafortunado en términos de rendimiento (que tiene las llamadas a noop identity), pero en realidad no se puede compilar.

¿Cuál sería una forma apropiada, razonablemente SECA de escribir esto?

Answer 1

Clojure moderna (es decir, a partir de 1.5) compatible con una variedad de opciones para enhebrar condicional.

as-> es quizás el más versátil, al darle un nombre para referirse a la "cosa" que se enhebra a través de los formularios. Por ejemplo:

(as-> 0 n 
    (inc n) 
    (if false 
    (inc n) 
    n)) 
=> 1 

(as-> 0 n 
    (inc n) 
    (if true 
    (inc n) 
    n)) 
=> 2 

Esto da flexibilidad sustancial cuando se trabaja con una mezcla de funciones que requieren enhebrar la expresión en diferentes puntos en la lista de parámetros (es decir, el cambio de -> a - >> sintaxis). Se debe evitar el uso de variables con nombres extraños en interés de la legibilidad del código, pero a menudo esta es la forma más clara y sencilla de expresar un proceso.

También hay cond->, que solicita un conjunto de pares: una prueba y una expresión si esa prueba se evalúa como verdadera. Esto es bastante similar a cond pero no se detiene en la primera prueba verdadera.

Answer 2

se puede fijar la parte compilación (aunque no la parte ascética haciendo que el sentencia if decidir qué función debe ejecutar poniendo otro conjunto de () como tan:

(defn my-fn [{:keys [foo bar baz]}] 
    (->> (get-data) 
    ((if foo do-foo identity)) 
    ((if bar do-bar identity)) 
    ((if baz do-baz identity))) 

se expandiría en una serie de llama así:

; choose function   and call it  
    ((if foo do-foo identity) args  ) 
    ((if bar do-bar identity) args  ) 
    ((if baz do-baz identity) args  ) 

Answer 3

esto funciona también:

(defn my-fn [{:keys [foo bar baz]}] 
    (->> (get-data) 
     (#(if foo (do-foo %) %)) 
     (#(if bar (do-bar %) %)) 
     (#(if baz (do-baz %) %)))) 

Answer 4

Una forma más general para ir si necesita este tipo de cosas a menudo:

 
(defn comp-opt [& flag-fns] 
    (->> flag-fns 
    (partition 2) 
    (filter first) 
    (map second) 
    (apply comp))) 

(defn my-fn [{:keys [foo bar baz]}] 
    (map (comp-opt foo do-foo 
       bar do-bar 
       baz do-baz) 
     (get-data))) 

Answer 5

que podría estar interesado en estas macros https://github.com/pallet/thread-expr