((wrap (vau root_env (quote)
((wrap (vau _ (let1)

(let1 lambda (vau se (p b) (wrap (eval (array vau (quote _) p b) se)))

(let1 do_helper (lambda (recurse s i se) (cond (= i (len s)) nil
                                               (= i (- (len s) 1)) (eval (idx s i) se)
                                               (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 (a1 a2) (concat_helper concat_helper a1 a2 (array-with-len (+ (len a1) (len a2))) 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 Y (lambda (f)
    ((lambda (x) (x x))
     (lambda (x) (f (lambda (& y) (lapply (x x) y))))))
(let1 vY (lambda (f)
    ((lambda (x) (x x))
     (lambda (x) (f (vau de (& y) (vapply (x x) y de))))))

(let1 let (vY (lambda (recurse) (vau de (vs b) (cond (= (len vs) 0) (eval b de)
                                                     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))) 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)
            (cond (is_pair? x)
                        (cond (and (symbol? (idx x 0)) (= (get-text (idx x 0)) "unquote"))
                                    (eval (idx x 1) de)
                              true
                                    (cond (and (is_pair? (idx x 0)) (symbol? (idx (idx x 0) 0)) (= (get-text (idx (idx x 0) 0)) "splice-unquote"))
                                                (concat (eval (idx (idx x 0) 1) de) (vapply recurse (array (slice x 1 -1)) de))
                                          true
                                                (concat (array (vapply recurse (array (idx x 0)) de)) (vapply recurse (array (slice x 1 -1)) de))))
                  true x))))
        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
                                quote
                                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
        (println "Welcome to Kraken! Parameters were" *ARGV*)
        (cond (and (>= (len *ARGV*) 3) (= "-C" (idx *ARGV* 1))) (eval (concat scope_let (array (read-string (idx *ARGV* 2)))) root_env)
              (> (len *ARGV*) 1)                                (eval (concat scope_let (array (read-string (slurp (idx *ARGV* 1))))) root_env)
              true                                              (eval (concat scope_let (array (array rep))) root_env)
        )
    )
)
))))))))))) ; 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)))
; impl of quote
)) (vau _ (x) x))