chore: don't depend on serapeum, other cleanup

data-lens+fset.asd

@@ -5,8 +5,7 @@
   :license "Apache v2"
   :depends-on (:data-lens
                :data-lens/transducers
-               :fset
-               :named-readtables)
+               :fset)
   :serial t
   :in-order-to ((test-op (test-op :data-lens/test)))
   :components ((:file "data-lens-fset")))

data-lens-fset.lisp

@@ -94,7 +94,7 @@
 (defmethod data-lens.transducers.internals:stepper ((bag (eql 'fset-bag-builder)))
   (data-lens.transducers:transducer-lambda
     ((acc next)
-     (:printv (fset:with acc next)))))
+     (fset:with acc next))))
 (defmethod data-lens:functionalize ((it fset:bag))
   (lambda (key)
     (fset:multiplicity it key)))

data-lens.asd

@@ -23,8 +23,7 @@
   :license "Apache v2"
   :depends-on (:data-lens
                :fiveam
-               :string-case
-               :serapeum)
+               :string-case)
   :serial t
   :perform (test-op (o c)
                     (unless (symbol-call :fiveam '#:run! :data-lens.lens)
@@ -38,8 +37,7 @@
   :author "Edward Langley <el-cl@elangley.org>"
   :license "Apache v2"
   :depends-on (:data-lens
-               :alexandria
-               :serapeum)
+               :alexandria)
   :serial t
   :in-order-to ((test-op (test-op :data-lens/transducers/test)))
   :components ((:file "package")

lazy-sequence.lisp

@@ -29,6 +29,11 @@
        (lambda ()
          v))))
 
+(defun unsplice (form)
+  (if form
+      (list form)
+      nil))
+
 (defun iota (&key (start 0) (step 1) count)
   (lazy-sequence
    (funcall
@@ -36,14 +41,14 @@
              `(lambda ()
                 (declare (optimize (speed 3) (debug 1) (safety 1)))
                 (let ((init ,start)
-                      ,@(serapeum:unsplice (when count
-                                             '(iterations 0))))
+                      ,@(unsplice (when count
+                                    '(iterations 0))))
                   (declare (type (integer ,start
                                           ,(if count
                                                (+ start (* count step))
                                                '*))
                                  init)
-                           ,@(serapeum:unsplice
+                           ,@(unsplice
                               (when count
                                 `(type (integer 0 ,count) iterations))))
                   (lambda ()
@@ -53,6 +58,6 @@
                            '(progn))
                      (prog1 init
                        (incf init ,step)
-                       ,@(serapeum:unsplice
+                       ,@(unsplice
                           (when count
                             '(incf iterations))))))))))))

t/lens.lisp

@@ -183,12 +183,22 @@
                                              (acons "c" (make-instance 'my-map) ())
                                              :test 'equal))))))))
 
+(defun eqq (a b)
+  (typecase a
+    (string (equal a b))
+    (vector (and (vectorp b)
+                 (= (length a) (length b))
+                 (every 'eqq a b)))
+    (cons (and (consp b)
+               (eqq (car a) (car b))
+               (eqq (cdr a) (cdr b))))
+    (t (eql a b))))
+
 (5am:def-test regex-match (:suite :data-lens.lens)
-  (5am:is (serapeum:seq=
-           (list "acb" #("c"))
-           (multiple-value-list
-            (funcall (data-lens:regex-match "a(.)b")
-                     "<acb>")))))
+  (5am:is (eqq (list "acb" #("c"))
+               (multiple-value-list
+                (funcall (data-lens:regex-match "a(.)b")
+                         "<acb>")))))
 
 (5am:def-test include (:suite :data-lens.lens)
   (5am:is (equal '(1 3 5)

t/transducers.lisp

@@ -1,6 +1,6 @@
 (defpackage :data-lens.t.transducers
-  (:use :cl )
-  (:export ))
+  (:use :cl)
+  (:export))
 (in-package :data-lens.t.transducers)
 
 (5am:def-suite :data-lens.transducers)
@@ -182,7 +182,8 @@
                   (data-lens.transducers:catting)
                   (data-lens.transducers:mapping #'parse-integer)
                   (data-lens.transducers:filtering (complement #'evenp))
-                  (data-lens.transducers:splitting (serapeum:op (* 2 _)) #'identity)
+                  (data-lens.transducers:splitting (lambda (_) (* 2 _))
+                                                   #'identity)
                   (data-lens.transducers:mapping (data-lens:transform-head #'1+))
                   (data-lens.transducers:taking 3))
                  'data-lens.transducers:hash-table-builder