Inspired by Build Your Own Lisp and Crafting Interpreters, Telescope is a Lisp-family language, which I built to better understand the world of programming languages (and learn Rust).

Because the world needs more civilized languages.

Telescope is modelled after the simplicity of Scheme, with the sensibility and syntax of Clojure. Vectors (resizeable arrays) are a first-class object, and maps (hashmaps) are planned for the future.

(At the moment, lists are implemented as vectors for simplicity and fewer borrow-checker headaches, but I'll change them to singly-linked lists later.)

This project requires a recent version of stable Rust (around 1.12 ). It's been tested and developed on Windows and Arch Linux.

Compile and run with Cargo, the world's greatest build tool ever (seriously why can't every build tool be this easy to use):

$ cargo run

There's even tests! (With a rock-solid 33% code coverage.)

$ cargo test

This is a private project. It's mine to goof up, break, and learn from. I hope to design and implement all major features of this language myself, because I learn best with practical experience.

That said, if I'm actually so far off the mark that I'm hitting the wall instead of the dartboard, feel free to fork and pull request minor changes. I will appreciate any constructive criticism you have.

Telescope comes with 7 primitive data types (maps WIP):

The first six (nil, int, flt, bool, str, fn) are considered atoms. Lists and vectors are collections.

A function call looks like this, in prefix notation:

(operator operands ...)

So adding numbers looks like:

(  1 2 3 4 5 6 7 8 9 10)
=> 55

A vector literal is denoted by []:

> [1 2 3]

(See src/ops.rs for the implementation.)

The usual suspects: arithmetic and comparison.

  - * / = < <= > >=

(At some point I should turn and and or into special forms, for short circuiting. I am not simply lazy.)

(not #f)
#t

(and (= 0 0) (= 1 0))
=> #f

(or (= 0 0) (= 1 0))
=> #t

Because it wouldn't be a Lisp without them.

(first [1 2 3])
=> 1

(rest [1 2 3])
=> [2 3]

(cons 0 1)
=> (0 1)

(See src/forms.rs for the implementation.)

Binds symbol in the current scope to the (evaluated) value of init.

Checks if cond is truthy (i.e. not nil or false). If so, executes the then clause. Otherwise the else? clause is executed (if present).

(Not yet implemented.)

Creates a new scope with the stated bindings before executing the exprs.

Executes exprs in order, returning the last value.

Returns the un-evaluated form.

Defines a named (or anonymous) function.

Defines a macro, which performs text substitution. Pretty much how the entire standard library of Telescope gets defined.

(Only a faint idea how to do this at the moment.)