Find software, services, subscriptions, and specialists; evaluate deliveries, claim source, and learn in the Python-powered Lisp lab.
A little Jik, one idea at a time
The falling code is a small language tour. Choose an example, explore its result, then try it in Lisp Lab.
(define (+ a b) 999)
[(+ 20 22) (#+ 20 22)][999 42]An ordinary name can be shadowed. A leading # looks in the native scope first, so #+ still adds these numbers.
In this runtime, #name falls back to the global scope when no native exists; it skips lexical bindings. The # is a lookup qualifier, not part of the symbol's name.
Try in Lisp Lab[#nil #f #t 42 3.5
"hello" .name 'answer][() #f #t 42 3.5d "hello" .name answer]Nil, booleans, integers, decimals, strings, keywords and quoted symbols are values you can place in a vector.
The bundled printer writes nil as () and adds d to decimal output. A quote keeps answer as a symbol instead of looking up a binding.
Try in Lisp Lab['(1 2 3) '(1 : 2)
[1 2 3] {.answer: 42}][(1 2 3) (1 : 2) [1 2 3] {.answer 42}]A quoted list, an improper pair, a vector and a hashmap each preserve a different shape. The colon separates a pair's head from its tail.
A leading dot makes .answer a keyword. The hashmap printer omits the optional colon between a key and its value.
Try in Lisp Lab((lambda [x] (#* x x))
(#+ 2 3))25A lambda receives evaluated arguments. Here addition produces 5 before the function squares x.
The parameter vector [x] names one argument. #([x] (#* x x)) is the compact form of this lambda.
Try in Lisp Lab(define make-adder
(lambda [n] (lambda [x] (#+ n x))))
(define add-five (funcall make-adder 5))
(funcall add-five 37)42The inner lambda captures n. The returned function still remembers 5 after make-adder has returned.
These functions are stored as values. funcall invokes them explicitly in Jik's separate value and function namespaces.
Try in Lisp Lab((lambda [first : rest] [first rest])
10 20 30)[10 [20 30]]A parameter after : receives all remaining arguments. first gets 10, while rest collects 20 and 30.
This website's runtime represents rest arguments as a vector. An empty rest sequence is [].
Try in Lisp Lab((vau E [form] form)
(#+ 20 22))(#+ 20 22)A vau receives raw operands instead of evaluated values. Returning form gives us the addition expression, without running it.
E is the caller's environment. #[E [form] form] is the compact form of this operative.
Try in Lisp Lab((lambda [x]
((vau E [form] (eval E form))
(#+ x 2)))
40)42The operative explicitly evaluates its operand in the caller's environment E, where x is bound to 40.
In this runtime, eval takes the environment first, then the expression. An operative controls which operands it evaluates.
Try in Lisp Lab(define-macro unless
(vau E [test : body]
`(if ~test #nil (begin ~@body))))
(unless #f (#+ 20 22))42unless builds an if expression from raw operands. Backquote supplies the template; ~ inserts the test and ~@ splices the body forms.
The returned expression is evaluated at the call site. This example introduces no temporary bindings; it does not claim automatic macro hygiene.
Try in Lisp Lab(map (lambda [n] (#* n n))
(range 1 5))[1 4 9 16]range includes its start and excludes its end. map applies the lambda to each element, producing the first four positive squares.
(range 5) starts at zero; (range 0) produces [].
Try in Lisp LabMarketplace
3 simple editors in one with Lisp-like support
JIK language and register VM 525+
An unsolved, community-preordered project request for visual continuation tracing and exercises.
JIK language and register VM 315+
Network
JIK language designer and register-VM knowledge provider
JIK language, compiler, VM, and assessed curriculum author.
◉ English · ◉ Čeština
✎ English · ✎ Čeština
Repository
aegwenia/jik/native-global-lookup
Keep # outside symbol identity; resolve #name native first and then global, with @ selecting the function namespace.
aegwenia/jik/reader-literals
Read nil, booleans, integers, decimals, strings, characters, bytes, keywords, symbols, lists, vectors, and maps. Bare t/f are Boolean fallbacks only when ordinary bindings do not shadow them; #t/#f are explicit literals.
aegwenia/jik/definitions-bindings
Create value cells, update an existing cell, and distinguish declaration from definition.
aegwenia/jik/lexical-binding
Choose parallel, sequential, recursive, or loop-shaped lexical binding without exposing host state.
aegwenia/jik/conditions-logic
Branch and compose predicates while preserving the value of the selected form.
aegwenia/jik/functions-lambda
Create closures with fixed/rest parameters; parameters are lexical cells and rest arguments are bounded views.