From 23d2c166cd174abeef9c4086d4e208ae42927d7a Mon Sep 17 00:00:00 2001
From: Nathan Braswell <miloignis@gmail.com>
Date: Sat, 19 Sep 2020 12:41:52 -0400
Subject: [PATCH] Basic provide & with_import, fix a rep bug where all but
 first execution was in root_env instead of standard env

---
 new_kraken.kp | 73 +++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 56 insertions(+), 17 deletions(-)

diff --git a/new_kraken.kp b/new_kraken.kp
index e844bdd..abeee4e 100644
--- a/new_kraken.kp
+++ b/new_kraken.kp
@@ -29,9 +29,35 @@
                                                      true (vapply let1 (array (idx vs 0) (idx vs 1) (array recurse (slice vs 2 -1) b)) de)))))
 
 (let (
-        rec-lambda (vau se (p b) (eval (array Y (array lambda (quote (recurse)) (array lambda p b)))))
-        rep (Y (lambda (recurse) (wrap (vau de () (do (println (eval (read-string (get_line "> ")) de))
-                                                      (recurse))))))
+        rec-lambda (vau se (p b) (eval (array Y (array lambda (quote (recurse)) (array lambda p b))) se))
+        rep (vY (lambda (recurse) (wrap (vau de () (do (println (eval (read-string (get_line "> ")) de))
+                                                       (eval (array recurse) de))))))
+
+        if (vau de (con than & else) (cond (eval con de) (eval than de)
+                                           (> (len else) 0) (eval (idx else 0) de)
+                                           true nil))
+
+        map (lambda (f l)
+            (let (helper (rec-lambda (f l n i)
+                                            (if (= i (len l))
+                                                n
+                                                (do (set-idx! n i (f (idx l i)))
+                                                    (recurse f l n (+ i 1))))))
+                 (helper f l (array-with-len (len l)) 0)))
+        flat_map (lambda (f l)
+            (let (helper (rec-lambda (f l n i)
+                                            (if (= i (len l))
+                                                n
+                                                (recurse f l (concat n (f (idx l i))) (+ i 1)))))
+                 (helper f l (array) 0)))
+        map_with_idx (lambda (f l)
+            (let (helper (rec-lambda (f l n i)
+                                            (if (= i (len l))
+                                                n
+                                                (do (set-idx! n i (f i (idx l i)))
+                                                    (recurse f l n (+ i 1))))))
+                 (helper f l (array-with-len (len l)) 0)))
+
         is_pair? (lambda (x) (and (array? x) (> (len x) 0)))
 
         quasiquote (vY (lambda (recurse) (vau de (x)
@@ -44,20 +70,33 @@
                                           true
                                                 (concat (array (vapply recurse (array (idx x 0)) de)) (vapply recurse (array (slice x 1 -1)) de))))
                   true x))))
-        scope_let (quasiquote ((unquote let) (
-                            root_env        (unquote root_env)
-                            lambda          (unquote lambda)
-                            rec-lambda      (unquote rec-lambda)
-                            let             (unquote let)
-                            do              (unquote do)
-                            concat          (unquote concat)
-                            lapply          (unquote lapply)
-                            vapply          (unquote vapply)
-                            Y               (unquote Y)
-                            vY              (unquote vY)
-                            quasiquote      (unquote quasiquote)
-                         )
-                   ))
+        provide (vau de (& items) (array let
+                                         (flat_map (lambda (item) (array item (eval item de))) items)))
+        scope_let_sans_import (provide
+                                root_env
+                                lambda
+                                rec-lambda
+                                let
+                                do
+                                if
+                                concat
+                                map
+                                flat_map
+                                map_with_idx
+                                lapply
+                                vapply
+                                Y
+                                vY
+                                quasiquote
+                                provide
+        )
+        insert_into_scope_let (lambda (scope_let name item) (array (idx scope_let 0) (concat (idx scope_let 1) (array name item))))
+        ; Gotta insert with_import into scope_let via vY combinator so it can use itself
+        with_import (vY (lambda (recurse) (vau de (lib_path code)
+                        (let (imported_scope_let (eval (concat (insert_into_scope_let scope_let_sans_import (quote with_import) recurse)
+                                                               (array (read-string (slurp (eval lib_path de))))) root_env))
+                             (eval (concat imported_scope_let (array code)) de)))))
+        scope_let (insert_into_scope_let scope_let_sans_import (quote with_import) with_import)
     )
 
     (do