r11859: Canonicalize whitespace

diff --git a/pipes-example.lisp b/pipes-example.lisp
index 6e7b0c0e993c26290a8d85bc513ca07ab9183c19..61d8d75ae649c0032d6a4dc63baf679433523f84 100644 (file)
--- a/pipes-example.lisp
+++ b/pipes-example.lisp
@@ -28,7 +28,7 @@
   (fibgen 0 1))
 
 
-(defun divisible? (x y) 
+(defun divisible? (x y)
   (zerop (rem x y)))
 
 (defun no-sevens ()
@@ -40,7 +40,7 @@
    (pipe-head stream)
    (sieve (pipe-filter
            #'(lambda (x)
-              (not (divisible? x (pipe-head stream))))
+               (not (divisible? x (pipe-head stream))))
            (pipe-tail stream)))))
 
 (defun primes ()
@@ -54,15 +54,15 @@
 
 (defun sum-pipe (sum s)
   (make-pipe sum
-            (sum-pipe (+ sum (pipe-head s))
-                      (pipe-tail s))))
+             (sum-pipe (+ sum (pipe-head s))
+                       (pipe-tail s))))
 
 (defun partial-sums (s)
   (make-pipe (pipe-head s) (sum-pipe 0 s)))
 
 (defun pi-summands (n)
   (make-pipe (/ 1d0 n)
-            (pipe-map #'- (pi-summands (+ n 2)))))
+             (pipe-map #'- (pi-summands (+ n 2)))))
 
 (defun pi-stream ()
   (scale-pipe 4d0 (partial-sums (pi-summands 1))))
@@ -72,48 +72,48 @@
 
 (defun euler-transform (s)
   (let ((s0 (pipe-elt s 0))
-       (s1 (pipe-elt s 1))    
-       (s2 (pipe-elt s 2)))
+        (s1 (pipe-elt s 1))
+        (s2 (pipe-elt s 2)))
     (if (and s0 s1 s2)
-       (if (eql s1 s2) ;;; series has converged 
-               +empty-pipe+
-         (make-pipe (- s2 (/ (square (- s2 s1))
-                             (+ s0 (* -2 s1) s2)))
-                    (euler-transform (pipe-tail s))))
-         +empty-pipe+)))
+        (if (eql s1 s2) ;;; series has converged
+                +empty-pipe+
+          (make-pipe (- s2 (/ (square (- s2 s1))
+                              (+ s0 (* -2 s1) s2)))
+                     (euler-transform (pipe-tail s))))
+          +empty-pipe+)))
 
 
 (defun ln2-summands (n)
   (make-pipe (/ 1d0 n)
-            (pipe-map #'- (ln2-summands (1+ n)))))
+             (pipe-map #'- (ln2-summands (1+ n)))))
 
 (defun ln2-stream ()
   (partial-sums (ln2-summands 1)))
 
 (defun make-tableau (transform s)
   (make-pipe s
-            (make-tableau transform
-                          (funcall transform s))))
+             (make-tableau transform
+                           (funcall transform s))))
 
 (defun accelerated-sequence (transform s)
   (pipe-map #'pipe-head
-           (make-tableau transform s)))
+            (make-tableau transform s)))
 
 
 (defun run-examples ()
   (let ((*print-length* 20))
     (format t "~&pi-stream:~&  ~S"
-           (pipe-values (pi-stream) 10))
+            (pipe-values (pi-stream) 10))
     (format t "~& pi-stream euler-transform:~&  ~S"
-           (pipe-values (euler-transform (pi-stream)) 10))
+            (pipe-values (euler-transform (pi-stream)) 10))
     (format t "~& pi-stream accelerate-sequence:~&  ~S"
-           (pipe-values
-            (accelerated-sequence #'euler-transform (pi-stream)) 10)))
+            (pipe-values
+             (accelerated-sequence #'euler-transform (pi-stream)) 10)))
       (format t "~&ln2-stream:~&  ~S"
-           (pipe-values (ln2-stream) 10))
+            (pipe-values (ln2-stream) 10))
     (format t "~& ln2-stream euler-transform:~&  ~S"
-           (pipe-values (euler-transform (ln2-stream)) 10))
+            (pipe-values (euler-transform (ln2-stream)) 10))
     (format t "~& ln2-stream accelerate-sequence:~&  ~S"
-           (pipe-values
-            (accelerated-sequence #'euler-transform (ln2-stream)) 10)))
+            (pipe-values
+             (accelerated-sequence #'euler-transform (ln2-stream)) 10)))
 

diff --git a/src.lisp b/src.lisp
index 506b84f6bd5c02d486201c176bd9f4c93476370d..c1d058be485838e40adeb0e11c08878205a34118 100644 (file)
--- a/src.lisp
+++ b/src.lisp
@@ -20,7 +20,7 @@
   `(cons ,head #'(lambda () ,tail)))
 
 (defun pipe-tail (pipe)
-  "Return tail of pipe or list, and destructively update 
+  "Return tail of pipe or list, and destructively update
    the tail if it is a function."
   (if (functionp (rest pipe))
     (setf (rest pipe) (funcall (rest pipe)))
@@ -38,7 +38,7 @@
 (defun pipe-enumerate (pipe &key count key (result pipe))
   "Go through all (or count) elements of pipe,
    possibly applying the KEY function. (Try PRINT.)"
-  ;; Returns RESULT, which defaults to the pipe itself. 
+  ;; Returns RESULT, which defaults to the pipe itself.
   (if (or (eq pipe +empty-pipe+) (eql count 0))
     result
     (progn
@@ -61,11 +61,11 @@ if the pipe is infinite in length."
   (if (eq pipe +empty-pipe+)
       +empty-pipe+
     (let ((head (pipe-head pipe))
-         (tail (pipe-tail pipe)))
+          (tail (pipe-tail pipe)))
       (if (funcall predicate head)
-         (make-pipe head (pipe-filter predicate tail))
+          (make-pipe head (pipe-filter predicate tail))
         (pipe-filter predicate tail)))))
-               
+
 
 (defun pipe-map (fn pipe)
   "Map fn over pipe, delaying all but the first fn call."
@@ -85,10 +85,10 @@ if the pipe is infinite in length."
            (result (funcall fn head)))
       (if (or (and filter-pred (funcall filter-pred result))
               result)
-         (make-pipe result (pipe-map-filtering fn tail filter-pred))
+          (make-pipe result (pipe-map-filtering fn tail filter-pred))
         (pipe-map-filtering fn tail filter-pred)))))
 
-      
+
 (defun pipe-append (x y)
   "Return a pipe that appends the elements of x and y."
   (if (eq x +empty-pipe+)
@@ -104,7 +104,7 @@ if the pipe is infinite in length."
     (let ((x (funcall fn (pipe-head pipe))))
       (make-pipe (pipe-head x)
                  (pipe-append (pipe-tail x)
-                             (pipe-mappend fn (pipe-tail pipe)))))))
+                              (pipe-mappend fn (pipe-tail pipe)))))))
 
 (defun pipe-mappend-filtering (fn pipe &optional filter-pred)
   "Map fn over pipe, delaying all but the first fn call,
@@ -116,7 +116,7 @@ if the pipe is infinite in length."
            (result (funcall fn head)))
       (if (or (and filter-pred (funcall filter-pred result))
               result)
-         (make-pipe (pipe-head result)
-                    (pipe-append (pipe-tail result)
-                                 (pipe-mappend-filtering fn tail filter-pred)))
+          (make-pipe (pipe-head result)
+                     (pipe-append (pipe-tail result)
+                                  (pipe-mappend-filtering fn tail filter-pred)))
         (pipe-mappend-filtering fn tail filter-pred)))))