JitterLisp ¶

1.3.1 Comparison with other Lisps ¶

The JitterLisp language is first of all a Lisp dialect, and as such will feel familiar to any programmer already mastering any other Lisp.

JitterLisp is a lexically-scoped higher-order homoiconic¹ Lisp/1 featuring closures, garbage collection, quasiquoting and Turing-complete macros.

Every syntactic form in JitterLisp is an expression, and nontrivial expressions will contain sub-expressions; JitterLisp has no “statements” as a distinct syntactic category, nor special forms which are only valid at the top level. Variables are mutable by default, and iteration and recursion are both supported. Tail calls incur no space overhead except in inter-calls between compiled and interpreted code.

Typing is dynamic. JitterLisp datatypes include the empty list object, symbols, characters, conses and procedures. Non-empty lists are cdr-nested conses. At the present time fixnums are the only numeric type.

Each procedure may be either interpreted or compiled, and procedures of different kinds are allowed to call each other with no restrictions and no difference in observable behavior apart from performance. Interpreted procedures can be compiled at run time without affecting their identity as objects.

[FIXME: quoting and quasiquoting are Lispy, not epsilonian]

[FIXME: compare with standard Lisp dialects]

[FIXME: Many of the superficial features of JitterLisp, particularly at the lexical level, come from Scheme]

[FIXME: define operating at the top level, like Common Lisp’s defun but differently from Scheme]

1.3.2 epsilonian features ¶

JitterLisp is more “dynamic” and more reflective than typical Lisp dialects: any expression is allowed to define, remove or alter any non-constant global binding; the Abstract Syntax Tree returned by macroexpansion and contained within each closure is a recursive data structure describing an expression in a minimalistic core language which can be interpreted, compiled, analyzed, optimized or in general used like any other data structure, at run time, in the language itself.

Exposed ASTs and reflection make it possible and natural for the compiler to be implemented as an ordinary procedure, itself written in Lisp and running on top of the interpreter or compiled by itself at run time.

These distinctly epsilonian features, while important in making the internal implementation simpler and more elegant, are meant to be invisible to the casual user. In particular user macros operate on ordinary non-AST Lisp data structures, usually through Lisp quasiquoting, and will feel instantly familiar to any Common Lisp or Emacs Lisp programmer; the fact that the core Lisp forms are themselves predefined macros expanding to ASTs may be safely ignored in almost all programs as an implementation detail.

See Interaction example for a quick demo session introducing most of the non-traditional features likely to surprise a Lisp user.

1.3.3 Simplifications ¶

• Intentionally omitted features
• Desirable but not implemented features

3.1.1 Uniques ¶

[FIXME: Fill this.] [FIXME: immutability]

A unique object important in practice is the empty list:

unique: () ¶

In read syntax it is acceptable to separate the open and closed parentheses with arbitrary whitespace or comments, in which last case the closed parentheses will be found on a separate line.

There exists exactly one empty list object, written as (). It is used, in particular, as the trailing part of the of every list spine: see lists.

A Boolean or canonical Boolean object represents a truth value, either false or true. There are exactly two Booleans:

unique: #f ¶

unique: #t ¶

The false object is written as #f; the true object is written as #t.

In practical use #f tends to be more important than #t, as JitterLisp conditionals and loops distinguish between the #f value and any other Lisp object which is taken as “true” for the purposes of tests. A Lisp object used as a Boolean in this extended sense is called a generalized Boolean. Of course generalized Booleans are not necessarily unique objects.

[FIXME: a few words about the following uniques]

unique, no read syntax: #<nothing> ¶

unique, no read syntax: #<eof> ¶

unique, no read syntax: #<undefined> ¶

[FIXME: what they are used for]

3.1.2 Fixnums ¶

3.1.3 Characters ¶

3.1.4 Symbols ¶

3.1.5 Conses ¶

A cons is a pair object containing exactly two other Lisp objects, allowed to be conses in their turn or objects of any other types. Conses are mutable, in the sense that the two components of a cons can be changed at run time while keeping the identity of the cons object.

The first object contained in a cons is called its car, the second is called its cdr.

Syntax: If a and b are two Lisp objects, then (a . b) is a cons containing a as its car and b as its cdr.

Let S be any nonempty sequence of the characters “a” and “d”. Then the caSr of a cons is the car of the cSr of the cons, and its cdSr is the cdr of its cSr. For example the caddr of an object is the car of the cdr of its cdr. Such composed cons selector names are convenient to use when referring to nested components of a cons, and the JitterLisp library provides functionality to access them with any S of length 1, 2 and 3—therefore, for a level of nesting up to 4.

A list is either the empty list object or a cons whose cdr is another list. For example (), (#t . ()), (#f . (3 . ())) and ((1 . 2) . ()) are lists; (#t . #t) is not a list.

A sublist of a nonempty list is either its cdr or a sublist of its cdr. The elements of a nonempty list are the car of the list and the elements of its sublists. The empty list has no sublists and no elements.
For example the list (foo . (10 . (bar . ()))) has the three sublists (10 . (bar . ())), (bar . ()) and (), and the three elements foo, 10 and bar. Given a nonempty list its first element and its first sublist can always be found by taking, respectively, the car and the cdr of the list. Taking the car and cdr of the first sublist yields the second element and the second sublist of the original list, and so on.
It is easy to see how some composed cons selectors applied to a list identify specific sublists and elements: the list sublists will be its cdr, cddr, cdddr, cddddr, and so on; then taking the car of the list itself and its sublists yields the list elements: therefore the first, second, third and fourth element of a list will be respectively its car, cadr, caddr and cadddr.

The following notation makes lists much easier to write, as it suppresses every dot on the list spine and many parentheses; it can be used on many non-list conses as well:

Compact cons notation: Let a and b be two objects. When b is either the empty list () or a cons, the cons (a . b) can be written in the compact cons notation: in compact notation both the dot and the parentheses around b are omitted.

JitterLisp always adopts the compact cons notation in output, whenever applicable. Its use in input is optional.

For example (7) is a compact way of writing (7 . ()), (1 2) is a compact way of writing (1 . (2 . ())), ((a)) is a compact way of writing ((a . ()) . ()), and (10 a . #t) is a compact way of writing the non-list (10 . (a . #t)).

A further syntactic convenience is available for particular conses, which are also lists:

Prefix notation: Let q be the read syntax for a Lisp object. Then:

• 'q is an alternative read syntax for (quote q);
• `q is an alternative read syntax for (quasiquote q);
• ,q is an alternative read syntax for (unquote q); and
• ,@q is an alternative read syntax for (unquote-splicing q).

The prefix notation is recognized by the reader, but currently not emitted in output. Its use in input, again, is optional.

The prefix notation serves to express quoting and quasiquoting in a more convenient way: see Quoting and quasiquoting.

It is worth stressing that lists are not special at the language level and do not constitute a separate type: the name “list” is just a characterization of the shape of some objects, common in practice, which include the empty list object and some conses.

3.1.6 Boxes ¶

Boxes have no read syntax.

3.1.7 Interpreted closures ¶

3.1.8 Compiled closures ¶

[FIXME: An interpreted closure can destructively change to a compiled closure (but not vice-versa) without changing its identity.]

3.1.9 Primitives ¶

3.1.10 Abstract Syntax Trees ¶

An Abstract Syntax Tree or AST is a recursive type representing code as a data structure. ASTs only support the core language forms which remain after macroexpanding away (see macroexpansion, see Macroexpanding) every macro use: Lisp code rewritten not to use any macro turns into an AST, which can be then interpreted or compiled, or even analyzed and transformed by other Lisp code.

JitterLisp in fact contains no executor for Lisp: there are only an AST interpreter, written in C, and an AST compiler written in Lisp and translating ASTs into code for the Jittery VM. It is thanks to the reflection capabilities provided by the AST data type that it is possible to write a self-compiler, and also a self-optimizer, in the language itself.

Even if ASTs have no read syntax the JitterLisp library provides facilities to conveniently inspect and build ASTs: see AST operations.

See Abstract Syntax Trees and their semantics for a complete description of the structure of Abstract Syntax Trees and their behavior.

3.1.11 Macros ¶

3.1.12 Primitive macros ¶

3.2.1 AST syntax ¶

ASTs define a minimalistic programming language, operating on Lisp data but otherwise not particularly similar to Lisp. The syntax given here is the output syntax used by the implementation for printing AST data, for example as the result of macroexpand (see Macroexpanding). This syntax is designed to be simple and unambiguous. In order to visually stand apart from user syntax it indicates grouping by brackets (‘[’, ‘]’) rather than parentheses.

A dot (‘.’) in the syntax below indicates the convention of writing a sequence of zero or more entities, represented in memory as a list, without the surrounding parentheses. For example a valid primitive following the syntax ‘[primitive operator . operands]’ will be [primitive + [literal 2] [variable x]], where [literal 2] and [variable x] are ASTs encoded as the two elements of a list within the AST for the primitive.

Every AST represents an expression. Each expression has exactly one of the following forms, named after the identifier immediately following the open bracket:

• [literal value], a literal.

  The literal value may be any Lisp datum.

• [variable name], a variable or variable reference.

  The variable name must be a symbol.

• [primitive operator . operands], a primitive or primitive use.

  The primitive operator or primitive name must be a symbol which is the name of a primitive. The primitive operands must be a list of ASTs, having exactly as many elements as the arguments expected by the named primitive.

• [let name bound-expression body], a let or block.

  The name or bound variable name in a block must be a symbol. A block bound-expression must be an AST. A block body must also be an AST.

• [define name expression], a definition or global definition.

  The global definition name must be a symbol. The definition expression or defined expression must be an AST.

• [set! name expression], an assignment.

  The assignment variable name must be a symbol. The assignment expression must be an AST.

• [sequence expression-0 expression-1], a sequence.

  Each of the first expression or expression-0 and the second expression or expression-1 in a sequence must be an AST.

• [if condition then-branch else-branch], a conditional.

  The conditional condition and its two branches must all be ASTs.

• [while guard body], a while or loop.

  Each of the loop guard and body must be an AST.

• [lambda formals body], a lambda or abstraction.

  The lambda or abstraction formals or formal arguments must be a list of symbols, all different from one another. The lambda body must be an AST.

• [call operator . operands], a call or procedure call.

  The call (or procedure call) operator must be an AST. The call operands must be a list of ASTs.

The forms above specify the entirety of the AST syntax: every JitterLisp form, before being executed, is translated into an AST having one of the shapes described above, which in many cases will contain other ASTs; all the language power and complexity arise solely from the combination of those AST forms.
Conspicuously absent from the forms above is any form of syntactic abstraction such as macros: macros serve to automatically rewrite complex user syntax into a combination of simple ASTs, so that no use of a macro survives the expansion process.

It is important to notice that the syntactic constraints specified above, for example [if …] having exactly three subforms and the first component of [set! …] being a symbol, are verified at AST construction time: it is impossible to build a syntactically incorrect AST without immediately failing. In this sense only syntactically correct ASTs may be said to “exist”.

3.2.2 AST semantics ¶

JitterLisp ASTs constitute an eager imperative call-by-value language based on named, lexically scoped variables and global state.

What follows is an attempt of describing the behavior of AST evaluation in a precise way without the burden of complicated notation.

The mathematically inclined reader will see immediately how the AST semantics would be easy to model in an operational style, with logic rules having multiple premises and one conclusion. Here I will content myself with rendering such rules into more accessible English.

• Semantics preliminaries
• Failure
• AST semantics in detail
• From ASTs to JitterLisp

/* Return the expansion of the given list of forms as a sequence.
   This is what the primitive macro begin does and the same code is
   used whenever a form sequence is allowed, for example in a lambda
   body. */
static jitterlisp_object
jitterlisp_macroexpand_begin (jitterlisp_object forms,
                              jitterlisp_object env)
{
  /* Zero-form body. */
  if (JITTERLISP_IS_EMPTY_LIST (forms))
    return jitterlisp_ast_make_literal (JITTERLISP_NOTHING);

  /* Ill-formed body. */
  if (! JITTERLISP_IS_CONS (forms))
    jitterlisp_error_cloned ("begin: non-list body");

  /* At this point we have to look inside the cons. */
  jitterlisp_object first = JITTERLISP_EXP_C_A_CAR(forms);
  jitterlisp_object rest = JITTERLISP_EXP_C_A_CDR(forms);

  /* One-form body. */
  if (JITTERLISP_IS_EMPTY_LIST (rest))
    return jitterlisp_macroexpand (first, env);

  /* Multiple-form body. */
  return jitterlisp_ast_make_sequence
            (jitterlisp_macroexpand (first, env),
             jitterlisp_macroexpand_begin (rest, env));
}

(macroexpand '(begin))
  ⇒
  [literal #<nothing>]
(macroexpand '(begin 42))
  ⇒
  [literal 42]
(macroexpand '(begin (display 42)))
  ⇒
  [call [variable display] [literal 42]]
(macroexpand '(begin (display 42) (newline)))
  ⇒
  [sequence
    [call [variable display] [literal 42]]
    [call [variable newline]]]
(macroexpand '(begin (display 42) (newline) (display 43) (newline)))
  ⇒
  [sequence
    [call [variable display] [literal 42]]
    [sequence
      [call [variable newline]]
      [sequence
        [call [variable display] [literal 43]]
        [call [variable newline]]]]]

3.4.1 Expressions ¶

[FIXME: Fill this.]

3.4.2 Definitions ¶

[FIXME: Fill this.]

3.4.3 Constants ¶

[FIXME: primitive wrappers are global constants]

3.5.1 Definition forms ¶

macro: define defined-thing . forms ¶

macro: define-constant defined-thing . forms ¶

macro: define-non-optimized defined-thing . forms ¶

macro: define-constant-non-optimized defined-thing . forms ¶

[FIXME: Write this]

macro: define-macro (name . args-pattern) . forms ¶

There is currently no syntactic support for local macros, such as Common Lisp’s macrolet.

3.5.2 Sequencing ¶

[FIXME: sequencing is nice]

[FIXME: “implicit progn” or “implicit begin”: I do it in more cases than Common Lisp and Scheme]

macro: begin . forms ¶

[FIXME: Write this]

macro: begin-from-first index . forms ¶

[FIXME: Write this]

macro: begin1 form-1 . other-forms ¶

macro: begin2 form-1 form-2 . other-forms ¶

macro: begin3 form-1 form-2 form-3 . other-forms ¶

macro: begin4 form-1 form-2 form-3 form-4 . other-forms ¶

[FIXME: Write this]

macro: begin-from-last index . forms ¶

[FIXME: Write this]

macro: begin-1 form-1 . other-forms ¶

macro: begin-2 form-1 form-2 . other-forms ¶

macro: begin-3 form-1 form-2 form-3 . other-forms ¶

macro: begin-4 form-1 form-2 form-3 form-4 . other-forms ¶

[FIXME: Write this]

begin-1 is only provided for symmetry, and is functionally equivalent to begin with the restriction of requiring at least one form.

3.5.3 Conditionals ¶

A conditional form consists in evaluating some condition form and then decide which form to evaluate next according to the result of the condition.

core macro: if condition then-form . else-forms ¶

[FIXME: Write this]

macro: when condition . forms ¶

[FIXME: Write this]

macro: unless condition . forms ¶

[FIXME: Write this]

core macro: cond . clauses ¶

[FIXME: Write this]

macro: case discriminand . clauses ¶

[FIXME: Write this]

3.5.4 Procedures ¶

core macro: lambda formals . forms ¶

3.5.5 Blocks ¶

A block introduces a scope where some variables are locally bound.

Following a lexical scoping discipline a variable binding is visible in the syntactic region where it has been bound and in every callee, as long as it is not shadowed by an inner binding for the same variable.

macro: let bindings . forms ¶

core macro: let* bindings . forms ¶

macro: letrec bindings . forms ¶

macro: let name bindings . forms ¶

[FIXME: Write this]

The fourth variant, with name being a symbol, is listed here out of completeness but belongs with looping forms; see named let for its description.

macro: destructuring-bind pattern structure . forms ¶

[FIXME: Write this. Common Lisp calls “template” what I call “pattern”.]

3.5.6 Assignment ¶

An assignment operation destructively modifies an existing variable binding.

core macro: set! x . forms ¶

Evaluate the forms forms left-to-right, then assign the result of the last one (or #<nothing> if no forms were given) to the innermost binding for the variable x.

Error out if x is not a symbol, if x is unbound, or if the binding for x is global and constant.

[FIXME: speak about constants]

Rationale: [FIXME: efficiency of compiled code]

primitive wrapper: make-constant! e ¶

[FIXME: write. e must evaluate to a symbol, which is allowed to be also lexically bound; however only its global binding is affected. If called on a globally unbound symbol, it becomes impossible to ever assign or define it.]

3.5.7 Loops ¶

A loop form consists in executing the same body forms potentially multiple times, in sequence.

core macro: while guard . forms ¶

[FIXME: Write this]

macro: do clauses (guard . result-forms) . body-forms ¶

[FIXME: Write this]

macro: dotimes (x count-form . result-forms) . body-forms ¶

macro: dotimesdown (x count-form . result-forms) . body-forms ¶

[FIXME: Write this]

macro: dolist (x list-form . result-forms) . body-forms ¶

[FIXME: Write this]

macro: named-let name bindings . forms ¶

macro: let name bindings . forms ¶

[FIXME: Write this]

The other, simpler, syntax for let is described among block forms: see let.

3.5.8 Making macros ¶

core macro: low-level-macro . forms ¶

[FIXME: Write this. Speak of low-level-macro-args]

macro: macro (macro-name . pattern) . forms ¶

[FIXME: Write this. This uses destructuring bind see destructuring-bind]

The macros above would suffice, along with define, for globally binding macros. However define-macro is provided as a more convenient syntax: see define-macro.

3.5.9 Quoting and quasiquoting ¶

core macro: quote thing ¶

macro: quasiquote template ¶

[FIXME: link prefixes. Remind that ’ is usable]

3.6.1 Type checking ¶

• Actual type cheking
• Pseudo-type checking

3.6.2 Boolean operations ¶

primitive wrapper: not x ¶

macro: or . clauses ¶

macro: lispy-or . clauses ¶

macro: and . clauses ¶

macro: lispy-and . clauses ¶

[FIXME: lispy-and is provided just for symmetry with lispy-or, and is in fact an alias for and. The traditional Lisp definition for and introduces no inefficiencies in this case, differently from the traditional Lisp implementation of or.]

primitive wrapper: boolean-canonicalize x ¶

3.6.3 Arithmetic ¶

[FIXME: fixnum only for the time being]

primitive wrapper: negate x ¶

primitive wrapper: 1+ x ¶

primitive wrapper: 1- x ¶

primitive wrapper: 2* x ¶

primitive wrapper: 2/ x ¶

primitive wrapper: 2quotient x ¶

primitive wrapper: 2remainder x ¶

primitive wrapper: primordial-+ x y ¶

primitive wrapper: primordial-- x y ¶

primitive wrapper: primordial-* x y ¶

primitive wrapper: primordial-/ x y ¶

primitive wrapper: quotient x y ¶

primitive wrapper: remainder x y ¶

procedure: *-by-sums-procedure x y ¶

procedure: **-procedure b e ¶

macro: + . args ¶

macro: * . args ¶

macro: *-by-sums . args ¶

macro: ** . args ¶

macro: - . args ¶

macro: / . args ¶

procedure: square x ¶

procedure: even? x ¶

procedure: odd? x ¶

fixnum: fixnum-bit-no ¶

fixnum: most-negative-fixnum ¶

fixnum: most-positive-fixnum ¶

3.6.4 Number comparison ¶

[FIXME: fixnum only for the time being]

primitive wrapper: zero? x ¶

primitive wrapper: non-zero? x ¶

primitive wrapper: positive? x ¶

primitive wrapper: non-positive? x ¶

primitive wrapper: negative? x ¶

primitive wrapper: non-negative? x ¶

primitive wrapper: = x y ¶

primitive wrapper: < x y ¶

primitive wrapper: > x y ¶

primitive wrapper: <= x y ¶

primitive wrapper: >= x y ¶

primitive wrapper: <> x y ¶

3.6.5 Symbol handling ¶

primitive wrapper: gensym ¶

primitive wrapper: interned-symbols ¶

primitive wrapper: symbol-global s ¶

primitive wrapper: make-constant! s ¶

primitive wrapper: constant? s ¶

primitive wrapper: defined? s ¶

primitive wrapper: undefine s ¶

3.6.6 Box handling ¶

primitive wrapper: box x ¶

primitive wrapper: box-get b ¶

primitive wrapper: box-set! b x ¶

3.6.7 Cons handling ¶

primitive wrapper: cons a b ¶

primitive wrapper: car c ¶

primitive wrapper: cdr c ¶

procedure: caar c ¶

procedure: cdar c ¶

procedure: cadr c ¶

procedure: cddr c ¶

procedure: caaar c ¶

procedure: cadar c ¶

procedure: caadr c ¶

procedure: caddr c ¶

procedure: cdaar c ¶

procedure: cddar c ¶

procedure: cdadr c ¶

procedure: cdddr c ¶

procedure: caaaar c ¶

procedure: caadar c ¶

procedure: caaadr c ¶

procedure: caaddr c ¶

procedure: cadaar c ¶

procedure: caddar c ¶

procedure: cadadr c ¶

procedure: cadddr c ¶

procedure: cdaaar c ¶

procedure: cdadar c ¶

procedure: cdaadr c ¶

procedure: cdaddr c ¶

procedure: cddaar c ¶

procedure: cdddar c ¶

procedure: cddadr c ¶

procedure: cddddr c ¶

primitive wrapper: set-car! c x ¶

primitive wrapper: set-cdr! c x ¶

procedure: set-caar! c x ¶

procedure: set-cdar! c x ¶

procedure: set-cadr! c x ¶

procedure: set-cddr! c x ¶

procedure: set-caaar! c x ¶

procedure: set-cadar! c x ¶

procedure: set-caadr! c x ¶

procedure: set-caddr! c x ¶

procedure: set-cdaar! c x ¶

procedure: set-cddar! c x ¶

procedure: set-cdadr! c x ¶

procedure: set-cdddr! c x ¶

procedure: set-caaaar! c x ¶

procedure: set-caadar! c x ¶

procedure: set-caaadr! c x ¶

procedure: set-caaddr! c x ¶

procedure: set-cadaar! c x ¶

procedure: set-caddar! c x ¶

procedure: set-cadadr! c x ¶

procedure: set-cadddr! c x ¶

procedure: set-cdaaar! c x ¶

procedure: set-cdadar! c x ¶

procedure: set-cdaadr! c x ¶

procedure: set-cdaddr! c x ¶

procedure: set-cddaar! c x ¶

procedure: set-cdddar! c x ¶

procedure: set-cddadr! c x ¶

procedure: set-cddddr! c x ¶

procedure: car-or-nil c ¶

procedure: cdr-or-nil c ¶

macro: improper-list first-element . more-elements ¶

macro: cons* first-element . more-elements ¶

macro: circular-list first-element . more-elements ¶

3.6.8 List handling ¶

procedure: singleton ¶

macro: list . elements ¶

procedure: replicate n x ¶

procedure: make-list n x ¶

procedure: last-cons xs ¶

procedure: last xs ¶

procedure: all-but-last xs ¶

procedure: all-but-last-reversed xs ¶

procedure: length xs ¶

procedure: reverse xs ¶

procedure: reverse! xs ¶

procedure: append-procedure xs ys ¶

procedure: append-reversed xs ys ¶

procedure: append!-procedure xs ys ¶

macro: append . xss ¶

macro: append! . xss ¶

procedure: flatten xss ¶

procedure: flatten! xss ¶

procedure: flatten-reversed xss ¶

procedure: flatten-reversed! xss ¶

procedure: list-copy xs ¶

procedure: nth-cons xs n ¶

procedure: nth-cons-or-nil xs n ¶

procedure: nth xs n ¶

procedure: take xs n ¶

procedure: take-reversed xs n ¶

procedure: take! xs n ¶

procedure: drop xs n ¶

procedure: drop! xs n ¶

procedure: zip xs n ¶

procedure: zip-reversed xs n ¶

procedure: unzip xs n ¶

procedure: unzip-reversed xs n ¶

procedure: map f xs ¶

procedure: map-reversed f xs ¶

procedure: map! f xs ¶

procedure: fold-left f x xs ¶

procedure: fold-right f xs y ¶

procedure: fold-right! f xs y ¶

procedure: exists? p xs ¶

procedure: for-all? p xs ¶

procedure: filter p xs ¶

procedure: filter-reversed p xs ¶

procedure: range a b ¶

procedure: range-reversed a b ¶

procedure: iota n ¶

procedure: sort xs ¶

procedure: list-has? xs x ¶

procedure: list-without xs x ¶

procedure: list-without! xs x ¶

procedure: all-different? ¶

[FIXME: quadratic]

3.6.9 Alist handling ¶

procedure: assq key alist ¶

procedure: rassq value alist ¶

procedure: del-assq-1 key alist ¶

procedure: del-assq key alist ¶

procedure: del-assq-noncopying key alist ¶

procedure: del-assq-list keys alist ¶

procedure: del-assq-list-noncopying keys alist ¶

procedure: alist-copy alist ¶

procedure: alist-get key alist ¶

3.6.10 Higher order ¶

procedure: compose-procedure f g ¶

procedure: compose-eta f g ¶

macro: compose . fs ¶

macro: compose-pipeline . fs ¶

procedure: square-function f ¶

procedure: square-function-eta f ¶

procedure: iterate f n ¶

procedure: iterate-eta f n ¶

procedure: iterate-pre f n ¶

procedure: iterate-post f n ¶

macro: lambda-wrapper rator arity ¶

3.6.11 Variadic utility ¶

macro: define-left-nested-variadic-extension name original-name neutral ¶

macro: define-right-nested-variadic-extension name original-name neutral ¶

macro: define-associative-variadic-extension name original-name neutral ¶

[FIXME: yes, the things that follow are really procedures]

procedure: variadic-left-deep rator neutral rands ¶

procedure: variadic-right-deep rator neutral rands ¶

3.6.12 Sets as lists ¶

[FIXME: Performance caveat]

[FIXME: order caveat]

[FIXME: The word “set” as used here refers to a collection of objects in the mathematical sense, and has nothing to do with the action of “setting” as performed by set-thing! procedures.]

unique: set-empty ¶

procedure: set-empty? s ¶

procedure: set-singleton x ¶

macro: set . elements ¶

procedure: set-has? s x ¶

procedure: set-with s x ¶

procedure: set-without s x ¶

procedure: set-unite-procedure s1 s2 ¶

procedure: set-intersect-procedure s1 s2 ¶

procedure: set-subtract-procedure s1 s2 ¶

macro: set-unite . sets ¶

macro: set-intersect . sets ¶

macro: set-subtract first-set . other-sets ¶

procedure: list->set xs ¶

[FIXME: No set->list is needed].

3.6.13 AST operations ¶

[FIXME: if the argument is not an AST these all fail.]

primitive wrapper: ast-literal? ¶

primitive wrapper: ast-variable? ¶

primitive wrapper: ast-define? ¶

primitive wrapper: ast-if? ¶

primitive wrapper: ast-set!? ¶

primitive wrapper: ast-while? ¶

primitive wrapper: ast-primitive? ¶

primitive wrapper: ast-call? ¶

primitive wrapper: ast-lambda? ¶

primitive wrapper: ast-let? ¶

primitive wrapper: ast-sequence? ¶

[FIXME: types: when we fail]

primitive wrapper: ast-literal value ¶

primitive wrapper: ast-variable name ¶

primitive wrapper: ast-define name body ¶

primitive wrapper: ast-if condition then else ¶

primitive wrapper: ast-set! name body ¶

primitive wrapper: ast-while guard body ¶

primitive wrapper: ast-primitive operator operands ¶

primitive wrapper: ast-call operator operands ¶

primitive wrapper: ast-lambda formals body ¶

primitive wrapper: ast-let bound-name bound-form body ¶

primitive wrapper: ast-sequence first second ¶

[FIXME: these fail if the argument is not an AST or if it’s an AST of the wrong case] [FIXME: no destructive operations right now. They would be easy to add, even if using them in an unrestricted way might destroy compiler properties; anyway, it is already possible to destroy the same compiler implied properties, by violating other unenforced invariants]

primitive wrapper: ast-literal-value ast ¶

primitive wrapper: ast-variable-name ast ¶

primitive wrapper: ast-define-name ast ¶

primitive wrapper: ast-define-body ast ¶

primitive wrapper: ast-if-condition ast ¶

primitive wrapper: ast-if-then ast ¶

primitive wrapper: ast-if-else ast ¶

primitive wrapper: ast-set!-name ast ¶

primitive wrapper: ast-set!-body ast ¶

primitive wrapper: ast-while-guard ast ¶

primitive wrapper: ast-while-body ast ¶

primitive wrapper: ast-primitive-operator ast ¶

primitive wrapper: ast-primitive-operands ast ¶

primitive wrapper: ast-call-operator ast ¶

primitive wrapper: ast-call-operands ast ¶

primitive wrapper: ast-lambda-formals ast ¶

primitive wrapper: ast-lambda-body ast ¶

primitive wrapper: ast-let-bound-name ast ¶

primitive wrapper: ast-let-bound-form ast ¶

primitive wrapper: ast-let-body ast ¶

primitive wrapper: ast-sequence-first ast ¶

primitive wrapper: ast-sequence-second ast ¶

[FIXME: An example showing a constuction, check and field access for the same case, to highlight the lexical conventions.]

3.6.14 AST optimization ¶

[FIXME: Fill this.]

3.6.15 Macroexpanding ¶

[FIXME: There is currently no syntactic support for local macros, such as Common Lisp’s macrolet.]

primitive wrapper: primordial-macroexpand form env ¶

macro: macroexpand form . optional-env ¶

3.6.16 Code execution ¶

primitive wrapper: apply operator operands ¶

primitive wrapper: apply-primitive operator operands ¶

primitive wrapper: primordial-eval form env ¶

macro: eval form . optional-env ¶

3.6.17 Compilation ¶

[FIXME: Fill this.]

3.6.18 Input and output ¶

JitterLisp provides very crude I/O functionalities. Files are not implemented, so input and output only use the standard input and standard output, respectively, or the terminal via ReadLine.

• Character I/O
• Lisp object I/O

3.6.19 Debugging and profiling ¶

primitive wrapper: print-locations ¶

Print data location information, mapping runtime VM data structures into hardware machine resources. This is convenient for reading disassemblies.

primitive wrapper: print-defects ¶

Print the names of all defective specialised instructions. Notice that the set of defective specialised instructions may be different from the set of replaced specialised instructions: when any call-related specialised instruction is defective then every call-related specialised instruction will be replaced.
The output is meant for the user.

primitive wrapper: print-defect-replacements ¶

Print information about defective specialised instruction, listing the name of each replaced specialised instruction along with the specialised instruction replacing it. About the difference between defective specialised instruction and replaced specialised instruction see ‘print-defects’.
The output is meant for the user.

primitive wrapper: print-profile-specialized ¶

Print cumulative profile information about the specialised VM instructions run up to this point. This just prints a warning if JitterLisp was not compiled with profiling instrumentation enabled, defining at least one of the CPP macros JITTERLISPVM_PROFILE_COUNT and JITTERLISPVM_PROFILE_SAMPLE; since profiling instrumentation incurs a performance penalty it is disabled by default.

primitive wrapper: print-profile-unspecialized ¶

This primitive wrapper behaves exactly like print-profile-specialized, except that it prints information about unspecialised VM instructions.

primitive wrapper: reset-profile! ¶

Reset profile information, changing the execution count for every instruction back to zero.

3.6.20 Legal notices ¶

primitive wrapper: copying ¶

primitive wrapper: no-warranty ¶

Display legal notices by printing, respectively, the full text of the GNU GPL or an excerpt explaining how there is no warranty of any kind.

3.6.21 Unclassified (move) ¶

procedure: identity x ¶

primitive wrapper: eq? x y ¶

primitive wrapper: not-eq? x y ¶

primitive wrapper: error thing ¶

primitive wrapper: gc ¶