**1. Mal is a Clojure inspired Lisp interpreter**
-**2. Mal is implemented in 80 languages (83 different implementations and 103 runtime modes)**
+**2. Mal is a learning tool**
+
+Each implementation of mal is separated into
+11 incremental, self-contained (and testable) steps that demonstrate
+core concepts of Lisp. The last step is capable of self-hosting
+(running the mal implementation of mal). See the [make-a-lisp process
+guide](process/guide.md).
+
+The make-a-lisp steps are:
+
+* [step0_repl](process/guide.md#step0)
+* [step1_read_print](process/guide.md#step1)
+* [step2_eval](process/guide.md#step2)
+* [step3_env](process/guide.md#step3)
+* [step4_if_fn_do](process/guide.md#step4)
+* [step5_tco](process/guide.md#step5)
+* [step6_file](process/guide.md#step6)
+* [step7_quote](process/guide.md#step7)
+* [step8_macros](process/guide.md#step8)
+* [step9_try](process/guide.md#step9)
+* [stepA_mal](process/guide.md#stepA)
+
+Each make-a-lisp step has an associated architectural diagram. That elements
+that are new for that step are highlighted in red.
+Here is the final diagram for [step A](process/guide.md#stepA):
+
+
+
+If you are interested in creating a mal implementation (or just
+interested in using mal for something), please drop by the #mal
+channel on freenode. In addition to the [make-a-lisp process
+guide](process/guide.md) there is also a [mal/make-a-lisp
+FAQ](docs/FAQ.md) where I attempt to answer some common questions.
+
+
+**3. Mal is implemented in 81 languages (84 different implementations and 104 runtime modes)**
| Language | Creator |
| -------- | ------- |
| [Io](#io) | [Dov Murik](https://github.com/dubek) |
| [Java](#java-17) | [Joel Martin](https://github.com/kanaka) |
| [JavaScript](#javascriptnode) ([Demo](http://kanaka.github.io/mal)) | [Joel Martin](https://github.com/kanaka) |
+| [jq](#jq) | [Ali MohammadPur](https://github.com/alimpfard) |
| [Julia](#julia) | [Joel Martin](https://github.com/kanaka) |
| [Kotlin](#kotlin) | [Javier Fernandez-Ivern](https://github.com/ivern) |
| [LiveScript](#livescript) | [Jos van Bakel](https://github.com/c0deaddict) |
| [Zig](#zig) | [Josh Tobin](https://github.com/rjtobin) |
-**3. Mal is a learning tool**
-
-Each implementation of mal is separated into
-11 incremental, self-contained (and testable) steps that demonstrate
-core concepts of Lisp. The last step is capable of self-hosting
-(running the mal implementation of mal). See the [make-a-lisp process
-guide](process/guide.md).
-
-The make-a-lisp steps are:
-
-* [step0_repl](process/guide.md#step0)
-* [step1_read_print](process/guide.md#step1)
-* [step2_eval](process/guide.md#step2)
-* [step3_env](process/guide.md#step3)
-* [step4_if_fn_do](process/guide.md#step4)
-* [step5_tco](process/guide.md#step5)
-* [step6_file](process/guide.md#step6)
-* [step7_quote](process/guide.md#step7)
-* [step8_macros](process/guide.md#step8)
-* [step9_try](process/guide.md#step9)
-* [stepA_mal](process/guide.md#stepA)
-
-Each make-a-lisp step has an associated architectural diagram. That elements
-that are new for that step are highlighted in red.
-Here is the final diagram for [step A](process/guide.md#stepA):
-
-
-
-If you are interested in creating a mal implementation (or just
-interested in using mal for something), please drop by the #mal
-channel on freenode. In addition to the [make-a-lisp process
-guide](process/guide.md) there is also a [mal/make-a-lisp
-FAQ](docs/FAQ.md) where I attempt to answer some common questions.
-
-
## Presentations
Mal was presented publicly for the first time in a lightning talk at
(readline not implemented).
```
-cd ada
+cd impls/ada
make
./stepX_YYY
```
the GNU readline library.
```
-cd ada
+cd impls/ada
make
./stepX_YYY
```
The GNU awk implementation of mal has been tested with GNU awk 4.1.1.
```
-cd gawk
+cd impls/gawk
gawk -O -f stepX_YYY.awk
```
### Bash 4
```
-cd bash
+cd impls/bash
bash stepX_YYY.sh
```
Generate C64 code and run it using cbmbasic:
```
-cd basic
+cd impls/basic
make stepX_YYY.bas
STEP=stepX_YYY ./run
```
Generate QBasic code and load it into qb64:
```
-cd basic
+cd impls/basic
make MODE=qbasic stepX_YYY.bas
./qb64 stepX_YYY.bas
```
The BBC BASIC V implementation can run in the Brandy interpreter:
```
-cd bbc-basic
+cd impls/bbc-basic
brandy -quit stepX_YYY.bbc
```
library.
```
-cd c
+cd impls/c
make
./stepX_YYY
```
more details:
```
-cd cpp
+cd impls/cpp
make
# OR
make CXX=clang++-3.5
required to build and run the C# implementation.
```
-cd cs
+cd impls/cs
make
mono ./stepX_YYY.exe
```
The ChucK implementation has been tested with ChucK 1.3.5.2.
```
-cd chuck
+cd impls/chuck
./run
```
however, to pass all tests, Clojure 1.8.0-RC4 is required.
```
-cd clojure
+cd impls/clojure
lein with-profile +stepX trampoline run
```
```
sudo npm install -g coffee-script
-cd coffee
+cd impls/coffee
coffee ./stepX_YYY
```
dependencies mentioned installed, do the following to run the implementation
```
-cd common-lisp
+cd impls/common-lisp
make
./run
```
The Crystal implementation of mal has been tested with Crystal 0.26.1.
```
-cd crystal
+cd impls/crystal
crystal run ./stepX_YYY.cr
# OR
make # needed to run tests
readline library.
```
-cd d
+cd impls/d
make
./stepX_YYY
```
The Dart implementation has been tested with Dart 1.20.
```
-cd dart
+cd impls/dart
dart ./stepX_YYY
```
`rlwrap`.
```
-cd elisp
+cd impls/elisp
emacs -Q --batch --load stepX_YYY.el
# with full readline support
rlwrap emacs -Q --batch --load stepX_YYY.el
The Elixir implementation of mal has been tested with Elixir 1.0.5.
```
-cd elixir
+cd impls/elixir
mix stepX_YYY
# Or with readline/line editing functionality:
iex -S mix stepX_YYY
The Elm implementation of mal has been tested with Elm 0.18.0
```
-cd elm
+cd impls/elm
make stepX_YYY.js
STEP=stepX_YYY ./run
```
and [rebar](https://github.com/rebar/rebar) to build.
```
-cd erlang
+cd impls/erlang
make
# OR
MAL_STEP=stepX_YYY rebar compile escriptize # build individual step
JavaScript. The generated code has been tested with Node 0.12.4.
```
-cd es6
+cd impls/es6
make
node build/stepX_YYY.js
```
required to build and run the F# implementation.
```
-cd fsharp
+cd impls/fsharp
make
mono ./stepX_YYY.exe
```
([factorcode.org](http://factorcode.org)).
```
-cd factor
+cd impls/factor
FACTOR_ROOTS=. factor -run=stepX_YYY
```
The Fantom implementation of mal has been tested with Fantom 1.0.70.
```
-cd fantom
+cd impls/fantom
make lib/fan/stepX_YYY.pod
STEP=stepX_YYY ./run
```
### Forth
```
-cd forth
+cd impls/forth
gforth stepX_YYY.fs
```
### GNU Guile 2.1+
```
-cd guile
+cd impls/guile
guile -L ./ stepX_YYY.scm
```
The Smalltalk implementation of mal has been tested with GNU Smalltalk 3.2.91.
```
-cd gnu-smalltalk
+cd impls/gnu-smalltalk
./run
```
path. The implementation has been tested with Go 1.3.1.
```
-cd go
+cd impls/go
make
./stepX_YYY
```
tested with Groovy 1.8.6.
```
-cd groovy
+cd impls/groovy
make
groovy ./stepX_YYY.groovy
```
later and also the Haskell parsec and readline (or editline) packages.
```
-cd haskell
+cd impls/haskell
make
./stepX_YYY
```
JavaScript.
```
-cd haxe
+cd impls/haxe
# Neko
make all-neko
neko ./stepX_YYY.n
The Hy implementation of mal has been tested with Hy 0.13.0.
```
-cd hy
+cd impls/hy
./stepX_YYY.hy
```
The Io implementation of mal has been tested with Io version 20110905.
```
-cd io
+cd impls/io
io ./stepX_YYY.io
```
The Java implementation of mal requires maven2 to build.
```
-cd java
+cd impls/java
mvn compile
mvn -quiet exec:java -Dexec.mainClass=mal.stepX_YYY
# OR
### JavaScript/Node
```
-cd js
+cd impls/js
npm install
node stepX_YYY.js
```
The Julia implementation of mal requires Julia 0.4.
```
-cd julia
+cd impls/julia
julia stepX_YYY.jl
```
+### jq
+
+Tested against version 1.6, with a lot of cheating in the IO department
+
+```
+cd impls/jq
+STEP=stepA_YYY ./run
+ # with Debug
+DEBUG=true STEP=stepA_YYY ./run
+```
+
### Kotlin
The Kotlin implementation of mal has been tested with Kotlin 1.0.
```
-cd kotlin
+cd impls/kotlin
make
java -jar stepX_YYY.jar
```
The LiveScript implementation of mal has been tested with LiveScript 1.5.
```
-cd livescript
+cd impls/livescript
make
node_modules/.bin/lsc stepX_YYY.ls
```
The Logo implementation of mal has been tested with UCBLogo 6.0.
```
-cd logo
+cd impls/logo
logo stepX_YYY.lg
```
### Lua
-The Lua implementation of mal has been tested with Lua 5.2. The
-implementation requires that luarocks and the lua-rex-pcre library
-are installed.
+The Lua implementation of mal has been tested with Lua 5.3.5 The
+implementation requires luarocks to be installed.
```
-cd lua
-make # to build and link linenoise.so
+cd impls/lua
+make # to build and link linenoise.so and rex_pcre.so
./stepX_YYY.lua
```
line argument.
```
-cd IMPL
+cd impls/IMPL
IMPL_STEPA_CMD ../mal/stepX_YYY.mal
```
### GNU Make 3.81
```
-cd make
+cd impls/make
make -f stepX_YYY.mk
```
with Linux 3.16.0-4-amd64 and NASM version 2.11.05.
```
-cd nasm
+cd impls/nasm
make
./stepX_YYY
```
The Nim implementation of mal has been tested with Nim 1.0.4.
```
-cd nim
+cd impls/nim
make
# OR
nimble build
Linux using the Free Pascal compiler version 2.6.2 and 2.6.4.
```
-cd objpascal
+cd impls/objpascal
make
./stepX_YYY
```
X using XCode 7.
```
-cd objc
+cd impls/objc
make
./stepX_YYY
```
### OCaml 4.01.0
```
-cd ocaml
+cd impls/ocaml
make
./stepX_YYY
```
MATLAB is a commercial product.
```
-cd matlab
+cd impls/matlab
./stepX_YYY
octave -q --no-gui --no-history --eval "stepX_YYY();quit;"
matlab -nodisplay -nosplash -nodesktop -nojvm -r "stepX_YYY();quit;"
implementation of mal you need to download/install the miniMAL
interpreter (which requires Node.js).
```
-cd miniMAL
+cd impls/miniMAL
# Download miniMAL and dependencies
npm install
export PATH=`pwd`/node_modules/minimal-lisp/:$PATH
Term::ReadLine::Gnu from CPAN.
```
-cd perl
+cd impls/perl
perl stepX_YYY.pl
```
The Perl 6 implementation was tested on Rakudo Perl 6 2016.04.
```
-cd perl6
+cd impls/perl6
perl6 stepX_YYY.pl
```
to run.
```
-cd php
+cd impls/php
php stepX_YYY.php
```
or later.
```
-cd picolisp
+cd impls/picolisp
./run
```
The Pike implementation was tested on Pike 8.0.
```
-cd pike
+cd impls/pike
pike stepX_YYY.pike
```
tested with PostgreSQL 9.4.
```
-cd plpgsql
+cd impls/plpgsql
./wrap.sh stepX_YYY.sql
# OR
PSQL_USER=myuser PGPASSWORD=mypass ./wrap.sh stepX_YYY.sql
ability of the wrapper script to communicate with the DB.
```
-cd plsql
+cd impls/plsql
./wrap.sh stepX_YYY.sql
# OR
ORACLE_LOGON=myuser/mypass@ORCL ./wrap.sh stepX_YYY.sql
has been tested with Ghostscript 9.10.
```
-cd ps
+cd impls/ps
gs -q -dNODISPLAY -I./ stepX_YYY.ps
```
language. It has been tested with PowerShell 6.0.0 Alpha 9 on Linux.
```
-cd powershell
+cd impls/powershell
powershell ./stepX_YYY.ps1
```
### Python (2.X and 3.X)
```
-cd python
+cd impls/python
python stepX_YYY.py
```
(included with [pypy](https://bitbucket.org/pypy/pypy/)).
```
-cd rpython
+cd impls/rpython
make # this takes a very long time
./stepX_YYY
```
The R implementation of mal requires R (r-base-core) to run.
```
-cd r
+cd impls/r
make libs # to download and build rdyncall
Rscript stepX_YYY.r
```
compiler/interpreter to run.
```
-cd racket
+cd impls/racket
./stepX_YYY.rkt
```
The Rexx implementation of mal has been tested with Regina Rexx 3.6.
```
-cd rexx
+cd impls/rexx
make
rexx -a ./stepX_YYY.rexxpp
```
### Ruby (1.9+)
```
-cd ruby
+cd impls/ruby
ruby stepX_YYY.rb
```
tool (cargo) to build.
```
-cd rust
+cd impls/rust
cargo run --release --bin stepX_YYY
```
Install scala and sbt (http://www.scala-sbt.org/0.13/tutorial/Installing-sbt-on-Linux.html):
```
-cd scala
+cd impls/scala
sbt 'run-main stepX_YYY'
# OR
sbt compile
`Makefile` and `run` script accordingly.
```
-cd scheme
+cd impls/scheme
make symlinks
# chibi
scheme_MODE=chibi ./run
The Skew implementation of mal has been tested with Skew 0.7.42.
```
-cd skew
+cd impls/skew
make
node stepX_YYY.js
```
language and standard library.
```
-cd swift
+cd impls/swift
make
./stepX_YYY
```
has been tested with Swift 3 Preview 3.
```
-cd swift3
+cd impls/swift3
make
./stepX_YYY
```
has been tested with Swift 4.2.3 release.
```
-cd swift4
+cd impls/swift4
make
./stepX_YYY
```
has been tested with Swift 5.1.1 release.
```
-cd swift5
+cd impls/swift5
swift run stepX_YYY
```
editing support, install tclreadline.
```
-cd tcl
+cd impls/tcl
tclsh ./stepX_YYY.tcl
```
It has been tested with Node.js v6.
```
-cd ts
+cd impls/ts
make
node ./stepX_YYY.js
```
equivalent.
```
-cd vala
+cd impls/vala
make
./stepX_YYY
```
The VHDL implementation of mal has been tested with GHDL 0.29.
```
-cd vhdl
+cd impls/vhdl
make
./run_vhdl.sh ./stepX_YYY
```
The Vimscript implementation of mal requires Vim 8.0 to run.
```
-cd vimscript
+cd impls/vimscript
./run_vimscript.sh ./stepX_YYY.vim
```
required to build and run the VB.NET implementation.
```
-cd vb
+cd impls/vb
make
mono ./stepX_YYY.exe
```
[warpy](https://github.com/kanaka/warpy).
```
-cd wasm
+cd impls/wasm
# node
make wasm_MODE=node
./run.js ./stepX_YYY.wasm
The Wren implementation of mal was tested on Wren 0.2.0.
```
-cd wren
+cd impls/wren
wren ./stepX_YYY.wren
```
The Yorick implementation of mal was tested on Yorick 2.2.04.
```
-cd yorick
+cd impls/yorick
yorick -batch ./stepX_YYY.i
```
The Zig implementation of mal was tested on Zig 0.5.
```
-cd zig
+cd impls/zig
zig build stepX_YYY
```
HCoop / jackhill / mal.git / blobdiff