common lisp:
http://www.gigamonkeys.com/book/
http://acl.readthedocs.org/en/latest/zhCN/
CL-USER> (remove-if-not #’evenp ‘(1 2 3 4 5 6 7 8 9 10))
(2 4 6 8 10)
In this case, the predicate is the function EVENP, which returns true if its
argument is an even number.
The funny notation #’ is shorthand for “Get me the function with the following
name.”
Without the #’, Lisp would treat evenp as the name of a variable and look up
the value of the variable, not the function.
Common Lisp provides two functions for invoking a function through a function
object: FUNCALL and APPLY.
Like FUNCALL, the first argument to APPLY is a function object. But after the
function object, instead of individual arguments, it expects a list.
(defun foo(a b c) (list a b c))
(foo 1 2 3)
(funcall #’foo 1 2 3)
(apply #’foo (list 1 2 3))
(apply #’foo 1 (list 2 3))
(apply #’foo 1 2 (list 3))
CL-USER> (let ((count 0)) #’(lambda () (setf count (1+ count))))
#
(defparameter fn (let ((count 0)) #’(lambda () (setf count (1+ count)))))
CL-USER> (funcall fn)
1
CL-USER> (funcall fn)
2
CL-USER> (funcall fn)
3
each macro defines its own syntax, determining how the s-expressions it’s
passed are turned into Lisp forms. With macros as part of the core language
it’s possible to build new syntax–control constructs such as WHEN, DOLIST,
and LOOP as well as definitional forms such as DEFUN and DEFPARAMETER–as part
of the “standard library” rather than having to hardwire them into the core.
This has implications for how the language itself is implemented, but as a
Lisp programmer you’ll care more that it gives you another way to extend the
language, making it a better language for expressing solutions to your
particular programming problems.
the job of a macro isn’t to do anything directly–its job is to generate code
that will later do what you want.
我们可以用 ‘ 作为 quote(…) 的缩写，也可以用 #’ 作为 function(…) 的缩写：
(defun plus(x y) (+ x y))
PLUS
(plus 1 4)
5
(funcall #’plus 1 4)
5
(funcall (function plus) 1 4)
5
(apply #’plus (list 1 4))
5
(apply (function plus) (list 1 4))
5#’plus
#
#’+
#
(function plus)
#
(function +)
#
((x) (+ x 100)) and
(lambda (x) (+ x 100)) is same
but we used to use lambda to express anonymous function
lambda表达式本身就是一个函数