From 168589c364b434f541abaf2c05915ba67fc0ca5a Mon Sep 17 00:00:00 2001
From: Nathan Braswell <miloignis@gmail.com>
Date: Sun, 18 Oct 2020 20:18:38 -0400
Subject: [PATCH] Finished generic concat, so let-rec properly works now

---
 even_odd.kp   | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++
 new_kraken.kp | 25 +++++++++++++++++--------
 2 files changed, 68 insertions(+), 8 deletions(-)
 create mode 100644 even_odd.kp

diff --git a/even_odd.kp b/even_odd.kp
new file mode 100644
index 0000000..e807a45
--- /dev/null
+++ b/even_odd.kp
@@ -0,0 +1,51 @@
+(do
+    (println "Double")
+    (let-rec (
+        even (lambda (n) (cond (= 0 n) true
+                               (= 1 n) false
+                               true    (odd (- n 1))))
+        odd (lambda (n) (cond (= 0 n) false
+                              (= 1 n) true
+                              true    (even (- n 1))))
+        )
+        (do
+            (println (even 7))
+            (println (even 8))
+            (println (odd 7))
+            (println (odd 8))
+        )
+    )
+
+    (println "Triple")
+    (let-rec (
+        first (lambda (n) (cond (= 0 n) true
+                                (= 1 n) false
+                                (= 2 n) false
+                                true    (third (- n 1))))
+
+        second (lambda (n) (cond (= 0 n) false
+                                 (= 1 n) true
+                                 (= 2 n) false
+                                 true    (first (- n 1))))
+
+        third (lambda (n) (cond (= 0 n) false
+                                (= 1 n) false
+                                (= 2 n) true
+                                true    (second (- n 1))))
+        )
+        (do
+            (println)
+            (println (first 7))
+            (println (first 8))
+            (println (first 9))
+            (println)
+            (println (second 7))
+            (println (second 8))
+            (println (second 9))
+            (println)
+            (println (third 7))
+            (println (third 8))
+            (println (third 9))
+        )
+    )
+)
diff --git a/new_kraken.kp b/new_kraken.kp
index 31ba3e3..fc48681 100644
--- a/new_kraken.kp
+++ b/new_kraken.kp
@@ -9,15 +9,16 @@
                                                (eval (idx s i) se) (recurse recurse s (+ i 1) se)
                                                true                (recurse recurse s (+ i 1) se)))
 (let1 do (vau se (& s) (do_helper do_helper s 0 se))
-
-(let1 concat_helper (lambda (recurse a1 a2 a3 i) (cond (< i (len a1))              (do (set-idx! a3 i (idx a1 i))              (recurse recurse a1 a2 a3 (+ i 1)))
-                                                       (< i (+ (len a1) (len a2))) (do (set-idx! a3 i (idx a2 (- i (len a1)))) (recurse recurse a1 a2 a3 (+ i 1)))
-                                                       true a3))
-(let1 concat (lambda (& as) (concat_helper concat_helper as (array-with-len (lapply + (map len as))) 0))
+(let1 cons (lambda (h t) (let1 a (array-with-len (+ 1 (len t)))
+                         (let1 helper (lambda (recurse d s i) (cond (< i (len s)) (do (set-idx! d (+ i 1) (idx s i))
+                                                                                    (recurse recurse d s (+ i 1)))
+                                                                    true          d))
+                            (do (set-idx! a 0 h)
+                                (helper helper a t 0)))))
 
 (let1 current-env (vau de () de)
-(let1 lapply (lambda (f p)     (eval (concat (array (unwrap f)) p) (current-env)))
-(let1 vapply (lambda (f p ede) (eval (concat (array f)          p) ede))
+(let1 lapply (lambda (f p)     (eval (cons (unwrap f) p) (current-env)))
+(let1 vapply (lambda (f p ede) (eval (cons f          p) ede))
 (let1 Y (lambda (f)
     ((lambda (x) (x x))
      (lambda (x) (f (lambda (& y) (lapply (x x) y))))))
@@ -30,6 +31,7 @@
 
 (let (
         print_through (lambda (x) (do (println x) x))
+
         rec-lambda (vau se (p b) (eval (array Y (array lambda (quote (recurse)) (array lambda p b))) se))
 
         if (vau de (con than & else) (cond (eval con de) (eval than de)
@@ -52,6 +54,13 @@
                                                     (recurse f l n (+ i 1))))))
                  (helper f l (array-with-len (len l)) 0)))
 
+        concat_helper (lambda (recurse as o i j k) (if (< i (len as))
+                                                            (if (< j (len (idx as i))) (do (set-idx! o k  (idx (idx as i) j))
+                                                                                           (recurse recurse as o i (+ j 1) (+ k 1)))
+                                                                                       (recurse recurse as o (+ i 1) 0 k))
+                                                            o))
+        concat (lambda (& as) (concat_helper concat_helper as (array-with-len (lapply + (map len as))) 0 0 0))
+
         filter_i (lambda (f l)
                (let (helper (rec-lambda (f l n i)
                                             (if (= i (len l))
@@ -164,7 +173,7 @@
         )
     )
 )
-))))))))))) ; end of all the let1's
+)))))))))) ; end of all the let1's
 
 ; impl of let1
 )) (vau de (s v b) (eval (array (array vau (quote _) (array s) b) (eval v de)) de)))