If statement 如何在Clojure中有条件地使用let绑定

我是Clojure的新手，试图简洁地编写一个递归函数，将两个排序序列合并成一个新的排序序列

这是我的尝试，没有编译：

(defn seq-merge [a-seq b-seq]
  (cond
    (empty? a-seq) b-seq
    (empty? b-seq) a-seq
    :else (let (if (< (first a-seq) (first b-seq))
                 [f (first a-seq) r (rest a-seq) h b-seq]
                 [f (first b-seq) r (rest b-seq) h a-seq])
            (cons f (seq-merge r h)))))

但似乎每个“let”都需要直接跟在代码后面，所以这不起作用

如果可以避免的话，目的是不必重复

（cons f（seq merge r h））

行两次

我目前的解决方案是：

(defn seq-merge [a-seq b-seq]
  (cond
    (empty? a-seq) b-seq
    (empty? b-seq) a-seq
    :else (let [a-low? (< (first a-seq) (first b-seq))
                f (if a-low? (first a-seq) (first b-seq))
                r (if a-low? (rest a-seq) (rest b-seq))
                h (if a-low? b-seq a-seq)]
            (cons f (seq-merge r h)))))

（定义顺序合并[a-顺序b-顺序]
（续）
（空？a-顺序）b-顺序
（空？b-顺序）a-顺序
：else（让[a-低”（<（第一个a-序列）（第一个b-序列））
f（如果a-低？（第一个a-序列）（第一个b-序列））
r（如果a-低？（剩余a-序列）（剩余b-序列））
h（如果a-低？b-序列a-序列）]
（反对f（以下合并r h(()()))）

但是，对于每个绑定值都有一个“if”，这似乎更为笨拙。

您可以尝试使用。在这种情况下，它不会创造奇迹，但可以说它更干净一些

(defn seq-merge [a-seq b-seq]
  (cond
    (empty? a-seq) b-seq
    (empty? b-seq) a-seq
    :else (let [[f r h] (if (< (first a-seq) (first b-seq))
                          [(first a-seq) (rest a-seq) b-seq]
                          [(first b-seq) (rest b-seq) a-seq])]
            (cons f (seq-merge r h)))))

（定义顺序合并[a-顺序b-顺序]
（续）
（空？a-顺序）b-顺序
（空？b-顺序）a-顺序
：else（让[[f r h]（如果（<（第一个a序列）（第一个b序列））
[（第一个a序列）（其余a序列）b序列]
[（第一个b序列）（其余b序列）a序列]]
（反对f（以下合并r h(()()))）

通过一个非常简单的改变，你也可以让它变得懒惰。这样它就不会溢出堆栈，并且可以处理无限的列表

(defn seq-merge [a-seq b-seq]
  (lazy-seq
   (cond
     (empty? a-seq) b-seq
     (empty? b-seq) a-seq
     :else (let [[f r h] (if (< (first a-seq) (first b-seq))
                           [(first a-seq) (rest a-seq) b-seq]
                           [(first b-seq) (rest b-seq) a-seq])]
             (cons f (seq-merge r h))))))

（定义顺序合并[a-顺序b-顺序]
（续）
（续）
（空？a-顺序）b-顺序
（空？b-顺序）a-顺序
：else（让[[f r h]（如果（<（第一个a序列）（第一个b序列））
[（第一个a序列）（其余a序列）b序列]
[（第一个b序列）（其余b序列）a序列]]
（反对f（以下合并r h(()()))）

在函数参数和中使用解构，您可以稍微清理一下：

(defn seq-merge [[a & as :as a-seq] [b & bs :as b-seq]]
  (cond
    (empty? a-seq) b-seq
    (empty? b-seq) a-seq
    :else (let [[f r h]
                (if (< a b) [a as b-seq] [b bs a-seq])]
            (cons f (seq-merge r h)))))

（定义顺序合并[[a&as:as a-seq][b&bs:as b-seq]]
（续）
（空？a-顺序）b-顺序
（空？b-顺序）a-顺序
：else（让[f r h]
（如果（

查看并@marco.m我认为这些在这里没有帮助，marco。如果查看，如果要绑定的表达式为false，则没有绑定。

(defn seq-merge [[a & as :as a-seq] [b & bs :as b-seq]]
  (cond
    (empty? a-seq) b-seq
    (empty? b-seq) a-seq
    :else (let [[f r h]
                (if (< a b) [a as b-seq] [b bs a-seq])]
            (cons f (seq-merge r h)))))