From 765d25857b0472e3f9df89ac822ad36ea0502466 Mon Sep 17 00:00:00 2001
From: Jan Tuomi <jans.tuomi@gmail.com>
Date: Tue, 6 Dec 2022 17:50:19 +0200
Subject: Rename stdlib -> core, allow import without .milch suffix

---
 core/common.milch      | 125 +++++++++++++++++++++++++++++++++++++++++++++++++
 core/maybe.milch       |  44 +++++++++++++++++
 examples/aoc22_1.milch |   2 +-
 examples/test.milch    |   6 +--
 src/Interpreter.hs     |   5 +-
 stdlib/common.milch    | 125 -------------------------------------------------
 stdlib/maybe.milch     |  44 -----------------
 7 files changed, 175 insertions(+), 176 deletions(-)
 create mode 100644 core/common.milch
 create mode 100644 core/maybe.milch
 delete mode 100644 stdlib/common.milch
 delete mode 100644 stdlib/maybe.milch

diff --git a/core/common.milch b/core/common.milch
new file mode 100644
index 0000000..f05c6a5
--- /dev/null
+++ b/core/common.milch
@@ -0,0 +1,125 @@
+(let compose (\[f g]
+    (\[x] (f (g x)))))
+
+(let id (\[a] a))
+
+(let mod (\[n k]
+    (- n (* k (/ n k)))))
+
+(let not (\[b]
+    (match b
+        true false
+        false true)))
+
+(let is-even (\[n]
+    (match (mod n 2)
+        0 true
+        1 false)))
+
+(let is-odd (compose not is-even))
+
+;; map :: (a -> b) -> [a] -> [b]
+(let map (\[f lst]
+    (match lst
+        []
+            []
+        otherwise
+            (prepend (f (head lst)) (map f (tail lst))))))
+
+; (map (+ 1) [1 2 3])
+
+;; foldr :: (a -> b -> b) -> b -> [a] -> b
+(let foldr (\[f accumulator lst]
+    (match lst
+        []
+            accumulator
+        otherwise
+            (f (head lst) (foldr f accumulator (tail lst))))))
+
+;; filter :: (a -> Bool) -> [a] -> [a]
+(let filter (\[pred lst]
+    (match lst
+        [] []
+        otherwise (match (pred (head lst))
+            true
+                (prepend (head lst) (filter pred (tail lst)))
+            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))
+    (match v
+        [] a
+        _  (reverse_ xs xa))))
+
+(let reverse (\[v]
+    (reverse_ v [])))
+
+(let flow (\[fs] (foldr compose id (reverse fs))))
+(let pipe (\[x fs] ((flow fs) x)))
+
+(let leq? (\[a b]
+    (or?
+        (eq? a b)
+        (lt? a b))))
+
+(let rt? (compose not leq?))
+(let req? (compose not lt?))
+
+(let max2 (\[a b]
+    (match (lt? a b)
+        true    b
+        false   a)))
+
+(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))
+
+    (match vs
+        []          (match v
+            delim       [(reverse acc)]
+            otherwise   [(prepend v (reverse acc))])
+        otherwise   (match v
+            delim       (prepend (reverse acc) (split-by' delim [] vs))
+            otherwise   (split-by' delim (prepend v acc) vs)))))
+
+; split vector by delimiter
+(let split-by (\[delim vals]
+    (split-by' delim [] vals)))
+
+(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/core/maybe.milch b/core/maybe.milch
new file mode 100644
index 0000000..ef9e906
--- /dev/null
+++ b/core/maybe.milch
@@ -0,0 +1,44 @@
+; LIB
+
+(record Maybe/Just value)
+(record Maybe/Nothing)
+
+(let Maybe/just Maybe/Just/create)
+(let Maybe/nothing Maybe/Nothing/create)
+
+(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]
+    (match (kind m)
+        "Maybe/Just" (f (Maybe/Just/get-value m))
+        "Maybe/Nothing" (Maybe/nothing))))
+
+; TESTING
+
+;; (let print-line! (\[s]
+;;     (print! (concat s "\n"))))
+
+;; (let a (Maybe/just 10))
+;; (let b (Maybe/nothing))
+
+;; (Maybe/map (+ 5) a)
+;; (Maybe/map (+ 5) b)
+
+;; (Maybe/and-then (\[n] (Maybe/just (+ n 5))) a)
+;; (Maybe/and-then (\[n] (Maybe/just (+ n 5))) b)
+
+;; (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))
+;; (pipe m [
+;;     (Maybe/map (+ 5))
+;;     (Maybe/and-then (\[val] (Maybe/just (- val 3))))
+;; ])
diff --git a/examples/aoc22_1.milch b/examples/aoc22_1.milch
index 7a4520a..becdaee 100644
--- a/examples/aoc22_1.milch
+++ b/examples/aoc22_1.milch
@@ -1,4 +1,4 @@
-(import "stdlib/common.milch")
+(import "core/common.milch")
 
 ;; utils
 
diff --git a/examples/test.milch b/examples/test.milch
index d8d0077..a8225b1 100644
--- a/examples/test.milch
+++ b/examples/test.milch
@@ -1,11 +1,7 @@
-(import "stdlib/common.milch")
+(import "core/common")
 
 (map (+ 1) [1 2 3])
-
 (foldr + 0 [1 2 3])
-
 (filter is-even [0 1 2 3 4 5])
-
 (reverse [1 2 3])
-
 (pipe 10 [(+ 1) (+ 2)])
diff --git a/src/Interpreter.hs b/src/Interpreter.hs
index de77fc9..f9e00b9 100644
--- a/src/Interpreter.hs
+++ b/src/Interpreter.hs
@@ -217,7 +217,10 @@ evaluateImport asts = do
     case args of
         -- non-qualified import
         [AST { astNode = ASTString path }] -> do
-            LState { stateEnv = evaledRawEnv } <- lift $ execStateT (runScriptFile path) initialState
+            let checkedPath = if (not $ ".milch" `L.isSuffixOf` path)
+                then (path ++ ".milch")
+                else path
+            LState { stateEnv = evaledRawEnv } <- lift $ execStateT (runScriptFile checkedPath) initialState
             let exportedEnvMap = envThis evaledRawEnv
 
             env <- getEnv
diff --git a/stdlib/common.milch b/stdlib/common.milch
deleted file mode 100644
index f05c6a5..0000000
--- a/stdlib/common.milch
+++ /dev/null
@@ -1,125 +0,0 @@
-(let compose (\[f g]
-    (\[x] (f (g x)))))
-
-(let id (\[a] a))
-
-(let mod (\[n k]
-    (- n (* k (/ n k)))))
-
-(let not (\[b]
-    (match b
-        true false
-        false true)))
-
-(let is-even (\[n]
-    (match (mod n 2)
-        0 true
-        1 false)))
-
-(let is-odd (compose not is-even))
-
-;; map :: (a -> b) -> [a] -> [b]
-(let map (\[f lst]
-    (match lst
-        []
-            []
-        otherwise
-            (prepend (f (head lst)) (map f (tail lst))))))
-
-; (map (+ 1) [1 2 3])
-
-;; foldr :: (a -> b -> b) -> b -> [a] -> b
-(let foldr (\[f accumulator lst]
-    (match lst
-        []
-            accumulator
-        otherwise
-            (f (head lst) (foldr f accumulator (tail lst))))))
-
-;; filter :: (a -> Bool) -> [a] -> [a]
-(let filter (\[pred lst]
-    (match lst
-        [] []
-        otherwise (match (pred (head lst))
-            true
-                (prepend (head lst) (filter pred (tail lst)))
-            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))
-    (match v
-        [] a
-        _  (reverse_ xs xa))))
-
-(let reverse (\[v]
-    (reverse_ v [])))
-
-(let flow (\[fs] (foldr compose id (reverse fs))))
-(let pipe (\[x fs] ((flow fs) x)))
-
-(let leq? (\[a b]
-    (or?
-        (eq? a b)
-        (lt? a b))))
-
-(let rt? (compose not leq?))
-(let req? (compose not lt?))
-
-(let max2 (\[a b]
-    (match (lt? a b)
-        true    b
-        false   a)))
-
-(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))
-
-    (match vs
-        []          (match v
-            delim       [(reverse acc)]
-            otherwise   [(prepend v (reverse acc))])
-        otherwise   (match v
-            delim       (prepend (reverse acc) (split-by' delim [] vs))
-            otherwise   (split-by' delim (prepend v acc) vs)))))
-
-; split vector by delimiter
-(let split-by (\[delim vals]
-    (split-by' delim [] vals)))
-
-(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.milch b/stdlib/maybe.milch
deleted file mode 100644
index ef9e906..0000000
--- a/stdlib/maybe.milch
+++ /dev/null
@@ -1,44 +0,0 @@
-; LIB
-
-(record Maybe/Just value)
-(record Maybe/Nothing)
-
-(let Maybe/just Maybe/Just/create)
-(let Maybe/nothing Maybe/Nothing/create)
-
-(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]
-    (match (kind m)
-        "Maybe/Just" (f (Maybe/Just/get-value m))
-        "Maybe/Nothing" (Maybe/nothing))))
-
-; TESTING
-
-;; (let print-line! (\[s]
-;;     (print! (concat s "\n"))))
-
-;; (let a (Maybe/just 10))
-;; (let b (Maybe/nothing))
-
-;; (Maybe/map (+ 5) a)
-;; (Maybe/map (+ 5) b)
-
-;; (Maybe/and-then (\[n] (Maybe/just (+ n 5))) a)
-;; (Maybe/and-then (\[n] (Maybe/just (+ n 5))) b)
-
-;; (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))
-;; (pipe m [
-;;     (Maybe/map (+ 5))
-;;     (Maybe/and-then (\[val] (Maybe/just (- val 3))))
-;; ])
-- 
cgit v1.3