From 4ed9af307ff413adc605b0945174931c82f689c0 Mon Sep 17 00:00:00 2001 From: Nathan Braswell Date: Tue, 22 Dec 2020 19:24:54 -0500 Subject: [PATCH] Port method stuff over to new_kraken --- new_kraken.kp | 60 ++++++++++++++++++++++++++++++++++++++++------ new_kraken_test.kp | 33 +++++++++++++++++++++++++ prelude.kp | 12 +++++----- 3 files changed, 92 insertions(+), 13 deletions(-) diff --git a/new_kraken.kp b/new_kraken.kp index 100510a..2e244c7 100644 --- a/new_kraken.kp +++ b/new_kraken.kp @@ -1,8 +1,31 @@ (let ( + + ; First quick lookup function, since maps are not built in + get-value-helper (rec-lambda recurse (dict key i) (if (>= i (len dict)) + nil + (if (= key (idx (idx dict i) 0)) + (idx (idx dict i) 1) + (recurse dict key (+ i 1))))) + get-value (lambda (dict key) (get-value-helper dict key 0)) + + ; Our actual method call function + method-call (lambda (object method & arguments) (let (method_fn (get-value (meta object) method)) + (if (= method_fn nil) + (println "no method " method) + (lapply method_fn (concat [object] arguments))))) + + + make_constructor (lambda (name members methods) + `(~rec-lambda ~name ~members + (~with-meta [,members] + [,(map_with_idx (lambda (i x) [array `'~x (lambda (o) (idx o i))]) members) + ,(map (lambda (x) [array `'~(idx x 0) (idx x 1)]) methods)]))) + + ; {} body translated to do and let - construct_body (rec-lambda (is_do current to_add i) + construct_body (rec-lambda recurse (is_do current to_add i) (if (> (len to_add) i) (cond (and is_do (= (len (idx to_add i)) 1)) (recurse true (concat current [(idx (idx to_add i) 0)]) to_add (+ i 1)) (= (len (idx to_add i)) 1) (concat current [(recurse true [do (idx (idx to_add i) 0)] to_add (+ i 1))]) @@ -10,7 +33,7 @@ current)) ; string interpolation - remove_dollar (rec-lambda (done to_do i j) (cond (>= j (- (len to_do) 2)) (str done (slice to_do i -1)) + remove_dollar (rec-lambda recurse (done to_do i j) (cond (>= j (- (len to_do) 2)) (str done (slice to_do i -1)) (= "\\$" (slice to_do j (+ j 2))) (recurse (str done (slice to_do i j) "$") to_do (+ j 2) (+ j 2)) true (recurse done to_do i (+ j 1)))) fixup_str_parts (lambda (s) (remove_dollar "" (slice s 0 -2) 0 0)) @@ -19,10 +42,37 @@ new_kraken_untyped (concat standard_grammar (array + (array 'call_innards [ 'WS * ] (lambda (_) (array))) + (array 'call_innards [ 'form [ 'WS 'form ] * ] (lambda (f r) (concat [f] (map (lambda (x) (idx x 1)) r)))) + + (array 'form ['form "\\." 'atom] + (lambda (o _ m) `(~method-call ~o '~m))) + ; params + (array 'form ['form "\\." 'atom "\\(" 'call_innards "\\)"] + (lambda (o _ m _ p _) `(~method-call ~o '~m ,p))) + + + (array 'form [ "\\|" 'call_innards "\\|" 'WS * 'form ] + (lambda (_ params _ _ body) `(lambda (,params) ~body))) + + ; Call functions with function first, c style (notice no whitespace) + (array 'form [ 'form "\\(" 'call_innards "\\)" ] + (lambda (f _ ps _) (concat [f] ps))) + + ; fun syntax + (array 'block_member [ "fun" 'WS 'atom 'WS * "\\(" 'call_innards "\\)" 'WS * 'form ] + (lambda (_ _ name _ _ params _ _ body) `(~name (~lambda (,params) ~body)))) + + ; object syntax + (array 'block_member ["obj" 'WS 'atom "\\(" ['WS * 'atom] * 'WS * "\\)" 'WS * "{" 'WS * ['atom 'WS * 'form 'WS *] * "}"] + (lambda (_ _ name _ members _ _ _ _ _ methods _) + [name (make_constructor name (map (lambda (x) (idx x 1)) members) + (map (lambda (x) [(idx x 0) (idx x 2)]) methods))])) + (array 'block_member [ 'form ] (lambda (x) [x])) (array 'block_member [ "let" 'WS * 'atom 'WS * "=" 'WS * 'form ] (lambda (_ _ name _ _ _ rhs) `(~name ~rhs))) - (array 'form ["{" 'WS * [ 'block_member 'WS * ] * "}"] + (array 'form ["{" 'WS * [ 'block_member 'WS ] * "}"] (lambda (_ _ inner _) (construct_body true [do] (map (lambda (x) (idx x 0)) inner) 0))) @@ -31,10 +81,6 @@ |[ -!]|(\\\\\"))*\"" ] (lambda (_ string_form_pairs end) `(str ,( flat_map (lambda (x) [ (fixup_str_parts (idx x 0)) (idx x 1) ]) string_form_pairs) ~(fixup_str_parts end)))) - - (array 'form [ "\\|" 'WS * [ 'atom 'WS * ] * "\\|" 'WS * 'form ] - (lambda (_ _ params _ _ body) `(lambda (,(map (lambda (x) (idx x 0)) params)) ~body))) - ))) (provide new_kraken_untyped) ) diff --git a/new_kraken_test.kp b/new_kraken_test.kp index 34d2789..e0b3d05 100644 --- a/new_kraken_test.kp +++ b/new_kraken_test.kp @@ -2,4 +2,37 @@ { let my_var = 1337 (println $"this is string interpolation: $(+ 1 3 4) <- cool right? another $my_var yep even variables") + + obj Point( x y ) { + add |self other| { Point((+ self.x other.x) (+ self.y other.y)) } + sub |self other| { Point((- self.x other.x) (- self.y other.y)) } + to_str |self| { str("x: " self.x ", y: " self.y) } + } + + fun say_hi(name) { + println("hayo" name) + } + + fun test() { + let plus_1 = |x| (+ x 1) + let a = 1 + let b = plus_1(a) + println("some" b) + + say_hi("Marcus") + + let p1 = Point(1 2) + let p2 = Point(3 4) + let p3 = p1.add(p2) + let p4 = p1.sub(p2) + say_hi("Charlie/Betty") + + println("p1:" p1.to_str) + println("p2:" p2.to_str) + println("p3:" p3.to_str) + println("p4:" p4.to_str) + + (+ a b) + } + println("Test result is" test()) } diff --git a/prelude.kp b/prelude.kp index 167a55e..da90907 100644 --- a/prelude.kp +++ b/prelude.kp @@ -32,14 +32,14 @@ (let ( print_through (lambda (x) (do (println x) x)) - rec-lambda (vau se (p b) (eval (array Y (array lambda (quote (recurse)) (array lambda p b))) se)) + 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 nil)) map (lambda (f l) - (let (helper (rec-lambda (f l n i) + (let (helper (rec-lambda recurse (f l n i) (if (= i (len l)) n (do (set-idx! n i (f (idx l i))) @@ -47,7 +47,7 @@ (helper f l (array-with-len (len l)) 0))) map_i (lambda (f l) - (let (helper (rec-lambda (f l n i) + (let (helper (rec-lambda recurse (f l n i) (if (= i (len l)) n (do (set-idx! n i (f i (idx l i))) @@ -62,7 +62,7 @@ concat (lambda (& as) (concat_helper concat_helper as (array-with-len (lapply + (map len as))) 0 0 0)) filter_i (lambda (f l) - (let (helper (rec-lambda (f l n i) + (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)) @@ -97,13 +97,13 @@ body) de))) flat_map (lambda (f l) - (let (helper (rec-lambda (f l n i) + (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))) map_with_idx (lambda (f l) - (let (helper (rec-lambda (f l n i) + (let (helper (rec-lambda recurse (f l n i) (if (= i (len l)) n (do (set-idx! n i (f i (idx l i)))