chore: don't use defun-ct because it's unnecessary

lens.lisp

@@ -63,11 +63,11 @@
                when (equal key a-key) do
                  (return (car value)))))))
 
-(defun-ct == (target &key (test 'eql))
+(defun == (target &key (test 'eql))
   (lambda (v)
     (funcall test target v)))
 
-(defun-ct deduplicate (&optional (test 'eql))
+(defun deduplicate (&optional (test 'eql))
   (lambda (it)
     (remove-duplicates it :test test)))
 
@@ -93,29 +93,29 @@
   (lambda (acc next)
     (matching-list-reducer test acc next)))
 
-(defun-ct compress-runs (&key (collector 'cons-new) (test 'eql) (key 'identity))
+(defun compress-runs (&key (collector 'cons-new) (test 'eql) (key 'identity))
   (lambda (it)
     (nreverse
      (reduce (funcall collector :test test :key key)
              it
              :initial-value ()))))
 
-(defun-ct of-length (len)
+(defun of-length (len)
   (lambda (it)
     (= (length it)
        len)))
 
-(defun-ct of-min-length (len)
+(defun of-min-length (len)
   (lambda (it)
     (>= (length it)
         len)))
 
-(defun-ct of-max-length (len)
+(defun of-max-length (len)
   (lambda (it)
     (<= (length it)
         len)))
 
-(defun-ct applicable-when (fun test)
+(defun applicable-when (fun test)
   (lambda (it)
     (if (funcall test it)
         (funcall fun it)
@@ -137,16 +137,16 @@
                      fns)))))
 
 
-(defun-ct sorted (comparator &rest r &key key)
+(defun sorted (comparator &rest r &key key)
   (declare (ignore key))
   (lambda (it)
     (apply #'stable-sort (copy-seq it) comparator r)))
 
-(defun-ct element (num)
+(defun element (num)
   (lambda (it)
     (elt it num)))
 
-(defun-ct key (key)
+(defun key (key)
   (lambda (map)
     (declare (dynamic-extent map))
     (extract-key map key)))
@@ -157,19 +157,19 @@
           for cur = (extract-key map key) then (extract-key cur key)
           finally (return cur))))
 
-(defun-ct regex-match (regex)
+(defun regex-match (regex)
   (lambda (data)
     (cl-ppcre:scan-to-strings regex data)))
 
-(defun-ct include (pred)
+(defun include (pred)
   (lambda (seq)
     (remove-if-not pred seq)))
 
-(defun-ct exclude (pred)
+(defun exclude (pred)
   (lambda (seq)
     (remove-if pred seq)))
 
-(defun-ct pick (selector)
+(defun pick (selector)
   (lambda (seq)
     (map 'list selector seq)))
 
@@ -177,13 +177,13 @@
   (lambda (it)
     (subseq it start end)))
 
-(defun-ct update (thing fun &rest args)
+(defun update (thing fun &rest args)
   (apply fun thing args))
 
 (define-modify-macro updatef (fun &rest args)
   update)
 
-(defun-ct suffixp (suffix &key (test 'eql test-p))
+(defun suffixp (suffix &key (test 'eql test-p))
   (lambda (it)
     (if test-p
         (alexandria:ends-with-subseq suffix
@@ -192,7 +192,7 @@
         (alexandria:ends-with-subseq suffix
                                      it))))
 
-(defun-ct transform-head (fun)
+(defun transform-head (fun)
   (lambda (it)
     (typecase it
       (list (list* (funcall fun (car it))
@@ -201,7 +201,7 @@
                 (prog1 result
                   (updatef (elt result 0) fun)))))))
 
-(defun-ct transform-tail (fun)
+(defun transform-tail (fun)
   (lambda (it)
     (typecase it
       (list (list* (car it)
@@ -211,25 +211,25 @@
                   (updatef (subseq result 1)
                            fun)))))))
 
-(defun-ct splice-elt (elt fun)
+(defun splice-elt (elt fun)
   (lambda (it)
     (append (subseq it 0 elt)
             (funcall fun (nth elt it))
             (subseq it (1+ elt)))))
 
-(defun-ct transform-elt (elt fun)
+(defun transform-elt (elt fun)
   (lambda (it)
     (append (subseq it 0 elt)
             (list (funcall fun (nth elt it)))
             (subseq it (1+ elt)))))
 
-(defun-ct key-transform (fun key-get key-set)
+(defun key-transform (fun key-get key-set)
   (lambda (it)
     (let ((key-val (funcall key-get it)))
       (funcall key-set
                (funcall fun key-val)))))
 
-(defun-ct juxt (fun1 &rest r)
+(defun juxt (fun1 &rest r)
   (lambda (&rest args)
     (list* (apply fun1 args)
            (when r
@@ -249,7 +249,7 @@
     (prog1 (funcall fun1 i)
       (funcall fun2))))
 
-(defun-ct derive (diff-fun &key (key #'identity))
+(defun derive (diff-fun &key (key #'identity))
   (lambda (seq)
     (typecase seq
       (list (cons (cons nil (car seq))
@@ -270,12 +270,12 @@
                             else collect (cons nil next))
                       'vector)))))
 
-(defun-ct inc (inc)
+(defun inc (inc)
   (declare (optimize (speed 3)))
   (lambda (base)
     (+ base inc)))
 
-(defun-ct cumsum
+(defun cumsum
     (&key (add-fun #'+) (key #'identity) (combine (lambda (x y) y x)) (zero 0))
   (lambda (seq)
     (nreverse
@@ -291,12 +291,12 @@
              seq
              :initial-value ()))))
 
-(defun-ct over (fun &key (result-type 'list))
+(defun over (fun &key (result-type 'list))
   (let ((fun (functionalize fun)))
     (lambda (seq)
       (map result-type fun seq))))
 
-(defun-ct denest (&key (result-type 'list))
+(defun denest (&key (result-type 'list))
   (lambda (seq)
     (apply #'concatenate result-type
            seq)))
@@ -312,7 +312,7 @@
        (lambda (,seq)
          (apply ,fsym ,@args ,seq)))))
 
-(defun-ct on (fun key)
+(defun on (fun key)
   "Transform arguments with KEY and then apply FUN
 
 > (eql (funcall (on 'equal 'car)
@@ -329,7 +329,7 @@
       (make-sequence 'vector (- length2 length1) :initial-element fill-value)
       #()))
 
-(defun-ct zipping (result-type &key (fill-value nil fill-value-p))
+(defun zipping (result-type &key (fill-value nil fill-value-p))
   (lambda (seq1 seq2)
     (let ((length1 (when fill-value-p (length seq1)))
           (length2 (when fill-value-p (length seq2))))
@@ -346,7 +346,7 @@
         (map result-type #'list
              seq1 seq2)))))
 
-(defun-ct maximizing (relation measure)
+(defun maximizing (relation measure)
   (lambda (it)
     (let ((it-length (length it)))
       (when (> it-length 0)
@@ -361,7 +361,7 @@
                           it
                           (alexandria:iota it-length))))))))
 
-(defun-ct group-by (fn &key (test 'equal))
+(defun group-by (fn &key (test 'equal))
   (lambda (seq)
     (let ((groups (make-hash-table :test test)))
       (map nil