StreetLISP

"Well, streetlisp sounds like yet another arrogant hacker Lisp."

Coverage report

Community

For development and support: #StreetLISP on Libera.Chat.

What's this?

A compact interpreter for a minimal lisp/scheme dialect. A street lisp.

This is a reanimation of https://github.com/lambdaconservatory/femtolisp with bigger plans.

Here you can see some of the syntax/naming differences between StreetLISP and other Scheme dialects.

There are no plans to turn this into Yet Another Scheme, which are already plenty to choose from. When it comes to general development directions, StreetLISP is moving towards being somewhere in between Common Lisp and Scheme, yet not striving to fit any specific standard. The goals are certain level of minimalism and less typing, useful standard library, good Unicode support, portability and interfacing with C of both POSIX-like operating systems and Plan 9. Eventually, hopefully, there will be experiments in cooperative/multithread computations with Erlang-style message passing between "processes".

Note: StreetLISP is in active development, thus should not be considered a stable software at this time.

< cinap_lenrek> maybe thats all you need
< cinap_lenrek> a street lisp
< cinap_lenrek> sl(1)

Supported OS: 9front, Unix-like operating systems (OpenBSD, NetBSD, Linux, etc).

Supported CPUs: any decent 32 or 64-bit, little or big endian.

Regularly tested on: 9front, OpenBSD, NetBSD, Alpine, Android.

Also runs on: MacOS 4.x-9.x, Mac OS X, Haiku, DOS.

Some of the changes from the original include:

• aggressive refactoring
• bignums
• defstruct
• T instead of #t/#T and NIL instead of #f
• supplied-p: (def (f (x 0 x-supplied) ...)
• c***r of empty list returns empty list
• automatic gensyms for macros (blah#) at read time
• previously available (but not merged) patches from the community and Julia are applied
• [ and ], { and } are synonyms to ( and )
• « and » for verbatim strings
• define → def, define-macro → defmacro
• λ as a shorthand for lambda
• docstrings - (def (f ...) "Docs here" ...) and (help ...)
• proper (void) and void?
• better error reporting - disassembly at the current instruction, location of syntax errors
• "boot" image is built into the executable
• vm opcode definitions and tables are generated from a single file

Two ways to learn about more changes:

• https://todo.sr.ht/~ft/sl?search=status:closed
• https://git.sr.ht/~ft/sl/log

Building

POSIX

meson setup build
ninja -C build test

Plan 9

mk all test

MacOS 4.x-9.x (m68k or PowerPC)

Clone and build Retro68. This fork grabs the necessary patches for more things to work as expected:

git clone https://git.sr.ht/~ft/retro68
mkdir retro68-build
cd retro68-build
../retro68/build-toolchain.bash --ninja
# wait until everything builds, make sure it did not error out

Now build sl:

cd sl
export PATH="$PATH:$(pwd)/../retro68-build/toolchain/bin"
# for PowerPC:
meson setup build . -Dbuildtype=minsize --cross-file cross/powerpc-apple.txt
# for m68k:
meson setup build . -Dbuildtype=minsize --cross-file cross/m68k-apple.txt
ninja -C build

Either build/sl.dsk or build/sl.bin is the file to get on your Mac.

NOTE: this isn't a full-fledged port and is going to stay low priority unless somebody wants to spend time polishing it.

DOS

Build DJGPP cross-compiler, then:

export PATH=$PATH:path-to-djgpp-toolchain/bin
meson setup build . -Dbuildtype=minsize --cross-file cross/djgpp.txt
ninja -C build

Result is build/sl.exe.

Characteristics

• lexical scope, lisp-1
• unrestricted macros
• case-sensitive
• simple compacting copying garbage collector
• Scheme-style varargs (dotted formal argument lists)
• "human-readable" bytecode with self-hosted compiler
• circular structure can be printed and read
• #. read macro for eval-when-read and readably printing builtins
• read macros for backquote
• symbol character-escaping printer
• exceptions
• gensyms (can be usefully read back in, too)
• #| multiline comments |#, #;(block comment..., lots of other lexical syntax
• generic compare function, cyclic equal
• cvalues system providing C data types and a C FFI
• constructor notation for nicely printing arbitrary values