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

151 lines
8.9 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)))")
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)))")
2 steps forward, 1 step back - I have arrays (and I think varargs) working, but let5_test is now not partial evaling as far as it should because of my fix. Detailed explanation in the comments, but it looks like we are going to have to insert that eval_strip hack, or somesuch
2021-09-05 00:25:33 -04:00
; I've broken this one with my parameter bailing I think
; The problem seems to be the second eval of let1, which is ( marked_array ( ( marked_array ( ( prim_comb combiner(wrap_level: 1) builtin_combiner_vau(wrap_level: 0) ) ( val ( y) ) ( val ( + y x a ) ) ) ) ( later ( builtin_combiner_+(wrap_level: 1) x a 1 ) ) ) )
; that is, ['ma ['ma vau ('val y) 'val (+ y x a) ] 'later [+ x a 1] ], and because of that later, eval_strip
; is returning not-ok, and so the whole thing can't be passed to partial_eval.
; To fix it, we'd need that strip-hack-thing to strip it out then sub it back in in the partial eval.
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 array_test)
2 steps forward, 1 step back - I have arrays (and I think varargs) working, but let5_test is now not partial evaling as far as it should because of my fix. Detailed explanation in the comments, but it looks like we are going to have to insert that eval_strip hack, or somesuch
2021-09-05 00:25:33 -04:00
_ (test-case vararg_test)
Implement variadic paremters, found additional bug for array, still need to handle recursion too
2021-08-26 01:03:36 -04:00
;_ (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