Lisp中的隐式编程

Question

是否可以在Lisp中使用/实现隐式编程（也称为无点编程）？如果答案是肯定的，它已经完成了吗？

Answer 1

原则上，

这种编程方式在CL中是可能的，但是，作为Lisp-2，必须添加几个#'和funcall。此外，与Haskell相比，函数在CL中没有柯里化，也没有隐式的部分应用。总的来说，我认为这样的风格不会很惯用的CL。

例如，您可以像这样定义部分应用程序和组合：

(defun partial (function &rest args)
  (lambda (&rest args2) (apply function (append args args2))))
(defun comp (&rest functions)
  (flet ((step (f g) (lambda (x) (funcall f (funcall g x)))))
    (reduce #'step functions :initial-value #'identity)))

（这些只是我捏造的简单示例——它们并没有针对不同的用例进行真正的测试或深思熟虑。

有了这些，类似于Haskell中的map ((*2) . (+1)) xs的东西变成了：

CL-USER> (mapcar (comp (partial #'* 2) #'1+) '(1 2 3))
(4 6 8)

sum示例：

CL-USER> (defparameter *sum* (partial #'reduce #'+))
*SUM*
CL-USER> (funcall *sum* '(1 2 3))
6

（在此示例中，您还可以设置符号的函数单元格，而不是将函数存储在值单元格中，以便绕过 funcall。

顺便说一下，在Emacs Lisp中，部分应用程序内置为apply-partially。

在 Qi/Shen 中，函数是柯里化的，并且支持隐式部分应用（当使用一个参数调用函数时）：

(41-) (define comp F G -> (/. X (F (G X))))
comp
(42-) ((comp (* 2) (+ 1)) 1)
4
(43-) (map (comp (* 2) (+ 1)) [1 2 3])
[4 6 8]

Clojure中还有句法线程糖，给人一种类似的"流水线"感觉：

user=> (-> 0 inc (* 2))
2

Answer 2

你可以

使用类似的东西（这比->多一点Clojure）：

(defmacro -> (obj &rest forms)
  "Similar to the -> macro from clojure, but with a tweak: if there is
  a $ symbol somewhere in the form, the object is not added as the
  first argument to the form, but instead replaces the $ symbol."
  (if forms
      (if (consp (car forms))
          (let* ((first-form (first forms))
                 (other-forms (rest forms))
                 (pos (position '$ first-form)))
            (if pos
                `(-> ,(append (subseq first-form 0 pos)
                              (list obj)
                              (subseq first-form (1+ pos)))
                     ,@other-forms)
                `(-> ,(list* (first first-form) obj (rest first-form))
                     ,@other-forms)))
          `(-> ,(list (car forms) obj)
               ,@(cdr forms)))
      obj))

（您还必须小心地从包中导出符号$你把它放在-> - 让我们称那个包为tacit - 并把 tacit在你计划使用的任何包的use子句中->，所以->和$是继承的）

用法示例：

(-> "TEST"
    string-downcase
    reverse)
(-> "TEST"
    reverse
    (elt $ 1))

这更像是F#的|>（和壳管），而不是Haskell的.，但他们几乎是一回事（我更喜欢|>，但这是个人品味的问题）。

要查看->在做什么，只需对最后一个示例进行三次宏展开（在 SLIME 中，这是通过将光标放在示例中的第一个(上并键入 C-c RET 三次来完成的）。

Answer 3

是的，这是可能的，@danlei已经解释得很好了。我将添加 Paul Graham 的《ANSI Common Lisp》一书中的一些例子，第 6.6 章关于函数构建器：

您可以像这样定义函数生成器：

(defun compose (&rest fns)
  (destructuring-bind (fn1 . rest) (reverse fns)
    #'(lambda (&rest args)
        (reduce #'(lambda (v f) (funcall f v))
                rest
                :initial-value (apply fn1 args)))))
(defun curry (fn &rest args)
  #'(lambda (&rest args2)
      (apply fn (append args args2))))

并像这样使用它

(mapcar (compose #'list #'round #'sqrt)
        '(4 9 16 25))

返回

((2) (3) (4) (5))

compose函数调用：

(compose #'a #'b #'c)

是等式的

#'(lambda (&rest args) (a (b (apply #'c args))))

这意味着撰写可以接受任意数量的参数，是的。

创建一个函数，将 3 添加到参数中：

(curry #'+ 3)

在书中查看更多内容。

Answer 4

是的，这通常是通过正确的功能实现的。例如，下面是维基百科页面的Racket实现sum的示例：

#lang racket
(define sum (curry foldr + 0))

由于默认情况下不对过程进行柯里化，因此使用curry或以显式柯里风格编写函数会有所帮助。您可以使用使用柯里的新define宏来抽象这一点。