新67194成人永久网站,91久久久在线,亚洲日本在线观看

lisp let,let*

�p�米 — Mon, 22 Aug 2011 03:50:00 GMT

let and let* create new variable bindings and execute a series of forms that use these bindings. 
let performs the bindings in parallel and let* does them sequentially.

The form

 (let ((var1 init-form-1)
       (var2 init-form-2)
       ...
       (varm init-form-m))
   declaration1
   declaration2
   ...
   declarationp
   form1
   form2
   ...
   formn)

first evaluates the expressions init-form-1, init-form-2, and so on, in that order, saving the resulting values. 
Then all of the variables varj are bound to the corresponding values; 
each binding is lexical unless there is a special declaration to the contrary. 
The expressions formk are then evaluated in order; the values of all but the last are discarded 
   (that is, the body of a let is an implicit progn).
let* is similar to let, but the bindings of variables are performed sequentially rather than in parallel. 
The expression for the init-form of a var can refer to vars previously bound in the let*.

The form

 (let* ((var1 init-form-1)
        (var2 init-form-2)
        ...
        (varm init-form-m))
   declaration1
   declaration2
   ...
   declarationp
   form1
   form2
   ...
   formn)
first evaluates the expression init-form-1, then binds the variable var1 to that value;
 then it evaluates init-form-2 and binds var2, and so on. 
The expressions formj are then evaluated in order; 
the values of all but the last are discarded (that is, the body of let* is an implicit progn).

For both let and let*, if there is not an init-form associated with a var, var is initialized to nil.

The special form let has the property that the scope of the name binding does not include any initial value form. 
For let*, a variable's scope also includes the remaining initial value forms for subsequent variable bindings.


Examples:

 (setq a 'top) =>  TOP
 (defun dummy-function () a) =>  DUMMY-FUNCTION
 (let ((a 'inside) (b a))
    (format nil "~S ~S ~S" a b (dummy-function))) =>  "INSIDE TOP TOP" 
 (let* ((a 'inside) (b a))
    (format nil "~S ~S ~S" a b (dummy-function))) =>  "INSIDE INSIDE TOP" 
 (let ((a 'inside) (b a))
    (declare (special a))
    (format nil "~S ~S ~S" a b (dummy-function))) =>  "INSIDE TOP INSIDE"

�p�米 2011-08-22 11:50 发表评论

lisp loop,dotimes,dolist,do

�p�米 — Mon, 22 Aug 2011 03:05:00 GMT

Simple LOOP loops forever...

? (loop
    (print "Look, I'm looping!"))
"Look, I'm looping!" 
"Look, I'm looping!" 
"Look, I'm looping!" 
"Look, I'm looping!" 
"Look, I'm looping!" 
"Look, I'm looping!" 
"Look, I'm looping!" 
"Look, I'm looping!" 
... and so on, until you interrupt execution... 
Aborted
?

? (let ((n 0))
    (loop
      (when (> n 10) (return))
      (print n) (prin1 (* n n))
      (incf n)))
0 0
1 1
2 4
3 9
4 16
5 25
6 36
7 49
8 64
9 81
10 100
NIL
?

Use DOTIMES for a counted loop

? (dotimes (n 11)
    (print n) (prin1 (* n n)))
0 0
1 1
2 4
3 9
4 16
5 25
6 36
7 49
8 64
9 81
10 100
NIL
?

Use DOLIST to process elements of a list

? (dolist (item '(1 2 4 5 9 17 25))
    (format t "~&~D is~:[n't~;~] a perfect square.~%" item (integerp (sqrt item))))
1 is a perfect square.
2 isn't a perfect square.
4 is a perfect square.
5 isn't a perfect square.
9 is a perfect square.
17 isn't a perfect square.
25 is a perfect square.
NIL

? (dolist (item `(1 foo "Hello" 79.3 2/3 ,#'abs))
    (format t "~&~S is a ~A~%" item (type-of item)))
1 is a FIXNUM
FOO is a SYMBOL
"Hello" is a (SIMPLE-BASE-STRING 5)
79.3 is a DOUBLE-FLOAT
2/3 is a RATIO
# is a FUNCTION
NIL
?

DO is tricky, but powerful

? (do ((which 1 (1+ which))
       (list '(foo bar baz qux) (rest list)))
      ((null list) 'done)
    (format t "~&Item ~D is ~S.~%" which (first list)))
Item 1 is FOO.
Item 2 is BAR.
Item 3 is BAZ.
Item 4 is QUX.
DONE
?

(do ((var1 init1 step1)

     (var2 init2 step2)
     ...)
    (end-test result)
  statement1
  ...)

var1       = which
init1      = 1
step1      = (1+ which)
var2       = list
init2      = '(foo bar baz qux)
step2      = (rest list)
end-test   = (null list)
result     = 'done
statement1 = (format t "~&Item ~D is ~S.~%" which (first list))

�p�米 2011-08-22 11:05 发表评论

lisp find find-if find-if-not

�p�米 — Fri, 19 Aug 2011 14:04:00 GMT

find item sequence &key from-end test test-not start end key => element

find-if predicate sequence &key from-end start end key => element

find-if-not predicate sequence &key from-end start end key => element

Arguments and Values:

item---an object.

sequence---a proper sequence.

predicate---a designator for a function of one argument that returns a generalized boolean.
接受一个参数的函数�Q�返回boolean

from-end---a generalized boolean. The default is false.
boolean�c�d��Q�默认�ؓfalse

test---a designator for a function of two arguments that returns a generalized boolean.
接受两个参数的函敎ͼ��q�回boolean

test-not---a designator for a function of two arguments that returns a generalized boolean.
接受两个参数的函敎ͼ��q�回boolean

start, end---bounding index designators of sequence. The defaults for start and end are 0 and nil, respectively.

key---a designator for a function of one argument, or nil.

element---an element of the sequence, or nil.

find, find-if, and find-if-not each search for an element of the sequence bounded by start and end that satisfies the predicate predicate or that satisfies the test test or test-not, as appropriate.

If from-end is true, then the result is the rightmost element that satisfies the test.

If the sequence contains an element that satisfies the test, then the leftmost or rightmost sequence element, depending on from-end, is returned; otherwise nil is returned.

Examples:

Examples: (find #\d "here are some letters that can be looked at" :test #'char>) => #\Space (find-if #'oddp '(1 2 3 4 5) :end 3 :from-end t) => 3 (find-if-not #'complexp '#(3.5 2 #C(1.0 0.0) #C(0.0 1.0)) :start 2) => NIL

�p�米 2011-08-19 22:04 发表评论

lisp MAPC, MAPCAR, MAPCAN, MAPL, MAPLIST, MAPCON

�p�米 — Fri, 19 Aug 2011 13:44:00 GMT

mapc function &rest lists+ => list-1

mapcar function &rest lists+ => result-list

mapcan function &rest lists+ => concatenated-results

mapl function &rest lists+ => list-1

maplist function &rest lists+ => result-list

mapcon function &rest lists+ => concatenated-results

mapcar operates on successive elements of the lists. function is applied to the first element of each list, then to the second element of each list, and so on. The iteration terminates when the shortest list runs out, and excess elements in other lists are ignored. The value returned by mapcar is a list of the results of successive calls to function.

mapcar 首先��函数apply到每个列表的�W�一个元素，再将函数apply到每个列表的�W�二个元素。�?br />一直到最短的列表的最后一个元素。剩下的元素��被忽略�?br />它的�l�果是返回��g��为nil的集合�?/em>

mapc is like mapcar except that the results of applying function are not accumulated. The list argument is returned.
mapc �?mapcar �c�M��。不�q�返回的是第一个列表�?/div>
maplist is like mapcar except that function is applied to successive sublists of the lists. function is first applied to the lists themselves, and then to the cdr of each list, and then to the cdr of the cdr of each list, and so on.
maplist �?mapcar �c�M��Q�不�q�首先将函数apply到每个列表，然后��函数apply到每个列表的cdr�Q�然后将函数apply到每个列表的cddr。�?br />直到最短的一个列表�ؓ�I�Zؓ止�?/div>
mapl is like maplist except that the results of applying function are not accumulated; list-1 is returned.
mapl和maplist�c�M��Q�但是返回的是第一个列表�?/div>

mapcan and mapcon are like mapcar and maplist respectively, except that the results of applying function are combined into a list by the use of nconc rather than list. That is,
mapcan �?mapcon �c�M��?mapcar �?maplist。它们��?nconc �q�接�l�果而不�?list�?br />
Examples
(mapcar #'car '((1 a) (2 b) (3 c))) => (1 2 3)
(mapcar #'abs '(3 -4 2 -5 -6)) => (3 4 2 5 6)
(mapcar #'cons '(a b c) '(1 2 3)) => ((A . 1) (B . 2) (C . 3))

(maplist #'append '(1 2 3 4) '(1 2) '(1 2 3)) => ((1 2 3 4 1 2 1 2 3) (2 3 4 2 2 3))
(maplist #'(lambda (x) (cons 'foo x)) '(a b c d)) => ((FOO A B C D) (FOO B C D) (FOO C D) (FOO D))
(maplist #'(lambda (x) (if (member (car x) (cdr x)) 0 1)) '(a b a c d b c)) => (0 0 1 0 1 1 1)
(setq dummy nil) => NIL
(mapc #'(lambda (&rest x) (setq dummy (append dummy x)))
'(1 2 3 4)
'(a b c d e)
'(x y z)) => (1 2 3 4)
dummy => (1 A X 2 B Y 3 C Z)

(setq dummy nil) => NIL
(mapl #'(lambda (x) (push x dummy)) '(1 2 3 4)) => (1 2 3 4)
dummy => ((4) (3 4) (2 3 4) (1 2 3 4))

(mapcan #'(lambda (x y) (if (null x) nil (list x y)))
'(nil nil nil d e)
'(1 2 3 4 5 6)) => (D 4 E 5)
(mapcan #'(lambda (x) (and (numberp x) (list x)))
'(a 1 b c 3 4 d 5)) => (1 3 4 5)

(mapcon #'list '(1 2 3 4)) => ((1 2 3 4) (2 3 4) (3 4) (4))

�p�米 2011-08-19 21:44 发表评论