Remove ! from end of builtin top-level functions

3 files changed, 70 insertions, 46 deletions

diff --git a/stdlib/common.milch b/stdlib/common.milch
index b69452e..f05c6a5 100644
--- a/stdlib/common.milch
+++ b/stdlib/common.milch
@@ -1,25 +1,25 @@
-(let! compose (\[f g]
+(let compose (\[f g]
     (\[x] (f (g x)))))
 
-(let! id (\[a] a))
+(let id (\[a] a))
 
-(let! mod (\[n k]
+(let mod (\[n k]
     (- n (* k (/ n k)))))
 
-(let! not (\[b]
+(let not (\[b]
     (match b
         true false
         false true)))
 
-(let! is-even (\[n]
+(let is-even (\[n]
     (match (mod n 2)
         0 true
         1 false)))
 
-(let! is-odd (compose not is-even))
+(let is-odd (compose not is-even))
 
 ;; map :: (a -> b) -> [a] -> [b]
-(let! map (\[f lst]
+(let map (\[f lst]
     (match lst
         []
             []
@@ -29,7 +29,7 @@
 ; (map (+ 1) [1 2 3])
 
 ;; foldr :: (a -> b -> b) -> b -> [a] -> b
-(let! foldr (\[f accumulator lst]
+(let foldr (\[f accumulator lst]
     (match lst
         []
             accumulator
@@ -37,7 +37,7 @@
             (f (head lst) (foldr f accumulator (tail lst))))))
 
 ;; filter :: (a -> Bool) -> [a] -> [a]
-(let! filter (\[pred lst]
+(let filter (\[pred lst]
     (match lst
         [] []
         otherwise (match (pred (head lst))
@@ -46,44 +46,44 @@
             false
                 (filter pred (tail lst))))))
 
-(let! reverse_ (\[v a]
-    (let! lazy x (head v))
-    (let! lazy xs (tail v))
-    (let! lazy xa (prepend x a))
+(let reverse_ (\[v a]
+    (let lazy x (head v))
+    (let lazy xs (tail v))
+    (let lazy xa (prepend x a))
     (match v
         [] a
         _  (reverse_ xs xa))))
 
-(let! reverse (\[v]
+(let reverse (\[v]
     (reverse_ v [])))
 
-(let! flow (\[fs] (foldr compose id (reverse fs))))
-(let! pipe (\[x fs] ((flow fs) x)))
+(let flow (\[fs] (foldr compose id (reverse fs))))
+(let pipe (\[x fs] ((flow fs) x)))
 
-(let! leq? (\[a b]
+(let leq? (\[a b]
     (or?
         (eq? a b)
         (lt? a b))))
 
-(let! rt? (compose not leq?))
-(let! req? (compose not lt?))
+(let rt? (compose not leq?))
+(let req? (compose not lt?))
 
-(let! max2 (\[a b]
+(let max2 (\[a b]
     (match (lt? a b)
         true    b
         false   a)))
 
-(let! max (\[vals]
-    (let! lazy v (head vals))
-    (let! vs (tail vals))
+(let max (\[vals]
+    (let lazy v (head vals))
+    (let vs (tail vals))
 
     (match vs
         []          v
         otherwise   (max2 v (max vs)))))
 
-(let! split-by' (\[delim acc vals]
-    (let! lazy v (head vals))
-    (let! vs (tail vals))
+(let split-by' (\[delim acc vals]
+    (let lazy v (head vals))
+    (let vs (tail vals))
 
     (match vs
         []          (match v
@@ -94,8 +94,32 @@
             otherwise   (split-by' delim (prepend v acc) vs)))))
 
 ; split vector by delimiter
-(let! split-by (\[delim vals]
+(let split-by (\[delim vals]
     (split-by' delim [] vals)))
 
-(let! print-fmt! (\![fstr args]
+(let at (\[n seq]
+    (match seq
+        []          (fatal! (fmt "at out of bounds, n: {0}" [n]))
+        otherwise   (match n
+            0           (head seq)
+            otherwise   (at (- n 1) (tail seq))))))
+
+(let print-fmt! (\![fstr args]
     (print! (fmt fstr args))))
+
+(let sort-by (\[keyf vals]
+    (let sorted (sort-by-first
+        (map (\[v]
+            [(keyf v) v]) vals)))
+
+    (map (at 1) sorted)))
+
+(let take (\[n xs]
+    (match n
+        0          []
+        otherwise  (prepend (head xs) (take (- n 1) (tail xs))))))
+
+(let drop (\[n xs]
+    (match n
+        0          xs
+        otherwise  (drop (- n 1) (tail xs)))))
diff --git a/stdlib/maybe-with-unions.milch b/stdlib/maybe-with-unions.milch
index 53a5024..8a15471 100644
--- a/stdlib/maybe-with-unions.milch
+++ b/stdlib/maybe-with-unions.milch
@@ -4,23 +4,23 @@
     (just value)
     (nothing))
 
-(let! Maybe/map (\[f m]
+(let Maybe/map (\[f m]
     (match (kind m)
         "Maybe/Just" (Maybe/just (f (Maybe/Just/get-value m)))
         "Maybe/Nothing" (Maybe/nothing))))
 
-(let! Maybe/and-then (\[f m]
+(let Maybe/and-then (\[f m]
     (match (kind m)
         "Maybe/Just" (f (Maybe/Just/get-value m))
         "Maybe/Nothing" (Maybe/nothing))))
 
 ; TESTING
 
-;; (let! print-line! (\[s]
+;; (let print-line! (\[s]
 ;;     (print! (concat s "\n"))))
 
-;; (let! a (Maybe/just 10))
-;; (let! b (Maybe/nothing))
+;; (let a (Maybe/just 10))
+;; (let b (Maybe/nothing))
 
 ;; (Maybe/map (+ 5) a)
 ;; (Maybe/map (+ 5) b)
@@ -28,14 +28,14 @@
 ;; (Maybe/and-then (\[n] (Maybe/just (+ n 5))) a)
 ;; (Maybe/and-then (\[n] (Maybe/just (+ n 5))) b)
 
-;; (let! m (Maybe/just 10))
+;; (let m (Maybe/just 10))
 ;; (match m
 ;;     (Maybe/just _)
 ;;         (print-line! (fmt "found just {0}!" [(Maybe/Just/get-value m)]))
 ;;     (Maybe/nothing)
 ;;         (print-line! "found nothing!"))
 
-;; (let! m (Maybe/just 10))
+;; (let m (Maybe/just 10))
 ;; (pipe m [
 ;;     (Maybe/map (+ 5))
 ;;     (Maybe/and-then (\[val] (Maybe/just (- val 3))))
diff --git a/stdlib/maybe.milch b/stdlib/maybe.milch
index 086b0dc..4114e22 100644
--- a/stdlib/maybe.milch
+++ b/stdlib/maybe.milch
@@ -1,11 +1,11 @@
 ; LIB
 
-(let! Maybe/just (\[a]
+(let Maybe/just (\[a]
     ["Maybe" "just" a]))
-(let! Maybe/nothing (\[]
+(let Maybe/nothing (\[]
     ["Maybe" "nothing"]))
 
-(let! Maybe/#at (\[n seq]
+(let Maybe/#at (\[n seq]
     (match seq
         []
             (fatal! "Maybe/#at out of bounds")
@@ -16,26 +16,26 @@
                 otherwise
                     (Maybe/#at (- n 1) (tail seq))))))
 
-(let! Maybe/unpack (Maybe/#at 2))
-(let! Maybe/kind (Maybe/#at 1))
+(let Maybe/unpack (Maybe/#at 2))
+(let Maybe/kind (Maybe/#at 1))
 
-(let! Maybe/map (\[f m]
+(let Maybe/map (\[f m]
     (match (Maybe/kind m)
         "just" (Maybe/just (f (Maybe/unpack m)))
         "nothing" (Maybe/nothing))))
 
-(let! Maybe/and-then (\[f m]
+(let Maybe/and-then (\[f m]
     (match (Maybe/kind m)
         "just" (f (Maybe/unpack m))
         "nothing" (Maybe/nothing))))
 
 ; TESTING
 
-;; (let! print-line! (\[s]
+;; (let print-line! (\[s]
 ;;     (print! (concat s "\n"))))
 
-;; (let! a (Maybe/just 10))
-;; (let! b (Maybe/nothing))
+;; (let a (Maybe/just 10))
+;; (let b (Maybe/nothing))
 
 ;; (Maybe/map (+ 5) a)
 ;; (Maybe/map (+ 5) b)
@@ -43,7 +43,7 @@
 ;; (Maybe/and-then (\[n] (Maybe/just (+ n 5))) a)
 ;; (Maybe/and-then (\[n] (Maybe/just (+ n 5))) b)
 
-;; (let! m (Maybe/just 10))
+;; (let m (Maybe/just 10))
 ;; (match m
 ;;     (Maybe/just _)
 ;;         (print-line! (fmt "found just {0}!" [(Maybe/unpack m)]))