From 7467bc8867df7ebae37b96f609deb50801fc97c0 Mon Sep 17 00:00:00 2001 From: Scott Richmond Date: Fri, 19 Jul 2024 16:48:11 -0400 Subject: [PATCH] disallow shadowing, remove all shadowing from Prelude. --- prelude.ld | 92 +++++++++++++++++++++++----------------------- src/ludus.janet | 9 +++-- src/validate.janet | 8 ++-- 3 files changed, 57 insertions(+), 52 deletions(-) diff --git a/prelude.ld b/prelude.ld index 64748c1..e06e038 100644 --- a/prelude.ld +++ b/prelude.ld @@ -50,8 +50,8 @@ fn ordered? { fn assoc? { "Returns true if a value is an associative collection: a dict or a pkg." - (assoc as :dict) -> true - (assoc as :pkg) -> true + (d as :dict) -> true + (p as :pkg) -> true (_) -> false } @@ -293,8 +293,8 @@ fn set? { fn contains? { "Returns true if a set or list contains a value." - (value, set as :set) -> bool (base :get (set, value)) - (value, list as :list) -> contains? (value, set (list)) + (value, s as :set) -> bool (base :get (s, value)) + (value, l as :list) -> contains? (value, set (list)) } fn omit { @@ -345,8 +345,8 @@ fn string { (x as :string) -> x (x) -> show (x) (x, ...xs) -> loop (x, xs) with { - (out, [x]) -> concat (out, show (x)) - (out, [x, ...xs]) -> recur (concat (out, show (x)), xs) + (out, [y]) -> concat (out, show (y)) + (out, [y, ...ys]) -> recur (concat (out, show (y)), ys) } } @@ -423,9 +423,9 @@ fn words { (str as :string) -> { let no_punct = strip (str) let strs = split (no_punct, " ") - fn worder (list, str) -> if empty? (str) - then list - else append (list, str) + fn worder (l, s) -> if empty? (s) + then l + else append (l, s) fold (worder, strs, []) } } @@ -744,31 +744,31 @@ fn or { fn assoc { "Takes a dict, key, and value, and returns a new dict with the key set to value." () -> #{} - (dict as :dict) -> dict - (dict as :dict, key as :keyword, value) -> base :assoc (dict, key, value) - (dict as :dict, (key as :keyword, value)) -> base :assoc (dict, key, value) + (d as :dict) -> d + (d as :dict, k as :keyword, val) -> base :assoc (d, k, val) + (d as :dict, (k as :keyword, val)) -> base :assoc (d, k, val) } fn dissoc { "Takes a dict and a key, and returns a new dict with the key and associated value omitted." - (dict as :dict) -> dict - (dict as :dict, key as :keyword) -> base :dissoc (dict, key) + (d as :dict) -> d + (d as :dict, k as :keyword) -> base :dissoc (d, k) } fn update { "Takes a dict, key, and function, and returns a new dict with the key set to the result of applying the function to original value held at the key." - (dict as :dict) -> dict - (dict as :dict, key as :keyword, updater as :fn) -> base :assoc (dict, key, updater (get (key, dict))) + (d as :dict) -> d + (d as :dict, k as :keyword, updater as :fn) -> base :assoc (d, k, updater (get (k, d))) } fn keys { "Takes a dict and returns a list of keys in that dict." - (dict as :dict) -> do dict > list > map (first, _) + (d as :dict) -> do d > list > map (first, _) } fn values { "Takes a dict and returns a list of values in that dict." - (dict) -> do dict > list > map (second, _) + (d as :dict) -> do d > list > map (second, _) } fn diff { @@ -801,28 +801,28 @@ fn diff { & TODO: consider merging `get` and `at` fn get { "Takes a key, dict, and optional default value; returns the value at key. If the value is not found, returns nil or the default value." - (key as :keyword) -> get (key, _) - (key as :keyword, dict as :dict) -> get (key, dict, nil) - (key as :keyword, dict as :dict, default) -> base :get (key, dict, default) + (k as :keyword) -> get (k, _) + (k as :keyword, d as :dict) -> get (k, d, nil) + (k as :keyword, d as :dict, default) -> base :get (k, d, default) } & TODO: add sets to this? fn has? { "Takes a key and a dict, and returns true if there is a non-`nil` value stored at the key." - (key as :keyword) -> has? (key, _) - (key as :keyword, dict as :dict) -> do dict > key > nil? + (k as :keyword) -> has? (k, _) + (k as :keyword, d as :dict) -> do d> k > nil? } fn dict { "Takes a list or tuple of (key, value) tuples and returns it as a dict. Returns dicts unharmed." - (dict as :dict) -> dict - (list as :list) -> fold (assoc, list) - (tup as :tuple) -> do tup > list > dict + (d as :dict) -> d + (l as :list) -> fold (assoc, l) + (t as :tuple) -> do t > list > dict } fn dict? { "Returns true if a value is a dict." - (dict as :dict) -> true + (d as :dict) -> true (_) -> false } @@ -869,10 +869,10 @@ fn tan { fn rotate { "Rotates a vector by an angle. Default angle measure is turns. An optional keyword argument specifies the units of the angle passed in." - ((x, y), angle) -> rotate ((x, y), angle, :turns) - ((x, y), angle, units as :keyword) -> ( - sub (mult (x, cos (angle, units)), mult (y, sin (angle, units))) - add (mult (x, sin (angle, units)), mult (y, cos (angle, units))) + ((x, y), a) -> rotate ((x, y), a, :turns) + ((x, y), a, units as :keyword) -> ( + sub (mult (x, cos (a, units)), mult (y, sin (a, units))) + add (mult (x, sin (a, units)), mult (y, cos (a, units))) ) } @@ -917,21 +917,21 @@ fn atan/2 { } fn mod { - "Returns the modulus of num and div. Truncates towards negative infinity. Panics if div is 0." - (num as :number, 0) -> panic! "Division by zero." - (num as :number, div as :number) -> base :mod (num, div) + "Returns the modulus of x and y. Truncates towards negative infinity. Panics if y is 0." + (x as :number, 0) -> panic! "Division by zero." + (x as :number, y as :number) -> base :mod (x, y) } fn mod/0 { - "Returns the modulus of num and div. Truncates towards negative infinity. Returns 0 if div is 0." - (num as :number, 0) -> 0 - (num as :number, div as :number) -> base :mod (num, div) + "Returns the modulus of x and y. Truncates towards negative infinity. Returns 0 if y is 0." + (x as :number, 0) -> 0 + (x as :number, y as :number) -> base :mod (x, y) } fn mod/safe { - "Returns the modulus of num and div in a result tuple, or an error if div is 0. Truncates towards negative infinity." - (num as :number, 0) -> (:err, "Division by zero.") - (num as :number, div as :number) -> (:ok, base :mod (num, div)) + "Returns the modulus of x and y in a result tuple, or an error if y is 0. Truncates towards negative infinity." + (x as :number, 0) -> (:err, "Division by zero.") + (x as :number, y as :number) -> (:ok, base :mod (x, y)) } fn square { @@ -1143,10 +1143,10 @@ fn render_turtle! () -> { :position (x, y) pendown? ...} = state - let first = mult ((0, 1), turtle_radius) - let (x1, y1) = first - let (x2, y2) = rotate (first, turtle_angle) - let (x3, y3) = rotate (first, neg (turtle_angle)) + let origin = mult ((0, 1), turtle_radius) + let (x1, y1) = origin + let (x2, y2) = rotate (origin, turtle_angle) + let (x3, y3) = rotate (origin, neg (turtle_angle)) add_call! ((:push)) add_call! ((:translate, x, y)) add_call! ((:rotate, turn/rad (heading))) @@ -1295,8 +1295,8 @@ fn heading/vector { "Takes a turtle heading, and returns a unit vector of that heading." (heading) -> { & 0 is 90º/0.25T, 0.25 is 180º/0.5T, 0.5 is 270º/0.75T, 0.75 is 0º/0T - let angle = add (heading, 0.25) - (cos (angle), sin (angle)) + let a = add (heading, 0.25) + (cos (a), sin (a)) } } diff --git a/src/ludus.janet b/src/ludus.janet index 3300113..9b45d28 100644 --- a/src/ludus.janet +++ b/src/ludus.janet @@ -51,11 +51,14 @@ (-> out j/encode string) ) -(comment -# (do +# (comment +(do # (def start (os/clock)) (def source ` - doc! (add) +let foo = :bar +{ + let foo = :baz +} `) (def out (-> source ludus diff --git a/src/validate.janet b/src/validate.janet index eb302eb..3f20743 100644 --- a/src/validate.janet +++ b/src/validate.janet @@ -157,10 +157,12 @@ Deferred until a later iteration of Ludus: (def ast (validator :ast)) (def name (ast :data)) (def ctx (validator :ctx)) - (when (has-key? ctx name) - (def {:line line :input input} (get-in ctx [name :token])) + ### XXX TODO: this resolution should ONLY be for userspace, NOT prelude + (def resolved (resolve-name ctx name)) + (when resolved + (def {:line line :input input} resolved) (array/push (validator :errors) - {:node ast :msg (string "name is already bound on line " + {:node ast :msg (string "name " name " is already bound on line " line " of " input)})) (set (ctx name) ast) # (pp ctx)