323 lines
21 KiB
Plaintext
323 lines
21 KiB
Plaintext
((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 (lambda (& y) (lapply (x2 x2) y))))))
|
|
(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) (cond (eval con de) (eval than de)
|
|
(> (len else) 0) (eval (idx else 0) de)
|
|
true false))
|
|
|
|
map (lambda (f5 l5)
|
|
; now maybe errors on can't find helper?
|
|
(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))) (slice (idx vs i) 1 -1))
|
|
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)))
|
|
|
|
id (lambda (x) x)
|
|
dlet (vau se (inners body) (vapply let (array (lapply concat inners) body) se))
|
|
|
|
test7 ((rec-lambda recurse (n) (cond (= 0 n) 1
|
|
true (* n (recurse (- n 1))))) 5)
|
|
|
|
|
|
cond (vau se (& inners) (vapply cond (lapply concat inners) se))
|
|
|
|
|
|
test18 ((rec-lambda recurse (n) (cond ((= 0 n) 1)
|
|
(true (* n (recurse (- n 1)))))) 5)
|
|
|
|
|
|
|
|
;test0 (map (lambda (x) (+ x 1)) (array 1 2))
|
|
;test1 (map_i (lambda (i x) (+ x i 1)) (array 1 2))
|
|
;test2 (filter_i (lambda (i x) (> i 0)) (array 1 2))
|
|
;test2 (filter (lambda ( x) (> x 1)) (array 1 2))
|
|
;test3 (not 1)
|
|
;test4 (flat_map (lambda (x) (array 1 x 2)) (array 1 2))
|
|
;test5 (flat_map_i (lambda (i x) (array i x 2)) (array 1 2))
|
|
;test6 (let ( (a b) (array 1 2) c (+ a b) ) c)
|
|
;test8 ((lambda (a b c) (+ a b c)) 1 13 14)
|
|
;test9 ((lambda (a (b c)) (+ a b c)) 1 (array 13 14))
|
|
|
|
;test10 (foldl + 0 (array 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 13371 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337))
|
|
;test11 (foldl + 0 (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 13371 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337))
|
|
;test12 (foldl + 0 (array 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 13371 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337))
|
|
;test13 (foldl + 0 (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 13371 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337))
|
|
|
|
;test10 (foldl + 0 (array 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337))
|
|
;test11 (foldl + 0 (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337))
|
|
|
|
;test10 (foldl + 0 (array 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337))
|
|
;test11 (foldl + 0 (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337))
|
|
;test12 (foldl + 0 (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337))
|
|
;test13 (foldl + 0 (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337))
|
|
|
|
;test14 (foldr + 0 (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337))
|
|
;test15 (reverse (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337))
|
|
;test16 (zip (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337) (array 2 3 4 5 1338 2 3 4 5 1338 2 3 4 5 1338 2 3 4 5 1338))
|
|
|
|
;monad (array 'open 3 "test_self_out" (lambda (fd code)
|
|
; (array 'write fd "wabcdefghijklmnopqrstuvwx" (lambda (written code)
|
|
; (array 'exit (if (= 0 written) 12 14))))))
|
|
;old 4
|
|
;test (+ old 4)
|
|
;test 4
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) (map (lambda (x) (+ x 133)) (array written code))))
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) (map_i (lambda (i x) (+ x i 133)) (array written code))))
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) (filter_i (lambda (i x) (> i 0)) (array written code))))
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) (filter (lambda (x) (> x 0)) (array written code))))
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) (not (array written code))))
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) (flat_map (lambda (x) (array 1 x 2)) (array written code))))
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) (flat_map_i (lambda (i x) (array i x 2)) (array written code))))
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) (let ( (a b) (array written code) c (+ a b test8 test9)) c)))
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) ((lambda (a (b c)) (+ a b c)) 1 (array written code))))
|
|
|
|
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) test10))
|
|
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) (foldl + 0 (array written code 1337))))
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) test14))
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) (foldr + 0 (array written code 1337))))
|
|
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) test15))
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) (reverse (array written code 1337))))
|
|
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) test16))
|
|
monad (array 'write 1 "test_self_out2" (vau (written code) (zip (array 1 2 3) (array written code 1337))))
|
|
|
|
|
|
;test17 (dlet ( (a 1) (b 2) ((c d) (array 3 4)) ) (+ a b c d))
|
|
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) test17))
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) (+ test7 test18)))
|
|
|
|
;monad (array 'write 1 "test_self_out2" (vau (written code) 7))
|
|
|
|
print log
|
|
println log
|
|
|
|
)
|
|
; monad
|
|
(dlet (
|
|
(in_array (dlet ((helper (rec-lambda recurse (x a i) (cond ((= i (len a)) false)
|
|
((= x (idx a i)) true)
|
|
(true (recurse x a (+ i 1)))))))
|
|
(lambda (x a) (helper x a 0))))
|
|
|
|
(val? (lambda (x) (= 'val (idx x 0))))
|
|
(marked_array? (lambda (x) (= 'marked_array (idx x 0))))
|
|
(marked_symbol? (lambda (x) (= 'marked_symbol (idx x 0))))
|
|
(comb? (lambda (x) (= 'comb (idx x 0))))
|
|
(prim_comb? (lambda (x) (= 'prim_comb (idx x 0))))
|
|
(marked_env? (lambda (x) (= 'env (idx x 0))))
|
|
|
|
(.hash (lambda (x) (idx x 1)))
|
|
|
|
(.val (lambda (x) (idx x 2)))
|
|
|
|
(.marked_array_is_val (lambda (x) (idx x 2)))
|
|
(.marked_array_is_attempted (lambda (x) (idx x 3)))
|
|
(.marked_array_needed_for_progress (lambda (x) (idx x 4)))
|
|
(.marked_array_values (lambda (x) (idx x 5)))
|
|
|
|
(.marked_symbol_needed_for_progress (lambda (x) (idx x 2)))
|
|
(.marked_symbol_is_val (lambda (x) (= nil (.marked_symbol_needed_for_progress x))))
|
|
(.marked_symbol_value (lambda (x) (idx x 3)))
|
|
(.comb (lambda (x) (slice x 2 -1)))
|
|
(.comb_id (lambda (x) (idx x 3)))
|
|
(.comb_des (lambda (x) (idx x 4)))
|
|
(.comb_env (lambda (x) (idx x 5)))
|
|
(.comb_body (lambda (x) (idx x 8)))
|
|
(.comb_wrap_level (lambda (x) (idx x 2)))
|
|
(.prim_comb_sym (lambda (x) (idx x 3)))
|
|
(.prim_comb_handler (lambda (x) (idx x 2)))
|
|
(.prim_comb_wrap_level (lambda (x) (idx x 4)))
|
|
(.prim_comb_val_head_ok (lambda (x) (idx x 5)))
|
|
(.prim_comb (lambda (x) (slice x 2 -1)))
|
|
|
|
(.marked_env (lambda (x) (slice x 2 -1)))
|
|
(.marked_env_has_vals (lambda (x) (idx x 2)))
|
|
(.marked_env_needed_for_progress (lambda (x) (idx x 3)))
|
|
(.marked_env_idx (lambda (x) (idx x 4)))
|
|
(.marked_env_upper (lambda (x) (idx (idx x 5) -1)))
|
|
(.env_marked (lambda (x) (idx x 5)))
|
|
(marked_env_real? (lambda (x) (= nil (.marked_env_needed_for_progress x))))
|
|
(.any_comb_wrap_level (lambda (x) (cond ((prim_comb? x) (.prim_comb_wrap_level x))
|
|
((comb? x) (.comb_wrap_level x))
|
|
(true (error "bad .any_comb_level")))))
|
|
|
|
; The actual needed_for_progress values are either
|
|
; #t - any eval will do something
|
|
; nil - is a value, no eval will do anything
|
|
; (3 4 1...) - list of env ids that would allow forward progress
|
|
; But these are paired with another list of hashes that if you're not inside
|
|
; of an evaluation of, then it could progress futher. These are all caused by
|
|
; the infinite recursion stopper.
|
|
(needed_for_progress (rec-lambda needed_for_progress (x) (cond ((marked_array? x) (.marked_array_needed_for_progress x))
|
|
((marked_symbol? x) (array (.marked_symbol_needed_for_progress x) nil))
|
|
((marked_env? x) (array (.marked_env_needed_for_progress x) nil))
|
|
((comb? x) (dlet ((id (.comb_id x))
|
|
(body_needed (idx (needed_for_progress (.comb_body x)) 0))
|
|
(se_needed (idx (needed_for_progress (.comb_env x)) 0)))
|
|
(if (or (= true body_needed) (= true se_needed)) (array true nil)
|
|
(array (foldl (lambda (a xi) (if (or (= id xi) (in_array xi a)) a (cons xi a)))
|
|
(array) (concat body_needed se_needed)) nil)
|
|
)))
|
|
((prim_comb? x) (array nil nil))
|
|
((val? x) (array nil nil))
|
|
(true (error (str "what is this? in need for progress" x))))))
|
|
(needed_for_progress_slim (lambda (x) (idx (needed_for_progress x) 0)))
|
|
|
|
|
|
|
|
|
|
|
|
(test17 (or false 1 "a" true))
|
|
(test18 (and 1 "a" nil true))
|
|
(monad (array 'write 1 "test_self_out2" (vau (written code) (array (or written code) test17 (or false nil 0) (and written code) test18 (and nil 0 false)))))
|
|
;(monad (array 'write 1 "test_self_out2" (vau (written code) (dlet ((_ (print 1234))) (in_array 0 (array written code))))))
|
|
|
|
) monad)
|
|
)
|
|
;(array 'write 1 "test_self_out2" (vau (written code) 7))
|
|
; end of all lets
|
|
))))))
|
|
; impl of let1
|
|
; this would be the macro style version (((
|
|
)) (vau de (s v b) (eval (array (array wrap (array vau (array s) b)) v) de)))
|
|
;)) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))
|
|
; impl of quote
|
|
)) (vau (x5) x5))
|