Lispaas (lisp as a service)

A mini lisp interpreter

How to use:

To execute code:

const result = @zackoverflow.lisp(" (+ 1 2)")

To just parse and return the AST:

const ast = @zackoverflow.lisp("(+ 1 2)", true)

The value returned is the last expression of the program, for example:

const lispResult = @zackoverflow.lisp("(+ 1 2) (+ 400 20)")
console.log('Val', lispResult.val === 420)

Example: Compute Fibonacci sequence

let result = @zackoverflow.lisp(`
(defun fib (x)
  (if (<= x 1)
    x
    (defun impl (i n-1 n-2)
        (if (= x i)
            (+ n-1 n-2)
            (impl (+ i 1) (+ n-1 n-2) n-1)))
    (impl 2 1 0)))

(assert-eq 0 (fib 0))
(assert-eq 1 (fib 1))
(assert-eq 1 (fib 2))
(assert-eq 2 (fib 3))
(assert-eq 3 (fib 4))
(assert-eq 5 (fib 5))
(assert-eq 8 (fib 6))
(assert-eq 13 (fib 7))
`);

Documentation

Functions

You can define a function like so:

(defun hello (x) (print x))

Rest/variadic arguments are also supported

(defun variable-amount-of-args (...args) (print args))

(variable-amount-of-args "Hello" "World!")

Lists

Define a list like so:

(let ((my-list (list 1 2 3 4)))
  (print my-list)
  (print (list-get my-list 1)))

Internally, a list is just a Javascript array. So indexing is O(1), but that does mean cdr requires copying (vs the linked list implementation).

Plists

Property lists, or records. Internally these are Javascript objects.

Create a plist like so:

(set null :key "Value")

TODO

Readme
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
export const lisp = (src: string, onlyParse: boolean = false) => {
type LispValue = {
type: "null";
value: null;
} | {
type: "str";
value: string;
} | {
type: "num";
value: number;
} | {
type: "sym";
value: string;
} | {
type: "symp";
value: string;
} | {
type: "lambda";
value: Lambda;
} | {
type: "builtin";
value: string;
} | {
type: "plist";
value: Plist;
} | {
type: "list";
value: Array<LispValue>;
};
type List = Array<LispValue>;
type Plist = Record<string, LispValue>;
type Lambda = {
containsSpreadArg: boolean;
args: string[];
code: AstExpr;
};
type AstExpr =
| {
type: "str";
value: [
string,
];
}
| {
type: "num";
value: [
number,
];
}
| App
👆 This is a val. Vals are TypeScript snippets of code, written in the browser and run on our servers. Create scheduled functions, email yourself, and persist small pieces of data — all from the browser.