Update lib.lisp to be more imperative and include a threading macro

Instead of (f (g (h (j (k x))))) we can write
(-> (k x)
    (j it)
    (h it)
    (g it)
    (f it))

which is works really well for particularly large and complicated
expressions.

1 files changed, 25 insertions, 15 deletions

diff --git a/2022/lib.lisp b/2022/lib.lisp
index 6c55508..28efbae 100644
--- a/2022/lib.lisp
+++ b/2022/lib.lisp
@@ -10,16 +10,23 @@
   "Splits LST by the first instance of DELIM"
   (let ((pos (position delim lst)))
     (if pos
-        (cons (subseq lst 0 pos) (list (subseq lst (+ pos 1))))
+        (list (subseq lst 0 pos) (subseq lst (+ pos 1)))
         (error (format nil "No instance of ~a was found in ~a" delim lst)))))
 
 (defun split-by-completely (lst delim)
-  (if (or (null lst) (not (cdr lst)))
-      (cons (list (car lst)) nil)
-      (if (member delim lst)
-          (destructuring-bind (first rest) (split-by-first lst delim)
-            (cons first (split-by-completely rest delim)))
-          (list lst))))
+  (cond
+    ((or (null lst) (not (cdr lst)))
+     (list (car lst)))
+    ((not (member delim lst))
+     (list lst))
+    (t
+     (loop
+       for (start rest) = (split-by-first lst delim)
+         then (split-by-first rest delim)
+       collect start
+       if (not (member delim rest))
+         collect rest
+         and do (loop-finish)))))
 
 (defun get-lines (input-string)
   (with-input-from-string (s input-string)
@@ -27,12 +34,15 @@
           while line
           collect line)))
 
-(defun id (x) x)
-
 (defun remove-nth (n lst)
-  (if (or (null lst) (= n 0))
-      (cdr lst)
-      (cons (car lst)
-            (remove-nth
-             (- n 1)
-             (cdr lst)))))
+  (loop for el in lst
+        for i from 0
+        if (not (= i n))
+          collect el))
+
+(defmacro --> (first &rest functions)
+  (let ((builder first))
+    (loop for function in functions
+          do (setq builder `(let ((it ,builder))
+                              ,function)))
+    builder))