assets/test_prelude.ld

@@ -791,16 +791,16 @@ fn range {
 & additional list operations now that we have comparitors
 fn at {
 	"Returns the element at index n of a list or tuple, or the byte at index n of a string. Zero-indexed: the first element is at index 0. Returns nil if nothing is found in a list or tuple; returns an empty string if nothing is found in a string."
-	(xs as :list, n as :number) -> base :at (xs, n)
+	(xs as :list, n as :number) -> base :nth (n, xs)
-	(xs as :tuple, n as :number) -> base :at (xs, n)
+	(xs as :tuple, n as :number) -> base :nth (n, xs)
-	& (str as :string, n as :number) -> {
+	(str as :string, n as :number) -> {
-	& 	let raw = base :at (str, n)
+		let raw = base :nth (n, str)
-	& 	when {
+		when {
-	& 		nil? (raw) -> nil
+			nil? (raw) -> nil
-	& 		gte? (raw, 128) -> panic! "not an ASCII char"
+			gte? (raw, 128) -> panic! "not an ASCII char"
-	& 		true -> base :str_slice (str, n, inc (n))
+			true -> base :str_slice (str, n, inc (n))
-	& 	}
+		}
-	& }
+	}
 	(_) -> nil
 }
 
@@ -819,6 +819,11 @@ fn last {
 	(xs) if ordered? (xs) -> at (xs, dec (count (xs)))
 }
 
+fn butlast {
+	"Returns a list, omitting the last element."
+	(xs as :list) -> base :slice (xs, 0, dec (count (xs)))
+}
+
 fn slice {
 	"Returns a slice of a list or a string, representing a sub-list or sub-string."
 	(xs as :list, end as :number) -> slice (xs, 0, end) 
@@ -832,11 +837,6 @@ fn slice {
 	(str as :string, start as :number, end as :number) -> base :str_slice (str, start, end)
 }
 
-fn butlast {
-	"Returns a list, omitting the last element."
-	(xs as :list) -> slice (xs, 0, dec (count (xs)))
-}
-
 &&& keywords: funny names
 fn keyword? {
 	"Returns true if a value is a keyword, otherwise returns false."
@@ -860,21 +860,10 @@ fn dissoc {
 	(d as :dict, k as :keyword) -> base :dissoc (d, k)
 }
 
-& 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."
-	(k as :keyword) -> get (k, _)
-	(k as :keyword, d as :dict) -> base :get (d, k)
-	(k as :keyword, d as :dict, default) -> match base :get (d, k) with {
-		nil -> default
-		val -> val
-	} 
-}
-
 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."
 	(d as :dict) -> d
-	(d as :dict, k as :keyword, updater as :fn) -> assoc (d, k, updater (get (k, d)))
+	(d as :dict, k as :keyword, updater as :fn) -> base :assoc (d, k, updater (k (d)))
 }
 
 fn keys {
@@ -887,11 +876,19 @@ fn values {
 	(d as :dict) -> do d > list > map (second, _)
 }
 
+& 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."
+	(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."
 	(k as :keyword) -> has? (k, _)
-	(k as :keyword, d as :dict) -> do d > get (k) > some?
+	(k as :keyword, d as :dict) -> do d > k > some?
 }
 
 fn dict {
@@ -941,273 +938,9 @@ fn random_int {
 }
 
 
-&&& Results, errors and other unhappy values
 
-fn ok {
-	"Takes a value and wraps it in an :ok result tuple."
-	(value) -> (:ok, value)	
-}
 
-fn ok? {
-	"Takes a value and returns true if it is an :ok result tuple."
-	((:ok, _)) -> true
-	(_) -> false
-}
 
-fn err {
-	"Takes a value and wraps it in an :err result tuple, presumably as an error message."
-	(msg) -> (:err, msg)
-}
-
-fn err? {
-	"Takes a value and returns true if it is an :err result tuple."
-	((:err, _)) -> true
-	(_) -> false
-}
-
-fn unwrap! {
-	"Takes a result tuple. If it's :ok, then returns the value. If it's not :ok, then it panics. If it's not a result tuple, it also panics."
-	((:ok, value)) -> value
-	((:err, msg)) -> panic! string ("Unwrapped :err! ", msg)
-	(_) -> panic! "Cannot unwrap something that's not an error tuple."
-}
-
-fn unwrap_or {
-	"Takes a value that is a result tuple and a default value. If it's :ok, then it returns the value. If it's :err, returns the default value."
-	((:ok, value), _) -> value
-	((:err, _), default) -> default
-}
-
-fn assert! {
-	"Asserts a condition: returns the value if the value is truthy, panics if the value is falsy. Takes an optional message."
-	(value) -> if value 
-		then value 
-		else panic! "Assert failed: {value}"
-	(msg, value) -> if value 
-		then value 
-		else panic! "Assert failed: {msg} with {value}"
-}
-
-&&& Turtle & other graphics
-
-& some basic colors
-& these are the "basic" css colors
-& https://developer.mozilla.org/en-US/docs/Web/CSS/named-color
-let colors = #{
-	:black (0, 0, 0, 255)
-	:silver (192, 192, 192, 255)
-	:gray (128, 128, 128, 255)
-	:white (255, 255, 255, 255)
-	:maroon (128, 0, 0, 255)
-	:red (255, 0, 0, 255)
-	:purple (128, 0, 128, 255)
-	:fuchsia (255, 0, 255, 255)
-	:green (0, 128, 0, 255)
-	:lime (0, 255, 0, 255)
-	:olive (128, 128, 0, 255)
-	:yellow (255, 255, 0, 255)
-	:navy (0, 0, 128, 255)
-	:blue (0, 0, 255, 255)
-	:teal (0, 128, 128, 255)
-	:aqua (0, 255, 25, 255)
-}
-
-& the initial turtle state
-let turtle_init = #{
-	:position (0, 0) & let's call this the origin for now
-	:heading 0 & this is straight up
-	:pendown? true
-	:pencolor :white
-	:penwidth 1
-	:visible? true
-}
-
-& turtle states: refs that get modified by calls
-& turtle_commands is a list of commands, expressed as tuples
-box turtle_commands = []
-box turtle_state = turtle_init
-
-fn apply_command
-
-fn add_command! (command) -> {
-	update! (turtle_commands, append (_, command))
-	let prev = unbox (turtle_state)
-	let curr = apply_command (prev, command)
-	store! (turtle_state, curr)
-	:ok
-}
-
-fn forward! {
-	"Moves the turtle forward by a number of steps. Alias: fd!"
-	(steps as :number) -> add_command! ((:forward, steps))
-}
-
-let fd! = forward!
-
-fn back! {
-	"Moves the turtle backward by a number of steps. Alias: bk!"
-	(steps as :number) -> add_command! ((:back, steps))
-}
-
-let bk! = back!
-
-fn left! {
-	"Rotates the turtle left, measured in turns. Alias: lt!"
-	(turns as :number) -> add_command! ((:left, turns))
-}
-
-let lt! = left!
-
-fn right! {
-	"Rotates the turtle right, measured in turns. Alias: rt!"
-	(turns as :number) -> add_command! ((:right, turns))
-}
-
-let rt! = right!
-
-fn penup! {
-	"Lifts the turtle's pen, stopping it from drawing. Alias: pu!"
-	() -> add_command! ((:penup))
-}
-
-let pu! = penup!
-
-fn pendown! {
-	"Lowers the turtle's pen, causing it to draw. Alias: pd!"
-	() -> add_command! ((:pendown))
-}
-
-let pd! = pendown!
-
-fn pencolor! {
-	"Changes the turtle's pen color. Takes a single grayscale value, an rgb tuple, or an rgba tuple. Alias: pc!"
-	(color as :keyword) -> add_command! ((:pencolor, color))
-	(gray as :number) -> add_command! ((:pencolor, (gray, gray, gray, 255)))
-	((r as :number, g as :number, b as :number)) -> add_command! ((:pencolor, (r, g, b, 255)))
-	((r as :number, g as :number, b as :number, a as :number)) -> add_command! ((:pencolor, (r, g, b, a)))
-}
-
-let pc! = pencolor!
-
-fn penwidth! {
-	"Sets the width of the turtle's pen, measured in pixels. Alias: pw!"
-	(width as :number) -> add_command! ((:penwidth, width))
-}
-
-let pw! = penwidth!
-
-fn background! {
-	"Sets the background color behind the turtle and path. Alias: bg!"
-	(color as :keyword) -> add_command! ((:background, color))
-	(gray as :number) -> add_command! ((:background, (gray, gray, gray, 255)))
-	((r as :number, g as :number, b as :number)) -> add_command! ((:background, (r, g, b, 255)))
-	((r as :number, g as :number, b as :number, a as :number)) -> add_command! ((:background, (r, g, b, a)))
-}
-
-let bg! = background!
-
-fn home! {
-	"Sends the turtle home: to the centre of the screen, pointing up. If the pen is down, the turtle will draw a path to home."
-	() -> add_command! ((:home))
-}
-
-fn clear! {
-	"Clears the canvas and sends the turtle home."
-	() -> add_command! ((:clear))
-}
-
-fn goto! {
-	"Sends the turtle to (x, y) coordinates. If the pen is down, the turtle will draw a path to its new location."
-	(x as :number, y as :number) -> add_command! ((:goto, (x, y)))
-	((x, y)) -> goto! (x, y)
-}
-
-fn setheading! {
-	"Sets the turtle's heading. The angle is specified in turns, with 0 pointing up. Increasing values rotate the turtle counter-clockwise."
-	(heading as :number) -> add_command! ((:setheading, heading))
-}
-
-fn showturtle! {
-	"If the turtle is hidden, shows the turtle. If the turtle is already visible, does nothing."
-	() -> add_command! ((:show))
-}
-
-fn hideturtle! {
-	"If the turtle is visible, hides it. If the turtle is already hidden, does nothing."
-	() -> add_command! ((:hide))
-}
-
-fn loadstate! {
-	"Sets the turtle state to a previously saved state."
-	(state) -> {
-		let #{position, heading, pendown?, pencolor, penwidth, visible?} = state
-		add_command! ((:loadstate, position, heading, visible?, pendown?, penwidth, pencolor))
-	}
-}
-
-fn apply_command {
-	"Takes a turtle state and a command and calculates a new state."
-	(state, command) -> match command with {
-		(:goto, (x, y)) -> assoc (state, :position, (x, y))
-		(:home) -> do state > 
-			assoc (_, :position, (0, 0)) >
-			assoc (_, :heading, 0)
-		(:clear) -> do state >
-			assoc (state, :position, (0, 0)) >
-			assoc (_, :heading, 0)
-		(:right, turns) -> update (state, :heading, add (_, turns))
-		(:left, turns) -> update (state, :heading, sub (_, turns))
-		(:forward, steps) -> {
-			let #{heading, position, ...} = state
-			let unit = heading/vector (heading)
-			let vect = mult (steps, unit)
-			update (state, :position, add (vect, _))
-		}
-		(:back, steps) -> {
-			let #{heading, position, ...} = state
-			let unit = heading/vector (heading)
-			let vect = mult (steps, unit)
-			update (state, :position, sub (_, vect))
-		}
-		(:penup) -> assoc (state, :pendown?, false)
-		(:pendown) -> assoc (state, :pendown?, true)
-		(:penwidth, pixels) -> assoc (state, :penwidth, pixels)
-		(:pencolor, color) -> assoc (state, :pencolor, color)
-		(:setheading, heading) -> assoc (state, :heading, heading)
-		(:loadstate, position, heading, visible?, pendown?, penwidth, pencolor) -> #{position, heading, visible?, pendown?, penwidth, pencolor}
-		(:show) -> assoc (state, :visible?, true)
-		(:hide) -> assoc (state, :visible?, false)
-		(:background, _) -> state
-	}
-}
-
-& position () -> (x, y)
-fn position {
-	"Returns the turtle's current position."
-	() -> do turtle_state > unbox > :position
-}
-
-fn heading {
-	"Returns the turtle's current heading."
-	() -> do turtle_state > unbox > :heading
-}
-
-fn pendown? {
-	"Returns the turtle's pen state: true if the pen is down."
-	() -> do turtle_state > unbox > :pendown?
-}
-
-fn pencolor {
-	"Returns the turtle's pen color as an (r, g, b, a) tuple or keyword."
-	() -> do turtle_state > unbox > :pencolor
-}
-
-fn penwidth {
-	"Returns the turtle's pen width in pixels."
-	() -> do turtle_state > unbox > :penwidth
-}
-
-box state = nil
 
 #{
   type
@@ -1332,46 +1065,4 @@ box state = nil
 	each!
 	random
 	random_int
-	ok
-	ok?
-	err
-	err?
-	unwrap!
-	unwrap_or
-	assert!
-	colors
-	turtle_init
-	turtle_commands
-	turtle_state
-	forward!
-	fd!
-	back!
-	bk!
-	left!
-	lt!
-	right!
-	rt!
-	penup!
-	pu!
-	pendown!
-	pd!
-	pencolor!
-	pc!
-	penwidth!
-	pw!
-	background!
-	bg!
-	home!
-	clear!
-	goto!
-	setheading!
-	showturtle!
-	hideturtle!
-	loadstate!
-	position
-	heading
-	pendown?
-	pencolor
-	penwidth
-	state
 }

may_2025_thoughts.md

@@ -488,8 +488,4 @@ Currently fixing little bugs in prelude.
 Here's a list of things that need doing:
 * [ ] Escape characters in strings: \n, \t, and \{,  \}.
 * [ ] `doc!` needs to print the patterns of a function.
-* [ ] I need to return to the question of whether/how strings are ordered; do we use `at`, or do we want `char_at`? etc.
-* [ ] Original implementation of `butlast` is breaking stack discipline; I don't know why. It ends up returning from evaluating one of the arguments straight into a `load` instruction. Something about tail calls and ternary synthetic expressions and base functions. (For now, I can call `slice` instead of `base :slice` and it works.)
-    - Original version of `update` also had this same problem with `assoc`; fixed it by calling the Ludus, rather than Rust, function.
-    - I need this fixed for optimization reasons.
 

sandbox.ld

@@ -1,3 +1,7 @@
-let #{a, b, ...} = #{:a 1, :b 2, :c 3} 
+when {
+	false -> :no
+	nil -> :nope
+	:else -> :yup
+}
+
 
-(a, b)

src/compiler.rs

@@ -607,7 +607,7 @@ impl<'a> Compiler<'a> {
 
                 // patch up the previous no match jumps to jump to clean-up code
                 for idx in jump_idxes {
-                    self.patch_jump(idx, self.len() - idx - 3)
+                    self.patch_jump(idx, self.len() - idx - 2)
                 }
                 // pop everything that was pushed
                 // don't change the compiler stack representation, tho
@@ -662,7 +662,7 @@ impl<'a> Compiler<'a> {
                 let jump_idx = self.stub_jump(Op::Jump);
 
                 for idx in jump_idxes {
-                    self.patch_jump(idx, self.len() - idx - 3)
+                    self.patch_jump(idx, self.len() - idx - 2)
                 }
 
                 self.emit_op(Op::PopN);
@@ -736,12 +736,11 @@ impl<'a> Compiler<'a> {
                 let jump_idx = self.stub_jump(Op::Jump);
 
                 for idx in jump_idxes {
-                    self.patch_jump(idx, self.len() - idx - 3);
+                    self.patch_jump(idx, self.len() - idx - 2);
                 }
 
-                self.pop_n(pairs.len());
+                self.emit_op(Op::PopN);
-                // self.emit_op(Op::PopN);
+                self.emit_byte(pairs.len());
-                // self.emit_byte(pairs.len());
 
                 self.patch_jump(before_load_dict_idx, self.len() - before_load_dict_idx - 3);
                 self.patch_jump(jump_idx, self.len() - jump_idx - 3);

src/main.rs

@@ -112,8 +112,8 @@ pub fn run(src: &'static str) {
     // in any event, the AST should live forever
     let parsed: &'static Spanned<Ast> = Box::leak(Box::new(parse_result.unwrap()));
 
-    let prelude = prelude();
+    // let prelude = prelude();
-    // let prelude = imbl::HashMap::new();
+    let prelude = imbl::HashMap::new();
 
     let mut validator = Validator::new(&parsed.0, &parsed.1, "user input", src, prelude.clone());
     validator.validate();

src/vm.rs

@@ -976,10 +976,6 @@ impl Vm {
                             self.ip = self.frame.ip;
                             // finally, throw the value on the stack
                             self.push(value);
-                            println!(
-                                "=== returning to {} ===",
-                                self.frame.function.as_fn().name()
-                            );
                         }
                         Value::Partial(partial) => {
                             let last_arg = self.pop();