miloignis/kraken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
b44ff104fb42b5a22a3e6ef132ffce81a904ef5e
kraken/partial_eval_test.kp

147 lines
8.4 KiB
Plaintext
Raw Normal View History

Starting work on a partial evaluator - just sketching for now, needs a bunch of work and likely some foundational changes
2021-08-09 23:58:40 -04:00
(with_import "./partial_eval.kp"
(let (
test-case (lambda (code) (let (
_ (println "Code: " code)
Create and pass through comb_to_mark_map to allow us to re-mark stripped expressions so we can evaluate them mutliple times, etc, etc
2021-08-11 23:30:49 -04:00
[comb_to_mark_map partially_evaled] (partial_eval code)
Starting work on a partial evaluator - just sketching for now, needs a bunch of work and likely some foundational changes
2021-08-09 23:58:40 -04:00
_ (println "Partially evaled: " partially_evaled)
Ok, I think this is a correct? skeleton, implemented as much as I did yesterday
2021-08-10 22:56:12 -04:00
stripped (strip partially_evaled)
_ (println "Stripped: " stripped)
fully_evaled (eval stripped)
Starting work on a partial evaluator - just sketching for now, needs a bunch of work and likely some foundational changes
2021-08-09 23:58:40 -04:00
_ (println "Fully evaled: " fully_evaled)
FIXED THE BUG!
2021-08-22 13:03:33 -04:00
fully_evaled_called (if (combiner? fully_evaled) (fully_evaled 1337))
_ (if (combiner? fully_evaled) (println "..and called " fully_evaled_called))
Ok, more bugfixes & comments, and got eval working!
2021-08-17 01:19:38 -04:00
outer_eval (eval code root_env)
_ (println " outer-eval " outer_eval)
FIXED THE BUG!
2021-08-22 13:03:33 -04:00
outer_called (if (combiner? outer_eval) (outer_eval 1337))
_ (if (combiner? outer_eval) (println "..and outer called " outer_called))
_ (cond (or (combiner? fully_evaled) (combiner? outer_eval))
(if (!= fully_evaled_called outer_called) (error (str "called versions unequal for " code " are " fully_evaled_called " vs " outer_called)))
(!= fully_evaled outer_eval) (error (str "partial-eval versions unequal for " code " are " fully_evaled " vs " outer_eval))
true nil)
Starting work on a partial evaluator - just sketching for now, needs a bunch of work and likely some foundational changes
2021-08-09 23:58:40 -04:00
_ (println)
) fully_evaled))
simple_add (read-string "(+ 1 2)")
More vau usage working
2021-08-16 00:37:56 -04:00
vau_with_add (read-string "(vau (y) (+ 1 2))")
vau_with_add_called (read-string "((vau (y) (+ 1 2)) 4)")
vau_with_passthrough (read-string "((vau (y) y) 4)")
vau_with_no_eval_add (read-string "((vau (y) (+ 13 2 y)) 4)")
Added wrap/unwrap and a vau test that uses wrap!
2021-08-16 01:20:10 -04:00
vau_with_wrap_add (read-string "((wrap (vau (y) (+ 13 2 y))) (+ 3 4))")
More vau usage working
2021-08-16 00:37:56 -04:00
vau_with_add_p (read-string "(vau de (y) (+ (eval y de) (+ 1 2)))")
Some more tests and cleanup, looks like we're going to have to do either a try-eval thing or CPS-style partial evaluator, which I'm reading up on
2021-08-22 20:27:48 -04:00
;; No longer works with our more aggressive partial-evaling of vaus with incomplete environments
;; BUT DOES CUZ I ROLLED THAT BACK
Ok, more bugfixes & comments, and got eval working!
2021-08-17 01:19:38 -04:00
vau_with_add_p_called (read-string "((vau de (y) ((vau dde (z) (+ 1 (eval z dde))) y)) 17)")
Factored out parameter eval for some combinators and then added combiner? and env?
2021-08-17 20:31:07 -04:00
Implement smart cond partial-eval
2021-08-17 18:17:42 -04:00
cond_test (read-string "(cond false 1 false 2 (+ 1 2) 3 true 1337)")
cond_vau_test (read-string "(vau de (x) (cond false 1 false 2 x 3 true 42))")
cond_vau_test2 (read-string "(vau de (x) (cond false 1 false 2 3 x true 42))")
Factored out parameter eval for some combinators and then added combiner? and env?
2021-08-17 20:31:07 -04:00
combiner_test (read-string "(combiner? true)")
combiner_test2 (read-string "(combiner? (vau de (x) x))")
combiner_test3 (read-string "(vau de (x) (combiner? x))")
env_test (read-string "(env? true)")
; this doesn't partially eval, but it could with a more percise if the marked values were more percise
env_test2 (read-string "(vau de (x) (env? de))")
env_test3 (read-string "(vau de (x) (env? x))")
env_test4 (read-string "((vau de (x) (env? de)) 1)")
FIXED THE BUG!
2021-08-22 13:03:33 -04:00
; let1 test
; ((wrap (vau root_env (quote) ((wrap (vau (let1) ;HERE;)) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de))))) (vau (x) x))
;let1_test (read-string "((wrap (vau root_env (quote) ((wrap (vau (let1) (let1 a 12 (+ a 1)))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de))))) (vau (x) x))")
let1_test (read-string "((wrap (vau (let1) (let1 a 12 (+ a 1)))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))")
Some more tests and cleanup, looks like we're going to have to do either a try-eval thing or CPS-style partial evaluator, which I'm reading up on
2021-08-22 20:27:48 -04:00
let2_test (read-string "((wrap (vau (let1) (let1 a 12 (vau (x) (+ a 1))))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))")
let3_test (read-string "((wrap (vau (let1) (let1 a 12 (wrap (vau (x) (+ x a 1)))))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))")
let4_test (read-string "((wrap (vau (let1) (let1 a 12 (wrap (vau (x) (let1 y (+ a 1) (+ y x a))))))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))")
And lambda is working nicely too, once I added support for val to the function call evaluaator (just looking it up in comb_to_mark_map)
2021-08-24 00:33:29 -04:00
let5_test (read-string "((wrap (vau (let1) (let1 a 12 (wrap (vau (x) (let1 y (+ x a 1) (+ y x a))))))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))")
lambda1_test (read-string "((wrap (vau (let1)
(let1 lambda (vau se (p b) (wrap (eval (array vau p b) se)))
(lambda (x) x)
))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))")
lambda2_test (read-string "((wrap (vau (let1)
(let1 lambda (vau se (p b) (wrap (eval (array vau p b) se)))
(let1 a 12
(lambda (x) (+ a x)))
))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))")
lambda3_test (read-string "((wrap (vau (let1)
(let1 lambda (vau se (p b) (wrap (eval (array vau p b) se)))
(let1 a 12
(lambda (x) (let1 b (+ a x)
(+ a x b))))
))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))")
Implement variadic paremters, found additional bug for array, still need to handle recursion too
2021-08-26 01:03:36 -04:00
array_test (read-string "(array 1 2 3 4 5)")
vararg_test (read-string "((wrap (vau (a & rest) rest)) 1 2 3 4 5)")
;do1_test (read-string "((wrap (vau (let1)
; (let1 lambda (vau se (p b) (wrap (eval (array vau 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))
; (do (println 1 2 3)
; (println 4 5 6))
; ))))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))")
;do2_test (read-string "((wrap (vau (let1)
; (let1 lambda (vau se (p b) (wrap (eval (array vau 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))
; (do (println 1 2 3)
; (println 4 5 6))
; ))))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))")
And lambda is working nicely too, once I added support for val to the function call evaluaator (just looking it up in comb_to_mark_map)
2021-08-24 00:33:29 -04:00
FIXED THE BUG!
2021-08-22 13:03:33 -04:00
;big_test1 [[vau ['*ARGV*] (read-string (slurp "./prelude.kp"))] ["" "-C" "1339"]]
;big_test1 [[vau ['*ARGV*] (read-string (slurp "./prelude.kp"))] ["" "-C" "(let (a 17) (vau (x) a))"]]
big_test1 [[vau ['*ARGV*] (read-string (slurp "./prelude.kp"))] ["" "-C" "(let (a 17) a)"]]
;big_test1 [[vau ['*ARGV*] (read-string (slurp "./prelude.kp"))] []]
Starting work on a partial evaluator - just sketching for now, needs a bunch of work and likely some foundational changes
2021-08-09 23:58:40 -04:00
_ (test-case simple_add)
_ (test-case vau_with_add)
Add 2 parameter vau that discards dynamic env
2021-08-10 23:26:22 -04:00
_ (test-case vau_with_add_called)
First vau-involved partial evals working!
2021-08-15 01:27:53 -04:00
_ (test-case vau_with_passthrough)
_ (test-case vau_with_no_eval_add)
Added wrap/unwrap and a vau test that uses wrap!
2021-08-16 01:20:10 -04:00
_ (test-case vau_with_wrap_add)
Bugfix and improvment, eval one works even though eval isn't implemented yet!
2021-08-16 11:54:05 -04:00
_ (test-case vau_with_add_p)
Ok, more bugfixes & comments, and got eval working!
2021-08-17 01:19:38 -04:00
_ (test-case vau_with_add_p_called)
Implement smart cond partial-eval
2021-08-17 18:17:42 -04:00
_ (test-case cond_test)
_ (test-case cond_vau_test)
_ (test-case cond_vau_test2)
Factored out parameter eval for some combinators and then added combiner? and env?
2021-08-17 20:31:07 -04:00
_ (test-case combiner_test)
_ (test-case combiner_test2)
_ (test-case combiner_test3)
_ (test-case env_test)
_ (test-case env_test2)
_ (test-case env_test3)
_ (test-case env_test4)
FIXED THE BUG!
2021-08-22 13:03:33 -04:00
_ (test-case let1_test)
Some more tests and cleanup, looks like we're going to have to do either a try-eval thing or CPS-style partial evaluator, which I'm reading up on
2021-08-22 20:27:48 -04:00
_ (test-case let2_test)
_ (test-case let3_test)
_ (test-case let4_test)
And lambda is working nicely too, once I added support for val to the function call evaluaator (just looking it up in comb_to_mark_map)
2021-08-24 00:33:29 -04:00
_ (test-case let5_test)
_ (test-case lambda1_test)
_ (test-case lambda2_test)
_ (test-case lambda3_test)
FIXED THE BUG!
2021-08-22 13:03:33 -04:00
Implement variadic paremters, found additional bug for array, still need to handle recursion too
2021-08-26 01:03:36 -04:00
_ (test-case vararg_test)
_ (test-case array_test)
;_ (test-case do1_test)
;_ (test-case do2_test)
Fix a bug in eval strip not actually stripping in the proper eval way - f there's a later anywhere in there, it has to desist, which is now implemented. Added do tests - we have to add support for & params, which I had forgotten, and I belive it now loops infinately because it tries to partially evaluate a recursive function!
2021-08-25 01:32:24 -04:00
FIXED THE BUG!
2021-08-22 13:03:33 -04:00
;_ (println "THE BIG SHOW")
;_ (println big_test1)
;_ (test-case big_test1)
Starting work on a partial evaluator - just sketching for now, needs a bunch of work and likely some foundational changes
2021-08-09 23:58:40 -04:00
) nil))
Reference in New Issue Copy Permalink