ludus/src/ludus.janet

# an integrated Ludus interpreter
# devised in order to run under wasm
# takes a string, returns a string with a json object
# (try (os/cd "janet") ([_] nil)) # for REPL
(import /src/scanner :as s)
(import /src/parser :as p)
(import /src/validate :as v)
(import /src/interpreter :as i)
(import /src/errors :as e)
(import /src/base :as b)
(import /src/prelude :as prelude)
(import /src/json :as j)

(defn ludus [source]
 (when (= :error prelude/pkg) (error "could not load prelude"))
 (def ctx @{:^parent prelude/ctx})
 (def errors @[])
 (def draw @[])
 (var result @"")
 (def console @"")
 (setdyn :out console)
 (def out @{:errors errors :draw draw :result result :console console})
 (def scanned (s/scan source))
 (when (any? (scanned :errors))
   (each err (scanned :errors)
    (e/scan-error err))
   (break (-> out j/encode string)))
 (def parsed (p/parse scanned))
 (when (any? (parsed :errors))
  (each err (parsed :errors)
   (e/parse-error err))
  (break (-> out j/encode string)))
 (def validated (v/valid parsed ctx))
 (when (any? (validated :errors))
  (each err (validated :errors)
   (e/validation-error err))
  (break (-> out j/encode string)))
 (try
  (set result (i/interpret (parsed :ast) ctx))
  ([err] 
   (e/runtime-error err)
   (break (-> out j/encode string))))
 (setdyn :out stdout)
 (set (out :result) (b/show result))
 (var post @{})
 (try
  (set post (i/interpret prelude/post/ast ctx))
  ([err] (e/runtime-error err)))
 (set (out :draw) (post :draw))
 (-> out j/encode string))

# (comment
(do
(def source `
fn strip_punctuation {
 ("{x},{y}") -> strip_punctuation ("{x}{y}")
 ("{x}.{y}") -> strip_punctuation ("{x}{y}")
 ("{x};{y}") -> strip_punctuation ("{x}{y}")
 ("{x}:{y}") -> strip_punctuation ("{x}{y}")
 ("{x}?{y}") -> strip_punctuation ("{x}{y}")
 ("{x}!{y}") -> strip_punctuation ("{x}{y}")
 (x) -> x
}

fn trim_left {
 (" {x}") -> trim_left ("{x}")
 ("\n{x}") -> trim_left ("{x}")
 ("\t{x}") -> trim_left ("{x}")
 (x) -> x
}

fn trim_right {
 ("{x} ") -> trim_right ("{x}")
 ("{x}\n") -> trim_right ("{x}")
 ("{x}\t") -> trim_right ("{x}")
 (x) -> x
}

fn trim (x) -> do x > trim_left > trim_right

trim_left ("      
 foo")
`)
(def out (-> source 
 ludus
 j/decode
 ))
(setdyn :out stdout)
(def console (out "console"))
(print console)
(def result (out "result"))
(print result)
)