Clojure 中的高阶 if-then-else？

Question

如果数据满足特定条件，我经常需要通过一个函数运行我的数据。通常，函数 f 和条件检查器 pred 都被参数化为数据。出于这个原因，我发现自己希望有一个既不知道 f 也不知道 pred.

的高阶 if-then-else

例如，假设我想将 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 库吗？

Answer 1

根据具体情况，使用 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，因为您通过多个阶段对值进行线程化。

如示例所示，您可以选择定义和命名转换器函数（我的最爱），或使用函数文字语法 #(...)

Answer 2

正如 Alan Thompson 提到的，cond-> 是一种相当标准的方法，可以隐式地将“其他”部分设为“return 值不变”。但是，它并没有真正解决您成为更高阶的希望。我还有另一个不喜欢 cond-> 的原因：我认为（并且在 cond-> 被发明时争论过）通过每个匹配测试而不是仅仅通过第一个匹配测试是错误的。它使得无法使用 cond-> 作为 cond.

的类比

如果您同意我的看法，您可以尝试 flatland.useful.fn/fix，或者我们在 cond->^{1[=38= 之前编写的该系列中的其他工具之一].}

to-fix 正是你的 fork，除了它可以处理多个子句并接受常量和函数（例如，也许你想将 10 加到其他偶数上但替换 0 20):

(map (to-fix zero? 20, even? #(+ % 10)) xs)

使用 fix 很容易复制 cond-> 的行为，但反之则不然，这就是为什么我认为 fix 是更好的设计选择。

¹ 显然，距离 fix 最终版本发布 10 周年还有几周的时间。时间过得真快。

Answer 3

我同意为此使用某种高阶函数构造可能非常有用，但我不知道有任何此类构造。确实，您可以实现更高阶的 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]]

Answer 4

另一种定义 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].

Clojure 中的高阶 if-then-else？

Higher-order if-then-else in Clojure?

clojure

pointfree

higher-order-functions