Turn bind and one-of into macros to avoid eagerly evaluating argumentsHEADmain

1 files changed, 27 insertions, 27 deletions

diff --git a/core.lisp b/core.lisp
index 2870f7b..4ba3cd7 100644
--- a/core.lisp
+++ b/core.lisp
@@ -30,33 +30,33 @@
                          :message (format nil "Expected: ~a, Got: ~a" ',predicate it))))
        (make-failure :place input :message "Reached end of input."))))
 
-(defun one-of (first-parser second-parser &rest other-parsers)
-  (lambda (input &key lazy)
-    (declare (ignore lazy))
-    (labels ((one-of-rec (parsers)
-                         (let ((intermediate-parsers '())
-                               (result (make-failure :place input
-                                                     :message "Exhausted options.")))
-                           (dolist (p parsers)
-                             (let ((r (funcall p
-                                               input
-                                               :lazy (> (length parsers) 1))))
-                               (cond ((functionp r)
-                                      (push r intermediate-parsers))
-                                     ((parsing-p r)
-                                      (when (or (not (parsing-p result))
-                                                (> (input-cursor (parsing-left r))
-                                                   (input-cursor (parsing-left result))))
-                                        (setf result r)))
-                                     ((failure-p r)
-                                      (when (or (failure-p result)
-                                                (= (length parsers) 1))
-                                        (setf result r)))
-                                     (t (error (format nil "Invalid return value: ~a" r))))))
-                           (if intermediate-parsers
-                             (one-of-rec intermediate-parsers)
-                             result))))
-      (one-of-rec (cons first-parser (cons second-parser other-parsers))))))
+(defmacro one-of (first-parser second-parser &rest other-parsers)
+  `(lambda (input &key lazy)
+     (declare (ignore lazy))
+     (labels ((one-of-rec (parsers)
+                          (let ((intermediate-parsers '())
+                                (result (make-failure :place input
+                                                      :message "Exhausted options.")))
+                            (dolist (p parsers)
+                              (let ((r (funcall p
+                                                input
+                                                :lazy (> (length parsers) 1))))
+                                (cond ((functionp r)
+                                       (push r intermediate-parsers))
+                                      ((parsing-p r)
+                                       (when (or (not (parsing-p result))
+                                                 (> (input-cursor (parsing-left r))
+                                                    (input-cursor (parsing-left result))))
+                                         (setf result r)))
+                                      ((failure-p r)
+                                       (when (or (failure-p result)
+                                                 (= (length parsers) 1))
+                                         (setf result r)))
+                                      (t (error (format nil "Invalid return value: ~a" r))))))
+                            (if intermediate-parsers
+                              (one-of-rec intermediate-parsers)
+                              result))))
+       (one-of-rec (list ,first-parser ,second-parser ,@other-parsers)))))
 
 (defmacro comp (bindings &body body)
   (if (null bindings)