From 7cf7504c7baa1270fb85c3b03e58f0ede82daea1 Mon Sep 17 00:00:00 2001
From: Kaz Kylheku <kaz@kylheku.com>
Date: Sun, 25 Dec 2011 21:30:08 -0800
Subject: More formatting changes.

---
 txr.1 | 459 ++++++++++++++++++++++++++++--------------------------------------
 1 file changed, 192 insertions(+), 267 deletions(-)

diff --git a/txr.1 b/txr.1
index 36fdf3ac..2bb42280 100644
--- a/txr.1
+++ b/txr.1
@@ -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:
-- 
cgit v1.2.3