((wrap (vau root_env (quote) ((wrap (vau (let1) (let1 lambda (vau se (p b1) (wrap (eval (array vau p b1) se))) (let1 current-env (vau de () de) (let1 cons (lambda (h t) (concat (array h) t)) (let1 Y (lambda (f3) ((lambda (x1) (x1 x1)) (lambda (x2) (f3 (wrap (vau app_env (& y) (lapply (x2 x2) y app_env))))))) (let1 vY (lambda (f) ((lambda (x3) (x3 x3)) (lambda (x4) (f (vau de1 (& y) (vapply (x4 x4) y de1)))))) (let1 let (vY (lambda (recurse) (vau de2 (vs b) (cond (= (len vs) 0) (eval b de2) true (vapply let1 (array (idx vs 0) (idx vs 1) (array recurse (slice vs 2 -1) b)) de2))))) (let ( lcompose (lambda (g f) (lambda (& args) (lapply g (array (lapply f args))))) rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se)) if (vau de (con than & else) (eval (array cond con than true (cond (> (len else) 0) (idx else 0) true false)) de)) map (lambda (f5 l5) (let (helper (rec-lambda recurse (f4 l4 n4 i4) (cond (= i4 (len l4)) n4 (<= i4 (- (len l4) 4)) (recurse f4 l4 (concat n4 (array (f4 (idx l4 (+ i4 0))) (f4 (idx l4 (+ i4 1))) (f4 (idx l4 (+ i4 2))) (f4 (idx l4 (+ i4 3))) )) (+ i4 4)) true (recurse f4 l4 (concat n4 (array (f4 (idx l4 i4)))) (+ i4 1))))) (helper f5 l5 (array) 0))) map_i (lambda (f l) (let (helper (rec-lambda recurse (f l n i) (cond (= i (len l)) n (<= i (- (len l) 4)) (recurse f l (concat n (array (f (+ i 0) (idx l (+ i 0))) (f (+ i 1) (idx l (+ i 1))) (f (+ i 2) (idx l (+ i 2))) (f (+ i 3) (idx l (+ i 3))) )) (+ i 4)) true (recurse f l (concat n (array (f i (idx l i)))) (+ i 1))))) (helper f l (array) 0))) filter_i (lambda (f l) (let (helper (rec-lambda recurse (f l n i) (if (= i (len l)) n (if (f i (idx l i)) (recurse f l (concat n (array (idx l i))) (+ i 1)) (recurse f l n (+ i 1)))))) (helper f l (array) 0))) filter (lambda (f l) (filter_i (lambda (i x) (f x)) l)) ; Huge thanks to Oleg Kiselyov for his fantastic website ; http://okmij.org/ftp/Computation/fixed-point-combinators.html Y* (lambda (& l) ((lambda (u) (u u)) (lambda (p) (map (lambda (li) (lambda (& x) (lapply (lapply li (p p)) x))) l)))) vY* (lambda (& l) ((lambda (u) (u u)) (lambda (p) (map (lambda (li) (vau ide (& x) (vapply (lapply li (p p)) x ide))) l)))) let-rec (vau de (name_func body) (let (names (filter_i (lambda (i x) (= 0 (% i 2))) name_func) funcs (filter_i (lambda (i x) (= 1 (% i 2))) name_func) overwrite_name (idx name_func (- (len name_func) 2))) (eval (array let (concat (array overwrite_name (concat (array Y*) (map (lambda (f) (array lambda names f)) funcs))) (lapply concat (map_i (lambda (i n) (array n (array idx overwrite_name i))) names))) body) de))) let-vrec (vau de (name_func body) (let (names (filter_i (lambda (i x) (= 0 (% i 2))) name_func) funcs (filter_i (lambda (i x) (= 1 (% i 2))) name_func) overwrite_name (idx name_func (- (len name_func) 2))) (eval (array let (concat (array overwrite_name (concat (array vY*) (map (lambda (f) (array lambda names f)) funcs))) (lapply concat (map_i (lambda (i n) (array n (array idx overwrite_name i))) names))) body) de))) flat_map (lambda (f l) (let (helper (rec-lambda recurse (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))) flat_map_i (lambda (f l) (let (helper (rec-lambda recurse (f l n i) (if (= i (len l)) n (recurse f l (concat n (f i (idx l i))) (+ i 1))))) (helper f l (array) 0))) ; with all this, we make a destrucutring-capable let let (let ( destructure_helper (rec-lambda recurse (vs i r) (cond (= (len vs) i) r (array? (idx vs i)) (let (bad_sym (str-to-symbol (str (idx vs i))) new_vs (flat_map_i (lambda (i x) (array x (array idx bad_sym i))) (idx vs i)) ) (recurse (concat new_vs (slice vs (+ i 2) -1)) 0 (concat r (array bad_sym (idx vs (+ i 1)))))) true (recurse vs (+ i 2) (concat r (slice vs i (+ i 2)))) ))) (vau de (vs b) (vapply let (array (destructure_helper vs 0 (array)) b) de))) ; and a destructuring-capable lambda! only_symbols (rec-lambda recurse (a i) (cond (= i (len a)) true (symbol? (idx a i)) (recurse a (+ i 1)) true false)) ; Note that if macro_helper is inlined, the mapping lambdas will close over ; se, and then not be able to be taken in as values to the maps, and the vau ; will fail to partially evaluate away. lambda (let (macro_helper (lambda (p b) (let ( sym_params (map (lambda (param) (if (symbol? param) param (str-to-symbol (str param)))) p) body (array let (flat_map_i (lambda (i x) (array (idx p i) x)) sym_params) b) ) (array vau sym_params body)))) (vau se (p b) (if (only_symbols p 0) (vapply lambda (array p b) se) (wrap (eval (macro_helper p b) se))))) ; and rec-lambda - yes it's the same definition again rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se)) nil (array) not (lambda (x) (if x false true)) or (let (macro_helper (rec-lambda recurse (bs i) (cond (= i (len bs)) false (= (+ 1 i) (len bs)) (idx bs i) true (array let (array 'tmp (idx bs i)) (array if 'tmp 'tmp (recurse bs (+ i 1))))))) (vau se (& bs) (eval (macro_helper bs 0) se))) and (let (macro_helper (rec-lambda recurse (bs i) (cond (= i (len bs)) true (= (+ 1 i) (len bs)) (idx bs i) true (array let (array 'tmp (idx bs i)) (array if 'tmp (recurse bs (+ i 1)) 'tmp))))) (vau se (& bs) (eval (macro_helper bs 0) se))) foldl (let (helper (rec-lambda recurse (f z vs i) (if (= i (len (idx vs 0))) z (recurse f (lapply f (cons z (map (lambda (x) (idx x i)) vs))) vs (+ i 1))))) (lambda (f z & vs) (helper f z vs 0))) foldr (let (helper (rec-lambda recurse (f z vs i) (if (= i (len (idx vs 0))) z (lapply f (cons (recurse f z vs (+ i 1)) (map (lambda (x) (idx x i)) vs)))))) (lambda (f z & vs) (helper f z vs 0))) reverse (lambda (x) (foldl (lambda (acc i) (cons i acc)) (array) x)) zip (lambda (& xs) (lapply foldr (concat (array (lambda (a & ys) (cons ys a)) (array)) xs))) match (let ( evaluate_case (rec-lambda evaluate_case (access c) (cond (symbol? c) (array true (lambda (b) (array let (array c access) b))) (and (array? c) (= 2 (len c)) (= 'unquote (idx c 0))) (array (array = access (idx c 1)) (lambda (b) b)) (and (array? c) (= 2 (len c)) (= 'quote (idx c 0))) (array (array = access c) (lambda (b) b)) (array? c) (let ( tests (array and (array array? access) (array = (len c) (array len access))) (tests body_func) ((rec-lambda recurse (tests body_func i) (if (= i (len c)) (array tests body_func) (let ( (inner_test inner_body_func) (evaluate_case (array idx access i) (idx c i)) ) (recurse (concat tests (array inner_test)) (lambda (b) (body_func (inner_body_func b))) (+ i 1))))) tests (lambda (b) b) 0) ) (array tests body_func)) true (array (array = access c) (lambda (b) b)) )) helper (rec-lambda helper (x_sym cases i) (cond (< i (- (len cases) 1)) (let ( (test body_func) (evaluate_case x_sym (idx cases i)) ) (concat (array test (body_func (idx cases (+ i 1)))) (helper x_sym cases (+ i 2)))) true (array true (array error "none matched")))) ) (vau de (x & cases) (eval (array let (array '___MATCH_SYM x) (concat (array cond) (helper '___MATCH_SYM cases 0))) de))) ; This is based on https://www.cs.cornell.edu/courses/cs3110/2020sp/a4/deletion.pdf ; and the figure references refer to it ; Insert is taken from the same paper, but is origional to Okasaki, I belive ; The tree has been modified slightly to take in a comparison function ; and override if insert replaces or not to allow use as a set or as a map ; I think this is actually pretty cool - instead of having a bunch of seperate ['B] ; be our leaf node, we use ['B] with all nils. This allows us to not use -B, as ; both leaf and non-leaf 'BB has the same structure with children! Also, we make ; sure to use empty itself so we don't make a ton of empties... empty (array 'B nil nil nil) E empty EE (array 'BB nil nil nil) size (rec-lambda recurse (t) (match t ,E 0 (c a x b) (+ 1 (recurse a) (recurse b)))) generic-foldl (rec-lambda recurse (f z t) (match t ,E z (c a x b) (recurse f (f (recurse f z a) x) b))) generic-contains? (rec-lambda recurse (t cmp v found not-found) (match t ,E (not-found) (c a x b) (match (cmp v x) '< (recurse a cmp v found not-found) '= (found x) '> (recurse b cmp v found not-found)))) blacken (lambda (t) (match t ('R a x b) (array 'B a x b) t t)) balance (lambda (t) (match t ; figures 1 and 2 ('B ('R ('R a x b) y c) z d) (array 'R (array 'B a x b) y (array 'B c z d)) ('B ('R a x ('R b y c)) z d) (array 'R (array 'B a x b) y (array 'B c z d)) ('B a x ('R ('R b y c) z d)) (array 'R (array 'B a x b) y (array 'B c z d)) ('B a x ('R b y ('R c z d))) (array 'R (array 'B a x b) y (array 'B c z d)) ; figure 8, double black cases ('BB ('R a x ('R b y c)) z d) (array 'B (array 'B a x b) y (array 'B c z d)) ('BB a x ('R ('R b y c) z d)) (array 'B (array 'B a x b) y (array 'B c z d)) ; already balenced t t)) generic-insert (lambda (t cmp v replace) (let ( ins (rec-lambda ins (t) (match t ,E (array 'R t v t) (c a x b) (match (cmp v x) '< (balance (array c (ins a) x b)) '= (if replace (array c a v b) t) '> (balance (array c a x (ins b)))))) ) (blacken (ins t)))) rotate (lambda (t) (match t ; case 1, fig 6 ('R ('BB a x b) y ('B c z d)) (balance (array 'B (array 'R (array 'B a x b) y c) z d)) ('R ('B a x b) y ('BB c z d)) (balance (array 'B a x (array 'R b y (array 'B c z d)))) ; case 2, figure 7 ('B ('BB a x b) y ('B c z d)) (balance (array 'BB (array 'R (array 'B a x b) y c) z d)) ('B ('B a x b) y ('BB c z d)) (balance (array 'BB a x (array 'R b y (array 'B c z d)))) ; case 3, figure 9 ('B ('BB a w b) x ('R ('B c y d) z e)) (array 'B (balance (array 'B (array 'R (array 'B a w b) x c) y d)) z e) ('B ('R a w ('B b x c)) y ('BB d z e)) (array 'B a w (balance (array 'B b x (array 'R c y (array 'B d z e))))) ; fall through t t)) redden (lambda (t) (match t ('B a x b) (if (and (= 'B (idx a 0)) (= 'B (idx b 0))) (array 'R a x b) t) t t)) min_delete (rec-lambda recurse (t) (match t ,E (error "min_delete empty tree") ('R ,E x ,E) (array x E) ('B ,E x ,E) (array x EE) ('B ,E x ('R a y b)) (array x (array 'B a y b)) (c a x b) (let ((v ap) (recurse a)) (array v (rotate (array c ap x b)))))) generic-delete (lambda (t cmp v) (let ( del (rec-lambda del (t v) (match t ; figure 3 ,E t ; figure 4 ('R ,E x ,E) (match (cmp v x) '= E _ t) ('B ('R a x b) y ,E) (match (cmp v y) '< (rotate (array 'B (del (array 'R a x b) v) y E)) '= (array 'B a x b) '> t) ; figure 5 ('B ,E x ,E) (match (cmp v x) '= EE _ t) (c a x b) (match (cmp v x) '< (rotate (array c (del a v) x b)) '= (let ((array vp bp) (min_delete b)) (rotate (array c a vp bp))) '> (rotate (array c a x (del b v)))))) ) (del (redden t) v))) set-cmp (lambda (a b) (cond (< a b) '< (= a b) '= true '>)) set-empty empty set-foldl generic-foldl set-insert (lambda (t x) (generic-insert t set-cmp x false)) set-contains? (lambda (t x) (generic-contains? t set-cmp x (lambda (f) true) (lambda () false))) set-remove (lambda (t x) (generic-delete t set-cmp x)) map-cmp (lambda (a b) (let (ak (idx a 0) bk (idx b 0)) (cond (< ak bk) '< (= ak bk) '= true '>))) map-empty empty map-insert (lambda (t k v) (generic-insert t map-cmp (array k v) true)) map-contains-key? (lambda (t k) (generic-contains? t map-cmp (array k nil) (lambda (f) true) (lambda () false))) map-get (lambda (t k) (generic-contains? t map-cmp (array k nil) (lambda (f) (idx f 1)) (lambda () (error (str "didn't find key " k " in map " t))))) map-get-or-default (lambda (t k d) (generic-contains? t map-cmp (array k nil) (lambda (f) (idx f 1)) (lambda () d))) map-get-with-default (lambda (t k d) (generic-contains? t map-cmp (array k nil) (lambda (f) (idx f 1)) (lambda () (d)))) map-remove (lambda (t k) (generic-delete t map-cmp (array k nil))) ; This could be 2x as efficent by being implmented on generic instead of map, ; as we wouldn't have to traverse once to find and once to insert multimap-empty map-empty multimap-insert (lambda (t k v) (map-insert t k (set-insert (map-get-or-default t k set-empty) v))) multimap-get (lambda (t k) (map-get-or-default t k set-empty)) make-test-tree (rec-lambda make-test-tree (n t) (cond (<= n 0) t true (make-test-tree (- n 1) (map-insert t n (= 0 (% n 10)))))) reduce-test-tree (lambda (tree) (generic-foldl (lambda (a x) (if (idx x 1) (+ a 1) a)) 0 tree)) monad (array 'write 1 (str "running tree test") (vau (written code) (array 'exit (log (reduce-test-tree (make-test-tree (log 420000) map-empty)))) ;(array 'read 0 60 (vau (data code) ; (array 'exit (log (reduce-test-tree (make-test-tree (read-string data) map-empty)))) ;)) )) ) monad) ; end of all lets )))))) ; impl of let1 )) (vau de (s v b) (eval (array (array wrap (array vau (array s) b)) v) de))) ; impl of quote )) (vau (x5) x5))