function renames and overloading

1 files changed, 28 insertions, 15 deletions

diff --git a/libs/sort.neb b/libs/sort.neb
index 081a678..66336e8 100644
--- a/libs/sort.neb
+++ b/libs/sort.neb
@@ -5,9 +5,9 @@
     (def orig lst)
     (def working (list))
     (def swp #false)
-    (for-count (list-length lst)
+    (for-count (length lst)
         (branch
-            ((eq? 0 (list-length (rest orig)))
+            ((eq? 0 (length (rest orig)))
                 (redef working (append working (first orig))))
             ((> (first orig) (first (rest orig)))
                 (block
@@ -46,15 +46,28 @@
         (append (take-while lst (strcmp _item_ item)) item)
         (drop-while lst (strcmp _item_ item))))
 
+; TODO closures don't work yet
+(func .insert-maker (cmp)
+    (lambda (lst item)
+        (extend-reduce
+            (append (take-while lst (cmp _item_ item)) item)
+            (drop-while lst (cmp _item_ item)))))
+
 ;(func insertion-reduce (lst)
 ;    (reduce insert lst (list)))
 
-(func insertion-strings (lst)
+(func .insertion-strings (lst)
     (reduce .insert-string lst (list)))
 
-(func insertion-nums (lst)
+(func .insertion-nums (lst)
     (reduce .insert-num lst (list)))
 
+(func insertion (lst :[:string])
+    (insertion-strings lst))
+
+(func insertion (lst :[:number])
+    (insertion-nums lst))
+
 (func insertion-iter (lst)
     (def ret (list))
     (for-each lst
@@ -64,10 +77,10 @@
 
 (func merge (lst)
     (print (concat "sorting: " (->string lst)))
-    (if (eq? 1 (list-length lst))
+    (if (eq? 1 (length lst))
         lst
         (block
-            (def half (floor (/ (list-length lst) 2)))
+            (def half (floor (/ (length lst) 2)))
             (def left (merge (slice lst 1 half)))
             (def right (merge (slice lst (+ 1 half))))
             (.merge left right))))
@@ -97,11 +110,11 @@
 
 (func quick (lst)
     (branch
-        ((eq? 1 (list-length lst)) lst)
-        ((eq? 2 (list-length lst))
+        ((<= (length lst) 1) lst)
+        ((eq? 2 (length lst))
             (if (<= (first lst) (first (rest lst)))
                 lst
-                (list-reverse lst)))
+                (reverse lst)))
         (#true
             (block
                 ; 1. pick the last element as a pivot
@@ -112,7 +125,7 @@
                 ;   > once there's nothing left to consider, run quicksort on the beginning and the end, and put the pivot in the middle
                 (def before (list))
                 (def after (list))
-                (def consider (list-reverse (rest (list-reverse lst))))
+                (def consider (reverse (rest (reverse lst))))
                 (def pivot (last lst))
                 (while (not (empty? consider))
                     (if (<= (first consider) pivot)
@@ -121,10 +134,10 @@
                             (redef consider (rest consider)))
                         (block
                             (redef after (prepend after (first consider)))
-                            (if (eq? 1 (list-length consider))
+                            (if (eq? 1 (length consider))
                                 (redef consider (list))
                             (redef consider
-                                (prepend (list-reverse (rest (list-reverse (rest consider)))) (last consider))))))
+                                (prepend (reverse (rest (reverse (rest consider)))) (last consider))))))
                     (print (concat "before: " (->string before)))
                     (print (concat "after: " (->string after)))
                     (print (concat "consider: " (->string consider))))
@@ -136,8 +149,8 @@
             (eq? 0 (length left))
             (eq? 0 (length right)))
                 (<= (length left) (length right)))
-        ((eq? (first-char left) (first-char right))
-            (strcmp (rest-char left) (rest-char right)))
+        ((eq? (first left) (first right))
+            (strcmp (rest left) (rest right)))
         (#true
-            (<= (ord (first-char left)) (ord (first-char right))))))
+            (<= (ord (first left)) (ord (first right))))))