Jester Script
A Lisp-inspired scripting language
Jester Scipt is a hobby-project intended to make a minimal yet flexible language
- This project is by no means professionally developed or maintained
Info
- Types are dynamic and with minimal type enforcement
- Jester Script uses a
prognmodel for every expression: the last thing evaluated is also returned - By default Jester Scipt isn't lazily evaluated but can achieve the same result through quoting
- Jester Script can integrate to bring C++ source code
- Jester Script's runtime is comparable in speed to that of python, although due to C++ extensibility this can vary
Examples
; define a sum function
(defun sum (a b)
(+ a b))
; call function
(sum 2 2)
; assign function result
(set x (sum 2 2))
In Jester Script variables are declared simply by typing out their name. Any symbol not previously defined is immediately declared with a type and value of nil.
; declare variables 'a', 'b', and 'c' to nil
a b c
; print - "nil nil nil"
(println a b c)
In the same manner lists are declared by default by writing out (elements...) - this reflects how everything in Jester Script is just a linked list of values.
; declare list {1, 2, 3}
(1 2 3)
(set list (1 2 3))
; print - "(1 2 3)"
(println list)
Move semantics are pretty simple: everything is copied by value unless a String or a List.
(set val 0)
(set val-cpy val)
; print "0"
(println val-cpy)
(+= val 1)
; print "0"
(println val-cpy)
; VS.
(set list (1 2 3))
(set list-cpy lst)
; print - "(1 2 3)"
(println list-cpy)
(append 4 list)
; print - "(1 2 3 4)"
(println list-cpy)
Lastly, scopes are dynamic, meaning they can be freely created or detsroyed such as with the case of functions of let bindings.
(set x 0)
(let
( (x 10) )
; print - "10"
(println x))
; print - "0"
(println x)
Once the let scope terminated, x reverted to its previous value of 0. The same would occur with function arguments.
Read-Eval-Print-Loop (REPL)
The REPL mode is a form of i/o programming and validating unique to Lisp's progn model. If unfamiliar, since every expression in Lisp must evaluate to something (essentially meaning there are no void evaluations/returns), then every line of code can be (1) Read (2) Evaluated and (3) Printed... in a (4) user Loop.
In Jester Script it looks something like this:
---------- Welcome to Jester-Script ----------
[0]>> x <-- user input
nil <-- computer output
[1]>> (set x 10)
10
[2]>> (+= x 10)
20
[3]>> (defun sum (a b) (+ a b))
sum
[4]>> (sum 2 2)
4
etc...
This mode is useful for testing new ideas and seeing the immediate evaluation of your queries