你能翻译函数式语言 101 中的这 2 个例子吗？ （方案 -> Clojure）

Question

得到了这些例子，我想理解，但它们在方案中。我希望它们在 Clojure 中：D

示例 1 - 计算列表的长度

(define length
  (lambda (ll)
    (cond
      ((null? ll) 0)
      (#t (add1
        (length (cdr ll)))))))

示例 2 - 对列表中的每个元素进行平方

(define squares
  (lambda (li)
    (cond
      ((null? li) ())
      (#t (cons
            (* (char li) (char li))
            (squares(cdr
    li)))))))

示例 3 - “map”函数（如map/reduce）

(define map (lambda (func lst)
  (cond ((null? lst) ())
        (#t (cons (func (car lst))
              (map func (cdr lst)))))))

柯里化“map”

(define map2
  (lambda (func)
    (lambda (lst)
      (cond ((null? lst) ())
        (#t (cons (func (car lst))
              ((map2 func) (cdr lst)))))))

动机

这些示例来自有关函数式编程的演示文稿，其他人可能对此感兴趣：函数式语言 101：什么有什么大惊小怪的吗？

一旦您提交了答案，我希望您同意将其作为评论发布在演示文稿中，以便 Clojure 人员理解原始代码

Answer 1

我这里有一些东西： http ://github.com/nickik/Essentials-of-PLs-in-Clojure/blob/master/src/EssentialsOfProgrammingLanguages/core.clj

这是 clojure 内容的所有方案。您可以下载Essentials ofProgramming Languages-Book的源码来获取Scheme代码。

---

以下是您的示例：

(defn length [lst]
    (cond
      (seq ll) 0
      :else (inc (length (rest lst))))))

注意：clojure 有一个计数函数

---

(defn squares1 [li]
   (cond (nil? (seq li)) (empty li)
     :else (conj (squares1 (rest li)) (* (first li) (first li)))))

(defn squares2 [li]
   (map #(* % %)  li))

---

(defn mymap [f coll]
        (cond (nil? (seq coll)) (empty coll)
          :else (conj (mymap f (rest coll)) (f (first coll)))))

---

(defn map2 [f]
    (fn [lst]
        (cond (nil? (seq lst)) (empty lst)
              :else (conj ((map2 f) (rest lst)) (f (first lst))))))

请注意，您不能仅进行 1:1 翻译。 '() 评估方式等之间的差异。

这里是最重要的

• (nil? (seq list)) 不是 (null? lst) 因为 '() 在 clojure conj 中不是 nil
• 比 conj 更好 缺点 你可以让函数使用更多数据结构
• (空 lst) 更好'() 因为 (empty lst) 保留类型向量、列表、记录、结构或其他类型

Answer 2

列表的长度：

(defn my-length [lst]
    (loop [len 0 x lst]
        (if (empty? x)
            len
            (recur (+ 1 len) (rest x)))))

user=> (my-length '(1))
1
user=> (my-length '(1 2 3 4))
4
user=> (my-length '())
0

对列表中的每个元素进行平方：

(defn squares [lst]
    (loop [sqrs '() x lst]
       (if (empty? x)
           (reverse sqrs)
           (recur (cons (* (first x) (first x)) sqrs) (rest x)))))

user=> (squares '(1 2 3 4))
(1 4 9 16)

Map：

(defn my-map [func lst]
    (loop [res '() x lst]
       (if (empty? x) 
           (reverse res) 
           (recur (cons (func (first x)) res) (rest x)))))

user=> (my-map (fn [x] (* x 2)) '(1 2 3))
(2 4 6)

Map2：

参见 nickik 的解决方案。

Answer 3

还有 map 的更多 clojurey 翻译：

(defn map
  [f coll]
  (lazy-seq
    (when-let [s (seq coll)]
      (cons (f (first s)) (map f (rest s))))))

利用闭包：像上面的 map 一样定义 map-inner 。

(defn map
  [f]
  (fn [coll]
    (map-inner f coll)))

在惯用的 clojure 中，通常你会利用 nil 是逻辑错误。

(defn length
  [coll]
  (loop [s   (seq coll)
         len 0]
    (if s
      (recur (next s) (inc len))
      len)))

与 map 一样：您可以使用惰性序列而不是急切列表。

(defn squares
  [coll]
  (lazy-seq
    (when-let [s (seq coll)]
      (let [fst (first s)]
        (cons (* fst fst) (squares (rest s)))))))

Answer 4

define 在 clojure 中是 def，lambda 是 fn，函数参数写成向量 []< /code>，不列出 ()，null? 为 empty，car 为 first，cdr 是 rest，cond 的默认情况是用 :else 指定的，而不是 #t。

因此，对于您的第一个示例，我们得到：

(def length
  (fn [ll]
    (cond
      (empty? ll) 0
      :else (+ 1 (length (rest ll))))))

使用 defn 而不是 def 和 fn 可以更简洁地编写，但情况也是如此对于scheme版本，所以我选择了最接近原来的方式。

其他例子也可以用同样的方法翻译。