fix: ON was defined incorrectly

.github/workflows/test.yml

@@ -48,10 +48,11 @@ jobs:
       - name: run tests
         run: |
           cd "$GITHUB_WORKSPACE"
-          sbcl --load "$HOME/quicklisp/setup.lisp" \
+          sbcl --disable-debugger --no-userinit \
+               --load "$HOME/quicklisp/setup.lisp" \
                --eval "(mapcar 'asdf:load-asd (directory \"*.asd\"))" \
                --eval "(ql:quickload :data-lens/test)" \
-               --eval "(asdf:test-system :data-lens/test)" \
+               --eval "(handler-case (asdf:test-system :data-lens/test) (error () (uiop:quit 42)))" \
                --eval "(ql:quickload :data-lens/transducers/test)" \
-               --eval "(asdf:test-system :data-lens/transducers/test)" \
+               --eval "(handler-case (asdf:test-system :data-lens/transducers/test) (error () (uiop:quit 43)))" \
                --quit

data-lens.asd

@@ -22,7 +22,9 @@
   :depends-on (:data-lens
                :fiveam)
   :serial t
-  :perform (test-op (o c) (symbol-call :fiveam '#:run! :data-lens.lens))
+  :perform (test-op (o c)
+                    (unless (symbol-call :fiveam '#:run! :data-lens.lens)
+                      (error "some tests failed")))
   :components ((:module "t"
                 :components ((:file "lens")))))
 
@@ -49,6 +51,6 @@
                :fiveam)
   :serial t
   :perform (test-op (o c) (unless (symbol-call :fiveam '#:run! :data-lens.transducers)
-                            (quit 42)))
+                            (error "some tests failed")))
   :components ((:module "t"
                 :components ((:file "transducers")))))

lens.lisp

@@ -111,6 +111,21 @@
         (funcall fun it)
         it)))
 
+(defmacro conj (&rest fns)
+  (let ((dat (gensym "dat")))
+    `(lambda (,dat)
+       (and ,@(mapcar (lambda (fn)
+                        `(funcall ,fn ,dat))
+                      fns)))))
+
+(defmacro disj (&rest fns)
+  (let ((dat (gensym "dat")))
+    `(lambda (,dat)
+       (or ,@(mapcar (lambda (fn)
+                       `(funcall ,fn ,dat))
+                     fns)))))
+
+
 (defun-ct sorted (comparator &rest r &key key)
   (declare (ignore key))
   (lambda (it)
@@ -284,7 +299,7 @@
   (let ((fun (functionalize fun))
         (key (functionalize key)))
     (lambda (&rest its)
-      (funcall fun (mapcar key its)))))
+      (apply fun (mapcar key its)))))
 
 (defun filler (length1 length2 fill-value)
   (if (< length1 length2)

package.lisp

@@ -16,25 +16,25 @@
            #:defun-ct #:key #:extract-key #:element #:let-fn #:juxt
            #:transform-tail #:slice #:compress-runs
            #:combine-matching-lists #:sorted #:applicable-when
-           #:of-length #:of-min-length #:of-max-length #:transform-head
+           #:of-length #:of-min-length #:of-max-length
-           #:maximizing #:zipping #:applying #:splice-elt
+           #:transform-head #:maximizing #:zipping #:applying
-           #:transform-elt #:denest #:op #:defalias #:<> #:<>1 #:== #:•
+           #:splice-elt #:transform-elt #:denest #:op #:defalias #:<>
-           #:suffixp #:functionalize #:inc #:group-by #:keys))
+           #:<>1 #:== #:• #:suffixp #:functionalize #:inc #:group-by
+           #:keys #:conj #:disj))
 
 (defpackage :data-lens.transducers.internals
   (:use :cl)
   (:export #:unwrap #:init #:reduce-generic #:stepper #:transduce
-           #:exit-early #:into
+           #:exit-early #:into #:builder-for-input))
-           #:builder-for-input))
 
 (defpackage :data-lens.transducers
   (:use :cl)
-  (:import-from #:data-lens.transducers.internals
+  (:import-from #:data-lens.transducers.internals #:unwrap #:init
-                #:unwrap #:init #:reduce-generic #:stepper #:transduce
+                #:reduce-generic #:stepper #:transduce #:exit-early
-                #:exit-early #:into)
+                #:into)
   (:export #:mapping #:filtering #:deduping #:catting #:splitting
            #:exit-early #:taking #:dropping #:transduce
            #:hash-table-builder #:vector-builder #:list-builder
-           #:collecting #:mv-mapping #:mv-selecting :hash-table-select
+           #:collecting #:mv-mapping #:mv-selecting #:hash-table-select
-           #:mv-filtering #:mapcatting :lazy-sequence
+           #:mv-filtering #:mapcatting #:lazy-sequence
-           #:compressing-runs #:iota :repeating #:repeating* #:into))
+           #:compressing-runs #:iota #:repeating #:repeating* #:into))

t/lens.lisp

@@ -0,0 +1,58 @@
+(defpackage :data-lens.t.lens
+  (:use :cl )
+  (:export ))
+(in-package :data-lens.t.lens)
+
+(5am:def-suite :data-lens.lens)
+(5am:in-suite :data-lens.lens)
+
+(5am:def-test == (:suite :data-lens.lens)
+  (5am:is (equal t
+                 (funcall (data-lens:== 1)
+                          1)))
+  (5am:is (equal nil
+                 (funcall (data-lens:== (list "1"))
+                          (list "1"))))
+  (5am:is (equal t
+                 (funcall (data-lens:== (list "1") :test #'equal)
+                          (list "1")))))
+
+(5am:def-test functionalize (:suite :data-lens.lens)
+  (5am:is (equal 2
+                 (funcall (data-lens:functionalize #'1+) 1)))
+  (5am:is (equal 0
+                 (funcall (data-lens:functionalize '1-) 1)))
+  (5am:is (equal 3
+                 (funcall (data-lens:functionalize #(0 3)) 1)))
+  (5am:is (equal 8
+                 (funcall (data-lens:functionalize
+                           (alexandria:plist-hash-table '(1 8 2 4)))
+                          1))))
+
+(5am:def-test on (:suite :data-lens.lens :depends-on (and functionalize))
+  (5am:is (equal 2
+                 (funcall (data-lens:on '1+ 'car)
+                          '(1 2))))
+  (5am:is (equal 5
+                 (funcall (data-lens:on '+ 'car)
+                          '(1 2)
+                          '(4 5))))
+  (5am:is (equal 13
+                 (funcall (data-lens:on '+ 'car)
+                          '(1 2)
+                          '(4 5)
+                          '(8 9)))))
+
+(5am:def-test over (:suite :data-lens.lens :depends-on (and functionalize))
+  (5am:is (equal '(1 2 3)
+                 (funcall (data-lens:over '1+)
+                          '(0 1 2))))
+  (5am:is (equal '(1 2 3)
+                 (funcall (data-lens:over '1+)
+                          #(0 1 2))))
+  (5am:is (equalp #(1 2 3)
+                  (funcall (data-lens:over '1+ :result-type 'vector)
+                           '(0 1 2))))
+  (5am:is (equalp #(1 2 3)
+                  (funcall (data-lens:over '1+ :result-type 'vector)
+                           #(0 1 2)))))