.gitignore

@@ -33,4 +33,3 @@ target/repl-port
 .repl-buffer.janet
 .env
 src/jpm_tree
-.zig-cache

prelude.ld

@@ -386,19 +386,6 @@ fn downcase {
 	(str as :string) -> base :downcase (str)
 }
 
-fn chars {
-	"Takes a string and returns its characters as a list. Works only for strings with only ascii characters. Panics on any non-ascii characters."
-	(str as :string) -> match base :chars (str) with {
-		(:ok, chrs) -> chrs
-		(:err, msg) -> panic! msg
-	}
-}
-
-fn chars/safe {
-	"Takes a string and returns its characters as a list, wrapped in a result tuple. Works only for strings with only ascii characters. Returns an error tuple on any non-ascii characters."
-	(str as :string) -> base :chars (str)
-}
-
 fn ws? {
 	"Tells if a string is a whitespace character."
 	(" ") -> true
@@ -1399,7 +1386,6 @@ pkg Prelude {
 	box? & boxes
 	butlast & lists strings tuples
 	ceil & math
-	chars & strings
 	clear! & turtles
 	coll? & dicts lists sets tuples
 	colors & turtles

src/base.janet

@@ -129,7 +129,7 @@
     :typed (string (show-patt (get-in x [:data 1])) " as " (show-patt (get-in x [:data 0])))
     :interpolated (get-in x [:token :lexeme])
     :string (get-in x [:token :lexeme])
-    :splat (string "..." (when (x :data) (show-patt (x :data))))
+    :splat (string "..." (when (x :splatted) (show-patt (x :splatted))))
     (error (string "cannot show pattern of unknown type " (x :type)))))
 
 (defn pretty-patterns [fnn]
@@ -235,19 +235,6 @@
 (defn mod [x y] 
   (% x y))
 
-(defn- byte->ascii [c i]
-  (if (< c 128) 
-    (string/from-bytes c)
-    (error (string "non-ASCII character at index" i))))
-
-(defn chars [str]
-  (def out @[])
-  (try 
-    (for i 0 (length str)
-      (array/push out (byte->ascii (str i) i)))
-    ([e] (break [:err e])))
-  [:ok out])
-
 (def ctx {
   "add" +
   "and" ludus/and
@@ -256,7 +243,6 @@
   "atan_2" math/atan2
   "bool" bool
   "ceil" math/ceil
-  "chars" chars
   "concat" concat
   "conj!" conj!
   "conj" conj
@@ -312,9 +298,10 @@
   "upcase" string/ascii-upper
 })
 
-(def base (let [b @{:^type :dict}]
+(def base (let [b @{}]
   (each [k v] (pairs ctx)
     (set (b (keyword k)) v))
   b))
 
+(set (base :^type) :dict)
 

src/doc.janet

@@ -28,7 +28,7 @@
  "lists" ["any?" "append" "at" "butlast" "coll?" "concat" "count" "each!" "empty?" "filter" "first" "fold" "join" "keep" "last" "list" "list?" "map" "ordered?" "random" "range" "rest" "second" "sentence" "slice"]
  "sets" ["any?" "append" "coll?" "concat" "contains?" "count" "empty?" "omit" "random" "set" "set?"]
  "tuples" ["any?" "at" "coll?" "count" "empty?" "first" "last" "ordered?" "rest" "second" "tuple?"]
- "strings" ["any?" "chars" "chars/safe" "concat" "count" "downcase" "empty?" "join" "sentence" "show" "slice" "split" "string" "string?" "strip" "trim" "upcase" "words"]
+ "strings" ["any?" "concat" "count" "downcase" "empty?" "join" "sentence" "show" "slice" "split" "string" "string?" "strip" "trim" "upcase" "words"]
  "types and values" ["assoc?" "bool?" "box?" "coll?" "dict?" "eq?" "fn?" "keyword?" "list?" "neq?" "nil?" "number?" "ordered?" "set?" "show" "some" "some?" "string?" "tuple?" "type"]
  "boxes and state" ["box?" "unbox" "store!" "update!"]
  "results" ["err" "err?" "ok" "ok?" "unwrap!" "unwrap_or"]

src/interpreter.janet

@@ -460,7 +460,6 @@
     [:function :tuple] (call-fn root-ast prev curr)
     # [:applied :tuple] (call-partial root-ast prev curr)
     [:keyword :args] (get (first curr) prev :^nil)
-    [:keyword :tuple] (get (first curr) prev :^nil)
     [:dict :keyword] (get prev curr :^nil)
     [:nil :keyword] :^nil
     [:pkg :keyword] (get prev curr :^nil)
@@ -474,7 +473,7 @@
   # (pp terms)
   (def first-term (first terms))
   (def last-term (last terms))
-   (var prev (interpret first-term ctx))
+  (var prev (interpret first-term ctx))
   # (print "root term: ")
   # (pp prev)
   (for i 1 (-> terms length dec)
@@ -490,9 +489,9 @@
   (def last-term (last terms))
   (for i 1 (-> terms length dec)
     (def curr (interpret (terms i) ctx))
-    (set prev (apply-synth-term (first terms) curr [prev])))
+    (set prev (call-fn (first terms) curr [prev])))
   (def last-fn (interpret last-term ctx))
-  (apply-synth-term (first terms) last-fn [prev]))
+  (call-fn (first terms) last-fn [prev]))
 
 (defn- pkg [ast ctx] 
   (def members (ast :data))

src/ludus.janet

@@ -53,21 +53,21 @@
 
 (comment
 # (do
- # (def start (os/clock))
+ (def start (os/clock))
  (def source `
- doc! (add)
+at ("aéc", 3)
  `)
  (def out (-> source 
   ludus
   j/decode
   ))
- # (def end (os/clock))
+ (def end (os/clock))
  (setdyn :out stdout)
  (pp out)
  (def console (out "console"))
  (print console)
  (def result (out "result"))
  (print result)
- # (print (- end start))
+ (print (- end start))
 )
 

src/parser.janet

@@ -1117,10 +1117,10 @@
 # (do
 (comment
 (def source `
-[...x]
+let foo = :bar
 `)
 (def scanned (s/scan source))
 # (print "\n***NEW PARSE***\n")
 (def a-parser (new-parser scanned))
-(try (def parsed (pattern a-parser)) ([e] (pp e)))
+(def parsed (lett a-parser))
 )

src/validate.janet

@@ -435,12 +435,12 @@ Deferred until a later iteration of Ludus:
  (def rest-arities (keys (arities :rest)))
  (when (empty? rest-arities)
   (array/push (validator :errors)
-   {:node ast :msg "wrong number of arguments"})
+   {:node ast :msg "mismatched arity"})
   (break validator))
  (def rest-min (min ;rest-arities))
  (when (< num-args rest-min)
   (array/push (validator :errors)
-   {:node ast :msg "wrong number of arguments"}))
+   {:node ast :msg "mismatched arity"}))
  validator)
 
 (defn- kw-root [validator]