• Sector Lisp is a pure version of FP (functional programming)
  • O/S (Operating System) processes are lambda wannabes
  • Arrays are simply optimized lists - no CDRs
  • Sub-dividing memory in a binary form, i.e. 2 sub-divisions (Atom and List, in the case of Sector Lisp) results in anti-code-bloat.


Pure FP

  • no allowance for mutation -> small code (less bloat)
  • GC is simple

Processes Are Lambdas

See Greenspun’s 10th Rule, if not already familiar with it.

Processes were first implemented in assembler and C.

Lisp implements processes, but calls them LAMBDAs and closures.

First-class functions are LAMBDAs.


Arrays are simply optimizations of lists, where the CDR is implied.

IIRC this was called “CDR Lists” in early literature.

Non-contiguous cells require special handling, but this need not apply to all cells.

Array cells -> Cdr(p) = p + 1

List cells (non-contiguous) -> Cdr(p) = *(p + 1)

String Function Library

String functions are easy to describe in pure FP.

For exampe, substring can be written as a combinatino of CAR and CDR applied to Strings (arrays of characters).

String functions become complicated (epicyclic) when mutation is desired.

Shared memory, memory reuse -> epicycles (code bloat).

Sub-Dividing Memory in a Binary Fashion

See Also

Table of Contents