问题描述
如果数据满足特定条件，我经常不得不通过函数运行我的数据。通常，函数 f 和条件检查器 pred 都被参数化为数据。出于这个原因，我发现自己希望得到一个既不知道 if-then-else 也不知道 f 的高阶 pred。
例如，假设我想将 10 添加到 (range 5) 中的所有偶数。而不是
(map #(if (even? %) (+ % 10) %) (range 5))
我更喜欢有一个帮手——我们称之为fork——然后这样做：
(map (fork even? #(+ % 10)) (range 5))
我可以继续将 fork 实现为函数。它看起来像这样：
(defn fork
([pred thenf elsef]
#(if (pred %) (thenf %) (elsef %)))
([pred thenf]
(fork pred thenf identity)))
这可以通过优雅地组合 core 函数来完成吗？也许是一些不错的 juxt / apply / some 链？
或者，您知道实现上述（或类似）的任何 Clojure 库吗？
解决方法
正如 Alan Thompson 所提到的，如今，cond-> 是一种相当标准的方式，可以隐式地让“else”部分“返回不变的值”。不过，它并没有真正解决您成为高阶人士的希望。我还有另一个不喜欢 cond-> 的原因：我认为（并且在发明 cond-> 时争论过）它遍历每个匹配的测试是错误的，而不仅仅是第一个。无法将 cond-> 用作 cond 的类似物。
如果您同意我的观点，您可以尝试使用 flatland.useful.fn/fix 或该系列中的其他工具之一，这些工具是我们在 cond->1 之前编写的。
to-fix 正是您的 fork，除了它可以处理多个子句并接受常量和函数（例如，您可能想将 10 添加到其他偶数但将 0 替换为 20 ):
(map (to-fix zero? 20,even? #(+ % 10)) xs)
使用 cond-> 很容易复制 fix 的行为，但反过来不行，这就是为什么我认为 fix 是更好的设计选择。
1 显然，我们距离 fix 最终版本 10 周年只有几周的时间。时光飞逝。
我同意为此拥有某种高阶函数构造可能非常有用，但我不知道任何此类构造。确实，您可以实现更高阶的 fork 函数，但它的用处非常有限，并且可以使用 if 或 cond-> 宏轻松实现，如其他答案中所建议的.
然而，我想到的是transducers。您可以相当轻松地实现一个 forking 转换器，该转换器可以与其他转换器组合以构建强大而简洁的序列处理算法。
实现可能如下所示：
(defn forking [pred true-transducer false-transducer]
(fn [step]
(let [true-step (true-transducer step)
false-step (false-transducer step)]
(fn
([] (step))
([dst x] ((if (pred x) true-step false-step) dst x))
([dst] dst))))) ;; flushing not performed.
这就是您在示例中使用它的方式：
(eduction (forking even?
(map #(+ 10 %))
identity)
(range 20))
;; => (10 1 12 3 14 5 16 7 18 9 20 11 22 13 24 15 26 17 28 19)
但它也可以comp与其他传感器一起构建更复杂的序列处理算法：
(into []
(comp (forking even?
(comp (drop 4)
(map #(+ 10 %)))
(comp (filter #(< 10 %))
(map #(vector % % %))
cat))
(partition-all 3))
(range 20))
;; => [[18 20 11] [11 11 22] [13 13 13] [24 15 15] [15 26 17] [17 17 28] [19 19 19]]
根据细节，使用 cond-> 宏和朋友通常最容易实现此目标：
(let [myfn (fn [val]
(cond-> val
(even? val) (+ val 10))) ]
结果
(mapv myfn (range 5)) => [10 1 14 3 18]
有一个变体 in the Tupelo library 有时很有用：
(mapv #(cond-it-> %
(even? it) (+ it 10))
(range 5))
允许您使用特殊符号 it 将值传递到多个阶段。
如示例所示，您可以选择定义和命名转换器函数（我最喜欢的），或使用函数文字语法 #(...)
定义 fork（具有三个输入）的另一种方法可能是：
(defn fork [pred then else]
(comp
(partial apply apply)
(juxt (comp {true then,false else} pred) list)))
请注意，在此版本中，输入和输出可以接收零个或多个参数。但是让我们采用更结构化的方法，定义一些其他有用的组合器。让我们从定义 pick 开始，它对应于态射的分类余积（和）：
(defn pick [actions]
(fn [[tag val]]
((actions tag) val)))
;alternatively
(defn pick [actions]
(comp
(partial apply apply)
(juxt (comp actions first) rest)))
例如(mapv (pick [inc dec]) [[0 1] [1 1]]) 给出 [2 0]。使用 pick 我们可以定义 switch，它的作用类似于 case:
(defn switch [test actions]
(comp
(pick actions)
(juxt test identity)))
例如(mapv (switch #(mod % 3) [inc dec -]) [3 4 5]) 给出 [4 3 -5]。使用 switch 我们可以轻松定义 fork:
(defn fork [pred then else]
(switch pred {true then,false else}))
例如(mapv (fork even? inc dec) [0 1]) 给出 [1 0]。最后，使用 fork 让我们还定义 fork*，它接收零个或多个谓词和动作对，并像 cond 一样工作：
(defn fork* [& args]
(->> args
(partition 2)
reverse
(reduce
(fn [else [pred then]]
(fork pred then else))
identity)))
;equivalently
(defn fork* [& args]
(->> args
(partition 2)
(map (partial apply (partial partial fork)))
(apply comp)
(#(% identity))))
例如(mapv (fork* neg? -,even? inc) [-1 0 1]) 给出 [1 1 1]。