sabaini gmbh

Numbers

First up, integers. By default they are Long but are automatically expanded to BigInts. Radixes other than decimal can also be used as well as the old 0xDEADBEEF and 0777 notations:

user> 1
1
user> -1
-1
user> 99999999999999999999999999999999999999
99999999999999999999999999999999999999N
user> 0xff
255
user> 2r1100
12
user> 010
8
user> 32r11
33

Floating point can be arbitrarily precise. They can be given in dot-notation or scientific:

user> 1.1
1.1
user> 1.1e10
1.1E10

Clojure has built-in support for rationals:

user> 1/9
1/9
user> 2/4
1/2
user> 4/4
1

Symbols

AKA names for function params, local vars, globals, etc. Syntax is more permissive than in other langs:

user> (def x 23)
#'user/x
user> x
23
user> (def i-am-a-pretty-long-name-for-something-simple! x)
#'user/i-am-a-pretty-long-name-for-something-simple!
user> i-am-a-pretty-long-name-for-something-simple!
23
user> (def "illegal" 3)
CompilerException ...

Keywords

Keywords are symbols that always evaluate to themselves. AFAICT the same thing as Erlangs' atoms: constants that can be used to (very efficiently) tag other values or serve as components in enumerations. I guess in C you'd probably use power-of-two preprocessor #defines to achieve something not too dissimilar, eg. #define FOO 2; #define BAR 4; #define QUUX 8; ...

Strings and characters

Pretty standard unicode strings; multiline strings allowed:

user> "α and ω"
"α and ω"
user> "embedded
 newlines are ok"
"embedded\n newlines are ok"

Character literals:

user> \A
\A
user> \α
\α
user> \
\space

Lists and function calls

Lisp == LISt Processing, so no wonder lists get some special treatment. Most importantly, Clojure will always try to resolve the first element of the list to a function (or macro or operator) and treat the rest of the list either as function args (after evaluating them) or pass them for handling to the operator or macro. Lists are written as elements in parentheses, separated by spaces. Eg. the plus operator, and several numbers in a list:

user> (+ 2 3)
5
user> (+ 1/4 2/4 1.0)
1.75

The function vector takes its arguments and puts them in a vector:

user> (vector 1 2 3)
[1 2 3]

Vectors

Vectors are lists without that Lispy evaluation, ie. all elements eval to themselves (like you would expect). Like lists, vectors may take any kind of element.

Notation is in square brackets:

user> [\a [2] [] () (+ 2 1)]
[\a [2] [] () 3]

Maps

Yay, maps! We Pythonistas love maps! Maps are dictionaries are hashmaps are associative arrays; but actually I like the term map best. Notation: curly brackets with key-value pairs.

user> {1 "one", 2 "two", (+ 1 2) "three"}
{1 "one", 2 "two", 3 "three"}
user> {1}
RuntimeException Map literal must contain...

The commas are actually optional. Unlike Python, maps as keys seem ok:

user> {{} "empty map" nil "nil" () "empty list"}
{{} "empty map", nil "nil", () "empty list"}

Sets

Unique items:

user> #{\a "a" :a}
#{\a "a" :a}
user> #{1 1}
IllegalArgumentException Duplicate key...