initial commit with basic expression interpreter

.gitignore

···
+_build/

LICENSE

···
+Copyright (c) 2025 Robert Nystrom, Peter Rice
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bundle/info.jdn

···
+@{:author "Peter Rice"
+  :dependencies @["judge" "spork"]
+  :description "Lox programming language, from the book Crafting Interpreters"
+  :jpm-dependencies @["spork" "judge"]
+  :license "MIT"
+  :name "lox"
+  :version "0.0.1"}

bundle/init.janet

···
+(if (dyn :install-time-syspath)
+  (use @install-time-syspath/spork/declare-cc)
+  (use spork/declare-cc))
+(dofile "project.janet" :env (jpm-shim-env))

flake.lock

···
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1754214453,
+        "narHash": "sha256-Q/I2xJn/j1wpkGhWkQnm20nShYnG7TI99foDBpXm1SY=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "5b09dc45f24cf32316283e62aec81ffee3c3e376",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

···
+{
+  description = "Janet implementation of Lox, from the book Crafting Interpreters";
+
+  inputs.nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+
+  outputs =
+    { self, nixpkgs }:
+    let
+      forAllSystems =
+        mkOutputs:
+        nixpkgs.lib.genAttrs [
+          "aarch64-linux"
+          "aarch64-darwin"
+          "x86_64-darwin"
+          "x86_64-linux"
+        ] (system: mkOutputs nixpkgs.legacyPackages.${system});
+    in
+    {
+      devShells = forAllSystems (pkgs: {
+        default = pkgs.mkShell {
+          packages = with pkgs; [
+            janet
+            jpm
+          ];
+        };
+      });
+    };
+}

lox/interpreter.janet

···
+(defn- unary-op [op right]
+  (match ((op :token) 0)
+    :minus (if (number? right) (- right) (error "Operand must be number"))
+    :bang (not right)
+    token (errorf "Unknown operator %q" token)))
+
+(defn- strings [op]
+  |(if (and (string? $0) (string? $1))
+     (op $0 $1)
+     (error "Operands must be strings")))
+
+(defn- numbers [op]
+  |(if (and (number? $0) (number? $1))
+     (op $0 $1)
+     (error "Operands must be numbers")))
+
+(defn- bin-op [left op right]
+  ((match ((op :token) 0)
+     :plus (cond
+             (and (number? left) (number? right)) +
+             (and (string? left) (string? right)) string
+             (error "Operands must be two numbers or two strings"))
+     :minus (numbers -)
+     :star (numbers *)
+     :slash (numbers /)
+     :eq-eq =
+     :bang-eq not=
+     :greater (numbers >)
+     :greater-eq (numbers >=)
+     :less (numbers <)
+     :less-eq (numbers <=)
+     token (errorf "Unknown operator %q" token))
+    left right))
+
+(defn evaluate [expr]
+  (match expr
+    [:literal value] value
+    [:grouping expr] (evaluate expr)
+    [:unary op right] (unary-op op (evaluate right))
+    [:binary left op right] (bin-op (evaluate left) op (evaluate right))
+    [:logical left op right] (case ((op :token) 0)
+                               :or (if-let [left (evaluate left)] left (evaluate right))
+                               :and (if-let [left (evaluate left)] (evaluate right) left))
+    (errorf "Unknown expression type %q" (expr 0))))
+
+(var execute nil)
+
+(defn- execute-block [stmts]
+  (each stmt stmts (execute stmt)))
+
+(varfn execute [stmt]
+  (match stmt
+    [:print expr] (printf "%q" (evaluate expr))
+    [:expr expr] (xprintf (dyn :expr-out stderr) "%Q" (evaluate expr))
+    # [:return word value] (throw return)
+    [:if cond then else] (do
+                           (cond
+                             (evaluate cond) (execute then)
+                             (not (nil? else)) (execute else)))
+    [:while cond body] (while (evaluate cond) (execute body))
+    [:block stmts] (execute-block stmts)
+    (errorf "Unknown statement type %q" (stmt 0))))
+
+(defn interpret [stmts]
+  # TODO error handling
+  (each stmt stmts (try (execute stmt)
+                     ([e] (eprint e)))))

lox/main.janet

···
+(import ./scanner)
+(import ./parser)
+(import ./interpreter)
+(import ./repl)
+
+(defn process [contents]
+  (-> contents
+      scanner/scan
+      parser/make-parser
+      :parse
+      interpreter/interpret))
+
+(defn main [_ &opt path & args]
+  (unless (empty? args) (error "expected 0 or 1 args"))
+  (if (nil? path)
+    (repl/run process)
+    (with-dyns [:expr-out @""] (process (slurp path)))))

lox/parser.janet

···
+(import ./scanner)
+
+# fns used out of declaration order
+(var- expression nil)
+(var- statement nil)
+(var- declaration nil)
+
+(defn- token-type [token] ((token :token) 0))
+
+(def- parser-proto
+  @{:peek |(($ :tokens) ($ :current))
+    :prev |(($ :tokens) (- ($ :current) 1))
+    :eof? |(= (length ($ :tokens)) ($ :current))
+    :advance |(++ ($ :current))
+    :check (fn [self ty]
+             (= ty (token-type (:peek self))))
+    :match (fn [self & types]
+             (unless (:eof? self)
+               (def token (:peek self))
+               (when (has-value? types (token-type token))
+                 (:advance self)
+                 token)))
+    :consume (fn [self ty msg]
+               (if-let [token (:match self ty)]
+                 token (error msg)))
+    :parse |(do (def stmts @[])
+              (while (not (:eof? $))
+                (array/push stmts (declaration $)))
+              stmts)})
+
+(defn make-parser [tokens]
+  (table/setproto @{:current 0 :tokens tokens} parser-proto))
+
+(defn- primary [parser]
+  (def token (:match parser :false :true :nil :num :str :ident :left-paren))
+  (unless token (errorf "Expect expression: %q" (:peek parser)))
+  (match (token :token)
+    [:false] [:literal false]
+    [:true] [:literal true]
+    [:nil] [:literal nil]
+    [:num val] [:literal val]
+    [:str val] [:literal val]
+    [:ident name] [:variable name]
+    [:left-paren] (do (def expr (expression parser))
+                    (:consume parser :right-paren "Expect ')' after expression.")
+                    [:grouping expr])))
+
+(defn- doCall [parser callee]
+  (def args @[])
+  (unless (:check parser :right-paren)
+    (array/push args (expression parser))
+    (while (:match parser :comma)
+      (when (>= (length args) 255)
+        (error "Can't have more than 255 arguments."))
+      (array/push args (expression parser))))
+  (def paren (:consume parser :right-paren "Expect ')' after arguments."))
+  [:call callee paren args])
+
+(defn- call [parser]
+  (var expr (primary parser))
+  (while (:match parser :left-paren)
+    (set expr (doCall parser expr)))
+  expr)
+
+(defn- unary [parser]
+  (if-let [token (:match parser :bang :minus)]
+    (let [op token
+          right (unary parser)]
+      [:unary op right])
+    (call parser)))
+
+(defmacro bin-parse [ty name f & token-types]
+  ~(defn- ,name [parser]
+     (var expr (,f parser))
+     (while (def op (:match parser ,;token-types))
+       (def right (,f parser))
+       (set expr [,ty expr op right]))
+     expr))
+(defmacro binary [& args] ~(bin-parse :binary ,;args))
+(defmacro logical [& args] ~(bin-parse :logical ,;args))
+(binary factor unary :slash :star)
+(binary term factor :plus :minus)
+(binary comparison term :greater :greater-eq :less :less-eq)
+(binary equality comparison :bang-eq :eq-eq)
+(logical op-and equality :and)
+(logical op-or op-and :or)
+
+(defn- assignment [parser]
+  (var expr (op-or parser))
+  (when (def equals (:match parser :eq))
+    (def value (assignment parser))
+    (match expr
+      [:variable name] (set expr [:assignment name value])
+      # TODO put equals token in error?
+      _ (errorf "Invalid assignment target: %M" expr)))
+  expr)
+
+(varfn expression [parser] (assignment parser))
+
+(defn- block [parser]
+  (def stmts @[])
+  (while (not (or (:check parser :right-brace) (:eof? parser)))
+    (do (array/push stmts (declaration parser))))
+  (:consume parser :right-brace "Expect '}' after block.")
+  stmts)
+
+(defn- function [parser kind]
+  (def name (:consume parser :ident (string/format "Expect %s name" kind)))
+  (:consume parser :left-paren (string/format "Expect '(' after %s name" kind))
+  (def params @[])
+  (unless (:check parser :right-paren)
+    (array/push params (:consume parser :ident "Expect parameter name."))
+    (while (:match parser :comma)
+      (when (>= (length params) 255)
+        # TODO token in error
+        (error "Can't have more than 255 parameters."))
+      (array/push params (:consume parser :ident "Expect parameter name."))))
+  (:consume parser :right-paren "Expect ')' after parameters.")
+  (:consume parser :left-brace (string/format "Expect '{' before %s body" kind))
+  [:fun name params (block parser)])
+
+(defn- var-decl [parser]
+  (def name (:consume parser :ident "Expect variable name"))
+  (def init (if (:match parser :eq) (expression parser) nil))
+  (:consume parser :semicolon "Expect ';' after variable declaration.")
+  [:var name init])
+
+(defn- expression-statement [parser]
+  (def expr (expression parser))
+  (:consume parser :semicolon "Expect ';' after value.")
+  [:expr expr])
+
+(defn- for-statement [parser]
+  (:consume parser :left-paren "Expect '(' after 'for'.")
+  (def ty (if-let [token (:match parser :semicolon :var)] (token-type token)))
+  (def init (case ty
+              :semicolon nil
+              :var (var-decl parser)
+              (expression-statement parser)))
+  (def cond (if (:check parser :semicolon) [:literal true] (expression parser)))
+  (:consume parser :semicolon "Expect ';' after loop condition.")
+  (def incr (unless (:check parser :right-paren) (expression parser)))
+  (:consume parser :right-paren "Expect ')' after for clauses.")
+  (var body (statement parser))
+  (when incr (set body [:block [body [:expr incr]]]))
+  (set body [:while cond body])
+  (if init [:block [init body]] body))
+
+(defn- if-statement [parser]
+  (:consume parser :left-paren "Expect '(' after 'if'.")
+  (def cond (expression parser))
+  (:consume parser :right-paren "Expect ')' after if condition.")
+  (def then (statement parser))
+  (def else (if (:match parser :else) (statement parser) nil))
+  [:if cond then else])
+
+(defn- print-statement [parser]
+  (def value (expression parser))
+  (:consume parser :semicolon "Expect ';' after value.")
+  [:print value])
+
+(defn- return-statement [parser]
+  (def kw (:prev parser))
+  (def value (if (:check parser :semicolon)
+               nil
+               (expression parser)))
+  (:consume parser :semicolon "Expect ';' after return value.")
+  [:return kw value])
+
+(defn- while-statement [parser]
+  (:consume parser :left-paren "Expect '(' after 'while'.")
+  (def cond (expression parser))
+  (:consume parser :right-paren "Expect ')' after while condition.")
+  (def body (statement parser))
+  [:while cond body])
+
+(varfn statement [parser]
+  (def token (:match parser :for :if :print :return :while :left-brace))
+  (def ty (if token (token-type token)))
+  (case ty
+    :for (for-statement parser)
+    :if (if-statement parser)
+    :print (print-statement parser)
+    :return (return-statement parser)
+    :while (while-statement parser)
+    :left-brace [:block (block parser)]
+    (expression-statement parser)))
+
+(varfn declaration [parser]
+  # TODO catch parse errors and synchronize
+  (def token (:match parser :fun :var))
+  (def ty (if token (token-type token)))
+  (match ty
+    :fun (function parser :function)
+    :var (var-decl parser)
+    (statement parser)))
+
+(defn parse [parser]
+  (:parse parser))

lox/project.janet

···
+(declare-project
+  :name "lox"
+  :description ```lox```
+  :license "MIT"
+  :author ```Peter Rice```
+  :dependencies @["spork" "judge"]
+  :version "0.0.1")
+
+(declare-binscript
+  :main "bin/lox"
+  :hardcode-syspath true
+  :is-janet true)
+
+(declare-executable
+  :name "lox"
+  :entry "./lox.janet")

lox/repl.janet

···
+(import spork/stream)
+
+(defn- inpput-prompt []
+  (prin "> ")
+  (:flush stdout))
+
+(defn run [process]
+  (var buf @"")
+  (os/sigaction :int |(do (buffer/clear buf) (print) (inpput-prompt)) true)
+  (with [input (os/open "/dev/stdin" :r)]
+    (forever
+      (inpput-prompt)
+      (prompt :a)
+      (forever (match (string (:read input 1))
+                 "" (when (empty? buf) (set buf nil) (break))
+                 "\n" (break)
+                 c (buffer/push-string buf c)))
+      (when (nil? buf) (break))
+      (try (process buf) ([err] (printf "error: %s" err)))
+      (buffer/clear buf))))

lox/scanner.janet

···
+(def- keywords (struct ;(mapcat
+                          |[$ (keyword $)]
+                          ["and" "class" "else" "false"
+                           "for" "fun" "if" "nil"
+                           "or" "print" "return" "super"
+                           "this" "true" "var" "while"])))
+
+(def- double-operators {"!=" :bang-eq "==" :eq-eq
+                        "<=" :less-eq ">=" :greater-eq})
+
+(def- single-operators {"(" :left-paren ")" :right-paren
+                        "{" :left-brace "}" :right-brace
+                        "-" :minus "+" :plus "*" :star "/" :slash
+                        "!" :bang "=" :eq "<" :less ">" :greater
+                        "," :comma "." :dot ";" :semicolon})
+
+(defn- get-keyword [word]
+  (if-let [kw (get keywords word)] [kw] [:ident word]))
+
+(defn- token [inner make-token]
+  ~(/ (* (line) ,inner) ,|{:token (make-token $&) :line $0}))
+
+(defn- token0 [inner tok]
+  (token inner (fn [&] [tok])))
+
+(defn- token1 [inner make-token]
+  (token inner (fn [[val]] (make-token val))))
+
+(def- grammar
+  ~{:keyword-or-ident (<- (* :a :w*))
+    :number (<- (* :d+ (? (* "." :d+))))
+    :string (* `"` (+ (<- (to `"`)) (error (constant "unterminated string"))) `"`)
+    :main (any (+ :s
+                  (* "//" (to "\n"))
+                  ,;(seq [[str tok] :pairs double-operators] (token0 str tok))
+                  ,;(seq [[str tok] :pairs single-operators] (token0 str tok))
+                  ,(token1 :keyword-or-ident get-keyword)
+                  ,(token1 :number |[:num (scan-number $)])
+                  ,(token1 :string |[:str $])))})
+
+(def- peg (peg/compile grammar))
+
+(defn scan [source]
+  (peg/match peg source))

project.janet

···
+(declare-project
+  :name "lox"
+  :description ```Implementation of the Lox programming language from Crafting Interpreters```
+  :license "MIT"
+  :author ```Peter Rice```
+  :dependencies @["spork" "judge"]
+  :version "0.0.1")
+
+(declare-executable
+  :name "lox"
+  :entry "lox/main.janet"
+  :install true)

test/test_interpreter.janet

···
+(use judge)
+(use ../lox/interpreter)
+
+(test (evaluate [:literal false]) false)
+(test (evaluate [:unary {:token [:minus]} [:literal 1]]) -1)
+(test (evaluate [:unary {:token [:bang]} [:literal false]]) true)
+(test (evaluate [:unary {:token [:bang]} [:literal 1]]) false)
+
+(def add [:binary [:literal 1] {:token [:plus]} [:literal 2]])
+(def concat [:binary [:literal "1"] {:token [:plus]} [:literal "2"]])
+(test (evaluate add) 3)
+(test (evaluate [:binary add {:token [:plus]} [:literal 2]]) 5)
+(test (evaluate concat) "12")
+(test (evaluate [:binary [:literal 1] {:token [:minus]} [:literal 2]]) -1)
+
+(test-error (evaluate [:unary {:token [:minus]} [:literal ""]])
+            "Operand must be number")
+(test-error (evaluate [:binary [:literal 1] {:token [:plus]} [:literal "2"]])
+            "Operands must be two numbers or two strings")
+(test-error (evaluate [:binary [:literal "1"] {:token [:plus]} [:literal 2]])
+            "Operands must be two numbers or two strings")
+(test-error (evaluate [:binary [:literal true] {:token [:plus]} [:literal true]])
+            "Operands must be two numbers or two strings")
+(test-error (evaluate [:binary [:literal ""] {:token [:minus]} [:literal 2]])
+            "Operands must be numbers")
+(test-error (evaluate [:binary [:literal 1] {:token [:minus]} [:literal ""]])
+            "Operands must be numbers")
+(test-error (evaluate [:binary [:literal 1] {:token [:pow]} [:literal 2]])
+            "Unknown operator :pow")
+
+(test (evaluate [:binary [:literal 1] {:token [:greater]} [:literal 2]]) false)
+(test (evaluate [:binary [:literal 2] {:token [:greater-eq]} [:literal 2]]) true)
+(test (evaluate [:binary [:literal "12"] {:token [:eq-eq]} concat]) true)
+(test (evaluate [:binary [:literal 1] {:token [:eq-eq]} [:literal 1]]) true)
+(test (evaluate [:binary [:literal 1] {:token [:eq-eq]} [:literal 2]]) false)
+(test (evaluate [:binary [:literal 1] {:token [:eq-eq]} [:literal "1"]]) false)
+
+(def nan [:binary [:literal 0] {:token [:slash]} [:literal 0]])
+(test (evaluate [:binary nan {:token [:eq-eq]} nan]) false)
+(test (evaluate [:binary [:literal 1] {:token [:bang-eq]} [:literal 1]]) false)
+(test (evaluate [:binary [:literal 1] {:token [:bang-eq]} [:literal 2]]) true)
+(test (evaluate [:logical [:literal false] {:token [:and]} [:literal true]]) false)
+(test (evaluate [:logical [:literal false] {:token [:or]} [:literal true]]) true)
+(test (evaluate [:logical [:literal false] {:token [:or]} [:literal false]]) false)
+
+(test-stdout (execute [:print [:literal nil]]) `
+  nil
+`)
+(test-stdout (execute [:print [:literal true]]) `
+  true
+`)
+(test-stdout (execute [:print [:literal 1]]) `
+  1
+`)
+(test-stdout (execute [:print [:literal 1.1]]) `
+  1.1
+`)
+(test-stdout (execute [:print [:literal "one"]]) `
+  "one"
+`)
+(test-stdout (execute [:if [:literal true] [:print [:literal 1]] nil]) `
+  1
+`)
+(test-stdout (execute [:if [:literal true] [:print [:literal 1]] [:print [:literal 2]]]) `
+  1
+`)
+# TODO judge fails on empty stdout
+# (test-stdout (execute [:if [:literal false] [:print [:literal 1]] nil]) "")
+(test-stdout (execute [:if [:literal false] [:print [:literal 1]] [:print [:literal 2]]]) `
+  2
+`)

test/test_main.janet

···
+(use judge)
+(use ../lox/main)
+
+(test-stdout (process "print 2 * (1 + 2);") `
+  6
+`)
+(test-stdout (process "if (true) print 1; else print 2;") `
+  1
+`)
+(test-stdout (process "if (false) print 1; else print 2;") `
+  2
+`)

test/test_parser.janet

···
+(use judge)
+(use ../lox/parser)
+
+(defn parse [tokens] (:parse (make-parser tokens)))
+
+(test (parse @[{:token [:num 1]}
+               {:token [:plus]}
+               {:token [:num 2]}
+               {:token [:semicolon]}])
+      @[[:expr
+         [:binary
+          [:literal 1]
+          {:token [:plus]}
+          [:literal 2]]]])
+(test (parse @[{:token [:print]}
+               {:token [:num 1]}
+               {:token [:plus]}
+               {:token [:num 2]}
+               {:token [:semicolon]}])
+      @[[:print
+         [:binary
+          [:literal 1]
+          {:token [:plus]}
+          [:literal 2]]]])
+
+(test (parse @[{:token [:if]}
+               {:token [:left-paren]}
+               {:token [:true]}
+               {:token [:right-paren]}
+               {:token [:print]}
+               {:token [:nil]}
+               {:token [:semicolon]}])
+      @[[:if
+         [:literal true]
+         [:print [:literal nil]]
+         nil]])
+
+(test (parse @[{:token [:if]}
+               {:token [:left-paren]}
+               {:token [:true]}
+               {:token [:right-paren]}
+               {:token [:print]}
+               {:token [:true]}
+               {:token [:semicolon]}
+               {:token [:else]}
+               {:token [:print]}
+               {:token [:false]}
+               {:token [:semicolon]}])
+      @[[:if
+         [:literal true]
+         [:print [:literal true]]
+         [:print [:literal false]]]])

test/test_scanner.janet

···
+(use judge)
+(use ../lox/scanner)
+
+(test (scan "1 + 2")
+      @[{:line 1 :token [:num 1]}
+        {:line 1 :token [:plus]}
+        {:line 1 :token [:num 2]}])
+(test (scan "true or false")
+      @[{:line 1 :token [:true]}
+        {:line 1 :token [:or]}
+        {:line 1 :token [:false]}])
+(test (scan "print 2 * (1 + 2)")
+      @[{:line 1 :token [:print]}
+        {:line 1 :token [:num 2]}
+        {:line 1 :token [:star]}
+        {:line 1 :token [:left-paren]}
+        {:line 1 :token [:num 1]}
+        {:line 1 :token [:plus]}
+        {:line 1 :token [:num 2]}
+        {:line 1 :token [:right-paren]}])
+(test (scan "if (true) print nil;")
+      @[{:line 1 :token [:if]}
+        {:line 1 :token [:left-paren]}
+        {:line 1 :token [:true]}
+        {:line 1 :token [:right-paren]}
+        {:line 1 :token [:print]}
+        {:line 1 :token [:nil]}
+        {:line 1 :token [:semicolon]}])
+(test (scan "if (true) { print nil; }")
+      @[{:line 1 :token [:if]}
+        {:line 1 :token [:left-paren]}
+        {:line 1 :token [:true]}
+        {:line 1 :token [:right-paren]}
+        {:line 1 :token [:left-brace]}
+        {:line 1 :token [:print]}
+        {:line 1 :token [:nil]}
+        {:line 1 :token [:semicolon]}
+        {:line 1 :token [:right-brace]}])