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

160 lines
9.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)
Ok, refactored the whole thing! It's now always operating on marked values with a mark step at the beginning, which should solve our stripping problems. It parses, but crashes, but it's 3am, so I'm saving and going to bed
2021-09-06 03:00:33 -04:00
; For right now we only support calling partial_eval in such a way that it partial evals against
; the root env, but this is could and really should be extended. We could at least check if the env we're called with
; is the root_env, or if what we look up in whatever env is passed in matches something in the root env
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)
Ok, refactored the whole thing! It's now always operating on marked values with a mark step at the beginning, which should solve our stripping problems. It parses, but crashes, but it's 3am, so I'm saving and going to bed
2021-09-06 03:00:33 -04:00
fully_evaled (eval stripped root_env)
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))")
Ok, refactored the whole thing! It's now always operating on marked values with a mark step at the beginning, which should solve our stripping problems. It parses, but crashes, but it's 3am, so I'm saving and going to bed
2021-09-06 03:00:33 -04:00
symbol_test (read-string "((vau (x) x) a)")
Factored out parameter eval for some combinators and then added combiner? and env?
2021-08-17 20:31:07 -04:00
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.
Ok, refactored the whole thing! It's now always operating on marked values with a mark step at the beginning, which should solve our stripping problems. It parses, but crashes, but it's 3am, so I'm saving and going to bed
2021-09-06 03:00:33 -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)))")
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
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)))")
Ok, refactored the whole thing! It's now always operating on marked values with a mark step at the beginning, which should solve our stripping problems. It parses, but crashes, but it's 3am, so I'm saving and going to bed
2021-09-06 03:00:33 -04:00
;!!!! Ditto to let5_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
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)
Ok, refactored the whole thing! It's now always operating on marked values with a mark step at the beginning, which should solve our stripping problems. It parses, but crashes, but it's 3am, so I'm saving and going to bed
2021-09-06 03:00:33 -04:00
_ (test-case symbol_test)
Factored out parameter eval for some combinators and then added combiner? and env?
2021-08-17 20:31:07 -04:00
_ (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