remove repl cruft

.gitignore

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

prelude.ld

@@ -386,6 +386,19 @@ 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
@@ -1386,6 +1399,7 @@ 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 :splatted) (show-patt (x :splatted))))
+    :splat (string "..." (when (x :data) (show-patt (x :data))))
     (error (string "cannot show pattern of unknown type " (x :type)))))
 
 (defn pretty-patterns [fnn]
@@ -235,6 +235,19 @@
 (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
@@ -243,6 +256,7 @@
   "atan_2" math/atan2
   "bool" bool
   "ceil" math/ceil
+  "chars" chars
   "concat" concat
   "conj!" conj!
   "conj" conj
@@ -298,10 +312,9 @@
   "upcase" string/ascii-upper
 })
 
-(def base (let [b @{}]
+(def base (let [b @{:^type :dict}]
   (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?" "concat" "count" "downcase" "empty?" "join" "sentence" "show" "slice" "split" "string" "string?" "strip" "trim" "upcase" "words"]
+ "strings" ["any?" "chars" "chars/safe" "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,6 +460,7 @@
     [: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)
@@ -489,9 +490,9 @@
   (def last-term (last terms))
   (for i 1 (-> terms length dec)
     (def curr (interpret (terms i) ctx))
-    (set prev (call-fn (first terms) curr [prev])))
+    (set prev (apply-synth-term (first terms) curr [prev])))
   (def last-fn (interpret last-term ctx))
-  (call-fn (first terms) last-fn [prev]))
+  (apply-synth-term (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 `
-at ("aéc", 3)
+ doc! (add)
  `)
  (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 `
-let foo = :bar
+[...x]
 `)
 (def scanned (s/scan source))
 # (print "\n***NEW PARSE***\n")
 (def a-parser (new-parser scanned))
-(def parsed (lett a-parser))
+(try (def parsed (pattern a-parser)) ([e] (pp e)))
 )

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 "mismatched arity"})
+   {:node ast :msg "wrong number of arguments"})
   (break validator))
  (def rest-min (min ;rest-arities))
  (when (< num-args rest-min)
   (array/push (validator :errors)
-   {:node ast :msg "mismatched arity"}))
+   {:node ast :msg "wrong number of arguments"}))
  validator)
 
 (defn- kw-root [validator]