diff options
author | Kaz Kylheku <kaz@kylheku.com> | 2011-12-25 21:30:08 -0800 |
---|---|---|
committer | Kaz Kylheku <kaz@kylheku.com> | 2011-12-25 21:30:08 -0800 |
commit | 7cf7504c7baa1270fb85c3b03e58f0ede82daea1 (patch) | |
tree | 60187076c0d09e81f55bc15626e4956983f8de39 | |
parent | 405b3a5705984a34507050793944e6fbcbf50e5d (diff) | |
download | txr-7cf7504c7baa1270fb85c3b03e58f0ede82daea1.tar.gz txr-7cf7504c7baa1270fb85c3b03e58f0ede82daea1.tar.bz2 txr-7cf7504c7baa1270fb85c3b03e58f0ede82daea1.zip |
More formatting changes.
-rw-r--r-- | txr.1 | 459 |
1 files changed, 192 insertions, 267 deletions
@@ -4343,7 +4343,7 @@ indicated as bar-separated items. .TP Syntax: -(progn <form>*) + (progn <form>*) .TP Description @@ -4360,10 +4360,8 @@ These operators are said to feature an "implicit progn". .TP Syntax: -.nf -(let ({<sym> | (<sym> <init-form>)}*) <body-form>*) -(let* ({<sym> | (<sym> <init-form>)}*) <body-form>*) -.fi + (let ({<sym> | (<sym> <init-form>)}*) <body-form>*) + (let* ({<sym> | (<sym> <init-form>)}*) <body-form>*) .TP Description: @@ -4396,19 +4394,17 @@ The variable list may be empty. .TP Examples: -.nf -(let ((a 1) (b 2)) (list a b)) -> (1 2) -(let* ((a 1) (b (+ a 1))) (list a b (+ a b))) -> (1 2 3) -(let ()) -> nil -(let (:a nil)) -> error, :a and nil can't be used as variables -.fi + (let ((a 1) (b 2)) (list a b)) -> (1 2) + (let* ((a 1) (b (+ a 1))) (list a b (+ a b))) -> (1 2 3) + (let ()) -> nil + (let (:a nil)) -> error, :a and nil can't be used as variables .SS Operator lambda .TP Syntax: -(lambda ({<sym>}*[. <sym>]) {<body-form>}*) + (lambda ({<sym>}*[. <sym>]) {<body-form>}*) .TP Description: @@ -4442,24 +4438,20 @@ Counting function. This function, which takes no arguments, captures the variable "counter". Whenever this object is called, it increments the counter by 1 and returns the incremented value. -.nf -(let ((counter 0)) - (lambda () (inc counter))) -.fi + (let ((counter 0)) + (lambda () (inc counter))) Function that takes two or more arguments. The third and subsequent arguments are aggregated into a list passed as the single parameter z: -.nf -(lambda (x y . z) (list 'my-arguments-are x y z)) -.fi + (lambda (x y . z) (list 'my-arguments-are x y z)) .SS Operator call .TP Syntax: -(call <function-form> {<argument-form>}*) + (call <function-form> {<argument-form>}*) .TP Description: @@ -4491,7 +4483,7 @@ Useless use of call on a named function; equivalent to (list 1 2): .TP Syntax: -(fun <function-name>) + (fun <function-name>) .TP Description: @@ -4510,7 +4502,7 @@ syntax (fun (lambda ...)) is invalid. .TP Syntax: -(cond {(<test> {form}*)}*) + (cond {(<test> {form}*)}*) .TP Description: @@ -4535,7 +4527,7 @@ nil. This holds in the case that the syntax is empty: (cond) yields nil. .TP Syntax: -(if <cond> <t-form> [<e-form>]) + (if <cond> <t-form> [<e-form>]) .TP Description: @@ -4552,7 +4544,7 @@ as if <e-form> were specified as nil. .TP Syntax: -(and {<form>}*) + (and {<form>}*) .TP Description: @@ -4572,18 +4564,16 @@ the return value. .TP Examples: -.nf -(and) -> t -(and (> 10 5) (stringp "foo")) -> t -(and 1 2 3) -> 3 -.fi + (and) -> t + (and (> 10 5) (stringp "foo")) -> t + (and 1 2 3) -> 3 .SS Operator or .TP Syntax: -(or {<form>}*) + (or {<form>}*) .TP Description: @@ -4603,19 +4593,17 @@ operator yields the return value. .TP Examples: -.nf -(or) -> nil -(or 1 2) -> 1 -(or nil 2) -> 2 -(or (> 10 20) (stringp "foo")) -> t -.fi + (or) -> nil + (or 1 2) -> 1 + (or nil 2) -> 2 + (or (> 10 20) (stringp "foo")) -> t .SS Operator defun .TP Syntax: -(defun <name> ({<param> [. <rest-param>]}*) <body-form>*) + (defun <name> ({<param> [. <rest-param>]}*) <body-form>*) Description: @@ -4633,14 +4621,12 @@ A function may call itself by name, allowing for recursion. .TP Syntax: -.nf -(inc <place> [<delta>]) -(dec <place> [<delta>]) -(set <place> <new-value>) -(push <item> <place>) -(pop <place>) -(flip <place>) -.fi + (inc <place> [<delta>]) + (dec <place> [<delta>]) + (set <place> <new-value>) + (push <item> <place>) + (pop <place>) + (flip <place>) .TP Description: @@ -4726,12 +4712,10 @@ to be treated as assignment places. .TP Syntax: -.nf -({for | for*} ({<sym> | (<sym> <init-form>)}*) - (<test-form> <result-form>*) - (<inc-form>*) - <body-form>*) -.fi + ({for | for*} ({<sym> | (<sym> <init-form>)}*) + (<test-form> <result-form>*) + (<inc-form>*) + <body-form>*) .TP Description: @@ -4767,10 +4751,8 @@ allowing the return operator to be used to terminate at any point. .TP Syntax: -.nf -(dohash (<key-var> <value-var> <hash-form> [<result-form>]) - <body-form>*) -.fi + (dohash (<key-var> <value-var> <hash-form> [<result-form>]) + <body-form>*) .TP Description: @@ -4798,7 +4780,7 @@ dohash early using (return) or (return <value>). .TP Syntax: -(unwind-protect <protected-form> <cleanup-form>*) + (unwind-protect <protected-form> <cleanup-form>*) .TP Description: @@ -4819,13 +4801,11 @@ is aborted and replaced with the new one. .TP Example: -.nf - (block foo - (unwind-protect - (progn (return-from foo 42) - (format t "not reached!\en")) - (format t "cleanup!\n"))) -.fi + (block foo + (unwind-protect + (progn (return-from foo 42) + (format t "not reached!\en")) + (format t "cleanup!\n"))) In this example, the protected progn form terminates by returning from block foo. Therefore the form does not complete and so the @@ -4838,7 +4818,7 @@ excecutes, producing the output "cleanup!". .TP Syntax: -(block <name> <body-form>*} + (block <name> <body-form>*} .TP Description: @@ -4884,10 +4864,8 @@ the construct. THROW itself is a function and not an operator. .TP Syntax: -.nf -(return [<value>]) -(return-from <name> [<value>]) -.fi + (return [<value>]) + (return-from <name> [<value>]) .TP Description: @@ -4906,14 +4884,12 @@ value. If the value is omitted, that block returns nil. .TP Example: -.nf - (block foo - (let ((a "abc\n") - (b "def\n")) - (pprint a *stdout*) - (return-from foo 42) - (pprint b *stdout*))) -.fi + (block foo + (let ((a "abc\n") + (b "def\n")) + (pprint a *stdout*) + (return-from foo 42) + (pprint b *stdout*))) Here, the output produced is "abc". The value of b is not printed because the return-from terminates block foo, and so the second pprint @@ -4936,7 +4912,7 @@ The following are Lisp functions and variables built-in to TXR. .TP Syntax: -(identity <value>) + (identity <value>) .TP Description: @@ -4949,7 +4925,7 @@ The identity function returns its argument. .TP Syntax: -(typeof <value>) + (typeof <value>) .TP Description @@ -5020,7 +4996,7 @@ There are additional kinds of objects, such as streams. .TP Syntax: -(cons <car-value> <cdr-value>) + (cons <car-value> <cdr-value>) .TP @@ -5054,10 +5030,8 @@ The list (1 2) is (1 . (2 . nil)). .TP Syntax: -.nf -(car <cons-or-nil>) -(first <cons-or-nil>) -.fi + (car <cons-or-nil>) + (first <cons-or-nil>) .TP Description: @@ -5073,10 +5047,8 @@ even though nil isn't a cons and doesn't have a "car" field. .TP Syntax: -.nf -(cdr <cons-or-nil>) -(rest <cons-or-nil>) -.fi + (cdr <cons-or-nil>) + (rest <cons-or-nil>) .TP Description: @@ -5092,11 +5064,9 @@ Example: Walk every element of the list (1 2 3): -.nf - (for ((i '(1 2 3))) (i) ((set i (cdr i))) - (print (car i) *stdout*) - (print #\newline *stdout*)) -.fi + (for ((i '(1 2 3))) (i) ((set i (cdr i))) + (print (car i) *stdout*) + (print #\newline *stdout*)) The variable i marches over the cons cells which make up the "backbone" of the list. The elements are retrieved using the car function. @@ -5109,10 +5079,8 @@ expression i fails and the loop terminates. .TP Syntax: -.nf -(rplaca <cons> <new-car-value>) -(rplacd <cons> <new-cdr-value>) -.fi + (rplaca <cons> <new-car-value>) + (rplacd <cons> <new-cdr-value>) .TP Description: @@ -5130,14 +5098,12 @@ whereas (car nil) is correct, (rplaca nil ...) is erroneous. .TP Syntax: -.nf -(first <list>) -(second <list>) -(third <list>) -(fourth <list>) -(fifth <list>) -(sixth <list>) -.fi + (first <list>) + (second <list>) + (third <list>) + (fourth <list>) + (fifth <list>) + (sixth <list>) .TP Description: @@ -5149,11 +5115,9 @@ If the list is shorter than implied, these functions return nil. .TP Examples: -.nf -(third '(1 2)) -> nil -(second '(1 2)) -> 2 -(third '(1 2 . 3)) -> **error** -.fi + (third '(1 2)) -> nil + (second '(1 2)) -> 2 + (third '(1 2 . 3)) -> **error** .SS Function append @@ -5182,36 +5146,34 @@ be an atom other than nil; in that case append produces an improper list. .TP Examples: -.nf -;; An atom is returned. -(append 3) -> 3 + ;; An atom is returned. + (append 3) -> 3 -;; A list is also just returned: no copying takes place. -;; The eq function can verify that the same object emerges -;; from append that went in. -(let ((list '(1 2 3))) - (eq (append list) list)) -> t + ;; A list is also just returned: no copying takes place. + ;; The eq function can verify that the same object emerges + ;; from append that went in. + (let ((list '(1 2 3))) + (eq (append list) list)) -> t -(append '(1 2 3) '(4 5 6) 7) -> '(1 2 3 4 5 6 . 7)) + (append '(1 2 3) '(4 5 6) 7) -> '(1 2 3 4 5 6 . 7)) -;; the (4 5 6) tail of the resulting list is the original -;; (4 5 6) object, shared with that list. + ;; the (4 5 6) tail of the resulting list is the original + ;; (4 5 6) object, shared with that list. -(append '(1 2 3) '(4 5 6)) -> '(1 2 3 4 5 6) + (append '(1 2 3) '(4 5 6)) -> '(1 2 3 4 5 6) -(append nil) -> nil + (append nil) -> nil -;; (1 2 3) is copied: it is not the last argument -(append '(1 2 3) nil) -> (1 2 3) + ;; (1 2 3) is copied: it is not the last argument + (append '(1 2 3) nil) -> (1 2 3) -;; empty lists disappear -(append nil '(1 2 3) nil '(4 5 6)) -> (1 2 3 4 5 6) -(append nil nil nil) -> nil + ;; empty lists disappear + (append nil '(1 2 3) nil '(4 5 6)) -> (1 2 3 4 5 6) + (append nil nil nil) -> nil -;; atoms and improper lists other than in the last position -;; are erroneous -(append '(a . b) 3 '(1 2 3)) -> **error** -.fi + ;; atoms and improper lists other than in the last position + ;; are erroneous + (append '(a . b) 3 '(1 2 3)) -> **error** .SS Function list @@ -5229,11 +5191,9 @@ argument values. .TP Examples: -.nf -(list) -> nil -(list 1) -> (1) -(list 'a 'b) -> (a b) -.fi + (list) -> nil + (list 1) -> (1) + (list 'a 'b) -> (a b) .SS Function atom @@ -5252,22 +5212,18 @@ case, nil otherwise. All values which are not cons cells are atoms. .TP Examples: -.nf -(atom 3) -> t -(atom (cons 1 2)) -> nil -(atom "abc") -> t -(atom '(3)) -> nil -.fi + (atom 3) -> t + (atom (cons 1 2)) -> nil + (atom "abc") -> t + (atom '(3)) -> nil .SS Functions null and not .TP Syntax: -.nf -(null <value>) -(not <value>) -.fi + (null <value>) + (not <value>) .TP Description: @@ -5278,17 +5234,15 @@ object nil. They returns t if this is the case, nil otherwise. .TP Examples: -.nf -(null '()) -> t -(null nil) -> t -(null ()) -> t + (null '()) -> t + (null nil) -> t + (null ()) -> t -(if (null x) (format t "x is nil!")) + (if (null x) (format t "x is nil!")) -(let ((list '(b c d))) - (if (not (memq 'a list)) - (format t "list ~s does not contain the symbol a\en"))) -.fi + (let ((list '(b c d))) + (if (not (memq 'a list)) + (format t "list ~s does not contain the symbol a\en"))) .SS Function consp @@ -5311,12 +5265,10 @@ as a reference to the first cons in a chain of one or more conses. .TP Examples: -.nf -(consp 3) -> nil -(consp (cons 1 2)) -> t -(consp "abc") -> nil -(consp '(3)) -> t -.fi + (consp 3) -> nil + (consp (cons 1 2)) -> t + (consp "abc") -> nil + (consp '(3)) -> t .SS Function make_lazy_cons @@ -5351,29 +5303,27 @@ and install the resulting cons as the cdr of the lazy cons. .TP Example: -.nf -;;; lazy list of integers between min and max -(defun integer-range (min max) - (let ((counter min)) - ;; min is greater than max; just return empty list, - ;; otherwise return a lazy list - (if (> min max) - nil - (make-lazy-cons (lambda (lcons) - ;; install next number into car - (rplaca lcons counter) - ;; now deal wit cdr field - (cond - ;; max reached, terminate list with nil! - ((eql counter max) - (rplacd lcons nil)) - ;; max not reached: increment counter - ;; and extend with another lazy cons - (t - (inc counter) - (rplacd lcons (make-lazy-cons - (lcons-fun lcons)))))))))) -.fi + ;;; lazy list of integers between min and max + (defun integer-range (min max) + (let ((counter min)) + ;; min is greater than max; just return empty list, + ;; otherwise return a lazy list + (if (> min max) + nil + (make-lazy-cons (lambda (lcons) + ;; install next number into car + (rplaca lcons counter) + ;; now deal wit cdr field + (cond + ;; max reached, terminate list with nil! + ((eql counter max) + (rplacd lcons nil)) + ;; max not reached: increment counter + ;; and extend with another lazy cons + (t + (inc counter) + (rplacd lcons (make-lazy-cons + (lcons-fun lcons)))))))))) .SS Function lcons-fun @@ -5397,10 +5347,8 @@ another lazy cons (as in the example under make-lazy-cons). .TP Syntax: -.nf -(listp <value>) -(proper-listp <value>) -.fi + (listp <value>) + (proper-listp <value>) .TP Description: @@ -5433,10 +5381,8 @@ list. The length of a list is the number of conses in that list. .TP Syntax: -.nf -(mapcar <function> <list> <list>*) -(mappend <function> <list> <list>*) -.fi + (mapcar <function> <list> <list>*) + (mappend <function> <list> <list>*) .TP When given three arguments, the mapcar function processes applies a function to @@ -5462,21 +5408,19 @@ That is to say, (mappend f a b c) is equivalent to .TP Examples: -.nf -;; multiply every element by two -(mapcar (lambda (item) (* 2 item)) '(1 2 3)) -> (4 6 8) + ;; multiply every element by two + (mapcar (lambda (item) (* 2 item)) '(1 2 3)) -> (4 6 8) -;; "zipper" two lists together -(mapcar (lambda (le ri) (list le ri)) '(1 2 3) '(a b c)) '((1 a) (2 b) (3 c))) + ;; "zipper" two lists together + (mapcar (lambda (le ri) (list le ri)) '(1 2 3) '(a b c)) '((1 a) (2 b) (3 c))) -;; like append, mappend allows a lone atom or a trailing atom: -(mappend (fun identity) 3) -> (3) -(mappend (fun identity) '((1) 2)) -> (1 . 2) + ;; like append, mappend allows a lone atom or a trailing atom: + (mappend (fun identity) 3) -> (3) + (mappend (fun identity) '((1) 2)) -> (1 . 2) -;; take just the even numbers -(mappend (lambda (item) (if (evenp x) (list x))) '(1 2 3 4 5)) --> (2 4) -.nf + ;; take just the even numbers + (mappend (lambda (item) (if (evenp x) (list x))) '(1 2 3 4 5)) + -> (2 4) .SS Function apply @@ -5495,10 +5439,8 @@ value becomes the return value of apply. .TP Examples: -.nf -;; '(1 2 3) becomes arguments to list, thus (list 1 2 3). -(apply (fun list) '(1 2 3)) -> (1 2 3) -.fi + ;; '(1 2 3) becomes arguments to list, thus (list 1 2 3). + (apply (fun list) '(1 2 3)) -> (1 2 3) .TP Dialect note: @@ -5514,10 +5456,8 @@ yields (1 2 3 4 5). In TXR Lisp, this usage can be simulated using .TP Syntax: -.nf -(reduce-left <binary-function> <list> <init-value> <key-function>) -(reduce-right <binary-function> <list> <init-value> <key-function>) -.fi + (reduce-left <binary-function> <list> <init-value> <key-function>) + (reduce-right <binary-function> <list> <init-value> <key-function>) .TP Description: @@ -5551,26 +5491,24 @@ to an argument to <binary-function>. The value nil is equivalent to .TP Examples: -.nf -;;; list is empty, so 1 is just returned: -(reduce-left (fun +) () 1 nil) -> 1 + ;;; list is empty, so 1 is just returned: + (reduce-left (fun +) () 1 nil) -> 1 -;;; computes (- (- (- 0 1) 2) 3) -(reduce-left (fun -) '(1 2 3) 0 nil) -> -6 + ;;; computes (- (- (- 0 1) 2) 3) + (reduce-left (fun -) '(1 2 3) 0 nil) -> -6 -;;; computes (- 1 (- 2 (- 3 0))) -(reduce-right (fun -) '(1 2 3) 0 nil) -> 2 + ;;; computes (- 1 (- 2 (- 3 0))) + (reduce-right (fun -) '(1 2 3) 0 nil) -> 2 -;;; computes (* 1 2 3) -(reduce-left (fun *) '((1) (2) (3)) 1 (fun first)) -> 6 -.fi + ;;; computes (* 1 2 3) + (reduce-left (fun *) '((1) (2) (3)) 1 (fun first)) -> 6 .SS Function copy-list .TP Syntax: -(copy-list <list>) + (copy-list <list>) .TP Description: @@ -5595,10 +5533,8 @@ for the empty list nil. .TP Syntax: -.nf -(reverse <list>) -(nreverse <list>) -.fi + (reverse <list>) + (nreverse <list>) .TP Description: @@ -5621,7 +5557,7 @@ reverse order. Other approaches are possible. .TP Syntax: -(ldiff <list> <sublist>) + (ldiff <list> <sublist>) .TP Description: @@ -5644,23 +5580,22 @@ then a copy of <list> is returned. .TP Examples: -.nf -;;; unspecified: the compiler could make '(2 3) a suffix of '(1 2 3), -;;; or they could be separate objects. -(ldiff '(1 2 3) '(2 3)) -> either (1) or (1 2 3) + ;;; unspecified: the compiler could make '(2 3) a suffix of '(1 2 3), + ;;; or they could be separate objects. + (ldiff '(1 2 3) '(2 3)) -> either (1) or (1 2 3) -;; b is the (1 2) suffix of a, so the ldiff is (1) -(let ((a '(1 2 3)) (b (cdr a))) - (ldiff a b)) --> (1) -.fi + ;; b is the (1 2) suffix of a, so the ldiff is (1) + (let ((a '(1 2 3)) (b (cdr a))) + (ldiff a b)) + -> (1) .SS Functions flatten, lazy-flatten .TP Syntax: -(flatten <list>) + (flatten <list>) + (lazy-flatten <list>) .TP Description: @@ -5675,27 +5610,23 @@ structure is itself lazy. .TP Examples: -.nf -(flatten '(1 2 () (3 4))) -> (1 2 3 4) + (flatten '(1 2 () (3 4))) -> (1 2 3 4) -;; precisely equivalent to previous example! nil is the same thing as () -(flatten '(1 2 nil (3 4))) -> (1 2 3 4) + ;; precisely equivalent to previous example! nil is the same thing as () + (flatten '(1 2 nil (3 4))) -> (1 2 3 4) -(flatten nil) -> nil + (flatten nil) -> nil -(flatten '(((()) ()))) -> nil -.fi + (flatten '(((()) ()))) -> nil .SS Functions memq, memql and memqual .TP Syntax: -.nf -(memq <object> <list>) -(memql <object> <list>) -(memqual <object> <list>) -.fi + (memq <object> <list>) + (memql <object> <list>) + (memqual <object> <list>) .TP Description: @@ -5714,7 +5645,7 @@ is the matching object. .TP Syntax: -(tree-find <obj> <tree> <test-function>) + (tree-find <obj> <tree> <test-function>) .TP Description: @@ -5739,11 +5670,9 @@ which returns non-nil. .TP Syntax: -.nf -(some <list> <predicate-fun> <key-fun>) -(all <list> <predicate-fun> <key-fun>) -(none <list> <predicate-fun> <key-fun>) -.fi + (some <list> <predicate-fun> <key-fun>) + (all <list> <predicate-fun> <key-fun>) + (none <list> <predicate-fun> <key-fun>) .TP Description @@ -5782,24 +5711,20 @@ values, the none function returns t. .TP Examples: -.nf -;; some of the integers are odd -(some (fun oddp) '(2 4 6 9) nil) -> t + ;; some of the integers are odd + (some (fun oddp) '(2 4 6 9) nil) -> t -;; none of the integers are even -(none (fun evenp) '(1 3 4 7) nil) -> t -.fi + ;; none of the integers are even + (none (fun evenp) '(1 3 4 7) nil) -> t .SS Functions eq, eql and equal .TP Syntax: -.nf -(eq <left-obj> <right-obj>) -(eql <left-obj> <right-obj>) -(equal <left-obj> <right-obj>) -.fi + (eq <left-obj> <right-obj>) + (eql <left-obj> <right-obj>) + (equal <left-obj> <right-obj>) .TP Description: |