Copy disabled (too large)
Download .txt
Showing preview only (12,144K chars total). Download the full file to get everything.
Repository: kanaka/mal
Branch: master
Commit: 2bbfaa54cca4
Files: 2441
Total size: 11.2 MB
Directory structure:
gitextract_0ybyg9g2/
├── .gitattributes
├── .github/
│ ├── pull_request_template.md
│ └── workflows/
│ └── main.yml
├── .gitignore
├── .gitmodules
├── .travis.yml
├── IMPLS.yml
├── LICENSE
├── Makefile
├── Makefile.impls
├── README.md
├── ci.sh
├── docs/
│ ├── FAQ.md
│ ├── Hints.md
│ ├── TODO
│ ├── cheatsheet.html
│ ├── exercises.md
│ ├── graph/
│ │ ├── README.md
│ │ ├── all_data.json
│ │ ├── base_data.yaml
│ │ ├── collect_data.js
│ │ ├── graph_languages.js
│ │ ├── index.html
│ │ ├── package.json
│ │ └── so-tags.csv
│ ├── index.html
│ ├── notes.md
│ ├── step_notes.txt
│ └── web/
│ ├── ansi.css
│ ├── base.css
│ ├── console.css
│ ├── himera.css
│ ├── layout.css
│ ├── mal.js
│ └── skeleton.css
├── examples/
│ ├── clojurewest2014.mal
│ ├── exercises.mal
│ ├── hello.mal
│ └── presentation.mal
├── get-ci-matrix.py
├── impls/
│ ├── .gitignore
│ ├── ada/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.adb
│ │ ├── core.ads
│ │ ├── envs.adb
│ │ ├── envs.ads
│ │ ├── eval_callback.ads
│ │ ├── printer.adb
│ │ ├── printer.ads
│ │ ├── reader.adb
│ │ ├── reader.ads
│ │ ├── run
│ │ ├── smart_pointers.adb
│ │ ├── smart_pointers.ads
│ │ ├── step0_repl.adb
│ │ ├── step1_read_print.adb
│ │ ├── step2_eval.adb
│ │ ├── step3_env.adb
│ │ ├── step4_if_fn_do.adb
│ │ ├── step5_tco.adb
│ │ ├── step6_file.adb
│ │ ├── step7_quote.adb
│ │ ├── step8_macros.adb
│ │ ├── step9_try.adb
│ │ ├── stepa_mal.adb
│ │ ├── types-hash_map.adb
│ │ ├── types-hash_map.ads
│ │ ├── types-vector.adb
│ │ ├── types-vector.ads
│ │ ├── types.adb
│ │ └── types.ads
│ ├── ada.2/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── README
│ │ ├── core.adb
│ │ ├── core.ads
│ │ ├── envs.adb
│ │ ├── envs.ads
│ │ ├── err.adb
│ │ ├── err.ads
│ │ ├── garbage_collected.adb
│ │ ├── garbage_collected.ads
│ │ ├── printer.adb
│ │ ├── printer.ads
│ │ ├── reader.adb
│ │ ├── reader.ads
│ │ ├── readline.adb
│ │ ├── readline.ads
│ │ ├── run
│ │ ├── step0_repl.adb
│ │ ├── step1_read_print.adb
│ │ ├── step2_eval.adb
│ │ ├── step3_env.adb
│ │ ├── step4_if_fn_do.adb
│ │ ├── step5_tco.adb
│ │ ├── step6_file.adb
│ │ ├── step7_quote.adb
│ │ ├── step8_macros.adb
│ │ ├── step9_try.adb
│ │ ├── stepa_mal.adb
│ │ ├── types-atoms.adb
│ │ ├── types-atoms.ads
│ │ ├── types-builtins.adb
│ │ ├── types-builtins.ads
│ │ ├── types-fns.adb
│ │ ├── types-fns.ads
│ │ ├── types-maps.adb
│ │ ├── types-maps.ads
│ │ ├── types-sequences.adb
│ │ ├── types-sequences.ads
│ │ ├── types-strings.adb
│ │ ├── types-strings.ads
│ │ ├── types.adb
│ │ └── types.ads
│ ├── awk/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.awk
│ │ ├── env.awk
│ │ ├── printer.awk
│ │ ├── reader.awk
│ │ ├── run
│ │ ├── step0_repl.awk
│ │ ├── step1_read_print.awk
│ │ ├── step2_eval.awk
│ │ ├── step3_env.awk
│ │ ├── step4_if_fn_do.awk
│ │ ├── step5_tco.awk
│ │ ├── step6_file.awk
│ │ ├── step7_quote.awk
│ │ ├── step8_macros.awk
│ │ ├── step9_try.awk
│ │ ├── stepA_mal.awk
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ └── types.awk
│ ├── bash/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.sh
│ │ ├── env.sh
│ │ ├── printer.sh
│ │ ├── reader.sh
│ │ ├── run
│ │ ├── step0_repl.sh
│ │ ├── step1_read_print.sh
│ │ ├── step2_eval.sh
│ │ ├── step3_env.sh
│ │ ├── step4_if_fn_do.sh
│ │ ├── step5_tco.sh
│ │ ├── step6_file.sh
│ │ ├── step7_quote.sh
│ │ ├── step8_macros.sh
│ │ ├── step9_try.sh
│ │ ├── stepA_mal.sh
│ │ ├── tests/
│ │ │ └── stepA_mal.mal
│ │ └── types.sh
│ ├── basic/
│ │ ├── .args.mal
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── basicpp.py
│ │ ├── cbmbasic_console.patch
│ │ ├── core.in.bas
│ │ ├── debug.in.bas
│ │ ├── env.in.bas
│ │ ├── mem.in.bas
│ │ ├── printer.in.bas
│ │ ├── reader.in.bas
│ │ ├── readline.in.bas
│ │ ├── run
│ │ ├── step0_repl.in.bas
│ │ ├── step1_read_print.in.bas
│ │ ├── step2_eval.in.bas
│ │ ├── step3_env.in.bas
│ │ ├── step4_if_fn_do.in.bas
│ │ ├── step5_tco.in.bas
│ │ ├── step6_file.in.bas
│ │ ├── step7_quote.in.bas
│ │ ├── step8_macros.in.bas
│ │ ├── step9_try.in.bas
│ │ ├── stepA_mal.in.bas
│ │ ├── types.in.bas
│ │ └── variables.txt
│ ├── bbc-basic/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── core.bas
│ │ ├── env.bas
│ │ ├── printer.bas
│ │ ├── reader.bas
│ │ ├── riscos/
│ │ │ ├── .gitignore
│ │ │ ├── setup,feb
│ │ │ └── tokenize,ffe
│ │ ├── run
│ │ ├── step0_repl.bas
│ │ ├── step1_read_print.bas
│ │ ├── step2_eval.bas
│ │ ├── step3_env.bas
│ │ ├── step4_if_fn_do.bas
│ │ ├── step5_tco.bas
│ │ ├── step6_file.bas
│ │ ├── step7_quote.bas
│ │ ├── step8_macros.bas
│ │ ├── step9_try.bas
│ │ ├── stepA_mal.bas
│ │ └── types.bas
│ ├── c/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.c
│ │ ├── core.h
│ │ ├── env.c
│ │ ├── interop.c
│ │ ├── interop.h
│ │ ├── printer.c
│ │ ├── printer.h
│ │ ├── reader.c
│ │ ├── reader.h
│ │ ├── readline.c
│ │ ├── readline.h
│ │ ├── run
│ │ ├── step0_repl.c
│ │ ├── step1_read_print.c
│ │ ├── step2_eval.c
│ │ ├── step3_env.c
│ │ ├── step4_if_fn_do.c
│ │ ├── step5_tco.c
│ │ ├── step6_file.c
│ │ ├── step7_quote.c
│ │ ├── step8_macros.c
│ │ ├── step9_try.c
│ │ ├── stepA_mal.c
│ │ ├── tests/
│ │ │ ├── step5_tco.mal
│ │ │ └── stepA_mal.mal
│ │ ├── types.c
│ │ └── types.h
│ ├── c.2/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── README
│ │ ├── core.c
│ │ ├── core.h
│ │ ├── env.c
│ │ ├── env.h
│ │ ├── error.c
│ │ ├── error.h
│ │ ├── hashmap.c
│ │ ├── hashmap.h
│ │ ├── linked_list.c
│ │ ├── linked_list.h
│ │ ├── printer.c
│ │ ├── printer.h
│ │ ├── reader.c
│ │ ├── reader.h
│ │ ├── readline.c
│ │ ├── readline.h
│ │ ├── run
│ │ ├── step0_repl.c
│ │ ├── step1_read_print.c
│ │ ├── step2_eval.c
│ │ ├── step3_env.c
│ │ ├── step4_if_fn_do.c
│ │ ├── step5_tco.c
│ │ ├── step6_file.c
│ │ ├── step7_quote.c
│ │ ├── step8_macros.c
│ │ ├── step9_try.c
│ │ ├── stepA_mal.c
│ │ ├── tests/
│ │ │ └── stepA_mal.mal
│ │ ├── types.c
│ │ ├── types.h
│ │ ├── vector.c
│ │ └── vector.h
│ ├── chuck/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── chuck.md
│ │ ├── core.ck
│ │ ├── env.ck
│ │ ├── func.ck
│ │ ├── notes.md
│ │ ├── printer.ck
│ │ ├── reader.ck
│ │ ├── readline.ck
│ │ ├── run
│ │ ├── step0_repl.ck
│ │ ├── step1_read_print.ck
│ │ ├── step2_eval.ck
│ │ ├── step3_env.ck
│ │ ├── step4_if_fn_do.ck
│ │ ├── step5_tco.ck
│ │ ├── step6_file.ck
│ │ ├── step7_quote.ck
│ │ ├── step8_macros.ck
│ │ ├── step9_try.ck
│ │ ├── stepA_mal.ck
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ ├── types/
│ │ │ ├── MalObject.ck
│ │ │ ├── MalSubr.ck
│ │ │ ├── mal/
│ │ │ │ ├── MalAtom.ck
│ │ │ │ ├── MalError.ck
│ │ │ │ ├── MalFalse.ck
│ │ │ │ ├── MalHashMap.ck
│ │ │ │ ├── MalInt.ck
│ │ │ │ ├── MalKeyword.ck
│ │ │ │ ├── MalList.ck
│ │ │ │ ├── MalNil.ck
│ │ │ │ ├── MalString.ck
│ │ │ │ ├── MalSymbol.ck
│ │ │ │ ├── MalTrue.ck
│ │ │ │ └── MalVector.ck
│ │ │ └── subr/
│ │ │ ├── MalAdd.ck
│ │ │ ├── MalApply.ck
│ │ │ ├── MalAssoc.ck
│ │ │ ├── MalAtomify.ck
│ │ │ ├── MalConcat.ck
│ │ │ ├── MalConj.ck
│ │ │ ├── MalCons.ck
│ │ │ ├── MalCount.ck
│ │ │ ├── MalDeref.ck
│ │ │ ├── MalDissoc.ck
│ │ │ ├── MalDiv.ck
│ │ │ ├── MalDoReset.ck
│ │ │ ├── MalDoSwap.ck
│ │ │ ├── MalEqual.ck
│ │ │ ├── MalFirst.ck
│ │ │ ├── MalGet.ck
│ │ │ ├── MalGreater.ck
│ │ │ ├── MalGreaterEqual.ck
│ │ │ ├── MalHashMapify.ck
│ │ │ ├── MalIsAtom.ck
│ │ │ ├── MalIsContains.ck
│ │ │ ├── MalIsEmpty.ck
│ │ │ ├── MalIsFalse.ck
│ │ │ ├── MalIsFn.ck
│ │ │ ├── MalIsHashMap.ck
│ │ │ ├── MalIsKeyword.ck
│ │ │ ├── MalIsList.ck
│ │ │ ├── MalIsMacro.ck
│ │ │ ├── MalIsNil.ck
│ │ │ ├── MalIsNumber.ck
│ │ │ ├── MalIsString.ck
│ │ │ ├── MalIsSymbol.ck
│ │ │ ├── MalIsTrue.ck
│ │ │ ├── MalIsVector.ck
│ │ │ ├── MalKeys.ck
│ │ │ ├── MalKeywordify.ck
│ │ │ ├── MalLess.ck
│ │ │ ├── MalLessEqual.ck
│ │ │ ├── MalListify.ck
│ │ │ ├── MalMap.ck
│ │ │ ├── MalMeta.ck
│ │ │ ├── MalMul.ck
│ │ │ ├── MalNth.ck
│ │ │ ├── MalPrStr.ck
│ │ │ ├── MalPrintln.ck
│ │ │ ├── MalPrn.ck
│ │ │ ├── MalReadStr.ck
│ │ │ ├── MalReadline.ck
│ │ │ ├── MalRest.ck
│ │ │ ├── MalSeq.ck
│ │ │ ├── MalSequential.ck
│ │ │ ├── MalSlurp.ck
│ │ │ ├── MalStr.ck
│ │ │ ├── MalSub.ck
│ │ │ ├── MalSymbolify.ck
│ │ │ ├── MalThrow.ck
│ │ │ ├── MalTimeMs.ck
│ │ │ ├── MalVals.ck
│ │ │ ├── MalVec.ck
│ │ │ ├── MalVectorify.ck
│ │ │ └── MalWithMeta.ck
│ │ └── util/
│ │ ├── Constants.ck
│ │ ├── String.ck
│ │ └── Util.ck
│ ├── clojure/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── package.json
│ │ ├── project.clj
│ │ ├── run
│ │ ├── src/
│ │ │ └── mal/
│ │ │ ├── core.cljc
│ │ │ ├── env.cljc
│ │ │ ├── node_readline.js
│ │ │ ├── printer.cljc
│ │ │ ├── reader.cljc
│ │ │ ├── readline.clj
│ │ │ ├── readline.cljs
│ │ │ ├── step0_repl.cljc
│ │ │ ├── step1_read_print.cljc
│ │ │ ├── step2_eval.cljc
│ │ │ ├── step3_env.cljc
│ │ │ ├── step4_if_fn_do.cljc
│ │ │ ├── step5_tco.cljc
│ │ │ ├── step6_file.cljc
│ │ │ ├── step7_quote.cljc
│ │ │ ├── step8_macros.cljc
│ │ │ ├── step9_try.cljc
│ │ │ └── stepA_mal.cljc
│ │ └── tests/
│ │ ├── step5_tco.mal
│ │ └── stepA_mal.mal
│ ├── coffee/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.coffee
│ │ ├── env.coffee
│ │ ├── node_readline.coffee
│ │ ├── package.json
│ │ ├── printer.coffee
│ │ ├── reader.coffee
│ │ ├── run
│ │ ├── step0_repl.coffee
│ │ ├── step1_read_print.coffee
│ │ ├── step2_eval.coffee
│ │ ├── step3_env.coffee
│ │ ├── step4_if_fn_do.coffee
│ │ ├── step5_tco.coffee
│ │ ├── step6_file.coffee
│ │ ├── step7_quote.coffee
│ │ ├── step8_macros.coffee
│ │ ├── step9_try.coffee
│ │ ├── stepA_mal.coffee
│ │ ├── tests/
│ │ │ ├── step5_tco.mal
│ │ │ └── stepA_mal.mal
│ │ └── types.coffee
│ ├── common-lisp/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── README.org
│ │ ├── fake-readline.lisp
│ │ ├── hist/
│ │ │ └── .keepdir
│ │ ├── run
│ │ ├── run-abcl.lisp
│ │ ├── run-mkcl.lisp
│ │ ├── src/
│ │ │ ├── core.lisp
│ │ │ ├── env.lisp
│ │ │ ├── printer.lisp
│ │ │ ├── reader.lisp
│ │ │ ├── step0_repl.lisp
│ │ │ ├── step1_read_print.lisp
│ │ │ ├── step2_eval.lisp
│ │ │ ├── step3_env.lisp
│ │ │ ├── step4_if_fn_do.lisp
│ │ │ ├── step5_tco.lisp
│ │ │ ├── step6_file.lisp
│ │ │ ├── step7_quote.lisp
│ │ │ ├── step8_macros.lisp
│ │ │ ├── step9_try.lisp
│ │ │ ├── stepA_mal.lisp
│ │ │ ├── types.lisp
│ │ │ └── utils.lisp
│ │ ├── step0_repl.asd
│ │ ├── step1_read_print.asd
│ │ ├── step2_eval.asd
│ │ ├── step3_env.asd
│ │ ├── step4_if_fn_do.asd
│ │ ├── step5_tco.asd
│ │ ├── step6_file.asd
│ │ ├── step7_quote.asd
│ │ ├── step8_macros.asd
│ │ ├── step9_try.asd
│ │ ├── stepA_mal.asd
│ │ └── tests/
│ │ └── stepA_mal.mal
│ ├── cpp/
│ │ ├── .gitignore
│ │ ├── Core.cpp
│ │ ├── Debug.h
│ │ ├── Dockerfile
│ │ ├── Environment.cpp
│ │ ├── Environment.h
│ │ ├── MAL.h
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── ReadLine.cpp
│ │ ├── ReadLine.h
│ │ ├── Reader.cpp
│ │ ├── RefCountedPtr.h
│ │ ├── StaticList.h
│ │ ├── String.cpp
│ │ ├── String.h
│ │ ├── Types.cpp
│ │ ├── Types.h
│ │ ├── Validation.cpp
│ │ ├── Validation.h
│ │ ├── docker.sh
│ │ ├── run
│ │ ├── step0_repl.cpp
│ │ ├── step1_read_print.cpp
│ │ ├── step2_eval.cpp
│ │ ├── step3_env.cpp
│ │ ├── step4_if_fn_do.cpp
│ │ ├── step5_tco.cpp
│ │ ├── step6_file.cpp
│ │ ├── step7_quote.cpp
│ │ ├── step8_macros.cpp
│ │ ├── step9_try.cpp
│ │ ├── stepA_mal.cpp
│ │ └── tests/
│ │ └── step5_tco.mal
│ ├── crystal/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.cr
│ │ ├── env.cr
│ │ ├── error.cr
│ │ ├── printer.cr
│ │ ├── reader.cr
│ │ ├── run
│ │ ├── shard.yml
│ │ ├── step0_repl.cr
│ │ ├── step1_read_print.cr
│ │ ├── step2_eval.cr
│ │ ├── step3_env.cr
│ │ ├── step4_if_fn_do.cr
│ │ ├── step5_tco.cr
│ │ ├── step6_file.cr
│ │ ├── step7_quote.cr
│ │ ├── step8_macros.cr
│ │ ├── step9_try.cr
│ │ ├── stepA_mal.cr
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ └── types.cr
│ ├── cs/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.cs
│ │ ├── env.cs
│ │ ├── getline.cs
│ │ ├── interop.cs
│ │ ├── printer.cs
│ │ ├── reader.cs
│ │ ├── readline.cs
│ │ ├── run
│ │ ├── step0_repl.cs
│ │ ├── step1_read_print.cs
│ │ ├── step2_eval.cs
│ │ ├── step3_env.cs
│ │ ├── step4_if_fn_do.cs
│ │ ├── step5_tco.cs
│ │ ├── step6_file.cs
│ │ ├── step7_quote.cs
│ │ ├── step8_macros.cs
│ │ ├── step9_try.cs
│ │ ├── stepA_mal.cs
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ └── types.cs
│ ├── d/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── env.d
│ │ ├── main.di
│ │ ├── mal_core.d
│ │ ├── printer.d
│ │ ├── reader.d
│ │ ├── readline.d
│ │ ├── run
│ │ ├── step0_repl.d
│ │ ├── step1_read_print.d
│ │ ├── step2_eval.d
│ │ ├── step3_env.d
│ │ ├── step4_if_fn_do.d
│ │ ├── step5_tco.d
│ │ ├── step6_file.d
│ │ ├── step7_quote.d
│ │ ├── step8_macros.d
│ │ ├── step9_try.d
│ │ ├── stepA_mal.d
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ └── types.d
│ ├── dart/
│ │ ├── .analysis_options
│ │ ├── .packages
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.dart
│ │ ├── env.dart
│ │ ├── printer.dart
│ │ ├── pubspec.yaml
│ │ ├── reader.dart
│ │ ├── run
│ │ ├── step0_repl.dart
│ │ ├── step1_read_print.dart
│ │ ├── step2_eval.dart
│ │ ├── step3_env.dart
│ │ ├── step4_if_fn_do.dart
│ │ ├── step5_tco.dart
│ │ ├── step6_file.dart
│ │ ├── step7_quote.dart
│ │ ├── step8_macros.dart
│ │ ├── step9_try.dart
│ │ ├── stepA_mal.dart
│ │ └── types.dart
│ ├── elisp/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── mal/
│ │ │ ├── core.el
│ │ │ ├── env.el
│ │ │ ├── printer.el
│ │ │ ├── reader.el
│ │ │ └── types.el
│ │ ├── run
│ │ ├── step0_repl.el
│ │ ├── step1_read_print.el
│ │ ├── step2_eval.el
│ │ ├── step3_env.el
│ │ ├── step4_if_fn_do.el
│ │ ├── step5_tco.el
│ │ ├── step6_file.el
│ │ ├── step7_quote.el
│ │ ├── step8_macros.el
│ │ ├── step9_try.el
│ │ ├── stepA_mal.el
│ │ └── tests/
│ │ ├── step5_tco.mal
│ │ └── stepA_mal.mal
│ ├── elixir/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── lib/
│ │ │ ├── mal/
│ │ │ │ ├── atom.ex
│ │ │ │ ├── core.ex
│ │ │ │ ├── env.ex
│ │ │ │ ├── printer.ex
│ │ │ │ ├── reader.ex
│ │ │ │ └── types.ex
│ │ │ ├── mal.ex
│ │ │ └── mix/
│ │ │ └── tasks/
│ │ │ ├── step0_repl.ex
│ │ │ ├── step1_read_print.ex
│ │ │ ├── step2_eval.ex
│ │ │ ├── step3_env.ex
│ │ │ ├── step4_if_fn_do.ex
│ │ │ ├── step5_tco.ex
│ │ │ ├── step6_file.ex
│ │ │ ├── step7_quote.ex
│ │ │ ├── step8_macros.ex
│ │ │ ├── step9_try.ex
│ │ │ └── stepA_mal.ex
│ │ ├── mix.exs
│ │ ├── run
│ │ └── tests/
│ │ └── step5_tco.mal
│ ├── elm/
│ │ ├── .dockerignore
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── bootstrap.js
│ │ ├── elm.json
│ │ ├── node_readline.js
│ │ ├── package.json
│ │ ├── run
│ │ └── src/
│ │ ├── Core.elm
│ │ ├── Env.elm
│ │ ├── Eval.elm
│ │ ├── IO.elm
│ │ ├── Printer.elm
│ │ ├── Reader.elm
│ │ ├── Step0_repl.elm
│ │ ├── Step1_read_print.elm
│ │ ├── Step2_eval.elm
│ │ ├── Step3_env.elm
│ │ ├── Step4_if_fn_do.elm
│ │ ├── Step5_tco.elm
│ │ ├── Step6_file.elm
│ │ ├── Step7_quote.elm
│ │ ├── Step8_macros.elm
│ │ ├── Step9_try.elm
│ │ ├── StepA_mal.elm
│ │ ├── Types.elm
│ │ └── Utils.elm
│ ├── erlang/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── rebar.config
│ │ ├── rebar.config.script
│ │ ├── run
│ │ ├── src/
│ │ │ ├── atom.erl
│ │ │ ├── core.erl
│ │ │ ├── env.erl
│ │ │ ├── mal.app.src
│ │ │ ├── printer.erl
│ │ │ ├── reader.erl
│ │ │ ├── step0_repl.erl
│ │ │ ├── step1_read_print.erl
│ │ │ ├── step2_eval.erl
│ │ │ ├── step3_env.erl
│ │ │ ├── step4_if_fn_do.erl
│ │ │ ├── step5_tco.erl
│ │ │ ├── step6_file.erl
│ │ │ ├── step7_quote.erl
│ │ │ ├── step8_macros.erl
│ │ │ ├── step9_try.erl
│ │ │ ├── stepA_mal.erl
│ │ │ └── types.erl
│ │ └── tests/
│ │ └── step5_tco.mal
│ ├── es6/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.mjs
│ │ ├── env.mjs
│ │ ├── node_readline.mjs
│ │ ├── package.json
│ │ ├── printer.mjs
│ │ ├── reader.mjs
│ │ ├── run
│ │ ├── step0_repl.mjs
│ │ ├── step1_read_print.mjs
│ │ ├── step2_eval.mjs
│ │ ├── step3_env.mjs
│ │ ├── step4_if_fn_do.mjs
│ │ ├── step5_tco.mjs
│ │ ├── step6_file.mjs
│ │ ├── step7_quote.mjs
│ │ ├── step8_macros.mjs
│ │ ├── step9_try.mjs
│ │ ├── stepA_mal.mjs
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ └── types.mjs
│ ├── factor/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── lib/
│ │ │ ├── core/
│ │ │ │ ├── core-tests.factor
│ │ │ │ └── core.factor
│ │ │ ├── env/
│ │ │ │ ├── env-tests.factor
│ │ │ │ └── env.factor
│ │ │ ├── printer/
│ │ │ │ ├── printer-tests.factor
│ │ │ │ └── printer.factor
│ │ │ ├── reader/
│ │ │ │ ├── reader-tests.factor
│ │ │ │ └── reader.factor
│ │ │ └── types/
│ │ │ └── types.factor
│ │ ├── run
│ │ ├── step0_repl/
│ │ │ ├── deploy.factor
│ │ │ └── step0_repl.factor
│ │ ├── step1_read_print/
│ │ │ ├── deploy.factor
│ │ │ └── step1_read_print.factor
│ │ ├── step2_eval/
│ │ │ ├── deploy.factor
│ │ │ └── step2_eval.factor
│ │ ├── step3_env/
│ │ │ ├── deploy.factor
│ │ │ └── step3_env.factor
│ │ ├── step4_if_fn_do/
│ │ │ ├── deploy.factor
│ │ │ └── step4_if_fn_do.factor
│ │ ├── step5_tco/
│ │ │ ├── deploy.factor
│ │ │ └── step5_tco.factor
│ │ ├── step6_file/
│ │ │ ├── deploy.factor
│ │ │ └── step6_file.factor
│ │ ├── step7_quote/
│ │ │ ├── deploy.factor
│ │ │ └── step7_quote.factor
│ │ ├── step8_macros/
│ │ │ ├── deploy.factor
│ │ │ └── step8_macros.factor
│ │ ├── step9_try/
│ │ │ ├── deploy.factor
│ │ │ └── step9_try.factor
│ │ ├── stepA_mal/
│ │ │ ├── deploy.factor
│ │ │ └── stepA_mal.factor
│ │ └── tests/
│ │ └── step5_tco.mal
│ ├── fantom/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── run
│ │ ├── src/
│ │ │ ├── mallib/
│ │ │ │ ├── build.fan
│ │ │ │ └── fan/
│ │ │ │ ├── core.fan
│ │ │ │ ├── env.fan
│ │ │ │ ├── interop.fan
│ │ │ │ ├── reader.fan
│ │ │ │ └── types.fan
│ │ │ ├── step0_repl/
│ │ │ │ ├── build.fan
│ │ │ │ └── fan/
│ │ │ │ └── main.fan
│ │ │ ├── step1_read_print/
│ │ │ │ ├── build.fan
│ │ │ │ └── fan/
│ │ │ │ └── main.fan
│ │ │ ├── step2_eval/
│ │ │ │ ├── build.fan
│ │ │ │ └── fan/
│ │ │ │ └── main.fan
│ │ │ ├── step3_env/
│ │ │ │ ├── build.fan
│ │ │ │ └── fan/
│ │ │ │ └── main.fan
│ │ │ ├── step4_if_fn_do/
│ │ │ │ ├── build.fan
│ │ │ │ └── fan/
│ │ │ │ └── main.fan
│ │ │ ├── step5_tco/
│ │ │ │ ├── build.fan
│ │ │ │ └── fan/
│ │ │ │ └── main.fan
│ │ │ ├── step6_file/
│ │ │ │ ├── build.fan
│ │ │ │ └── fan/
│ │ │ │ └── main.fan
│ │ │ ├── step7_quote/
│ │ │ │ ├── build.fan
│ │ │ │ └── fan/
│ │ │ │ └── main.fan
│ │ │ ├── step8_macros/
│ │ │ │ ├── build.fan
│ │ │ │ └── fan/
│ │ │ │ └── main.fan
│ │ │ ├── step9_try/
│ │ │ │ ├── build.fan
│ │ │ │ └── fan/
│ │ │ │ └── main.fan
│ │ │ └── stepA_mal/
│ │ │ ├── build.fan
│ │ │ └── fan/
│ │ │ └── main.fan
│ │ └── tests/
│ │ ├── step5_tco.mal
│ │ └── stepA_mal.mal
│ ├── fennel/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.fnl
│ │ ├── env.fnl
│ │ ├── printer.fnl
│ │ ├── reader.fnl
│ │ ├── run
│ │ ├── step0_repl.fnl
│ │ ├── step1_read_print.fnl
│ │ ├── step2_eval.fnl
│ │ ├── step3_env.fnl
│ │ ├── step4_if_fn_do.fnl
│ │ ├── step5_tco.fnl
│ │ ├── step6_file.fnl
│ │ ├── step7_quote.fnl
│ │ ├── step8_macros.fnl
│ │ ├── step9_try.fnl
│ │ ├── stepA_mal.fnl
│ │ ├── types.fnl
│ │ └── utils.fnl
│ ├── forth/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.fs
│ │ ├── env.fs
│ │ ├── misc-tests.fs
│ │ ├── printer.fs
│ │ ├── reader.fs
│ │ ├── run
│ │ ├── step0_repl.fs
│ │ ├── step1_read_print.fs
│ │ ├── step2_eval.fs
│ │ ├── step3_env.fs
│ │ ├── step4_if_fn_do.fs
│ │ ├── step5_tco.fs
│ │ ├── step6_file.fs
│ │ ├── step7_quote.fs
│ │ ├── step8_macros.fs
│ │ ├── step9_try.fs
│ │ ├── stepA_mal.fs
│ │ ├── str.fs
│ │ ├── tests/
│ │ │ ├── step5_tco.mal
│ │ │ └── stepA_mal.mal
│ │ └── types.fs
│ ├── fsharp/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.fs
│ │ ├── env.fs
│ │ ├── error.fs
│ │ ├── node.fs
│ │ ├── printer.fs
│ │ ├── reader.fs
│ │ ├── readline.fs
│ │ ├── run
│ │ ├── step0_repl.fs
│ │ ├── step1_read_print.fs
│ │ ├── step2_eval.fs
│ │ ├── step3_env.fs
│ │ ├── step4_if_fn_do.fs
│ │ ├── step5_tco.fs
│ │ ├── step6_file.fs
│ │ ├── step7_quote.fs
│ │ ├── step8_macros.fs
│ │ ├── step9_try.fs
│ │ ├── stepA_mal.fs
│ │ ├── terminal.cs
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ ├── tokenizer.fs
│ │ └── types.fs
│ ├── gnu-smalltalk/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.st
│ │ ├── env.st
│ │ ├── func.st
│ │ ├── printer.st
│ │ ├── reader.st
│ │ ├── readline.st
│ │ ├── run
│ │ ├── step0_repl.st
│ │ ├── step1_read_print.st
│ │ ├── step2_eval.st
│ │ ├── step3_env.st
│ │ ├── step4_if_fn_do.st
│ │ ├── step5_tco.st
│ │ ├── step6_file.st
│ │ ├── step7_quote.st
│ │ ├── step8_macros.st
│ │ ├── step9_try.st
│ │ ├── stepA_mal.st
│ │ ├── tests/
│ │ │ └── stepA_mal.mal
│ │ ├── types.st
│ │ └── util.st
│ ├── go/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── go.mod
│ │ ├── run
│ │ ├── src/
│ │ │ ├── core/
│ │ │ │ └── core.go
│ │ │ ├── env/
│ │ │ │ └── env.go
│ │ │ ├── printer/
│ │ │ │ └── printer.go
│ │ │ ├── reader/
│ │ │ │ └── reader.go
│ │ │ ├── readline/
│ │ │ │ └── readline.go
│ │ │ ├── step0_repl/
│ │ │ │ └── step0_repl.go
│ │ │ ├── step1_read_print/
│ │ │ │ └── step1_read_print.go
│ │ │ ├── step2_eval/
│ │ │ │ └── step2_eval.go
│ │ │ ├── step3_env/
│ │ │ │ └── step3_env.go
│ │ │ ├── step4_if_fn_do/
│ │ │ │ └── step4_if_fn_do.go
│ │ │ ├── step5_tco/
│ │ │ │ └── step5_tco.go
│ │ │ ├── step6_file/
│ │ │ │ └── step6_file.go
│ │ │ ├── step7_quote/
│ │ │ │ └── step7_quote.go
│ │ │ ├── step8_macros/
│ │ │ │ └── step8_macros.go
│ │ │ ├── step9_try/
│ │ │ │ └── step9_try.go
│ │ │ ├── stepA_mal/
│ │ │ │ └── stepA_mal.go
│ │ │ └── types/
│ │ │ └── types.go
│ │ └── tests/
│ │ ├── step2_eval.mal
│ │ ├── step4_if_fn_do.mal
│ │ └── step5_tco.mal
│ ├── groovy/
│ │ ├── Dockerfile
│ │ ├── GroovyWrapper.groovy
│ │ ├── Makefile
│ │ ├── core.groovy
│ │ ├── env.groovy
│ │ ├── printer.groovy
│ │ ├── reader.groovy
│ │ ├── run
│ │ ├── step0_repl.groovy
│ │ ├── step1_read_print.groovy
│ │ ├── step2_eval.groovy
│ │ ├── step3_env.groovy
│ │ ├── step4_if_fn_do.groovy
│ │ ├── step5_tco.groovy
│ │ ├── step6_file.groovy
│ │ ├── step7_quote.groovy
│ │ ├── step8_macros.groovy
│ │ ├── step9_try.groovy
│ │ ├── stepA_mal.groovy
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ └── types.groovy
│ ├── guile/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.scm
│ │ ├── env.scm
│ │ ├── pcre.scm
│ │ ├── printer.scm
│ │ ├── reader.scm
│ │ ├── readline.scm
│ │ ├── run
│ │ ├── step0_repl.scm
│ │ ├── step1_read_print.scm
│ │ ├── step2_eval.scm
│ │ ├── step3_env.scm
│ │ ├── step4_if_fn_do.scm
│ │ ├── step5_tco.scm
│ │ ├── step6_file.scm
│ │ ├── step7_quote.scm
│ │ ├── step8_macros.scm
│ │ ├── step9_try.scm
│ │ ├── stepA_mal.scm
│ │ └── types.scm
│ ├── hare/
│ │ ├── .gitignore
│ │ ├── Dockerfile
│ │ ├── makefile
│ │ ├── mal/
│ │ │ ├── core.ha
│ │ │ ├── env.ha
│ │ │ ├── error.ha
│ │ │ ├── gc.ha
│ │ │ ├── hashmap.ha
│ │ │ ├── printer.ha
│ │ │ ├── reader.ha
│ │ │ ├── tokenizer.ha
│ │ │ └── types.ha
│ │ ├── run
│ │ ├── step0_repl.ha
│ │ ├── step1_read_print.ha
│ │ ├── step2_eval.ha
│ │ ├── step3_env.ha
│ │ ├── step4_if_fn_do.ha
│ │ ├── step5_tco.ha
│ │ ├── step6_file.ha
│ │ ├── step7_quote.ha
│ │ ├── step8_macros.ha
│ │ ├── step9_try.ha
│ │ └── stepA_mal.ha
│ ├── haskell/
│ │ ├── Core.hs
│ │ ├── Dockerfile
│ │ ├── Env.hs
│ │ ├── Makefile
│ │ ├── Printer.hs
│ │ ├── Reader.hs
│ │ ├── Readline.hs
│ │ ├── Types.hs
│ │ ├── run
│ │ ├── step0_repl.hs
│ │ ├── step1_read_print.hs
│ │ ├── step2_eval.hs
│ │ ├── step3_env.hs
│ │ ├── step4_if_fn_do.hs
│ │ ├── step5_tco.hs
│ │ ├── step6_file.hs
│ │ ├── step7_quote.hs
│ │ ├── step8_macros.hs
│ │ ├── step9_try.hs
│ │ ├── stepA_mal.hs
│ │ └── tests/
│ │ └── step5_tco.mal
│ ├── haxe/
│ │ ├── Compat.hx
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── Step0_repl.hx
│ │ ├── Step1_read_print.hx
│ │ ├── Step2_eval.hx
│ │ ├── Step3_env.hx
│ │ ├── Step4_if_fn_do.hx
│ │ ├── Step5_tco.hx
│ │ ├── Step6_file.hx
│ │ ├── Step7_quote.hx
│ │ ├── Step8_macros.hx
│ │ ├── Step9_try.hx
│ │ ├── StepA_mal.hx
│ │ ├── core/
│ │ │ └── Core.hx
│ │ ├── env/
│ │ │ └── Env.hx
│ │ ├── node_readline.js
│ │ ├── package.json
│ │ ├── printer/
│ │ │ └── Printer.hx
│ │ ├── reader/
│ │ │ ├── BlankLine.hx
│ │ │ └── Reader.hx
│ │ ├── run
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ └── types/
│ │ ├── MalException.hx
│ │ └── Types.hx
│ ├── hy/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.hy
│ │ ├── env.hy
│ │ ├── mal_types.hy
│ │ ├── printer.hy
│ │ ├── reader.hy
│ │ ├── run
│ │ ├── step0_repl.hy
│ │ ├── step1_read_print.hy
│ │ ├── step2_eval.hy
│ │ ├── step3_env.hy
│ │ ├── step4_if_fn_do.hy
│ │ ├── step5_tco.hy
│ │ ├── step6_file.hy
│ │ ├── step7_quote.hy
│ │ ├── step8_macros.hy
│ │ ├── step9_try.hy
│ │ ├── stepA_mal.hy
│ │ └── tests/
│ │ └── step5_tco.mal
│ ├── io/
│ │ ├── Dockerfile
│ │ ├── Env.io
│ │ ├── Makefile
│ │ ├── MalCore.io
│ │ ├── MalReader.io
│ │ ├── MalReadline.io
│ │ ├── MalTypes.io
│ │ ├── run
│ │ ├── step0_repl.io
│ │ ├── step1_read_print.io
│ │ ├── step2_eval.io
│ │ ├── step3_env.io
│ │ ├── step4_if_fn_do.io
│ │ ├── step5_tco.io
│ │ ├── step6_file.io
│ │ ├── step7_quote.io
│ │ ├── step8_macros.io
│ │ ├── step9_try.io
│ │ ├── stepA_mal.io
│ │ └── tests/
│ │ ├── step5_tco.mal
│ │ └── stepA_mal.mal
│ ├── janet/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.janet
│ │ ├── env.janet
│ │ ├── printer.janet
│ │ ├── reader.janet
│ │ ├── run
│ │ ├── step0_repl.janet
│ │ ├── step1_read_print.janet
│ │ ├── step2_eval.janet
│ │ ├── step3_env.janet
│ │ ├── step4_if_fn_do.janet
│ │ ├── step5_tco.janet
│ │ ├── step6_file.janet
│ │ ├── step7_quote.janet
│ │ ├── step8_macros.janet
│ │ ├── step9_try.janet
│ │ ├── stepA_mal.janet
│ │ ├── tests/
│ │ │ └── stepA_mal.mal
│ │ ├── types.janet
│ │ └── utils.janet
│ ├── java/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── pom.xml
│ │ ├── run
│ │ ├── src/
│ │ │ └── main/
│ │ │ └── java/
│ │ │ └── mal/
│ │ │ ├── core.java
│ │ │ ├── env.java
│ │ │ ├── printer.java
│ │ │ ├── reader.java
│ │ │ ├── readline.java
│ │ │ ├── step0_repl.java
│ │ │ ├── step1_read_print.java
│ │ │ ├── step2_eval.java
│ │ │ ├── step3_env.java
│ │ │ ├── step4_if_fn_do.java
│ │ │ ├── step5_tco.java
│ │ │ ├── step6_file.java
│ │ │ ├── step7_quote.java
│ │ │ ├── step8_macros.java
│ │ │ ├── step9_try.java
│ │ │ ├── stepA_mal.java
│ │ │ └── types.java
│ │ └── tests/
│ │ └── step5_tco.mal
│ ├── java-truffle/
│ │ ├── .gitignore
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── build.gradle
│ │ ├── make-native.sh
│ │ ├── run
│ │ ├── settings.gradle
│ │ └── src/
│ │ └── main/
│ │ └── java/
│ │ └── truffle/
│ │ └── mal/
│ │ ├── Core.java
│ │ ├── MalEnv.java
│ │ ├── Printer.java
│ │ ├── Reader.java
│ │ ├── Types.java
│ │ ├── step0_repl.java
│ │ ├── step1_read_print.java
│ │ ├── step2_eval.java
│ │ ├── step3_env.java
│ │ ├── step4_if_fn_do.java
│ │ ├── step5_tco.java
│ │ ├── step6_file.java
│ │ ├── step7_quote.java
│ │ ├── step8_macros.java
│ │ ├── step9_try.java
│ │ ├── stepA_mal.java
│ │ ├── stepB_calls.java
│ │ ├── stepC_slots.java
│ │ ├── stepD_caching.java
│ │ └── stepE_macros.java
│ ├── jq/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.jq
│ │ ├── docs/
│ │ │ └── impl-notes.md
│ │ ├── env.jq
│ │ ├── interp.jq
│ │ ├── printer.jq
│ │ ├── reader.jq
│ │ ├── run
│ │ ├── step0_repl.jq
│ │ ├── step1_read_print.jq
│ │ ├── step2_eval.jq
│ │ ├── step3_env.jq
│ │ ├── step4_if_fn_do.jq
│ │ ├── step5_tco.jq
│ │ ├── step6_file.jq
│ │ ├── step7_quote.jq
│ │ ├── step8_macros.jq
│ │ ├── step9_try.jq
│ │ ├── stepA_mal.jq
│ │ └── utils.jq
│ ├── js/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.js
│ │ ├── env.js
│ │ ├── interop.js
│ │ ├── jq_readline.js
│ │ ├── node_readline.js
│ │ ├── package.json
│ │ ├── printer.js
│ │ ├── reader.js
│ │ ├── run
│ │ ├── step0_repl.js
│ │ ├── step1_read_print.js
│ │ ├── step2_eval.js
│ │ ├── step3_env.js
│ │ ├── step4_if_fn_do.js
│ │ ├── step5_tco.js
│ │ ├── step6_file.js
│ │ ├── step7_quote.js
│ │ ├── step8_macros.js
│ │ ├── step9_try.js
│ │ ├── stepA_mal.js
│ │ ├── tests/
│ │ │ ├── common.js
│ │ │ ├── reader.js
│ │ │ ├── step5_tco.mal
│ │ │ ├── stepA_mal.mal
│ │ │ └── types.js
│ │ └── types.js
│ ├── julia/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.jl
│ │ ├── env.jl
│ │ ├── printer.jl
│ │ ├── reader.jl
│ │ ├── readline_mod.jl
│ │ ├── run
│ │ ├── step0_repl.jl
│ │ ├── step1_read_print.jl
│ │ ├── step2_eval.jl
│ │ ├── step3_env.jl
│ │ ├── step4_if_fn_do.jl
│ │ ├── step5_tco.jl
│ │ ├── step6_file.jl
│ │ ├── step7_quote.jl
│ │ ├── step8_macros.jl
│ │ ├── step9_try.jl
│ │ ├── stepA_mal.jl
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ └── types.jl
│ ├── kotlin/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── run
│ │ ├── src/
│ │ │ └── mal/
│ │ │ ├── core.kt
│ │ │ ├── env.kt
│ │ │ ├── printer.kt
│ │ │ ├── reader.kt
│ │ │ ├── readline.kt
│ │ │ ├── step0_repl.kt
│ │ │ ├── step1_read_print.kt
│ │ │ ├── step2_eval.kt
│ │ │ ├── step3_env.kt
│ │ │ ├── step4_if_fn_do.kt
│ │ │ ├── step5_tco.kt
│ │ │ ├── step6_file.kt
│ │ │ ├── step7_quote.kt
│ │ │ ├── step8_macros.kt
│ │ │ ├── step9_try.kt
│ │ │ ├── stepA_mal.kt
│ │ │ └── types.kt
│ │ └── tests/
│ │ └── step5_tco.mal
│ ├── latex3/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.sty
│ │ ├── env.sty
│ │ ├── printer.sty
│ │ ├── reader.sty
│ │ ├── run
│ │ ├── step0_repl.tex
│ │ ├── step1_read_print.tex
│ │ ├── step2_eval.tex
│ │ ├── step3_env.tex
│ │ ├── step4_if_fn_do.tex
│ │ ├── step6_file.tex
│ │ ├── step7_quote.tex
│ │ ├── step8_macros.tex
│ │ ├── step9_try.tex
│ │ ├── stepA_mal.tex
│ │ └── types.sty
│ ├── lib/
│ │ ├── README.md
│ │ ├── alias-hacks.mal
│ │ ├── benchmark.mal
│ │ ├── equality.mal
│ │ ├── load-file-once.mal
│ │ ├── memoize.mal
│ │ ├── perf.mal
│ │ ├── pprint.mal
│ │ ├── protocols.mal
│ │ ├── reducers.mal
│ │ ├── test_cascade.mal
│ │ ├── threading.mal
│ │ └── trivial.mal
│ ├── livescript/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.ls
│ │ ├── env.ls
│ │ ├── error.ls
│ │ ├── node_readline.js
│ │ ├── package.json
│ │ ├── printer.ls
│ │ ├── reader.ls
│ │ ├── run
│ │ ├── step0_repl.ls
│ │ ├── step1_read_print.ls
│ │ ├── step2_eval.ls
│ │ ├── step3_env.ls
│ │ ├── step4_if_fn_do.ls
│ │ ├── step5_tco.ls
│ │ ├── step6_file.ls
│ │ ├── step7_quote.ls
│ │ ├── step8_macros.ls
│ │ ├── step9_try.ls
│ │ ├── stepA_mal.ls
│ │ └── utils.ls
│ ├── logo/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.lg
│ │ ├── env.lg
│ │ ├── examples/
│ │ │ └── tree.mal
│ │ ├── printer.lg
│ │ ├── reader.lg
│ │ ├── readline.lg
│ │ ├── run
│ │ ├── step0_repl.lg
│ │ ├── step1_read_print.lg
│ │ ├── step2_eval.lg
│ │ ├── step3_env.lg
│ │ ├── step4_if_fn_do.lg
│ │ ├── step5_tco.lg
│ │ ├── step6_file.lg
│ │ ├── step7_quote.lg
│ │ ├── step8_macros.lg
│ │ ├── step9_try.lg
│ │ ├── stepA_mal.lg
│ │ ├── tests/
│ │ │ └── stepA_mal.mal
│ │ └── types.lg
│ ├── lua/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.lua
│ │ ├── env.lua
│ │ ├── printer.lua
│ │ ├── reader.lua
│ │ ├── readline.lua
│ │ ├── run
│ │ ├── step0_repl.lua
│ │ ├── step1_read_print.lua
│ │ ├── step2_eval.lua
│ │ ├── step3_env.lua
│ │ ├── step4_if_fn_do.lua
│ │ ├── step5_tco.lua
│ │ ├── step6_file.lua
│ │ ├── step7_quote.lua
│ │ ├── step8_macros.lua
│ │ ├── step9_try.lua
│ │ ├── stepA_mal.lua
│ │ ├── tests/
│ │ │ ├── step5_tco.mal
│ │ │ └── stepA_mal.mal
│ │ ├── types.lua
│ │ └── utils.lua
│ ├── make/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── README
│ │ ├── core.mk
│ │ ├── env.mk
│ │ ├── gmsl.mk
│ │ ├── numbers.mk
│ │ ├── printer.mk
│ │ ├── reader.mk
│ │ ├── readline.mk
│ │ ├── rules.mk
│ │ ├── run
│ │ ├── step0_repl.mk
│ │ ├── step1_read_print.mk
│ │ ├── step2_eval.mk
│ │ ├── step3_env.mk
│ │ ├── step4_if_fn_do.mk
│ │ ├── step6_file.mk
│ │ ├── step7_quote.mk
│ │ ├── step8_macros.mk
│ │ ├── step9_try.mk
│ │ ├── stepA_mal.mk
│ │ ├── tests/
│ │ │ └── stepA_mal.mal
│ │ ├── types.mk
│ │ └── util.mk
│ ├── matlab/
│ │ ├── +types/
│ │ │ ├── Atom.m
│ │ │ ├── Function.m
│ │ │ ├── HashMap.m
│ │ │ ├── List.m
│ │ │ ├── MalException.m
│ │ │ ├── Nil.m
│ │ │ ├── Reader.m
│ │ │ ├── Symbol.m
│ │ │ └── Vector.m
│ │ ├── .dockerignore
│ │ ├── Dict.m
│ │ ├── Dockerfile
│ │ ├── Env.m
│ │ ├── Makefile
│ │ ├── core.m
│ │ ├── printer.m
│ │ ├── reader.m
│ │ ├── run
│ │ ├── step0_repl.m
│ │ ├── step1_read_print.m
│ │ ├── step2_eval.m
│ │ ├── step3_env.m
│ │ ├── step4_if_fn_do.m
│ │ ├── step5_tco.m
│ │ ├── step6_file.m
│ │ ├── step7_quote.m
│ │ ├── step8_macros.m
│ │ ├── step9_try.m
│ │ ├── stepA_mal.m
│ │ └── type_utils.m
│ ├── miniMAL/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.json
│ │ ├── env.json
│ │ ├── miniMAL-core.json
│ │ ├── node_readline.js
│ │ ├── package.json
│ │ ├── printer.json
│ │ ├── reader.json
│ │ ├── run
│ │ ├── step0_repl.json
│ │ ├── step1_read_print.json
│ │ ├── step2_eval.json
│ │ ├── step3_env.json
│ │ ├── step4_if_fn_do.json
│ │ ├── step5_tco.json
│ │ ├── step6_file.json
│ │ ├── step7_quote.json
│ │ ├── step8_macros.json
│ │ ├── step9_try.json
│ │ ├── stepA_mal.json
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ └── types.json
│ ├── nasm/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── core.asm
│ │ ├── env.asm
│ │ ├── exceptions.asm
│ │ ├── macros.mac
│ │ ├── printer.asm
│ │ ├── reader.asm
│ │ ├── run
│ │ ├── step0_repl.asm
│ │ ├── step1_read_print.asm
│ │ ├── step2_eval.asm
│ │ ├── step3_env.asm
│ │ ├── step4_if_fn_do.asm
│ │ ├── step5_tco.asm
│ │ ├── step6_file.asm
│ │ ├── step7_quote.asm
│ │ ├── step8_macros.asm
│ │ ├── step9_try.asm
│ │ ├── stepA_mal.asm
│ │ ├── system.asm
│ │ └── types.asm
│ ├── nim/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.nim
│ │ ├── env.nim
│ │ ├── mal.nimble
│ │ ├── nim.cfg
│ │ ├── printer.nim
│ │ ├── reader.nim
│ │ ├── run
│ │ ├── step0_repl.nim
│ │ ├── step1_read_print.nim
│ │ ├── step2_eval.nim
│ │ ├── step3_env.nim
│ │ ├── step4_if_fn_do.nim
│ │ ├── step5_tco.nim
│ │ ├── step6_file.nim
│ │ ├── step7_quote.nim
│ │ ├── step8_macros.nim
│ │ ├── step9_try.nim
│ │ ├── stepA_mal.nim
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ └── types.nim
│ ├── objc/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.h
│ │ ├── core.m
│ │ ├── env.h
│ │ ├── env.m
│ │ ├── mal_readline.c
│ │ ├── mal_readline.h
│ │ ├── malfunc.h
│ │ ├── malfunc.m
│ │ ├── printer.h
│ │ ├── printer.m
│ │ ├── reader.h
│ │ ├── reader.m
│ │ ├── run
│ │ ├── step0_repl.m
│ │ ├── step1_read_print.m
│ │ ├── step2_eval.m
│ │ ├── step3_env.m
│ │ ├── step4_if_fn_do.m
│ │ ├── step5_tco.m
│ │ ├── step6_file.m
│ │ ├── step7_quote.m
│ │ ├── step8_macros.m
│ │ ├── step9_try.m
│ │ ├── stepA_mal.m
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ ├── types.h
│ │ └── types.m
│ ├── objpascal/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.pas
│ │ ├── mal_env.pas
│ │ ├── mal_func.pas
│ │ ├── mal_readline.pas
│ │ ├── mal_types.pas
│ │ ├── printer.pas
│ │ ├── reader.pas
│ │ ├── regexpr/
│ │ │ └── Source/
│ │ │ └── RegExpr.pas
│ │ ├── run
│ │ ├── step0_repl.pas
│ │ ├── step1_read_print.pas
│ │ ├── step2_eval.pas
│ │ ├── step3_env.pas
│ │ ├── step4_if_fn_do.pas
│ │ ├── step5_tco.pas
│ │ ├── step6_file.pas
│ │ ├── step7_quote.pas
│ │ ├── step8_macros.pas
│ │ ├── step9_try.pas
│ │ ├── stepA_mal.pas
│ │ └── tests/
│ │ └── step5_tco.mal
│ ├── ocaml/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.ml
│ │ ├── env.ml
│ │ ├── printer.ml
│ │ ├── reader.ml
│ │ ├── run
│ │ ├── step0_repl.ml
│ │ ├── step1_read_print.ml
│ │ ├── step2_eval.ml
│ │ ├── step3_env.ml
│ │ ├── step4_if_fn_do.ml
│ │ ├── step6_file.ml
│ │ ├── step7_quote.ml
│ │ ├── step8_macros.ml
│ │ ├── step9_try.ml
│ │ ├── stepA_mal.ml
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ └── types.ml
│ ├── perl/
│ │ ├── Core.pm
│ │ ├── Dockerfile
│ │ ├── Env.pm
│ │ ├── Interop.pm
│ │ ├── Makefile
│ │ ├── Printer.pm
│ │ ├── README.md
│ │ ├── Reader.pm
│ │ ├── Readline.pm
│ │ ├── Types.pm
│ │ ├── run
│ │ ├── step0_repl.pl
│ │ ├── step1_read_print.pl
│ │ ├── step2_eval.pl
│ │ ├── step3_env.pl
│ │ ├── step4_if_fn_do.pl
│ │ ├── step5_tco.pl
│ │ ├── step6_file.pl
│ │ ├── step7_quote.pl
│ │ ├── step8_macros.pl
│ │ ├── step9_try.pl
│ │ ├── stepA_mal.pl
│ │ └── tests/
│ │ ├── step5_tco.mal
│ │ └── stepA_mal.mal
│ ├── perl6/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.pm
│ │ ├── env.pm
│ │ ├── printer.pm
│ │ ├── reader.pm
│ │ ├── run
│ │ ├── step0_repl.pl
│ │ ├── step1_read_print.pl
│ │ ├── step2_eval.pl
│ │ ├── step3_env.pl
│ │ ├── step4_if_fn_do.pl
│ │ ├── step5_tco.pl
│ │ ├── step6_file.pl
│ │ ├── step7_quote.pl
│ │ ├── step8_macros.pl
│ │ ├── step9_try.pl
│ │ ├── stepA_mal.pl
│ │ ├── tests/
│ │ │ └── stepA_mal.mal
│ │ └── types.pm
│ ├── php/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── core.php
│ │ ├── env.php
│ │ ├── interop.php
│ │ ├── printer.php
│ │ ├── reader.php
│ │ ├── readline.php
│ │ ├── run
│ │ ├── step0_repl.php
│ │ ├── step1_read_print.php
│ │ ├── step2_eval.php
│ │ ├── step3_env.php
│ │ ├── step4_if_fn_do.php
│ │ ├── step5_tco.php
│ │ ├── step6_file.php
│ │ ├── step7_quote.php
│ │ ├── step8_macros.php
│ │ ├── step9_try.php
│ │ ├── stepA_mal.php
│ │ ├── tests/
│ │ │ ├── step5_tco.mal
│ │ │ └── stepA_mal.mal
│ │ ├── types.php
│ │ └── webrunner.php
│ ├── picolisp/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.l
│ │ ├── env.l
│ │ ├── func.l
│ │ ├── printer.l
│ │ ├── reader.l
│ │ ├── readline.l
│ │ ├── run
│ │ ├── step0_repl.l
│ │ ├── step1_read_print.l
│ │ ├── step2_eval.l
│ │ ├── step3_env.l
│ │ ├── step4_if_fn_do.l
│ │ ├── step5_tco.l
│ │ ├── step6_file.l
│ │ ├── step7_quote.l
│ │ ├── step8_macros.l
│ │ ├── step9_try.l
│ │ ├── stepA_mal.l
│ │ ├── tests/
│ │ │ ├── step5_tco.mal
│ │ │ └── stepA_mal.mal
│ │ └── types.l
│ ├── pike/
│ │ ├── Core.pmod
│ │ ├── Dockerfile
│ │ ├── Env.pmod
│ │ ├── Interop.pmod
│ │ ├── Makefile
│ │ ├── Printer.pmod
│ │ ├── Reader.pmod
│ │ ├── Readline.pmod
│ │ ├── Types.pmod
│ │ ├── run
│ │ ├── step0_repl.pike
│ │ ├── step1_read_print.pike
│ │ ├── step2_eval.pike
│ │ ├── step3_env.pike
│ │ ├── step4_if_fn_do.pike
│ │ ├── step5_tco.pike
│ │ ├── step6_file.pike
│ │ ├── step7_quote.pike
│ │ ├── step8_macros.pike
│ │ ├── step9_try.pike
│ │ ├── stepA_mal.pike
│ │ └── tests/
│ │ ├── step5_tco.mal
│ │ └── stepA_mal.mal
│ ├── plpgsql/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.sql
│ │ ├── entrypoint.sh
│ │ ├── envs.sql
│ │ ├── init.sql
│ │ ├── io.sql
│ │ ├── printer.sql
│ │ ├── reader.sql
│ │ ├── run
│ │ ├── step0_repl.sql
│ │ ├── step1_read_print.sql
│ │ ├── step2_eval.sql
│ │ ├── step3_env.sql
│ │ ├── step4_if_fn_do.sql
│ │ ├── step5_tco.sql
│ │ ├── step6_file.sql
│ │ ├── step7_quote.sql
│ │ ├── step8_macros.sql
│ │ ├── step9_try.sql
│ │ ├── stepA_mal.sql
│ │ ├── types.sql
│ │ └── wrap.sh
│ ├── plsql/
│ │ ├── Dockerfile
│ │ ├── Dockerfile-oracle
│ │ ├── Dockerfile-postgres
│ │ ├── Makefile
│ │ ├── core.sql
│ │ ├── entrypoint.sh
│ │ ├── env.sql
│ │ ├── io.sql
│ │ ├── login.sql
│ │ ├── printer.sql
│ │ ├── reader.sql
│ │ ├── run
│ │ ├── step0_repl.sql
│ │ ├── step1_read_print.sql
│ │ ├── step2_eval.sql
│ │ ├── step3_env.sql
│ │ ├── step4_if_fn_do.sql
│ │ ├── step5_tco.sql
│ │ ├── step6_file.sql
│ │ ├── step7_quote.sql
│ │ ├── step8_macros.sql
│ │ ├── step9_try.sql
│ │ ├── stepA_mal.sql
│ │ ├── types.sql
│ │ └── wrap.sh
│ ├── powershell/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.psm1
│ │ ├── env.psm1
│ │ ├── printer.psm1
│ │ ├── reader.psm1
│ │ ├── run
│ │ ├── step0_repl.ps1
│ │ ├── step1_read_print.ps1
│ │ ├── step2_eval.ps1
│ │ ├── step3_env.ps1
│ │ ├── step4_if_fn_do.ps1
│ │ ├── step5_tco.ps1
│ │ ├── step6_file.ps1
│ │ ├── step7_quote.ps1
│ │ ├── step8_macros.ps1
│ │ ├── step9_try.ps1
│ │ ├── stepA_mal.ps1
│ │ └── types.psm1
│ ├── prolog/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.pl
│ │ ├── env.pl
│ │ ├── printer.pl
│ │ ├── reader.pl
│ │ ├── run
│ │ ├── step0_repl.pl
│ │ ├── step1_read_print.pl
│ │ ├── step2_eval.pl
│ │ ├── step3_env.pl
│ │ ├── step4_if_fn_do.pl
│ │ ├── step6_file.pl
│ │ ├── step7_quote.pl
│ │ ├── step8_macros.pl
│ │ ├── step9_try.pl
│ │ ├── stepA_mal.pl
│ │ ├── tests/
│ │ │ └── stepA_mal.mal
│ │ ├── types.pl
│ │ └── utils.pl
│ ├── ps/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.ps
│ │ ├── env.ps
│ │ ├── interop.ps
│ │ ├── printer.ps
│ │ ├── reader.ps
│ │ ├── run
│ │ ├── step0_repl.ps
│ │ ├── step1_read_print.ps
│ │ ├── step2_eval.ps
│ │ ├── step3_env.ps
│ │ ├── step4_if_fn_do.ps
│ │ ├── step5_tco.ps
│ │ ├── step6_file.ps
│ │ ├── step7_quote.ps
│ │ ├── step8_macros.ps
│ │ ├── step9_try.ps
│ │ ├── stepA_mal.ps
│ │ ├── tests/
│ │ │ ├── step5_tco.mal
│ │ │ └── stepA_mal.mal
│ │ └── types.ps
│ ├── purs/
│ │ ├── .gitignore
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── package.json
│ │ ├── packages.dhall
│ │ ├── run
│ │ ├── spago.dhall
│ │ └── src/
│ │ ├── Core.purs
│ │ ├── Env.purs
│ │ ├── Printer.purs
│ │ ├── Reader.purs
│ │ ├── Readline.js
│ │ ├── Readline.purs
│ │ ├── Types.purs
│ │ ├── step0_repl.purs
│ │ ├── step1_read_print.purs
│ │ ├── step2_eval.purs
│ │ ├── step3_env.purs
│ │ ├── step4_if_fn_do.purs
│ │ ├── step5_tco.purs
│ │ ├── step6_file.purs
│ │ ├── step7_quote.purs
│ │ ├── step8_macros.purs
│ │ ├── step9_try.purs
│ │ └── stepA_mal.purs
│ ├── python2/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.py
│ │ ├── env.py
│ │ ├── mal_readline.py
│ │ ├── mal_types.py
│ │ ├── printer.py
│ │ ├── reader.py
│ │ ├── run
│ │ ├── step0_repl.py
│ │ ├── step1_read_print.py
│ │ ├── step2_eval.py
│ │ ├── step3_env.py
│ │ ├── step4_if_fn_do.py
│ │ ├── step5_tco.py
│ │ ├── step6_file.py
│ │ ├── step7_quote.py
│ │ ├── step8_macros.py
│ │ ├── step9_try.py
│ │ ├── stepA_mal.py
│ │ └── tests/
│ │ ├── step5_tco.mal
│ │ └── stepA_mal.mal
│ ├── python3/
│ │ ├── .gitignore
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.py
│ │ ├── env.py
│ │ ├── mal_readline.py
│ │ ├── mal_types.py
│ │ ├── reader.py
│ │ ├── run
│ │ ├── step0_repl.py
│ │ ├── step1_read_print.py
│ │ ├── step2_eval.py
│ │ ├── step3_env.py
│ │ ├── step4_if_fn_do.py
│ │ ├── step5_tco.py
│ │ ├── step6_file.py
│ │ ├── step7_quote.py
│ │ ├── step8_macros.py
│ │ ├── step9_try.py
│ │ ├── stepA_mal.py
│ │ └── tests/
│ │ ├── __init__.py
│ │ ├── step5_tco.mal
│ │ ├── stepA_mal.mal
│ │ ├── test_step2.py
│ │ ├── test_step3.py
│ │ ├── test_step4.py
│ │ ├── test_step5.py
│ │ ├── test_step6.py
│ │ ├── test_step7.py
│ │ ├── test_step8.py
│ │ ├── test_step9.py
│ │ └── test_stepA.py
│ ├── r/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.r
│ │ ├── env.r
│ │ ├── printer.r
│ │ ├── reader.r
│ │ ├── readline.r
│ │ ├── run
│ │ ├── step0_repl.r
│ │ ├── step1_read_print.r
│ │ ├── step2_eval.r
│ │ ├── step3_env.r
│ │ ├── step4_if_fn_do.r
│ │ ├── step5_tco.r
│ │ ├── step6_file.r
│ │ ├── step7_quote.r
│ │ ├── step8_macros.r
│ │ ├── step9_try.r
│ │ ├── stepA_mal.r
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ └── types.r
│ ├── racket/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.rkt
│ │ ├── env.rkt
│ │ ├── printer.rkt
│ │ ├── reader.rkt
│ │ ├── readline.rkt
│ │ ├── run
│ │ ├── step0_repl.rkt
│ │ ├── step1_read_print.rkt
│ │ ├── step2_eval.rkt
│ │ ├── step3_env.rkt
│ │ ├── step4_if_fn_do.rkt
│ │ ├── step5_tco.rkt
│ │ ├── step6_file.rkt
│ │ ├── step7_quote.rkt
│ │ ├── step8_macros.rkt
│ │ ├── step9_try.rkt
│ │ ├── stepA_mal.rkt
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ └── types.rkt
│ ├── rexx/
│ │ ├── .gitignore
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.rexx
│ │ ├── env.rexx
│ │ ├── printer.rexx
│ │ ├── reader.rexx
│ │ ├── readline.rexx
│ │ ├── run
│ │ ├── step0_repl.rexx
│ │ ├── step1_read_print.rexx
│ │ ├── step2_eval.rexx
│ │ ├── step3_env.rexx
│ │ ├── step4_if_fn_do.rexx
│ │ ├── step5_tco.rexx
│ │ ├── step6_file.rexx
│ │ ├── step7_quote.rexx
│ │ ├── step8_macros.rexx
│ │ ├── step9_try.rexx
│ │ ├── stepA_mal.rexx
│ │ ├── tests/
│ │ │ ├── step5_tco.mal
│ │ │ └── stepA_mal.mal
│ │ └── types.rexx
│ ├── rpython/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.py
│ │ ├── env.py
│ │ ├── mal_readline.py
│ │ ├── mal_types.py
│ │ ├── printer.py
│ │ ├── reader.py
│ │ ├── run
│ │ ├── step0_repl.py
│ │ ├── step1_read_print.py
│ │ ├── step2_eval.py
│ │ ├── step3_env.py
│ │ ├── step4_if_fn_do.py
│ │ ├── step5_tco.py
│ │ ├── step6_file.py
│ │ ├── step7_quote.py
│ │ ├── step8_macros.py
│ │ ├── step9_try.py
│ │ ├── stepA_mal.py
│ │ └── tests/
│ │ └── step5_tco.mal
│ ├── ruby/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.rb
│ │ ├── env.rb
│ │ ├── mal_readline.rb
│ │ ├── printer.rb
│ │ ├── reader.rb
│ │ ├── run
│ │ ├── step0_repl.rb
│ │ ├── step1_read_print.rb
│ │ ├── step2_eval.rb
│ │ ├── step3_env.rb
│ │ ├── step4_if_fn_do.rb
│ │ ├── step5_tco.rb
│ │ ├── step6_file.rb
│ │ ├── step7_quote.rb
│ │ ├── step8_macros.rb
│ │ ├── step9_try.rb
│ │ ├── stepA_mal.rb
│ │ ├── tests/
│ │ │ ├── step5_tco.mal
│ │ │ └── stepA_mal.mal
│ │ └── types.rb
│ ├── ruby.2/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.rb
│ │ ├── env.rb
│ │ ├── errors.rb
│ │ ├── printer.rb
│ │ ├── reader.rb
│ │ ├── run
│ │ ├── step0_repl.rb
│ │ ├── step1_read_print.rb
│ │ ├── step2_eval.rb
│ │ ├── step3_env.rb
│ │ ├── step4_if_fn_do.rb
│ │ ├── step5_tco.rb
│ │ ├── step6_file.rb
│ │ ├── step7_quote.rb
│ │ ├── step8_macros.rb
│ │ ├── step9_try.rb
│ │ ├── stepA_mal.rb
│ │ └── types.rb
│ ├── rust/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.rs
│ │ ├── env.rs
│ │ ├── printer.rs
│ │ ├── reader.rs
│ │ ├── readline.rs
│ │ ├── run
│ │ ├── step0_repl.rs
│ │ ├── step1_read_print.rs
│ │ ├── step2_eval.rs
│ │ ├── step3_env.rs
│ │ ├── step4_if_fn_do.rs
│ │ ├── step5_tco.rs
│ │ ├── step6_file.rs
│ │ ├── step7_quote.rs
│ │ ├── step8_macros.rs
│ │ ├── step9_try.rs
│ │ ├── stepA_mal.rs
│ │ └── types.rs
│ ├── scala/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── assembly.sbt
│ │ ├── build.sbt
│ │ ├── core.scala
│ │ ├── env.scala
│ │ ├── printer.scala
│ │ ├── project/
│ │ │ └── assembly.sbt
│ │ ├── reader.scala
│ │ ├── run
│ │ ├── step0_repl.scala
│ │ ├── step1_read_print.scala
│ │ ├── step2_eval.scala
│ │ ├── step3_env.scala
│ │ ├── step4_if_fn_do.scala
│ │ ├── step5_tco.scala
│ │ ├── step6_file.scala
│ │ ├── step7_quote.scala
│ │ ├── step8_macros.scala
│ │ ├── step9_try.scala
│ │ ├── stepA_mal.scala
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ └── types.scala
│ ├── scheme/
│ │ ├── .gitignore
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── lib/
│ │ │ ├── core.sld
│ │ │ ├── env.sld
│ │ │ ├── printer.sld
│ │ │ ├── reader.sld
│ │ │ ├── types.sld
│ │ │ └── util.sld
│ │ ├── run
│ │ ├── step0_repl.scm
│ │ ├── step1_read_print.scm
│ │ ├── step2_eval.scm
│ │ ├── step3_env.scm
│ │ ├── step4_if_fn_do.scm
│ │ ├── step5_tco.scm
│ │ ├── step6_file.scm
│ │ ├── step7_quote.scm
│ │ ├── step8_macros.scm
│ │ ├── step9_try.scm
│ │ ├── stepA_mal.scm
│ │ └── tests/
│ │ └── stepA_mal.mal
│ ├── skew/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.sk
│ │ ├── env.sk
│ │ ├── printer.sk
│ │ ├── reader.sk
│ │ ├── run
│ │ ├── step0_repl.sk
│ │ ├── step1_read_print.sk
│ │ ├── step2_eval.sk
│ │ ├── step3_env.sk
│ │ ├── step4_if_fn_do.sk
│ │ ├── step5_tco.sk
│ │ ├── step6_file.sk
│ │ ├── step7_quote.sk
│ │ ├── step8_macros.sk
│ │ ├── step9_try.sk
│ │ ├── stepA_mal.sk
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ ├── types.sk
│ │ └── util.sk
│ ├── sml/
│ │ ├── .gitignore
│ │ ├── Dockerfile
│ │ ├── LargeInt.sml
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── core.sml
│ │ ├── env.sml
│ │ ├── main.sml
│ │ ├── printer.sml
│ │ ├── reader.sml
│ │ ├── run
│ │ ├── step0_repl.mlb
│ │ ├── step0_repl.sml
│ │ ├── step1_read_print.mlb
│ │ ├── step1_read_print.sml
│ │ ├── step2_eval.mlb
│ │ ├── step2_eval.sml
│ │ ├── step3_env.mlb
│ │ ├── step3_env.sml
│ │ ├── step4_if_fn_do.mlb
│ │ ├── step4_if_fn_do.sml
│ │ ├── step6_file.mlb
│ │ ├── step6_file.sml
│ │ ├── step7_quote.mlb
│ │ ├── step7_quote.sml
│ │ ├── step8_macros.mlb
│ │ ├── step8_macros.sml
│ │ ├── step9_try.mlb
│ │ ├── step9_try.sml
│ │ ├── stepA_mal.mlb
│ │ ├── stepA_mal.sml
│ │ ├── types.sml
│ │ └── util.sml
│ ├── swift3/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── Sources/
│ │ │ ├── core.swift
│ │ │ ├── env.swift
│ │ │ ├── printer.swift
│ │ │ ├── reader.swift
│ │ │ ├── step0_repl/
│ │ │ │ └── main.swift
│ │ │ ├── step1_read_print/
│ │ │ │ └── main.swift
│ │ │ ├── step2_eval/
│ │ │ │ └── main.swift
│ │ │ ├── step3_env/
│ │ │ │ └── main.swift
│ │ │ ├── step4_if_fn_do/
│ │ │ │ └── main.swift
│ │ │ ├── step5_tco/
│ │ │ │ └── main.swift
│ │ │ ├── step6_file/
│ │ │ │ └── main.swift
│ │ │ ├── step7_quote/
│ │ │ │ └── main.swift
│ │ │ ├── step8_macros/
│ │ │ │ └── main.swift
│ │ │ ├── step9_try/
│ │ │ │ └── main.swift
│ │ │ ├── stepA_mal/
│ │ │ │ └── main.swift
│ │ │ └── types.swift
│ │ ├── run
│ │ └── tests/
│ │ └── step5_tco.mal
│ ├── swift4/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── Sources/
│ │ │ ├── core.swift
│ │ │ ├── env.swift
│ │ │ ├── printer.swift
│ │ │ ├── reader.swift
│ │ │ ├── step0_repl/
│ │ │ │ └── main.swift
│ │ │ ├── step1_read_print/
│ │ │ │ └── main.swift
│ │ │ ├── step2_eval/
│ │ │ │ └── main.swift
│ │ │ ├── step3_env/
│ │ │ │ └── main.swift
│ │ │ ├── step4_if_fn_do/
│ │ │ │ └── main.swift
│ │ │ ├── step5_tco/
│ │ │ │ └── main.swift
│ │ │ ├── step6_file/
│ │ │ │ └── main.swift
│ │ │ ├── step7_quote/
│ │ │ │ └── main.swift
│ │ │ ├── step8_macros/
│ │ │ │ └── main.swift
│ │ │ ├── step9_try/
│ │ │ │ └── main.swift
│ │ │ ├── stepA_mal/
│ │ │ │ └── main.swift
│ │ │ └── types.swift
│ │ └── run
│ ├── swift6/
│ │ ├── .gitignore
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── Package.swift
│ │ ├── Sources/
│ │ │ ├── core/
│ │ │ │ ├── Core.swift
│ │ │ │ ├── Env.swift
│ │ │ │ ├── Errors.swift
│ │ │ │ ├── Parser.swift
│ │ │ │ ├── Printer.swift
│ │ │ │ ├── Reader.swift
│ │ │ │ ├── Types.swift
│ │ │ │ └── Utils.swift
│ │ │ ├── step0_repl/
│ │ │ │ └── main.swift
│ │ │ ├── step1_read_print/
│ │ │ │ └── main.swift
│ │ │ ├── step2_eval/
│ │ │ │ └── main.swift
│ │ │ ├── step3_env/
│ │ │ │ └── main.swift
│ │ │ ├── step4_if_fn_do/
│ │ │ │ └── main.swift
│ │ │ ├── step5_tco/
│ │ │ │ └── main.swift
│ │ │ ├── step6_file/
│ │ │ │ └── main.swift
│ │ │ ├── step7_quote/
│ │ │ │ └── main.swift
│ │ │ ├── step8_macros/
│ │ │ │ └── main.swift
│ │ │ ├── step9_try/
│ │ │ │ └── main.swift
│ │ │ └── stepA_mal/
│ │ │ └── main.swift
│ │ └── run
│ ├── tcl/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.tcl
│ │ ├── env.tcl
│ │ ├── mal_readline.tcl
│ │ ├── printer.tcl
│ │ ├── reader.tcl
│ │ ├── run
│ │ ├── step0_repl.tcl
│ │ ├── step1_read_print.tcl
│ │ ├── step2_eval.tcl
│ │ ├── step3_env.tcl
│ │ ├── step4_if_fn_do.tcl
│ │ ├── step5_tco.tcl
│ │ ├── step6_file.tcl
│ │ ├── step7_quote.tcl
│ │ ├── step8_macros.tcl
│ │ ├── step9_try.tcl
│ │ ├── stepA_mal.tcl
│ │ ├── tests/
│ │ │ ├── step5_tco.mal
│ │ │ └── stepA_mal.mal
│ │ └── types.tcl
│ ├── tests/
│ │ ├── busywork.mal
│ │ ├── computations.mal
│ │ ├── docker/
│ │ │ └── Dockerfile
│ │ ├── docker-build.sh
│ │ ├── docker-run.sh
│ │ ├── fib.mal
│ │ ├── inc.mal
│ │ ├── incA.mal
│ │ ├── incB.mal
│ │ ├── incC.mal
│ │ ├── lib/
│ │ │ ├── alias-hacks.mal
│ │ │ ├── equality.mal
│ │ │ ├── load-file-once-inc.mal
│ │ │ ├── load-file-once.mal
│ │ │ ├── memoize.mal
│ │ │ ├── pprint.mal
│ │ │ ├── protocols.mal
│ │ │ ├── reducers.mal
│ │ │ ├── test_cascade.mal
│ │ │ ├── threading.mal
│ │ │ └── trivial.mal
│ │ ├── perf1.mal
│ │ ├── perf2.mal
│ │ ├── perf3.mal
│ │ ├── print_argv.mal
│ │ ├── run_argv_test.sh
│ │ ├── step0_repl.mal
│ │ ├── step1_read_print.mal
│ │ ├── step2_eval.mal
│ │ ├── step3_env.mal
│ │ ├── step4_if_fn_do.mal
│ │ ├── step5_tco.mal
│ │ ├── step6_file.mal
│ │ ├── step7_quote.mal
│ │ ├── step8_macros.mal
│ │ ├── step9_try.mal
│ │ ├── stepA_mal.mal
│ │ ├── test.txt
│ │ └── travis_trigger.sh
│ ├── ts/
│ │ ├── .gitignore
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.ts
│ │ ├── env.ts
│ │ ├── node_readline.ts
│ │ ├── package.json
│ │ ├── printer.ts
│ │ ├── reader.ts
│ │ ├── run
│ │ ├── step0_repl.ts
│ │ ├── step1_read_print.ts
│ │ ├── step2_eval.ts
│ │ ├── step3_env.ts
│ │ ├── step4_if_fn_do.ts
│ │ ├── step5_tco.ts
│ │ ├── step6_file.ts
│ │ ├── step7_quote.ts
│ │ ├── step8_macros.ts
│ │ ├── step9_try.ts
│ │ ├── stepA_mal.ts
│ │ ├── tsconfig.json
│ │ └── types.ts
│ ├── vala/
│ │ ├── .gitignore
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── core.vala
│ │ ├── env.vala
│ │ ├── gc.vala
│ │ ├── printer.vala
│ │ ├── reader.vala
│ │ ├── run
│ │ ├── step0_repl.vala
│ │ ├── step1_read_print.vala
│ │ ├── step2_eval.vala
│ │ ├── step3_env.vala
│ │ ├── step4_if_fn_do.vala
│ │ ├── step5_tco.vala
│ │ ├── step6_file.vala
│ │ ├── step7_quote.vala
│ │ ├── step8_macros.vala
│ │ ├── step9_try.vala
│ │ ├── stepA_mal.vala
│ │ └── types.vala
│ ├── vb/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.vb
│ │ ├── env.vb
│ │ ├── getline.cs
│ │ ├── printer.vb
│ │ ├── reader.vb
│ │ ├── readline.vb
│ │ ├── run
│ │ ├── step0_repl.vb
│ │ ├── step1_read_print.vb
│ │ ├── step2_eval.vb
│ │ ├── step3_env.vb
│ │ ├── step4_if_fn_do.vb
│ │ ├── step5_tco.vb
│ │ ├── step6_file.vb
│ │ ├── step7_quote.vb
│ │ ├── step8_macros.vb
│ │ ├── step9_try.vb
│ │ ├── stepA_mal.vb
│ │ ├── tests/
│ │ │ └── step5_tco.mal
│ │ └── types.vb
│ ├── vbs/
│ │ ├── Makefile
│ │ ├── core.vbs
│ │ ├── env.vbs
│ │ ├── install.vbs
│ │ ├── io.vbs
│ │ ├── printer.vbs
│ │ ├── reader.vbs
│ │ ├── run
│ │ ├── step0_repl.vbs
│ │ ├── step1_read_print.vbs
│ │ ├── step2_eval.vbs
│ │ ├── step3_env.vbs
│ │ ├── step4_if_fn_do.vbs
│ │ ├── step5_tco.vbs
│ │ ├── step6_file.vbs
│ │ ├── step7_quote.vbs
│ │ ├── step8_macros.vbs
│ │ ├── step9_try.vbs
│ │ ├── stepA_mal.vbs
│ │ ├── tests/
│ │ │ ├── step4_if_fn_do.mal
│ │ │ └── step9_try.mal
│ │ └── types.vbs
│ ├── vhdl/
│ │ ├── .gitignore
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.vhdl
│ │ ├── env.vhdl
│ │ ├── pkg_readline.vhdl
│ │ ├── printer.vhdl
│ │ ├── reader.vhdl
│ │ ├── run
│ │ ├── run_vhdl.sh
│ │ ├── step0_repl.vhdl
│ │ ├── step1_read_print.vhdl
│ │ ├── step2_eval.vhdl
│ │ ├── step3_env.vhdl
│ │ ├── step4_if_fn_do.vhdl
│ │ ├── step5_tco.vhdl
│ │ ├── step6_file.vhdl
│ │ ├── step7_quote.vhdl
│ │ ├── step8_macros.vhdl
│ │ ├── step9_try.vhdl
│ │ ├── stepA_mal.vhdl
│ │ └── types.vhdl
│ ├── vimscript/
│ │ ├── .gitignore
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.vim
│ │ ├── env.vim
│ │ ├── printer.vim
│ │ ├── reader.vim
│ │ ├── readline.vim
│ │ ├── run
│ │ ├── run_vimscript.sh
│ │ ├── step0_repl.vim
│ │ ├── step1_read_print.vim
│ │ ├── step2_eval.vim
│ │ ├── step3_env.vim
│ │ ├── step4_if_fn_do.vim
│ │ ├── step5_tco.vim
│ │ ├── step6_file.vim
│ │ ├── step7_quote.vim
│ │ ├── step8_macros.vim
│ │ ├── step9_try.vim
│ │ ├── stepA_mal.vim
│ │ ├── tests/
│ │ │ ├── step5_tco.mal
│ │ │ └── stepA_mal.mal
│ │ ├── types.vim
│ │ └── vimextras.c
│ ├── wasm/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.wam
│ │ ├── debug.wam
│ │ ├── env.wam
│ │ ├── mem.wam
│ │ ├── node_readline.js
│ │ ├── package.json
│ │ ├── platform_direct.wam
│ │ ├── platform_libc.wam
│ │ ├── platform_wasi.wam
│ │ ├── printer.wam
│ │ ├── printf.wam
│ │ ├── reader.wam
│ │ ├── run
│ │ ├── run.js
│ │ ├── step0_repl.wam
│ │ ├── step1_read_print.wam
│ │ ├── step2_eval.wam
│ │ ├── step3_env.wam
│ │ ├── step4_if_fn_do.wam
│ │ ├── step5_tco.wam
│ │ ├── step6_file.wam
│ │ ├── step7_quote.wam
│ │ ├── step8_macros.wam
│ │ ├── step9_try.wam
│ │ ├── stepA_mal.wam
│ │ ├── string.wam
│ │ └── types.wam
│ ├── wren/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── core.wren
│ │ ├── env.wren
│ │ ├── interop.wren
│ │ ├── printer.wren
│ │ ├── reader.wren
│ │ ├── readline.wren
│ │ ├── run
│ │ ├── step0_repl.wren
│ │ ├── step1_read_print.wren
│ │ ├── step2_eval.wren
│ │ ├── step3_env.wren
│ │ ├── step4_if_fn_do.wren
│ │ ├── step5_tco.wren
│ │ ├── step6_file.wren
│ │ ├── step7_quote.wren
│ │ ├── step8_macros.wren
│ │ ├── step9_try.wren
│ │ ├── stepA_mal.wren
│ │ ├── tests/
│ │ │ ├── step5_tco.mal
│ │ │ └── stepA_mal.mal
│ │ ├── types.wren
│ │ └── wren-add-gettimeofday.patch
│ ├── xslt/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.xslt
│ │ ├── env.xslt
│ │ ├── printer.xslt
│ │ ├── reader.xslt
│ │ ├── readline.xslt
│ │ ├── run
│ │ ├── step0_repl.inc.xslt
│ │ ├── step0_repl.xslt
│ │ ├── step1_read_print.inc.xslt
│ │ ├── step1_read_print.xslt
│ │ ├── step2_eval.inc.xslt
│ │ ├── step2_eval.xslt
│ │ ├── step3_env.inc.xslt
│ │ ├── step3_env.xslt
│ │ ├── step4_if_fn_do.inc.xslt
│ │ ├── step4_if_fn_do.xslt
│ │ ├── step6_file.inc.xslt
│ │ ├── step6_file.xslt
│ │ ├── step7_quote.inc.xslt
│ │ ├── step7_quote.xslt
│ │ ├── step8_macros.inc.xslt
│ │ ├── step8_macros.xslt
│ │ ├── step9_try.inc.xslt
│ │ ├── step9_try.xslt
│ │ ├── stepA_mal.inc.xslt
│ │ ├── stepA_mal.xslt
│ │ └── test.xslt
│ ├── yorick/
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── core.i
│ │ ├── env.i
│ │ ├── hash.i
│ │ ├── printer.i
│ │ ├── reader.i
│ │ ├── run
│ │ ├── step0_repl.i
│ │ ├── step1_read_print.i
│ │ ├── step2_eval.i
│ │ ├── step3_env.i
│ │ ├── step4_if_fn_do.i
│ │ ├── step5_tco.i
│ │ ├── step6_file.i
│ │ ├── step7_quote.i
│ │ ├── step8_macros.i
│ │ ├── step9_try.i
│ │ ├── stepA_mal.i
│ │ ├── tests/
│ │ │ └── stepA_mal.mal
│ │ └── types.i
│ └── zig/
│ ├── Dockerfile
│ ├── Makefile
│ ├── README
│ ├── build.zig
│ ├── core.zig
│ ├── env.zig
│ ├── error.zig
│ ├── hmap.zig
│ ├── linked_list.zig
│ ├── printer.zig
│ ├── reader.zig
│ ├── readline.zig
│ ├── run
│ ├── step0_repl.zig
│ ├── step1_read_print.zig
│ ├── step2_eval.zig
│ ├── step3_env.zig
│ ├── step4_if_fn_do.zig
│ ├── step5_tco.zig
│ ├── step6_file.zig
│ ├── step7_quote.zig
│ ├── step8_macros.zig
│ ├── step9_try.zig
│ ├── stepA_mal.zig
│ └── types.zig
├── process/
│ ├── guide.md
│ ├── step0_repl.txt
│ ├── step1_read_print.txt
│ ├── step2_eval.txt
│ ├── step3_env.txt
│ ├── step4_if_fn_do.txt
│ ├── step5_tco.txt
│ ├── step6_file.txt
│ ├── step7_quote.txt
│ ├── step8_macros.txt
│ ├── step9_try.txt
│ ├── stepA_mal.txt
│ └── steps.drawio
├── runtest.py
└── voom-like-version.sh
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitattributes
================================================
* text=auto eol=lf
impls/vbs/*.vbs text eol=crlf
================================================
FILE: .github/pull_request_template.md
================================================
Pull request requirements:
- [ ] Commits are well written and well organized.
- [ ] Commits for a specific implementation should be prefixed with
the implementation name.
- [ ] Github Actions CI passes all checks (including self-host)
Additional requirements if you are adding a new implementation (see [FAQ](../docs/FAQ.md#add_implementation) for details):
- [ ] Follow incremental structure (no common eval code)
- [ ] Add `impls/<IMPL>/Dockerfile`
- [ ] Add `impls/<IMPL>/Makefile`
- [ ] Update `IMPLS.yml`
- [ ] Update `Makefile.impls`
- [ ] Update `README.md`
================================================
FILE: .github/workflows/main.yml
================================================
name: Build and Test
permissions:
contents: read
packages: write
on:
push: {}
pull_request: {}
workflow_dispatch:
inputs:
impls:
description: 'Space separated list of impls to test (or all)'
required: true
default: 'all'
self-hosted:
description: 'Include self-hosted tests'
required: true
default: 'yes'
options: ['yes', 'no']
jobs:
get-matrix:
runs-on: ubuntu-24.04
outputs:
do-linux: ${{ steps.get-matrix-step.outputs.do_linux }}
matrix-linux: ${{ steps.get-matrix-step.outputs.linux }}
do-macos: ${{ steps.get-matrix-step.outputs.do_macos }}
matrix-macos: ${{ steps.get-matrix-step.outputs.macos }}
do-windows: ${{ steps.get-matrix-step.outputs.do_windows }}
matrix-windows: ${{ steps.get-matrix-step.outputs.windows }}
steps:
- uses: actions/checkout@v4
- id: files
if: ${{ github.event_name != 'workflow_dispatch' }}
uses: kanaka/get-changed-files@v4
with:
default-base: master
- id: get-matrix-step
run: |
export OVERRIDE_IMPLS="${{ github.event.inputs.impls }}" # "
echo "OVERRIDE_IMPLS: ${OVERRIDE_IMPLS}"
./get-ci-matrix.py ${{ steps.files.outputs.all }} > "${GITHUB_OUTPUT}"
linux:
needs: get-matrix
if: ${{ needs.get-matrix.outputs.do-linux == 'true' }}
runs-on: ubuntu-24.04
strategy:
fail-fast: false
matrix: ${{ fromJson(needs.get-matrix.outputs.matrix-linux) }}
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0 # Need full history for voom like versions
- name: Log in to GitHub Container Registry
uses: docker/login-action@v3
with:
registry: ghcr.io
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- name: Docker Build/Push
run: |
export ${{ matrix.IMPL }}
./ci.sh docker-build-push ${IMPL}
- name: Build
run: |
export ${{ matrix.IMPL }}
./ci.sh build ${IMPL}
- name: Step Tests
run: |
export ${{ matrix.IMPL }}
./ci.sh test ${IMPL}
- name: Regression Tests
run: |
export ${{ matrix.IMPL }}
STEP=stepA REGRESS=1 HARD=1 OPTIONAL=0 ./ci.sh test ${IMPL}
- name: Performance Tests
run: |
export ${{ matrix.IMPL }}
./ci.sh perf ${IMPL}
- name: Self-hosted Tests
if: ${{ github.event.inputs.self-hosted != 'no' }}
run: |
export ${{ matrix.IMPL }}
if [ -n "${NO_SELF_HOST:-}" ]; then
echo "Skipping self-host for ${IMPL} due to NO_SELF_HOST variable"
else
DO_SELF_HOST=1 ./ci.sh test ${IMPL}
# Check that self-hosted mode really ran
[ "`grep -a "mal-user>" test-mal-*${IMPL}.debug | wc -l`" -gt 800 ]
fi
- name: Print debug log
if: failure()
run: cat *.debug
- name: Archive logs and debug output
uses: actions/upload-artifact@v4
with:
name: logs.${{ matrix.IMPL }}
path: |
*.log
*.debug
macos:
needs: get-matrix
if: ${{ needs.get-matrix.outputs.do-macos == 'true' }}
runs-on: macos-12
strategy:
fail-fast: false
matrix: ${{ fromJson(needs.get-matrix.outputs.matrix-macos) }}
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export ${{ matrix.IMPL }}
./ci.sh build ${IMPL}
- name: Step Tests
run: |
export ${{ matrix.IMPL }}
./ci.sh test ${IMPL}
- name: Regression Tests
run: |
export ${{ matrix.IMPL }}
STEP=stepA REGRESS=1 HARD=1 OPTIONAL=0 ./ci.sh test ${IMPL}
- name: Performance Tests
run: |
export ${{ matrix.IMPL }}
./ci.sh perf ${IMPL}
- name: Self-hosted Tests
if: ${{ github.event.inputs.self-hosted != 'no' }}
run: |
export ${{ matrix.IMPL }}
if [ -n "${NO_SELF_HOST:-}" ]; then
echo "Skipping self-host for ${IMPL} due to NO_SELF_HOST variable"
else
DO_SELF_HOST=1 ./ci.sh test ${IMPL}
# Check that self-hosted mode really ran
[ "`grep -a "mal-user>" test-mal-*${IMPL}.debug | wc -l`" -gt 800 ]
fi
- name: Print debug log
if: failure()
run: cat *.debug
- name: Archive logs and debug output
uses: actions/upload-artifact@v4
with:
name: logs.${{ matrix.IMPL }}
path: |
*.log
*.debug
windows:
needs: get-matrix
if: ${{ needs.get-matrix.outputs.do-windows == 'true' }}
runs-on: windows-2022
strategy:
fail-fast: false
matrix: ${{ fromJson(needs.get-matrix.outputs.matrix-windows) }}
steps:
- uses: Vampire/setup-wsl@v3
with:
distribution: Ubuntu-24.04
- name: Install requirements for WSL
shell: wsl-bash {0}
run: |
sudo apt update -y
sudo apt install make -y
sudo apt install python3 -y
sudo ln -s /usr/bin/python3 /usr/bin/python
- uses: actions/checkout@v4
- name: Build
shell: wsl-bash {0}
run: |
export ${{ matrix.IMPL }}
./ci.sh build ${IMPL}
- name: Step Tests
shell: wsl-bash {0}
run: |
export ${{ matrix.IMPL }}
./ci.sh test ${IMPL}
- name: Regression Tests
shell: wsl-bash {0}
run: |
export ${{ matrix.IMPL }}
STEP=stepA REGRESS=1 HARD=1 OPTIONAL=0 ./ci.sh test ${IMPL}
- name: Performance Tests
shell: wsl-bash {0}
run: |
export ${{ matrix.IMPL }}
./ci.sh perf ${IMPL}
- name: Self-hosted Tests
if: ${{ github.event.inputs.self-hosted != 'no' }}
shell: wsl-bash {0}
run: |
export ${{ matrix.IMPL }}
if [ -n "${NO_SELF_HOST:-}" ]; then
echo "Skipping self-host for ${IMPL} due to NO_SELF_HOST variable"
else
DO_SELF_HOST=1 ./ci.sh test ${IMPL}
# Check that self-hosted mode really ran
[ "`grep -a "mal-user>" test-mal-*${IMPL}.debug | wc -l`" -gt 800 ]
fi
- name: Print debug log
if: failure()
run: cat *.debug
- name: Archive logs and debug output
uses: actions/upload-artifact@v4
with:
name: logs.${{ matrix.IMPL }}
path: |
*.log
*.debug
================================================
FILE: .gitignore
================================================
.DS_Store
.bash_history
.cache
.cargo
.config
.mal-history
.mal_history
.crystal
.lein
.local
.m2
.ivy2
.sbt
.npm
.node-gyp
*/experiments
node_modules
*/notes
GPATH
GTAGS
GRTAGS
logs
old
tmp/
.xslt_mal_history
zig-cache/
================================================
FILE: .gitmodules
================================================
================================================
FILE: .travis.yml
================================================
sudo: required
# matrix layout based on:
# https://github.com/libressl-portable/portable/blob/9e090286b55def5ca2c0cc375c65023a70d8796e/.travis.yml
matrix:
include:
- {env: IMPL=objc NO_DOCKER=1, os: osx, osx_image: xcode7}
- {env: IMPL=swift NO_DOCKER=1, os: osx, osx_image: xcode7.3}
- {env: IMPL=swift3 NO_DOCKER=1, os: osx, osx_image: xcode8}
- {env: IMPL=swift4 NO_DOCKER=1, os: osx, osx_image: xcode10}
- {env: IMPL=swift5 NO_DOCKER=1, os: osx, osx_image: xcode11}
script:
# Build, test, perf
- ./ci.sh build ${IMPL}
- ./ci.sh test ${IMPL}
- STEP=stepA REGRESS=1 HARD=1 OPTIONAL=0 ./ci.sh test ${IMPL}
- ./ci.sh perf ${IMPL}
================================================
FILE: IMPLS.yml
================================================
IMPL:
- {IMPL: ada}
- {IMPL: ada.2}
- {IMPL: awk}
- {IMPL: bash, NO_SELF_HOST: 1} # step8 timeout
- {IMPL: basic, basic_MODE: cbm, NO_SELF_HOST: 1} # step4 OOM
- {IMPL: basic, basic_MODE: qbasic, NO_SELF_HOST: 1} # step4 OOM
- {IMPL: bbc-basic}
- {IMPL: c}
- {IMPL: c.2}
- {IMPL: cpp}
- {IMPL: coffee}
- {IMPL: cs}
- {IMPL: chuck, NO_SELF_HOST_PERF: 1} # perf OOM
- {IMPL: clojure, clojure_MODE: clj}
- {IMPL: clojure, clojure_MODE: cljs}
- {IMPL: common-lisp}
- {IMPL: crystal}
- {IMPL: d, d_MODE: gdc}
- {IMPL: d, d_MODE: ldc2}
- {IMPL: d, d_MODE: dmd}
- {IMPL: dart}
- {IMPL: elisp}
- {IMPL: elixir}
- {IMPL: elm}
- {IMPL: erlang, NO_SELF_HOST: 1} # step4 silent exit on "(DO 3)"
- {IMPL: es6}
- {IMPL: factor}
- {IMPL: fantom}
- {IMPL: fennel}
- {IMPL: forth}
- {IMPL: fsharp}
- {IMPL: go}
- {IMPL: groovy}
- {IMPL: gnu-smalltalk}
- {IMPL: guile}
- {IMPL: hare}
- {IMPL: haskell}
- {IMPL: haxe, haxe_MODE: neko}
- {IMPL: haxe, haxe_MODE: python}
- {IMPL: haxe, haxe_MODE: cpp, SLOW: 1}
- {IMPL: haxe, haxe_MODE: js}
- {IMPL: hy}
- {IMPL: io, NO_SELF_HOST: 1, NO_SELF_HOST_PERF: 1} # invalid pointer, perf OOM
- {IMPL: janet}
- {IMPL: java}
- {IMPL: java-truffle}
- {IMPL: jq, NO_SELF_HOST: 1} # start-up failure and other issues
- {IMPL: js}
- {IMPL: julia}
- {IMPL: kotlin}
- {IMPL: latex3, NO_PERF: 1, NO_SELF_HOST: 1, SLOW: 1}
- {IMPL: livescript}
- {IMPL: logo}
- {IMPL: lua}
- {IMPL: make, NO_SELF_HOST: 1} # step4 timeout
- {IMPL: mal, MAL_IMPL: js, BUILD_IMPL: js, NO_SELF_HOST: 1}
- {IMPL: mal, MAL_IMPL: js-mal, BUILD_IMPL: js, NO_SELF_HOST: 1, NO_PERF: 1, SLOW: 1}
- {IMPL: mal, MAL_IMPL: nim, BUILD_IMPL: nim, NO_SELF_HOST: 1}
- {IMPL: mal, MAL_IMPL: nim-mal, BUILD_IMPL: nim, NO_SELF_HOST: 1, NO_PERF: 1, SLOW: 1}
- {IMPL: matlab, NO_SELF_HOST_PERF: 1} # Octave, perf timeout
- {IMPL: miniMAL, NO_SELF_HOST_PERF: 1, SLOW: 1} # perf timeout
- {IMPL: nasm, NO_SELF_HOST: 1} # needs memory bump, then fails in step7/quasiquote
- {IMPL: nim}
- {IMPL: objpascal}
- {IMPL: objc}
- {IMPL: ocaml}
- {IMPL: perl}
- {IMPL: perl6}
- {IMPL: php}
- {IMPL: picolisp}
- {IMPL: pike}
- {IMPL: plpgsql, NO_SELF_HOST: 1, SLOW: 1} # step3 timeout
# - {IMPL: plsql}
- {IMPL: prolog}
- {IMPL: ps}
- {IMPL: powershell, NO_SELF_HOST: 1} # works, but too slow be default enabled
- {IMPL: purs}
- {IMPL: python2}
- {IMPL: python3}
- {IMPL: r}
- {IMPL: racket}
- {IMPL: rexx}
- {IMPL: rpython, SLOW: 1}
- {IMPL: ruby}
- {IMPL: ruby.2}
- {IMPL: rust}
- {IMPL: scala}
- {IMPL: scheme, scheme_MODE: chibi}
- {IMPL: scheme, scheme_MODE: kawa}
- {IMPL: scheme, scheme_MODE: gauche}
- {IMPL: scheme, scheme_MODE: chicken}
- {IMPL: scheme, scheme_MODE: sagittarius}
- {IMPL: scheme, scheme_MODE: cyclone}
# - {IMPL: scheme, scheme_MODE: foment}
- {IMPL: skew}
- {IMPL: sml, sml_MODE: polyml}
- {IMPL: sml, sml_MODE: mlton}
- {IMPL: sml, sml_MODE: mosml}
- {IMPL: tcl}
- {IMPL: ts}
- {IMPL: vala}
- {IMPL: vb}
- {IMPL: vhdl, NO_SELF_HOST_PERF: 1} # perf timeout
- {IMPL: vimscript}
# no self-host perf for wasm due to mac stack overflow
- {IMPL: wasm, wasm_MODE: wasmtime, NO_SELF_HOST_PERF: 1, NO_PERF: 1}
- {IMPL: wasm, wasm_MODE: wasmer, NO_SELF_HOST_PERF: 1, NO_PERF: 1}
#- {IMPL: wasm, wasm_MODE: wax, NO_SELF_HOST_PERF: 1} # Hangs on GH Actions
- {IMPL: wasm, wasm_MODE: node, NO_SELF_HOST_PERF: 1, NO_PERF: 1}
#- {IMPL: wasm, wasm_MODE: warpy, NO_SELF_HOST_PERF: 1} # Hangs on GH Actions
#- {IMPL: wasm, wasm_MODE: wace_libc, NO_SELF_HOST_PERF: 1} # Hangs on GH Actions
- {IMPL: wren}
- {IMPL: xslt, NO_SELF_HOST: 1} # step1 fail: "Too many nested template ..."
- {IMPL: yorick}
- {IMPL: zig}
# See .travis.yml (for older osx / xcode tests)
- {IMPL: swift3}
# - {IMPL: swift3, NO_DOCKER: 1, OS: xcode8}
- {IMPL: swift4}
# - {IMPL: swift4, NO_DOCKER: 1, OS: xcode10}
- {IMPL: swift6}
# - {IMPL: swift6, NO_DOCKER: 1, OS: macos} # works but too expensive in GH Actions
- {IMPL: vbs, NO_SELF_HOST: 1, NO_DOCKER: 1, OS: windows} # self-host too slow/expensive in GH Actions
================================================
FILE: LICENSE
================================================
Copyright (C) 2015 Joel Martin <github@martintribe.org>
Mal (make-a-lisp) is licensed under the MPL 2.0 (Mozilla Public
License 2.0). The text of the MPL 2.0 license is included below and
can be found at https://www.mozilla.org/MPL/2.0/
Many of the implementations run or compile using a line editing
library. In some cases, the implementations provide an option in the
code to switch between the GNU GPL licensed GNU readline library and
the BSD licensed editline (libedit) library.
Mozilla Public License Version 2.0
==================================
1. Definitions
--------------
1.1. "Contributor"
means each individual or legal entity that creates, contributes to
the creation of, or owns Covered Software.
1.2. "Contributor Version"
means the combination of the Contributions of others (if any) used
by a Contributor and that particular Contributor's Contribution.
1.3. "Contribution"
means Covered Software of a particular Contributor.
1.4. "Covered Software"
means Source Code Form to which the initial Contributor has attached
the notice in Exhibit A, the Executable Form of such Source Code
Form, and Modifications of such Source Code Form, in each case
including portions thereof.
1.5. "Incompatible With Secondary Licenses"
means
(a) that the initial Contributor has attached the notice described
in Exhibit B to the Covered Software; or
(b) that the Covered Software was made available under the terms of
version 1.1 or earlier of the License, but not also under the
terms of a Secondary License.
1.6. "Executable Form"
means any form of the work other than Source Code Form.
1.7. "Larger Work"
means a work that combines Covered Software with other material, in
a separate file or files, that is not Covered Software.
1.8. "License"
means this document.
1.9. "Licensable"
means having the right to grant, to the maximum extent possible,
whether at the time of the initial grant or subsequently, any and
all of the rights conveyed by this License.
1.10. "Modifications"
means any of the following:
(a) any file in Source Code Form that results from an addition to,
deletion from, or modification of the contents of Covered
Software; or
(b) any new file in Source Code Form that contains any Covered
Software.
1.11. "Patent Claims" of a Contributor
means any patent claim(s), including without limitation, method,
process, and apparatus claims, in any patent Licensable by such
Contributor that would be infringed, but for the grant of the
License, by the making, using, selling, offering for sale, having
made, import, or transfer of either its Contributions or its
Contributor Version.
1.12. "Secondary License"
means either the GNU General Public License, Version 2.0, the GNU
Lesser General Public License, Version 2.1, the GNU Affero General
Public License, Version 3.0, or any later versions of those
licenses.
1.13. "Source Code Form"
means the form of the work preferred for making modifications.
1.14. "You" (or "Your")
means an individual or a legal entity exercising rights under this
License. For legal entities, "You" includes any entity that
controls, is controlled by, or is under common control with You. For
purposes of this definition, "control" means (a) the power, direct
or indirect, to cause the direction or management of such entity,
whether by contract or otherwise, or (b) ownership of more than
fifty percent (50%) of the outstanding shares or beneficial
ownership of such entity.
2. License Grants and Conditions
--------------------------------
2.1. Grants
Each Contributor hereby grants You a world-wide, royalty-free,
non-exclusive license:
(a) under intellectual property rights (other than patent or trademark)
Licensable by such Contributor to use, reproduce, make available,
modify, display, perform, distribute, and otherwise exploit its
Contributions, either on an unmodified basis, with Modifications, or
as part of a Larger Work; and
(b) under Patent Claims of such Contributor to make, use, sell, offer
for sale, have made, import, and otherwise transfer either its
Contributions or its Contributor Version.
2.2. Effective Date
The licenses granted in Section 2.1 with respect to any Contribution
become effective for each Contribution on the date the Contributor first
distributes such Contribution.
2.3. Limitations on Grant Scope
The licenses granted in this Section 2 are the only rights granted under
this License. No additional rights or licenses will be implied from the
distribution or licensing of Covered Software under this License.
Notwithstanding Section 2.1(b) above, no patent license is granted by a
Contributor:
(a) for any code that a Contributor has removed from Covered Software;
or
(b) for infringements caused by: (i) Your and any other third party's
modifications of Covered Software, or (ii) the combination of its
Contributions with other software (except as part of its Contributor
Version); or
(c) under Patent Claims infringed by Covered Software in the absence of
its Contributions.
This License does not grant any rights in the trademarks, service marks,
or logos of any Contributor (except as may be necessary to comply with
the notice requirements in Section 3.4).
2.4. Subsequent Licenses
No Contributor makes additional grants as a result of Your choice to
distribute the Covered Software under a subsequent version of this
License (see Section 10.2) or under the terms of a Secondary License (if
permitted under the terms of Section 3.3).
2.5. Representation
Each Contributor represents that the Contributor believes its
Contributions are its original creation(s) or it has sufficient rights
to grant the rights to its Contributions conveyed by this License.
2.6. Fair Use
This License is not intended to limit any rights You have under
applicable copyright doctrines of fair use, fair dealing, or other
equivalents.
2.7. Conditions
Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
in Section 2.1.
3. Responsibilities
-------------------
3.1. Distribution of Source Form
All distribution of Covered Software in Source Code Form, including any
Modifications that You create or to which You contribute, must be under
the terms of this License. You must inform recipients that the Source
Code Form of the Covered Software is governed by the terms of this
License, and how they can obtain a copy of this License. You may not
attempt to alter or restrict the recipients' rights in the Source Code
Form.
3.2. Distribution of Executable Form
If You distribute Covered Software in Executable Form then:
(a) such Covered Software must also be made available in Source Code
Form, as described in Section 3.1, and You must inform recipients of
the Executable Form how they can obtain a copy of such Source Code
Form by reasonable means in a timely manner, at a charge no more
than the cost of distribution to the recipient; and
(b) You may distribute such Executable Form under the terms of this
License, or sublicense it under different terms, provided that the
license for the Executable Form does not attempt to limit or alter
the recipients' rights in the Source Code Form under this License.
3.3. Distribution of a Larger Work
You may create and distribute a Larger Work under terms of Your choice,
provided that You also comply with the requirements of this License for
the Covered Software. If the Larger Work is a combination of Covered
Software with a work governed by one or more Secondary Licenses, and the
Covered Software is not Incompatible With Secondary Licenses, this
License permits You to additionally distribute such Covered Software
under the terms of such Secondary License(s), so that the recipient of
the Larger Work may, at their option, further distribute the Covered
Software under the terms of either this License or such Secondary
License(s).
3.4. Notices
You may not remove or alter the substance of any license notices
(including copyright notices, patent notices, disclaimers of warranty,
or limitations of liability) contained within the Source Code Form of
the Covered Software, except that You may alter any license notices to
the extent required to remedy known factual inaccuracies.
3.5. Application of Additional Terms
You may choose to offer, and to charge a fee for, warranty, support,
indemnity or liability obligations to one or more recipients of Covered
Software. However, You may do so only on Your own behalf, and not on
behalf of any Contributor. You must make it absolutely clear that any
such warranty, support, indemnity, or liability obligation is offered by
You alone, and You hereby agree to indemnify every Contributor for any
liability incurred by such Contributor as a result of warranty, support,
indemnity or liability terms You offer. You may include additional
disclaimers of warranty and limitations of liability specific to any
jurisdiction.
4. Inability to Comply Due to Statute or Regulation
---------------------------------------------------
If it is impossible for You to comply with any of the terms of this
License with respect to some or all of the Covered Software due to
statute, judicial order, or regulation then You must: (a) comply with
the terms of this License to the maximum extent possible; and (b)
describe the limitations and the code they affect. Such description must
be placed in a text file included with all distributions of the Covered
Software under this License. Except to the extent prohibited by statute
or regulation, such description must be sufficiently detailed for a
recipient of ordinary skill to be able to understand it.
5. Termination
--------------
5.1. The rights granted under this License will terminate automatically
if You fail to comply with any of its terms. However, if You become
compliant, then the rights granted under this License from a particular
Contributor are reinstated (a) provisionally, unless and until such
Contributor explicitly and finally terminates Your grants, and (b) on an
ongoing basis, if such Contributor fails to notify You of the
non-compliance by some reasonable means prior to 60 days after You have
come back into compliance. Moreover, Your grants from a particular
Contributor are reinstated on an ongoing basis if such Contributor
notifies You of the non-compliance by some reasonable means, this is the
first time You have received notice of non-compliance with this License
from such Contributor, and You become compliant prior to 30 days after
Your receipt of the notice.
5.2. If You initiate litigation against any entity by asserting a patent
infringement claim (excluding declaratory judgment actions,
counter-claims, and cross-claims) alleging that a Contributor Version
directly or indirectly infringes any patent, then the rights granted to
You by any and all Contributors for the Covered Software under Section
2.1 of this License shall terminate.
5.3. In the event of termination under Sections 5.1 or 5.2 above, all
end user license agreements (excluding distributors and resellers) which
have been validly granted by You or Your distributors under this License
prior to termination shall survive termination.
************************************************************************
* *
* 6. Disclaimer of Warranty *
* ------------------------- *
* *
* Covered Software is provided under this License on an "as is" *
* basis, without warranty of any kind, either expressed, implied, or *
* statutory, including, without limitation, warranties that the *
* Covered Software is free of defects, merchantable, fit for a *
* particular purpose or non-infringing. The entire risk as to the *
* quality and performance of the Covered Software is with You. *
* Should any Covered Software prove defective in any respect, You *
* (not any Contributor) assume the cost of any necessary servicing, *
* repair, or correction. This disclaimer of warranty constitutes an *
* essential part of this License. No use of any Covered Software is *
* authorized under this License except under this disclaimer. *
* *
************************************************************************
************************************************************************
* *
* 7. Limitation of Liability *
* -------------------------- *
* *
* Under no circumstances and under no legal theory, whether tort *
* (including negligence), contract, or otherwise, shall any *
* Contributor, or anyone who distributes Covered Software as *
* permitted above, be liable to You for any direct, indirect, *
* special, incidental, or consequential damages of any character *
* including, without limitation, damages for lost profits, loss of *
* goodwill, work stoppage, computer failure or malfunction, or any *
* and all other commercial damages or losses, even if such party *
* shall have been informed of the possibility of such damages. This *
* limitation of liability shall not apply to liability for death or *
* personal injury resulting from such party's negligence to the *
* extent applicable law prohibits such limitation. Some *
* jurisdictions do not allow the exclusion or limitation of *
* incidental or consequential damages, so this exclusion and *
* limitation may not apply to You. *
* *
************************************************************************
8. Litigation
-------------
Any litigation relating to this License may be brought only in the
courts of a jurisdiction where the defendant maintains its principal
place of business and such litigation shall be governed by laws of that
jurisdiction, without reference to its conflict-of-law provisions.
Nothing in this Section shall prevent a party's ability to bring
cross-claims or counter-claims.
9. Miscellaneous
----------------
This License represents the complete agreement concerning the subject
matter hereof. If any provision of this License is held to be
unenforceable, such provision shall be reformed only to the extent
necessary to make it enforceable. Any law or regulation which provides
that the language of a contract shall be construed against the drafter
shall not be used to construe this License against a Contributor.
10. Versions of the License
---------------------------
10.1. New Versions
Mozilla Foundation is the license steward. Except as provided in Section
10.3, no one other than the license steward has the right to modify or
publish new versions of this License. Each version will be given a
distinguishing version number.
10.2. Effect of New Versions
You may distribute the Covered Software under the terms of the version
of the License under which You originally received the Covered Software,
or under the terms of any subsequent version published by the license
steward.
10.3. Modified Versions
If you create software not governed by this License, and you want to
create a new license for such software, you may create and use a
modified version of this License if you rename the license and remove
any references to the name of the license steward (except to note that
such modified license differs from this License).
10.4. Distributing Source Code Form that is Incompatible With Secondary
Licenses
If You choose to distribute Source Code Form that is Incompatible With
Secondary Licenses under the terms of this version of the License, the
notice described in Exhibit B of this License must be attached.
Exhibit A - Source Code Form License Notice
-------------------------------------------
This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/.
If it is not possible or desirable to put the notice in a particular
file, then You may include the notice in a location (such as a LICENSE
file in a relevant directory) where a recipient would be likely to look
for such a notice.
You may add additional accurate notices of copyright ownership.
Exhibit B - "Incompatible With Secondary Licenses" Notice
---------------------------------------------------------
This Source Code Form is "Incompatible With Secondary Licenses", as
defined by the Mozilla Public License, v. 2.0.
================================================
FILE: Makefile
================================================
# Usage/help
all help:
@echo
@echo 'USAGE:'
@echo
@echo 'Rules/Targets:'
@echo
@echo 'make "IMPL" # build all steps of IMPL'
@echo 'make "build^IMPL" # build all steps of IMPL'
@echo 'make "IMPL^STEP" # build STEP of IMPL'
@echo 'make "build^IMPL^STEP" # build STEP of IMPL'
@echo
@echo 'make "test" # test all implementations'
@echo 'make "test^IMPL" # test all steps of IMPL'
@echo 'make "test^STEP" # test STEP for all implementations'
@echo 'make "test^IMPL^STEP" # test STEP of IMPL'
@echo
@echo 'make "perf" # run microbenchmarks for all implementations'
@echo 'make "perf^IMPL" # run microbenchmarks for IMPL'
@echo
@echo 'make "repl^IMPL" # run stepA of IMPL'
@echo 'make "repl^IMPL^STEP" # test STEP of IMPL'
@echo
@echo 'make "clean" # run 'make clean' for all implementations'
@echo 'make "clean^IMPL" # run 'make clean' for IMPL'
@echo
@echo 'make "stats" # run 'make stats' for all implementations'
@echo 'make "stats-lisp" # run 'make stats-lisp' for all implementations'
@echo 'make "stats^IMPL" # run 'make stats' for IMPL'
@echo 'make "stats-lisp^IMPL" # run 'make stats-lisp' for IMPL'
@echo
@echo 'Options/Settings:'
@echo
@echo 'make MAL_IMPL=IMPL "test^mal..." # use IMPL for self-host tests'
@echo 'make REGRESS=1 "test..." # test with previous step tests too'
@echo 'make DOCKERIZE=1 ... # to dockerize above rules/targets'
@echo 'make TEST_OPTS="--opt ..." # options to pass to runtest.py'
@echo
@echo 'Other:'
@echo
@echo 'make "docker-build^IMPL" # build docker image for IMPL'
@echo
@echo 'make "docker-shell^IMPL" # start bash shell in docker image for IMPL'
@echo
# Implementation specific settings are here:
include Makefile.impls
#
# General command line settings
#
MAL_IMPL = js
# Path to loccount for counting LOC stats
LOCCOUNT = loccount
# Extra options to pass to runtest.py
TEST_OPTS =
# Test with previous test files not just the test files for the
# current step. Step 0 and 1 tests are special and not included in
# later steps.
REGRESS =
HARD=
DEFERRABLE=1
OPTIONAL=1
# Run target/rule within docker image for the implementation
DOCKERIZE =
#
# General settings and utility functions
#
EXTENSION = .mal
step0 = step0_repl
step1 = step1_read_print
step2 = step2_eval
step3 = step3_env
step4 = step4_if_fn_do
step5 = step5_tco
step6 = step6_file
step7 = step7_quote
step8 = step8_macros
step9 = step9_try
stepA = stepA_mal
argv_STEP = step6_file
regress_step0 = step0
regress_step1 = step1
regress_step2 = step2
regress_step3 = $(regress_step2) step3
regress_step4 = $(regress_step3) step4
regress_step5 = $(regress_step4) step5
regress_step6 = $(regress_step5) step6
regress_step7 = $(regress_step6) step7
regress_step8 = $(regress_step7) step8
regress_step9 = $(regress_step8) step9
regress_stepA = $(regress_step9) stepA
# Needed some argument munging
COMMA = ,
noop =
SPACE = $(noop) $(noop)
export FACTOR_ROOTS := .
opt_HARD = $(if $(strip $(HARD)),$(if $(filter t true T True TRUE 1 y yes Yes YES,$(HARD)),--hard,),)
opt_DEFERRABLE = $(if $(strip $(DEFERRABLE)),$(if $(filter t true T True TRUE 1 y yes Yes YES,$(DEFERRABLE)),--deferrable,--no-deferrable),--no-deferrable)
opt_OPTIONAL = $(if $(strip $(OPTIONAL)),$(if $(filter t true T True TRUE 1 y yes Yes YES,$(OPTIONAL)),--optional,--no-optional),--no-optional)
# Return list of test files for a given step. If REGRESS is set then
# test files will include step 2 tests through tests for the step
# being tested.
STEP_TEST_FILES = $(strip $(wildcard \
$(foreach s,$(if $(strip $(REGRESS)),\
$(filter-out $(if $(filter $(1),$(step5_EXCLUDES)),step5,),\
$(regress_$(2)))\
,$(2)),\
impls/$(1)/tests/$($(s))$(EXTENSION) impls/tests/$($(s))$(EXTENSION))))
# DOCKERIZE utility functions
lc = $(subst A,a,$(subst B,b,$(subst C,c,$(subst D,d,$(subst E,e,$(subst F,f,$(subst G,g,$(subst H,h,$(subst I,i,$(subst J,j,$(subst K,k,$(subst L,l,$(subst M,m,$(subst N,n,$(subst O,o,$(subst P,p,$(subst Q,q,$(subst R,r,$(subst S,s,$(subst T,t,$(subst U,u,$(subst V,v,$(subst W,w,$(subst X,x,$(subst Y,y,$(subst Z,z,$1))))))))))))))))))))))))))
impl_to_image = ghcr.io/kanaka/mal-test-$(call lc,$(1)):$(shell ./voom-like-version.sh impls/$(1)/Dockerfile)
actual_impl = $(if $(filter mal,$(1)),$(patsubst %-mal,%,$(MAL_IMPL)),$(1))
# Takes impl
# Returns nothing if DOCKERIZE is not set, otherwise returns the
# docker prefix necessary to run make within the docker environment
# for this impl
get_build_command = $(strip $(foreach mode,$(1)_MODE, \
$(if $(strip $(DOCKERIZE)),\
docker run \
-it --rm -u $(shell id -u) \
-v $(dir $(abspath $(lastword $(MAKEFILE_LIST)))):/mal \
-w /mal/impls/$(1) \
$(if $(strip $($(mode))),-e $(mode)=$($(mode)),) \
$(if $(filter factor,$(1)),-e FACTOR_ROOTS=$(FACTOR_ROOTS),) \
$(call impl_to_image,$(1)) \
make $(if $(strip $($(mode))),$(mode)=$($(mode)),) \
,\
$(MAKE) $(if $(strip $($(mode))),$(mode)=$($(mode)),) -C impls/$(impl))))
# Takes impl and step args. Optional env vars and dockerize args
# Returns a command prefix (docker command and environment variables)
# necessary to launch the given impl and step
get_run_prefix = $(strip $(foreach mode,$(call actual_impl,$(1))_MODE, \
$(if $(strip $(DOCKERIZE) $(4)),\
docker run -e STEP=$($2) -e MAL_IMPL=$(MAL_IMPL) \
-it --rm -u $(shell id -u) \
-v $(dir $(abspath $(lastword $(MAKEFILE_LIST)))):/mal \
-w /mal/impls/$(call actual_impl,$(1)) \
$(if $(strip $($(mode))),-e $(mode)=$($(mode)),) \
$(if $(filter factor,$(1)),-e FACTOR_ROOTS=$(FACTOR_ROOTS),) \
$(foreach env,$(3),-e $(env)) \
$(call impl_to_image,$(call actual_impl,$(1))) \
,\
env STEP=$($2) MAL_IMPL=$(MAL_IMPL) \
$(if $(strip $($(mode))),$(mode)=$($(mode)),) \
$(if $(filter factor,$(1)),FACTOR_ROOTS=$(FACTOR_ROOTS),) \
$(3))))
# Takes impl and step
# Returns the runtest command prefix (with runtest options) for testing the given step
get_runtest_cmd = $(call get_run_prefix,$(1),$(2),$(if $(filter cs fsharp mal tcl vb,$(1)),RAW=1,)) \
../../runtest.py $(opt_HARD) $(opt_DEFERRABLE) $(opt_OPTIONAL) $(call $(1)_TEST_OPTS) $(TEST_OPTS)
# Takes impl and step
# Returns the runtest command prefix (with runtest options) for testing the given step
get_argvtest_cmd = $(call get_run_prefix,$(1),$(2)) ../tests/run_argv_test.sh
# Derived lists
STEPS = $(sort $(filter-out %_EXCLUDES,$(filter step%,$(.VARIABLES))))
DO_IMPLS = $(filter-out $(SKIP_IMPLS),$(IMPLS))
IMPL_TESTS = $(foreach impl,$(DO_IMPLS),test^$(impl))
STEP_TESTS = $(foreach step,$(STEPS),test^$(step))
ALL_TESTS = $(filter-out $(foreach e,$(step5_EXCLUDES),test^$(e)^step5),\
$(strip $(sort \
$(foreach impl,$(DO_IMPLS),\
$(foreach step,$(STEPS),test^$(impl)^$(step))))))
ALL_BUILDS = $(strip $(sort \
$(foreach impl,$(DO_IMPLS),\
$(foreach step,$(STEPS),build^$(impl)^$(step)))))
DOCKER_BUILD = $(foreach impl,$(DO_IMPLS),docker-build^$(impl))
DOCKER_SHELL = $(foreach impl,$(DO_IMPLS),docker-shell^$(impl))
IMPL_PERF = $(foreach impl,$(filter-out $(perf_EXCLUDES),$(DO_IMPLS)),perf^$(impl))
IMPL_STATS = $(foreach impl,$(DO_IMPLS),stats^$(impl))
IMPL_REPL = $(foreach impl,$(DO_IMPLS),repl^$(impl))
ALL_REPL = $(strip $(sort \
$(foreach impl,$(DO_IMPLS),\
$(foreach step,$(STEPS),repl^$(impl)^$(step)))))
#
# Build rules
#
# Enable secondary expansion for all rules
.SECONDEXPANSION:
# Build a program in an implementation directory
# Make sure we always try and build first because the dependencies are
# encoded in the implementation Makefile not here
.PHONY: $(foreach i,$(DO_IMPLS),$(foreach s,$(STEPS),$(call $(i)_STEP_TO_PROG,$(s))))
$(foreach i,$(DO_IMPLS),$(foreach s,$(STEPS),$(call $(i)_STEP_TO_PROG,$(s)))):
$(foreach impl,$(word 2,$(subst /, ,$(@))),\
$(if $(DOCKERIZE), \
$(call get_build_command,$(impl)) $(patsubst impls/$(impl)/%,%,$(@)), \
$(call get_build_command,$(impl)) $(subst impls/$(impl)/,,$(@))))
# Allow IMPL, build^IMPL, IMPL^STEP, and build^IMPL^STEP
$(DO_IMPLS): $$(foreach s,$$(STEPS),$$(call $$(@)_STEP_TO_PROG,$$(s)))
$(foreach i,$(DO_IMPLS),$(foreach s,$(STEPS),build^$(i))): $$(foreach s,$$(STEPS),$$(call $$(word 2,$$(subst ^, ,$$(@)))_STEP_TO_PROG,$$(s)))
$(foreach i,$(DO_IMPLS),$(foreach s,$(STEPS),$(i)^$(s))): $$(call $$(word 1,$$(subst ^, ,$$(@)))_STEP_TO_PROG,$$(word 2,$$(subst ^, ,$$(@))))
$(foreach i,$(DO_IMPLS),$(foreach s,$(STEPS),build^$(i)^$(s))): $$(call $$(word 2,$$(subst ^, ,$$(@)))_STEP_TO_PROG,$$(word 3,$$(subst ^, ,$$(@))))
#
# Test rules
#
$(ALL_TESTS): $$(call $$(word 2,$$(subst ^, ,$$(@)))_STEP_TO_PROG,$$(word 3,$$(subst ^, ,$$(@))))
@$(foreach impl,$(word 2,$(subst ^, ,$(@))),\
$(foreach step,$(word 3,$(subst ^, ,$(@))),\
echo "(call STEP_TEST_FILES,$(impl),$(step)): $(call STEP_TEST_FILES,$(impl),$(step))" && \
cd impls/$(call actual_impl,$(impl)) && \
$(foreach test,$(patsubst impls/%,%,$(call STEP_TEST_FILES,$(impl),$(step))),\
echo '----------------------------------------------' && \
echo 'Testing $@; step file: $+, test file: $(test)' && \
echo 'Running: $(call get_runtest_cmd,$(impl),$(step)) ../$(test) -- ../$(impl)/run' && \
$(call get_runtest_cmd,$(impl),$(step)) ../$(test) -- ../$(impl)/run && \
$(if $(filter tests/$(argv_STEP)$(EXTENSION),$(test)),\
echo '----------------------------------------------' && \
echo 'Testing ARGV of $@; step file: $+' && \
echo 'Running: $(call get_argvtest_cmd,$(impl),$(step)) ../$(impl)/run ' && \
$(call get_argvtest_cmd,$(impl),$(step)) ../$(impl)/run && ,\
true && ))\
true))
# Allow test, tests, test^STEP, test^IMPL, and test^IMPL^STEP
test: $(ALL_TESTS)
tests: $(ALL_TESTS)
$(IMPL_TESTS): $$(filter $$@^%,$$(ALL_TESTS))
$(STEP_TESTS): $$(foreach step,$$(subst test^,,$$@),$$(filter %^$$(step),$$(ALL_TESTS)))
#
# Docker build rules
#
docker-build: $(DOCKER_BUILD)
$(DOCKER_BUILD):
@echo "----------------------------------------------"; \
$(foreach impl,$(word 2,$(subst ^, ,$(@))),\
echo "Running: docker build -t $(call impl_to_image,$(impl)) .:"; \
cd impls/$(impl) && docker build -t $(call impl_to_image,$(impl)) .)
#
# Docker shell rules
#
$(DOCKER_SHELL):
@echo "----------------------------------------------"; \
$(foreach impl,$(word 2,$(subst ^, ,$(@))),\
echo "Running: $(call get_run_prefix,$(impl),stepA,,dockerize) bash"; \
$(call get_run_prefix,$(impl),stepA,,dockerize) bash)
#
# Performance test rules
#
perf: $(IMPL_PERF)
$(IMPL_PERF):
@echo "----------------------------------------------"; \
$(foreach impl,$(word 2,$(subst ^, ,$(@))),\
cd impls/$(call actual_impl,$(impl)); \
echo "Performance test for $(impl):"; \
echo 'Running: $(call get_run_prefix,$(impl),stepA) ../$(impl)/run ../tests/perf1.mal'; \
$(call get_run_prefix,$(impl),stepA) ../$(impl)/run ../tests/perf1.mal; \
echo 'Running: $(call get_run_prefix,$(impl),stepA) ../$(impl)/run ../tests/perf2.mal'; \
$(call get_run_prefix,$(impl),stepA) ../$(impl)/run ../tests/perf2.mal; \
echo 'Running: $(call get_run_prefix,$(impl),stepA) ../$(impl)/run ../tests/perf3.mal'; \
$(call get_run_prefix,$(impl),stepA) ../$(impl)/run ../tests/perf3.mal)
#
# REPL invocation rules
#
$(ALL_REPL): $$(call $$(word 2,$$(subst ^, ,$$(@)))_STEP_TO_PROG,$$(word 3,$$(subst ^, ,$$(@))))
@$(foreach impl,$(word 2,$(subst ^, ,$(@))),\
$(foreach step,$(word 3,$(subst ^, ,$(@))),\
cd impls/$(call actual_impl,$(impl)); \
echo 'REPL implementation $(impl), step file: $+'; \
echo 'Running: $(call get_run_prefix,$(impl),$(step)) ../$(impl)/run $(RUN_ARGS)'; \
$(call get_run_prefix,$(impl),$(step)) ../$(impl)/run $(RUN_ARGS);))
# Allow repl^IMPL^STEP and repl^IMPL (which starts REPL of stepA)
$(IMPL_REPL): $$@^stepA
#
# Stats test rules
#
# For a concise summary:
# make stats | egrep -A1 "^Stats for|^all" | egrep -v "^all|^--"
stats: $(IMPL_STATS)
$(IMPL_STATS):
@$(foreach impl,$(word 2,$(subst ^, ,$(@))),\
echo "Stats for $(impl):"; \
$(LOCCOUNT) -x "[sS]tep[0-9]_.*|[.]md$$|tests|examples|Makefile|package.json|tsconfig.json|Cargo.toml|project.clj|node_modules|getline.cs|terminal.cs|elm-stuff|objpascal/regexpr|rdyncall|swift/templates" impls/$(impl))
#
# Utility functions
#
print-%:
@echo "$($(*))"
#
# Recursive rules (call make FOO in each subdirectory)
#
define recur_template
.PHONY: $(1)
$(1): $(2)
$(2):
@echo "----------------------------------------------"; \
$$(foreach impl,$$(word 2,$$(subst ^, ,$$(@))),\
echo "Running: $$(call get_build_command,$$(impl)) --no-print-directory $(1)"; \
$$(call get_build_command,$$(impl)) --no-print-directory $(1))
endef
recur_impls_ = $(filter-out $(foreach impl,$($(1)_EXCLUDES),$(1)^$(impl)),$(foreach impl,$(IMPLS),$(1)^$(impl)))
# recursive clean
$(eval $(call recur_template,clean,$(call recur_impls_,clean)))
# recursive dist
$(eval $(call recur_template,dist,$(call recur_impls_,dist)))
================================================
FILE: Makefile.impls
================================================
# HOWTO add a new implementation (named "foo"):
# - Add "foo" to the IMPLS variable (alphabetical order)
# - Add a new "foo_STEP_TO_PROG" variable.
# - Add an "impls/foo/run" script.
# - Add an "impls/foo/Makefile"
# - Add an "impls/foo/Dockerfile"
# - Implement each step in "impls/foo/".
#
# Implementation specific command line settings
#
# cbm or qbasic
basic_MODE = cbm
# clj or cljs (Clojure vs ClojureScript/lumo)
clojure_MODE = clj
# gdc, ldc2, or dmd
d_MODE = gdc
# python, js, cpp, or neko
haxe_MODE = neko
# octave or matlab
matlab_MODE = octave
# scheme (chibi, kawa, gauche, chicken, sagittarius, cyclone, foment)
scheme_MODE = chibi
# sml (polyml, mlton, mosml)
sml_MODE = polyml
# wasmtime wasmer wax node warpy wace_libc direct js wace_fooboot
wasm_MODE = wasmtime
#
# Implementation specific settings
#
IMPLS = ada ada.2 awk bash basic bbc-basic c c.2 chuck clojure coffee common-lisp cpp crystal cs d dart \
elisp elixir elm erlang es6 factor fantom fennel forth fsharp go groovy gnu-smalltalk \
guile hare haskell haxe hy io janet java java-truffle js jq julia kotlin latex3 livescript logo lua make mal \
matlab miniMAL nasm nim objc objpascal ocaml perl perl6 php picolisp pike plpgsql \
plsql powershell prolog ps purs python2 python3 r racket rexx rpython ruby ruby.2 rust scala scheme skew sml \
swift swift3 swift4 swift6 tcl ts vala vb vbs vhdl vimscript wasm wren yorick xslt zig
step5_EXCLUDES += bash # never completes at 10,000
step5_EXCLUDES += basic # too slow, and limited to ints of 2^16
step5_EXCLUDES += latex3 # no iteration, limited native stack
step5_EXCLUDES += make # no TCO capability (iteration or recursion)
step5_EXCLUDES += mal # host impl dependent
step5_EXCLUDES += matlab # never completes at 10,000
step5_EXCLUDES += plpgsql # too slow for 10,000
step5_EXCLUDES += plsql # too slow for 10,000
step5_EXCLUDES += powershell # too slow for 10,000
step5_EXCLUDES += prolog # no iteration (but interpreter does TCO implicitly)
step5_EXCLUDES += sml # not implemented :(
step5_EXCLUDES += $(if $(filter cpp,$(haxe_MODE)),haxe,) # cpp finishes 10,000, segfaults at 100,000
step5_EXCLUDES += xslt # iteration cannot be expressed
step5_EXCLUDES += vbs # too slow for 10,000
dist_EXCLUDES += mal
# TODO: still need to implement dist
dist_EXCLUDES += guile io julia matlab swift
# Extra options to pass to runtest.py
bbc-basic_TEST_OPTS = --test-timeout 60
guile_TEST_OPTS = --test-timeout 120
io_TEST_OPTS = --test-timeout 120
java-truffle_TEST_OPTS = --start-timeout 30
logo_TEST_OPTS = --start-timeout 60 --test-timeout 120
mal_TEST_OPTS = --start-timeout 60 --test-timeout 120
miniMAL_TEST_OPTS = --start-timeout 60 --test-timeout 120
perl6_TEST_OPTS = --test-timeout=60
plpgsql_TEST_OPTS = --start-timeout 60 --test-timeout 180
plsql_TEST_OPTS = --start-timeout 120 --test-timeout 120
vimscript_TEST_OPTS = --test-timeout 30
ifeq ($(MAL_IMPL),vimscript)
mal_TEST_OPTS = --start-timeout 60 --test-timeout 180
else ifeq ($(MAL_IMPL),powershell)
mal_TEST_OPTS = --start-timeout 60 --test-timeout 180
else ifeq ($(MAL_IMPL),vbs)
mal_TEST_OPTS = --start-timeout 60 --test-timeout 180 --no-pty
endif
xslt_TEST_OPTS = --test-timeout 120
vbs_TEST_OPTS = --no-pty
#
# Implementation specific utility functions
#
basic_STEP_TO_PROG_cbm = impls/basic/$($(1)).bas
basic_STEP_TO_PROG_qbasic = impls/basic/$($(1))
clojure_STEP_TO_PROG_clj = impls/clojure/target/$($(1)).jar
clojure_STEP_TO_PROG_cljs = impls/clojure/src/mal/$($(1)).cljc
haxe_STEP_TO_PROG_neko = impls/haxe/$($(1)).n
haxe_STEP_TO_PROG_python = impls/haxe/$($(1)).py
haxe_STEP_TO_PROG_cpp = impls/haxe/cpp/$($(1))
haxe_STEP_TO_PROG_js = impls/haxe/$($(1)).js
scheme_STEP_TO_PROG_chibi = impls/scheme/$($(1)).scm
scheme_STEP_TO_PROG_kawa = impls/scheme/out/$($(1)).class
scheme_STEP_TO_PROG_gauche = impls/scheme/$($(1)).scm
scheme_STEP_TO_PROG_chicken = impls/scheme/$($(1))
scheme_STEP_TO_PROG_sagittarius = impls/scheme/$($(1)).scm
scheme_STEP_TO_PROG_cyclone = impls/scheme/$($(1))
scheme_STEP_TO_PROG_foment = impls/scheme/$($(1)).scm
# Map of step (e.g. "step8") to executable file for that step
ada_STEP_TO_PROG = impls/ada/$($(1))
ada.2_STEP_TO_PROG = impls/ada.2/$($(1))
awk_STEP_TO_PROG = impls/awk/$($(1)).awk
bash_STEP_TO_PROG = impls/bash/$($(1)).sh
basic_STEP_TO_PROG = $(basic_STEP_TO_PROG_$(basic_MODE))
bbc-basic_STEP_TO_PROG = impls/bbc-basic/$($(1)).bas
c_STEP_TO_PROG = impls/c/$($(1))
c.2_STEP_TO_PROG = impls/c.2/$($(1))
chuck_STEP_TO_PROG = impls/chuck/$($(1)).ck
clojure_STEP_TO_PROG = $(clojure_STEP_TO_PROG_$(clojure_MODE))
coffee_STEP_TO_PROG = impls/coffee/$($(1)).coffee
common-lisp_STEP_TO_PROG = impls/common-lisp/$($(1))
cpp_STEP_TO_PROG = impls/cpp/$($(1))
crystal_STEP_TO_PROG = impls/crystal/$($(1))
cs_STEP_TO_PROG = impls/cs/$($(1)).exe
d_STEP_TO_PROG = impls/d/$($(1))
dart_STEP_TO_PROG = impls/dart/$($(1)).dart
elisp_STEP_TO_PROG = impls/elisp/$($(1)).el
elixir_STEP_TO_PROG = impls/elixir/lib/mix/tasks/$($(1)).ex
elm_STEP_TO_PROG = impls/elm/$($(1)).js
erlang_STEP_TO_PROG = impls/erlang/$($(1))
es6_STEP_TO_PROG = impls/es6/$($(1)).mjs
factor_STEP_TO_PROG = impls/factor/$($(1))/$($(1)).factor
fantom_STEP_TO_PROG = impls/fantom/lib/fan/$($(1)).pod
fennel_STEP_TO_PROG = impls/fennel/$($(1)).fnl
forth_STEP_TO_PROG = impls/forth/$($(1)).fs
fsharp_STEP_TO_PROG = impls/fsharp/$($(1)).exe
go_STEP_TO_PROG = impls/go/$($(1))
groovy_STEP_TO_PROG = impls/groovy/$($(1)).groovy
gnu-smalltalk_STEP_TO_PROG = impls/gnu-smalltalk/$($(1)).st
guile_STEP_TO_PROG = impls/guile/$($(1)).scm
hare_STEP_TO_PROG = impls/hare/$($(1))
haskell_STEP_TO_PROG = impls/haskell/$($(1))
haxe_STEP_TO_PROG = $(haxe_STEP_TO_PROG_$(haxe_MODE))
hy_STEP_TO_PROG = impls/hy/$($(1)).hy
io_STEP_TO_PROG = impls/io/$($(1)).io
janet_STEP_TO_PROG = impls/janet/$($(1)).janet
java_STEP_TO_PROG = impls/java/target/classes/mal/$($(1)).class
java-truffle_STEP_TO_PROG = impls/java-truffle/build/classes/java/main/truffle/mal/$($(1)).class
js_STEP_TO_PROG = impls/js/$($(1)).js
jq_STEP_PROG = impls/jq/$($(1)).jq
julia_STEP_TO_PROG = impls/julia/$($(1)).jl
kotlin_STEP_TO_PROG = impls/kotlin/$($(1)).jar
latex3_STEP_TO_PROG = impls/latex3/$($(1)).tex
livescript_STEP_TO_PROG = impls/livescript/$($(1)).js
logo_STEP_TO_PROG = impls/logo/$($(1)).lg
lua_STEP_TO_PROG = impls/lua/$($(1)).lua
make_STEP_TO_PROG = impls/make/$($(1)).mk
mal_STEP_TO_PROG = impls/mal/$($(1)).mal
matlab_STEP_TO_PROG = impls/matlab/$($(1)).m
miniMAL_STEP_TO_PROG = impls/miniMAL/$($(1)).json
nasm_STEP_TO_PROG = impls/nasm/$($(1))
nim_STEP_TO_PROG = impls/nim/$($(1))
objc_STEP_TO_PROG = impls/objc/$($(1))
objpascal_STEP_TO_PROG = impls/objpascal/$($(1))
ocaml_STEP_TO_PROG = impls/ocaml/$($(1))
perl_STEP_TO_PROG = impls/perl/$($(1)).pl
perl6_STEP_TO_PROG = impls/perl6/$($(1)).pl
php_STEP_TO_PROG = impls/php/$($(1)).php
picolisp_STEP_TO_PROG = impls/picolisp/$($(1)).l
pike_STEP_TO_PROG = impls/pike/$($(1)).pike
plpgsql_STEP_TO_PROG = impls/plpgsql/$($(1)).sql
plsql_STEP_TO_PROG = impls/plsql/$($(1)).sql
powershell_STEP_TO_PROG = impls/powershell/$($(1)).ps1
prolog_STEP_TO_PROG = impls/prolog/$($(1)).pl
ps_STEP_TO_PROG = impls/ps/$($(1)).ps
purs_STEP_TO_PROG = impls/purs/$($(1)).js
python2_STEP_TO_PROG = impls/python2/$($(1)).py
python3_STEP_TO_PROG = impls/python3/$($(1)).py
r_STEP_TO_PROG = impls/r/$($(1)).r
racket_STEP_TO_PROG = impls/racket/$($(1)).rkt
rexx_STEP_TO_PROG = impls/rexx/$($(1)).rexxpp
rpython_STEP_TO_PROG = impls/rpython/$($(1))
ruby_STEP_TO_PROG = impls/ruby/$($(1)).rb
ruby.2_STEP_TO_PROG = impls/ruby.2/$($(1)).rb
rust_STEP_TO_PROG = impls/rust/target/release/$($(1))
scala_STEP_TO_PROG = impls/scala/target/scala-2.11/classes/$($(1)).class
scheme_STEP_TO_PROG = $(scheme_STEP_TO_PROG_$(scheme_MODE))
skew_STEP_TO_PROG = impls/skew/$($(1)).js
sml_STEP_TO_PROG = impls/sml/$($(1))
swift_STEP_TO_PROG = impls/swift/$($(1))
swift3_STEP_TO_PROG = impls/swift3/$($(1))
swift4_STEP_TO_PROG = impls/swift4/$($(1))
swift6_STEP_TO_PROG = impls/swift6/$($(1))
tcl_STEP_TO_PROG = impls/tcl/$($(1)).tcl
ts_STEP_TO_PROG = impls/ts/$($(1)).js
vala_STEP_TO_PROG = impls/vala/$($(1))
vb_STEP_TO_PROG = impls/vb/$($(1)).exe
vbs_STEP_TO_PROG = impls/vbs/$($(1)).vbs
vhdl_STEP_TO_PROG = impls/vhdl/$($(1))
vimscript_STEP_TO_PROG = impls/vimscript/$($(1)).vim
wasm_STEP_TO_PROG = impls/wasm/$($(1)).wasm
wren_STEP_TO_PROG = impls/wren/$($(1)).wren
yorick_STEP_TO_PROG = impls/yorick/$($(1)).i
xslt_STEP_TO_PROG = impls/xslt/$($(1))
zig_STEP_TO_PROG = impls/zig/$($(1))
================================================
FILE: README.md
================================================
# mal - Make a Lisp
[](https://github.com/kanaka/mal/actions/workflows/main.yml)
## Description
**1. Mal is a Clojure inspired Lisp interpreter**
**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#step-0-the-repl)
* [step1_read_print](process/guide.md#step-1-read-and-print)
* [step2_eval](process/guide.md#step-2-eval)
* [step3_env](process/guide.md#step-3-environments)
* [step4_if_fn_do](process/guide.md#step-4-if-fn-do)
* [step5_tco](process/guide.md#step-5-tail-call-optimization)
* [step6_file](process/guide.md#step-6-files-mutation-and-evil)
* [step7_quote](process/guide.md#step-7-quoting)
* [step8_macros](process/guide.md#step-8-macros)
* [step9_try](process/guide.md#step-9-try)
* [stepA_mal](process/guide.md#step-a-metadata-self-hosting-and-interop)
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 architecture once [step A](process/guide.md#stepA)
is complete:
If you are interested in creating a mal implementation (or just
interested in using mal for something) you are welcome to to join our
[Discord](https://discord.gg/CKgnNbJBpF). 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 89 languages (95 different implementations and 118 runtime modes)**
| Language | Creator |
| -------- | ------- |
| [Ada](#ada) | [Chris Moore](https://github.com/zmower) |
| [Ada #2](#ada2) | [Nicolas Boulenguez](https://github.com/asarhaddon) |
| [GNU Awk](#gnu-awk) | [Mitsuru Kariya](https://github.com/kariya-mitsuru) |
| [Bash 4](#bash-4) | [Joel Martin](https://github.com/kanaka) |
| [BASIC](#basic-c64-and-qbasic) (C64 & QBasic) | [Joel Martin](https://github.com/kanaka) |
| [BBC BASIC V](#bbc-basic-v) | [Ben Harris](https://github.com/bjh21) |
| [C](#c) | [Joel Martin](https://github.com/kanaka) |
| [C #2](#c2) | [Duncan Watts](https://github.com/fungiblecog) |
| [C++](#c-1) | [Stephen Thirlwall](https://github.com/sdt) |
| [C#](#c-2) | [Joel Martin](https://github.com/kanaka) |
| [ChucK](#chuck) | [Vasilij Schneidermann](https://github.com/wasamasa) |
| [Clojure](#clojure) (Clojure & ClojureScript) | [Joel Martin](https://github.com/kanaka) |
| [CoffeeScript](#coffeescript) | [Joel Martin](https://github.com/kanaka) |
| [Common Lisp](#common-lisp) | [Iqbal Ansari](https://github.com/iqbalansari) |
| [Crystal](#crystal) | [Linda_pp](https://github.com/rhysd) |
| [D](#d) | [Dov Murik](https://github.com/dubek) |
| [Dart](#dart) | [Harry Terkelsen](https://github.com/hterkelsen) |
| [Elixir](#elixir) | [Martin Ek](https://github.com/ekmartin) |
| [Elm](#elm) | [Jos van Bakel](https://github.com/c0deaddict) |
| [Emacs Lisp](#emacs-lisp) | [Vasilij Schneidermann](https://github.com/wasamasa) |
| [Erlang](#erlang) | [Nathan Fiedler](https://github.com/nlfiedler) |
| [ES6](#es6-ecmascript-2015) (ECMAScript 2015) | [Joel Martin](https://github.com/kanaka) |
| [F#](#f) | [Peter Stephens](https://github.com/pstephens) |
| [Factor](#factor) | [Jordan Lewis](https://github.com/jordanlewis) |
| [Fantom](#fantom) | [Dov Murik](https://github.com/dubek) |
| [Fennel](#fennel) | [sogaiu](https://github.com/sogaiu) |
| [Forth](#forth) | [Chris Houser](https://github.com/chouser) |
| [GNU Guile](#gnu-guile-21) | [Mu Lei](https://github.com/NalaGinrut) |
| [GNU Smalltalk](#gnu-smalltalk) | [Vasilij Schneidermann](https://github.com/wasamasa) |
| [Go](#go) | [Joel Martin](https://github.com/kanaka) |
| [Groovy](#groovy) | [Joel Martin](https://github.com/kanaka) |
| [Hare](#hare) | [Lou Woell](http://github.com/einsiedlerspiel) |
| [Haskell](#haskell) | [Joel Martin](https://github.com/kanaka) |
| [Haxe](#haxe-neko-python-c-and-javascript) (Neko, Python, C++, & JS) | [Joel Martin](https://github.com/kanaka) |
| [Hy](#hy) | [Joel Martin](https://github.com/kanaka) |
| [Io](#io) | [Dov Murik](https://github.com/dubek) |
| [Janet](#janet) | [sogaiu](https://github.com/sogaiu) |
| [Java](#java-17) | [Joel Martin](https://github.com/kanaka) |
| [Java Truffle](#java-using-truffle-for-graalvm) (Truffle/GraalVM) | [Matt McGill](https://github.com/mmcgill) |
| [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) |
| [LaTeX3](#latex3) | [Nicolas Boulenguez](https://github.com/asarhaddon) |
| [LiveScript](#livescript) | [Jos van Bakel](https://github.com/c0deaddict) |
| [Logo](#logo) | [Dov Murik](https://github.com/dubek) |
| [Lua](#lua) | [Joel Martin](https://github.com/kanaka) |
| [GNU Make](#gnu-make-381) | [Joel Martin](https://github.com/kanaka) |
| [mal itself](#mal) | [Joel Martin](https://github.com/kanaka) |
| [MATLAB](#matlab-gnu-octave-and-matlab) (GNU Octave & MATLAB) | [Joel Martin](https://github.com/kanaka) |
| [miniMAL](#minimal) ([Repo](https://github.com/kanaka/miniMAL), [Demo](https://kanaka.github.io/miniMAL/)) | [Joel Martin](https://github.com/kanaka) |
| [NASM](#nasm) | [Ben Dudson](https://github.com/bendudson) |
| [Nim](#nim-104) | [Dennis Felsing](https://github.com/def-) |
| [Object Pascal](#object-pascal) | [Joel Martin](https://github.com/kanaka) |
| [Objective C](#objective-c) | [Joel Martin](https://github.com/kanaka) |
| [OCaml](#ocaml-4010) | [Chris Houser](https://github.com/chouser) |
| [Perl](#perl-5) | [Joel Martin](https://github.com/kanaka) |
| [Perl 6](#perl-6) | [Hinrik Örn Sigurðsson](https://github.com/hinrik) |
| [PHP](#php-53) | [Joel Martin](https://github.com/kanaka) |
| [Picolisp](#picolisp) | [Vasilij Schneidermann](https://github.com/wasamasa) |
| [Pike](#pike) | [Dov Murik](https://github.com/dubek) |
| [PL/pgSQL](#plpgsql-postgresql-sql-procedural-language) (PostgreSQL) | [Joel Martin](https://github.com/kanaka) |
| [PL/SQL](#plsql-oracle-sql-procedural-language) (Oracle) | [Joel Martin](https://github.com/kanaka) |
| [PostScript](#postscript-level-23) | [Joel Martin](https://github.com/kanaka) |
| [PowerShell](#powershell) | [Joel Martin](https://github.com/kanaka) |
| [Prolog](#prolog-logical-language) | [Nicolas Boulenguez](https://github.com/asarhaddon) |
| [PureScript](#purescript) | [mrsekut](https://github.com/mrsekut) |
| [Python2](#python2) | [Joel Martin](https://github.com/kanaka) |
| [Python3](#python3) | [Gavin Lewis](https://github.com/epylar) |
| [RPython](#rpython) | [Joel Martin](https://github.com/kanaka) |
| [R](#r) | [Joel Martin](https://github.com/kanaka) |
| [Racket](#racket-53) | [Joel Martin](https://github.com/kanaka) |
| [Rexx](#rexx) | [Dov Murik](https://github.com/dubek) |
| [Ruby](#ruby-19) | [Joel Martin](https://github.com/kanaka) |
| [Ruby #2](#ruby) | [Ryan Cook](https://github.com/cookrn) |
| [Rust](#rust-138) | [Joel Martin](https://github.com/kanaka) |
| [Scala](#scala) | [Joel Martin](https://github.com/kanaka) |
| [Scheme (R7RS)](#scheme-r7rs) | [Vasilij Schneidermann](https://github.com/wasamasa) |
| [Skew](#skew) | [Dov Murik](https://github.com/dubek) |
| [Standard ML](#sml) | [Fabian Bergström](https://github.com/fabjan) |
| [Swift 3](#swift-3) | [Joel Martin](https://github.com/kanaka) |
| [Swift 4](#swift-4) | [陆遥](https://github.com/LispLY) |
| [Swift 6](#swift-6) | [Oleg Montak](https://github.com/MontakOleg) |
| [Tcl](#tcl-86) | [Dov Murik](https://github.com/dubek) |
| [TypeScript](#typescript) | [Masahiro Wakame](https://github.com/vvakame) |
| [Vala](#vala) | [Simon Tatham](https://github.com/sgtatham) |
| [VHDL](#vhdl) | [Dov Murik](https://github.com/dubek) |
| [Vimscript](#vimscript) | [Dov Murik](https://github.com/dubek) |
| [Visual Basic.NET](#visual-basicnet) | [Joel Martin](https://github.com/kanaka) |
| [Visual Basic Script](#visual-basic-script) | [刘百超](https://github.com/OldLiu001) |
| [WebAssembly](#webassembly-wasm) (wasm) | [Joel Martin](https://github.com/kanaka) |
| [Wren](#wren) | [Dov Murik](https://github.com/dubek) |
| [XSLT](#xslt) | [Ali MohammadPur](https://github.com/alimpfard) |
| [Yorick](#yorick) | [Dov Murik](https://github.com/dubek) |
| [Zig](#zig) | [Josh Tobin](https://github.com/rjtobin) |
## Presentations
Mal was presented publicly for the first time in a lightning talk at
Clojure West 2014 (unfortunately there is no video). See
examples/clojurewest2014.mal for the presentation that was given at the
conference (yes, the presentation is a mal program).
At Midwest.io 2015, Joel Martin gave a presentation on Mal titled
"Achievement Unlocked: A Better Path to Language Learning".
[Video](https://www.youtube.com/watch?v=lgyOAiRtZGw),
[Slides](http://kanaka.github.io/midwest.io.mal/).
More recently Joel gave a presentation on "Make Your Own Lisp Interpreter
in 10 Incremental Steps" at LambdaConf 2016:
[Part 1](https://www.youtube.com/watch?v=jVhupfthTEk),
[Part 2](https://www.youtube.com/watch?v=X5OQBMGpaTU),
[Part 3](https://www.youtube.com/watch?v=6mARZzGgX4U),
[Part 4](https://www.youtube.com/watch?v=dCO1SYR5kDU),
[Slides](http://kanaka.github.io/lambdaconf/).
## Building/running implementations
The simplest way to run any given implementation is to use docker.
Every implementation has a docker image pre-built with language
dependencies installed. You can launch the REPL using a convenient
target in the top level Makefile (where IMPL is the implementation
directory name and stepX is the step to run):
```
make DOCKERIZE=1 "repl^IMPL^stepX"
# OR stepA is the default step:
make DOCKERIZE=1 "repl^IMPL"
```
## External / Alternate Implementations
The following implementations are maintained as separate projects:
### HolyC
* [by Alexander Bagnalla](https://github.com/bagnalla/holyc_mal)
### Rust
* [by Tim Morgan](https://github.com/seven1m/mal-rust)
* [by vi](https://github.com/vi/mal-rust-vi) - using [Pest](https://pest.rs/) grammar, not using typical Mal infrastructure (cargo-ized steps and built-in converted tests).
### Swift 2
* [by Keith Rollin](https://github.com/kanaka/mal/tree/fbfe678/impls/swift) - This implementation used to be in the repo. However, Swift 2 is no longer easily buildable/testable.
### Q
* [by Ali Mohammad Pur](https://github.com/alimpfard/mal/tree/q/impls/q) - The Q implementation works fine but it requires a proprietary manual download that can't be Dockerized (or integrated into the mal CI pipeline) so for now it remains a separate project.
## Other mal Projects
* [malc](https://github.com/dubek/malc) - Mal (Make A Lisp) compiler. Compiles a Mal program to LLVM assembly language, then binary.
* [malcc](https://github.com/seven1m/malcc) - malcc is an incremental compiler implementation for the Mal language. It uses the Tiny C Compiler as the compiler backend and has full support for the Mal language, including macros, tail-call elimination, and even run-time eval. ["I Built a Lisp Compiler"](https://mpov.timmorgan.org/i-built-a-lisp-compiler/) post about the process.
* [frock](https://github.com/chr15m/frock) - Clojure-flavoured PHP. Uses mal/php to run programs.
* [flk](https://github.com/chr15m/flk) - A LISP that runs wherever Bash is
* [glisp](https://github.com/baku89/glisp) - Self-bootstrapping graphic design tool on Lisp. [Live Demo](https://baku89.com/glisp/)
* [mal2py-compiler](https://github.com/jcguu95/mal2py-compiler) - MAL-to-Python. A fork of the python3 implementation that compiles mal to python with a 16x performance improvement on the perf3 synthetic benchmark.
## Implementation Details
### Ada
The Ada implementation was developed with GNAT 4.9 on debian. It also
compiles unchanged on windows if you have windows versions of git,
GNAT and (optionally) make. There are no external dependencies
(readline not implemented).
```
cd impls/ada
make
./stepX_YYY
```
### Ada.2
The second Ada implementation was developed with GNAT 8 and links with
the GNU readline library.
```
cd impls/ada
make
./stepX_YYY
```
### GNU awk
The GNU awk implementation of mal has been tested with GNU awk 4.1.1.
```
cd impls/gawk
gawk -O -f stepX_YYY.awk
```
### Bash 4
```
cd impls/bash
bash stepX_YYY.sh
```
### BASIC (C64 and QBasic)
The BASIC implementation uses a preprocessor that can generate BASIC
code that is compatible with both C64 BASIC (CBM v2) or QBasic. The
C64 mode has been tested with
[cbmbasic](https://github.com/kanaka/cbmbasic) (the patched version is
currently required to fix issues with line input) and the QBasic mode
has been tested with [FreeBASIC](freebasic.net).
Generate C64 code and run it using cbmbasic:
```
cd impls/basic
make MODE=cbm stepX_YYY.bas
STEP=stepX_YYY basic_MODE=cbm ./run
```
Generate QBasic code, compile using FreeBASIC, and execute it:
```
cd impls/basic
make MODE=qbasic stepX_YYY.bas
make MODE=qbasic stepX_YYY
./stepX_YYY
```
Thanks to [Steven Syrek](https://github.com/sjsyrek) for the original
inspiration for this implementation.
### BBC BASIC V
The BBC BASIC V implementation can run in the Brandy interpreter:
```
cd impls/bbc-basic
brandy -quit stepX_YYY.bbc
```
Or in ARM BBC BASIC V under RISC OS 3 or later:
```
*Dir bbc-basic.riscos
*Run setup
*Run stepX_YYY
```
### C
The C implementation of mal requires the following libraries (lib and
header packages): glib, libffi6, libgc, and either the libedit or GNU readline
library.
```
cd impls/c
make
./stepX_YYY
```
### C.2
The second C implementation of mal requires the following libraries (lib and
header packages): libedit, libgc, libdl, and libffi.
```
cd impls/c.2
make
./stepX_YYY
```
### C++
The C++ implementation of mal requires g++-4.9 or clang++-3.5 and
a readline compatible library to build. See the `cpp/README.md` for
more details:
```
cd impls/cpp
make
# OR
make CXX=clang++-3.5
./stepX_YYY
```
### C# ###
The C# implementation of mal has been tested on Linux using the Mono
C# compiler (mcs) and the Mono runtime (version 2.10.8.1). Both are
required to build and run the C# implementation.
```
cd impls/cs
make
mono ./stepX_YYY.exe
```
### ChucK
The ChucK implementation has been tested with ChucK 1.3.5.2.
```
cd impls/chuck
./run
```
### Clojure
For the most part the Clojure implementation requires Clojure 1.5,
however, to pass all tests, Clojure 1.8.0-RC4 is required.
```
cd impls/clojure
lein with-profile +stepX trampoline run
```
### CoffeeScript
```
sudo npm install -g coffee-script
cd impls/coffee
coffee ./stepX_YYY
```
### Common Lisp
The implementation has been tested with SBCL, CCL, CMUCL, GNU CLISP, ECL and
Allegro CL on Ubuntu 16.04 and Ubuntu 12.04, see
the [README](impls/common-lisp/README.org) for more details. Provided you have the
dependencies mentioned installed, do the following to run the implementation
```
cd impls/common-lisp
make
./run
```
### Crystal
The Crystal implementation of mal has been tested with Crystal 0.26.1.
```
cd impls/crystal
crystal run ./stepX_YYY.cr
# OR
make # needed to run tests
./stepX_YYY
```
### D
The D implementation of mal was tested with GDC 4.8. It requires the GNU
readline library.
```
cd impls/d
make
./stepX_YYY
```
### Dart
The Dart implementation has been tested with Dart 1.20.
```
cd impls/dart
dart ./stepX_YYY
```
### Emacs Lisp
The Emacs Lisp implementation of mal has been tested with Emacs 24.3
and 24.5. While there is very basic readline editing (`<backspace>`
and `C-d` work, `C-c` cancels the process), it is recommended to use
`rlwrap`.
```
cd impls/elisp
emacs -Q --batch --load stepX_YYY.el
# with full readline support
rlwrap emacs -Q --batch --load stepX_YYY.el
```
### Elixir
The Elixir implementation of mal has been tested with Elixir 1.0.5.
```
cd impls/elixir
mix stepX_YYY
# Or with readline/line editing functionality:
iex -S mix stepX_YYY
```
### Elm
The Elm implementation of mal has been tested with Elm 0.18.0
```
cd impls/elm
make stepX_YYY.js
STEP=stepX_YYY ./run
```
### Erlang
The Erlang implementation of mal requires [Erlang/OTP R17](http://www.erlang.org/download.html)
and [rebar](https://github.com/rebar/rebar) to build.
```
cd impls/erlang
make
# OR
MAL_STEP=stepX_YYY rebar compile escriptize # build individual step
./stepX_YYY
```
### ES6 (ECMAScript 2015)
The ES6 / ECMAScript 2015 implementation uses the
[babel](https://babeljs.io) compiler to generate ES5 compatible
JavaScript. The generated code has been tested with Node 0.12.4.
```
cd impls/es6
make
node build/stepX_YYY.js
```
### F# ###
The F# implementation of mal has been tested on Linux using the Mono
F# compiler (fsharpc) and the Mono runtime (version 3.12.1). The mono C#
compiler (mcs) is also necessary to compile the readline dependency. All are
required to build and run the F# implementation.
```
cd impls/fsharp
make
mono ./stepX_YYY.exe
```
### Factor
The Factor implementation of mal has been tested with Factor 0.97
([factorcode.org](http://factorcode.org)).
```
cd impls/factor
FACTOR_ROOTS=. factor -run=stepX_YYY
```
### Fantom
The Fantom implementation of mal has been tested with Fantom 1.0.70.
```
cd impls/fantom
make lib/fan/stepX_YYY.pod
STEP=stepX_YYY ./run
```
### Fennel
The Fennel implementation of mal has been tested with Fennel version
0.9.1 on Lua 5.4.
```
cd impls/fennel
fennel ./stepX_YYY.fnl
```
### Forth
```
cd impls/forth
gforth stepX_YYY.fs
```
### GNU Guile 2.1+
```
cd impls/guile
guile -L ./ stepX_YYY.scm
```
### GNU Smalltalk
The Smalltalk implementation of mal has been tested with GNU Smalltalk 3.2.91.
```
cd impls/gnu-smalltalk
./run
```
### Go
The Go implementation of mal requires that go is installed on on the
path. The implementation has been tested with Go 1.3.1.
```
cd impls/go
make
./stepX_YYY
```
### Groovy
The Groovy implementation of mal requires Groovy to run and has been
tested with Groovy 1.8.6.
```
cd impls/groovy
make
groovy ./stepX_YYY.groovy
```
### Hare
The hare implementation was tested against Hare 0.25.2.
```
cd impls/hare
make
./stepX_YYY
```
### Haskell
The Haskell implementation requires the ghc compiler version 7.10.1 or
later and also the Haskell parsec and readline (or editline) packages.
```
cd impls/haskell
make
./stepX_YYY
```
### Haxe (Neko, Python, C++ and JavaScript)
The Haxe implementation of mal requires Haxe version 3.2 to compile.
Four different Haxe targets are supported: Neko, Python, C++, and
JavaScript.
```
cd impls/haxe
# Neko
make all-neko
neko ./stepX_YYY.n
# Python
make all-python
python3 ./stepX_YYY.py
# C++
make all-cpp
./cpp/stepX_YYY
# JavaScript
make all-js
node ./stepX_YYY.js
```
### Hy
The Hy implementation of mal has been tested with Hy 0.13.0.
```
cd impls/hy
./stepX_YYY.hy
```
### Io
The Io implementation of mal has been tested with Io version 20110905.
```
cd impls/io
io ./stepX_YYY.io
```
### Janet
The Janet implementation of mal has been tested with Janet version 1.12.2.
```
cd impls/janet
janet ./stepX_YYY.janet
```
### Java 1.7
The Java implementation of mal requires maven2 to build.
```
cd impls/java
mvn compile
mvn -quiet exec:java -Dexec.mainClass=mal.stepX_YYY
# OR
mvn -quiet exec:java -Dexec.mainClass=mal.stepX_YYY -Dexec.args="CMDLINE_ARGS"
```
### Java, using Truffle for GraalVM
This Java implementation will run on OpenJDK, but can run
as much as 30x faster on GraalVM thanks to the Truffle framework.
It's been tested with OpenJDK 11, GraalVM CE 20.1.0, and
GraalVM CE 21.1.0.
```
cd impls/java-truffle
./gradlew build
STEP=stepX_YYY ./run
```
### JavaScript/Node
```
cd impls/js
npm install
node stepX_YYY.js
```
### Julia
The Julia implementation of mal requires Julia 0.4.
```
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 impls/kotlin
make
java -jar stepX_YYY.jar
```
### LaTeX3
The LaTeX3 implementation of mal has been tested with pdfTeX
3.141592653-2.6-1.40.24.
Self hosting is too slow for any sensible timeout, and crashes in
step4, apparently because of hard-coded limitations.
Anybody working on this should uncomment the two lines of (slow)
debugging options in the step file, and export DEBUG=1 (for more
output than tests accept).
### LiveScript
The LiveScript implementation of mal has been tested with LiveScript 1.5.
```
cd impls/livescript
make
node_modules/.bin/lsc stepX_YYY.ls
```
### Logo
The Logo implementation of mal has been tested with UCBLogo 6.0.
```
cd impls/logo
logo stepX_YYY.lg
```
### Lua
The Lua implementation of mal has been tested with Lua 5.3.5 The
implementation requires luarocks to be installed.
```
cd impls/lua
make # to build and link linenoise.so and rex_pcre.so
./stepX_YYY.lua
```
### Mal
Running the mal implementation of mal involves running stepA of one of
the other implementations and passing the mal step to run as a command
line argument.
```
cd impls/IMPL
IMPL_STEPA_CMD ../mal/stepX_YYY.mal
```
### GNU Make 3.81
```
cd impls/make
make -f stepX_YYY.mk
```
### NASM
The NASM implementation of mal is written for x86-64 Linux, and has been tested
with Linux 3.16.0-4-amd64 and NASM version 2.11.05.
```
cd impls/nasm
make
./stepX_YYY
```
### Nim 1.0.4
The Nim implementation of mal has been tested with Nim 1.0.4.
```
cd impls/nim
make
# OR
nimble build
./stepX_YYY
```
### Object Pascal
The Object Pascal implementation of mal has been built and tested on
Linux using the Free Pascal compiler version 2.6.2 and 2.6.4.
```
cd impls/objpascal
make
./stepX_YYY
```
### Objective C
The Objective C implementation of mal has been built and tested on
Linux using clang/LLVM 3.6. It has also been built and tested on OS
X using Xcode 7.
```
cd impls/objc
make
./stepX_YYY
```
### OCaml 4.01.0
```
cd impls/ocaml
make
./stepX_YYY
```
### MATLAB (GNU Octave and MATLAB)
The MatLab implementation has been tested with GNU Octave 4.2.1.
It has also been tested with MATLAB version R2014a on Linux. Note that
MATLAB is a commercial product.
```
cd impls/matlab
./stepX_YYY
octave -q --no-gui --no-history --eval "stepX_YYY();quit;"
matlab -nodisplay -nosplash -nodesktop -nojvm -r "stepX_YYY();quit;"
# OR with command line arguments
octave -q --no-gui --no-history --eval "stepX_YYY('arg1','arg2');quit;"
matlab -nodisplay -nosplash -nodesktop -nojvm -r "stepX_YYY('arg1','arg2');quit;"
```
### miniMAL
[miniMAL](https://github.com/kanaka/miniMAL) is small Lisp interpreter
implemented in less than 1024 bytes of JavaScript. To run the miniMAL
implementation of mal you need to download/install the miniMAL
interpreter (which requires Node.js).
```
cd impls/miniMAL
# Download miniMAL and dependencies
npm install
export PATH=`pwd`/node_modules/minimal-lisp/:$PATH
# Now run mal implementation in miniMAL
miniMAL ./stepX_YYY
```
### Perl 5
The Perl 5 implementation should work with perl 5.19.3 and later.
For readline line editing support, install Term::ReadLine::Perl or
Term::ReadLine::Gnu from CPAN.
```
cd impls/perl
perl stepX_YYY.pl
```
### Perl 6
The Perl 6 implementation was tested on Rakudo Perl 6 2016.04.
```
cd impls/perl6
perl6 stepX_YYY.pl
```
### PHP 5.3
The PHP implementation of mal requires the php command line interface
to run.
```
cd impls/php
php stepX_YYY.php
```
### Picolisp
The Picolisp implementation requires libreadline and Picolisp 3.1.11
or later.
```
cd impls/picolisp
./run
```
### Pike
The Pike implementation was tested on Pike 8.0.
```
cd impls/pike
pike stepX_YYY.pike
```
### PL/pgSQL (PostgreSQL SQL Procedural Language)
The PL/pgSQL implementation of mal requires a running PostgreSQL server
(the "kanaka/mal-test-plpgsql" docker image automatically starts
a PostgreSQL server). The implementation connects to the PostgreSQL server
and create a database named "mal" to store tables and stored
procedures. The wrapper script uses the psql command to connect to the
server and defaults to the user "postgres" but this can be overridden
with the PSQL_USER environment variable. A password can be specified
using the PGPASSWORD environment variable. The implementation has been
tested with PostgreSQL 9.4.
```
cd impls/plpgsql
./wrap.sh stepX_YYY.sql
# OR
PSQL_USER=myuser PGPASSWORD=mypass ./wrap.sh stepX_YYY.sql
```
### PL/SQL (Oracle SQL Procedural Language)
The PL/SQL implementation of mal requires a running Oracle DB
server (the "kanaka/mal-test-plsql" docker image automatically
starts an Oracle Express server). The implementation connects to the
Oracle server to create types, tables and stored procedures. The
default SQL\*Plus logon value (username/password@connect_identifier) is
"system/oracle" but this can be overridden with the ORACLE_LOGON
environment variable. The implementation has been tested with Oracle
Express Edition 11g Release 2. Note that any SQL\*Plus connection
warnings (user password expiration, etc) will interfere with the
ability of the wrapper script to communicate with the DB.
```
cd impls/plsql
./wrap.sh stepX_YYY.sql
# OR
ORACLE_LOGON=myuser/mypass@ORCL ./wrap.sh stepX_YYY.sql
```
### PostScript Level 2/3
The PostScript implementation of mal requires Ghostscript to run. It
has been tested with Ghostscript 9.10.
```
cd impls/ps
gs -q -dNODISPLAY -I./ stepX_YYY.ps
```
### PowerShell
The PowerShell implementation of mal requires the PowerShell script
language. It has been tested with PowerShell 6.0.0 Alpha 9 on Linux.
```
cd impls/powershell
powershell ./stepX_YYY.ps1
```
### Prolog
The Prolog implementation uses some constructs specific to SWI-Prolog,
includes readline support and has been tested on Debian GNU/Linux with
version 8.2.1.
```
cd impls/prolog
swipl stepX_YYY
```
### PureScript
The PureScript implementation requires the spago compiler version 0.20.2.
```
cd impls/purs
make
node ./stepX_YYY.js
```
### Python2
This implementation only uses python2 features, but avoids
incompatibilities with python3.
### Python3
This implementation is checked for style and types
(flake8, pylint, mypy). It reports all errors with details.
It demonstrates iterators, decorators, functional tools, chain maps,
dataclasses, introspection, match statements, assignement expressions.
### RPython
You must have [rpython](https://rpython.readthedocs.org/) on your path
(included with [pypy](https://bitbucket.org/pypy/pypy/)).
```
cd impls/rpython
make # this takes a very long time
./stepX_YYY
```
### R
The R implementation of mal requires R (r-base-core) to run.
```
cd impls/r
make libs # to download and build rdyncall
Rscript stepX_YYY.r
```
### Racket (5.3)
The Racket implementation of mal requires the Racket
compiler/interpreter to run.
```
cd impls/racket
./stepX_YYY.rkt
```
### Rexx
The Rexx implementation of mal has been tested with Regina Rexx 3.6.
```
cd impls/rexx
make
rexx -a ./stepX_YYY.rexxpp
```
### Ruby (1.9+)
```
cd impls/ruby
ruby stepX_YYY.rb
```
### Ruby #2
A second Ruby implementation with the following goals:
- No global variables
- No modification (monkey-patching) of core Ruby classes
- Modularized into the `Mal` module namespace
```
cd impls/ruby.2
ruby stepX_YYY.rb
```
### Rust (1.38+)
The rust implementation of mal requires the rust compiler and build
tool (cargo) to build.
```
cd impls/rust
cargo run --release --bin stepX_YYY
```
### Scala ###
Install scala and sbt (http://www.scala-sbt.org/0.13/tutorial/Installing-sbt-on-Linux.html):
```
cd impls/scala
sbt 'run-main stepX_YYY'
# OR
sbt compile
scala -classpath target/scala*/classes stepX_YYY
```
### Scheme (R7RS) ###
The Scheme implementation of MAL has been tested with Chibi-Scheme
0.10, Kawa 3.1.1, Gauche 0.9.6, CHICKEN 5.1.0, Sagittarius 0.9.7,
Cyclone 0.32.0 (Git version) and Foment 0.4 (Git version). You should
be able to get it running on other conforming R7RS implementations
after figuring out how libraries are loaded and adjusting the
`Makefile` and `run` script accordingly.
```
cd impls/scheme
# chibi
scheme_MODE=chibi ./run
# kawa
make kawa
scheme_MODE=kawa ./run
# gauche
scheme_MODE=gauche ./run
# chicken
make chicken
scheme_MODE=chicken ./run
# sagittarius
scheme_MODE=sagittarius ./run
# cyclone
make cyclone
scheme_MODE=cyclone ./run
# foment
scheme_MODE=foment ./run
```
### Skew ###
The Skew implementation of mal has been tested with Skew 0.7.42.
```
cd impls/skew
make
node stepX_YYY.js
```
### Standard ML (Poly/ML, MLton, Moscow ML)
The Standard ML implementation of mal requires an
[SML97](https://github.com/SMLFamily/The-Definition-of-Standard-ML-Revised)
implementation. The Makefile supports Poly/ML, MLton, Moscow ML, and has
been tested with Poly/ML 5.8.1, MLton 20210117, and Moscow ML version 2.10.
```
cd impls/sml
# Poly/ML
make sml_MODE=polyml
./stepX_YYY
# MLton
make sml_MODE=mlton
./stepX_YYY
# Moscow ML
make sml_MODE=mosml
./stepX_YYY
```
### Swift 3
The Swift 3 implementation of mal requires the Swift 3.0 compiler. It
has been tested with Swift 3 Preview 3.
```
cd impls/swift3
make
./stepX_YYY
```
### Swift 4
The Swift 4 implementation of mal requires the Swift 4.0 compiler. It
has been tested with Swift 4.2.3 release.
```
cd impls/swift4
make
./stepX_YYY
```
### Swift 5
The Swift 5 implementation of mal requires the Swift 5.0 compiler. It
has been tested with Swift 5.1.1 release.
```
cd impls/swift6
swift run stepX_YYY
```
### Tcl 8.6
The Tcl implementation of mal requires Tcl 8.6 to run. For readline line
editing support, install tclreadline.
```
cd impls/tcl
tclsh ./stepX_YYY.tcl
```
### TypeScript
The TypeScript implementation of mal requires the TypeScript 2.2 compiler.
It has been tested with Node.js v6.
```
cd impls/ts
make
node ./stepX_YYY.js
```
### Vala
The Vala implementation of mal has been tested with the Vala 0.40.8
compiler. You will need to install `valac` and `libreadline-dev` or
equivalent.
```
cd impls/vala
make
./stepX_YYY
```
### VHDL
The VHDL implementation of mal has been tested with GHDL 0.29.
```
cd impls/vhdl
make
./run_vhdl.sh ./stepX_YYY
```
### Vimscript
The Vimscript implementation of mal requires Vim 8.0 to run.
```
cd impls/vimscript
./run_vimscript.sh ./stepX_YYY.vim
```
### Visual Basic.NET ###
The VB.NET implementation of mal has been tested on Linux using the Mono
VB compiler (vbnc) and the Mono runtime (version 2.10.8.1). Both are
required to build and run the VB.NET implementation.
```
cd impls/vb
make
mono ./stepX_YYY.exe
```
### Visual Basic Script ###
The VBScript implementation of mal has been tested on Windows 10 1909.
`install.vbs` can help you install the requirements (.NET 2.0 3.0 3.5).
If you havn't install `.NET 2.0 3.0 3.5`, it will popup a window for installation.
If you already installed that, it will do nothing.
```
cd impls\vbs
install.vbs
cscript -nologo stepX_YYY.vbs
```
### WebAssembly (wasm) ###
The WebAssembly implementation is written in
[Wam](https://github.com/kanaka/wam) (WebAssembly Macro language) and
runs under several different non-web embeddings (runtimes):
[node](https://nodejs.org),
[wasmtime](https://github.com/CraneStation/wasmtime),
[wasmer](https://wasmer.io),
[wax](https://github.com/kanaka/wac),
[wace](https://github.com/kanaka/wac),
[warpy](https://github.com/kanaka/warpy).
```
cd impls/wasm
# node
make wasm_MODE=node
./run.js ./stepX_YYY.wasm
# wasmtime
make wasm_MODE=wasmtime
wasmtime --dir=./ --dir=../ --dir=/ ./stepX_YYY.wasm
# wasmer
make wasm_MODE=wasmer
wasmer run --dir=./ --dir=../ --dir=/ ./stepX_YYY.wasm
# wax
make wasm_MODE=wax
wax ./stepX_YYY.wasm
# wace
make wasm_MODE=wace_libc
wace ./stepX_YYY.wasm
# warpy
make wasm_MODE=warpy
warpy --argv --memory-pages 256 ./stepX_YYY.wasm
```
### XSLT
The XSLT implementation of mal is written with XSLT 3 and tested on Saxon 9.9.1.6 Home Edition.
```
cd impls/xslt
STEP=stepX_YY ./run
```
### Wren
The Wren implementation of mal was tested on Wren 0.2.0.
```
cd impls/wren
wren ./stepX_YYY.wren
```
### Yorick
The Yorick implementation of mal was tested on Yorick 2.2.04.
```
cd impls/yorick
yorick -batch ./stepX_YYY.i
```
### Zig
The Zig implementation of mal was tested on Zig 0.5.
```
cd impls/zig
zig build stepX_YYY
```
## Running tests
The top level Makefile has a number of useful targets to assist with
implementation development and testing. The `help` target provides
a list of the targets and options:
```
make help
```
### Functional tests
The are almost 800 generic functional tests (for all implementations)
in the `tests/` directory. Each step has a corresponding test file
containing tests specific to that step. The `runtest.py` test harness
launches a Mal step implementation and then feeds the tests one at
a time to the implementation and compares the output/return value to
the expected output/return value.
* To run all the tests across all implementations (be prepared to wait):
```
make test
```
* To run all tests against a single implementation:
```
make "test^IMPL"
# e.g.
make "test^clojure"
make "test^js"
```
* To run tests for a single step against all implementations:
```
make "test^stepX"
# e.g.
make "test^step2"
make "test^step7"
```
* To run tests for a specific step against a single implementation:
```
make "test^IMPL^stepX"
# e.g
make "test^ruby^step3"
make "test^ps^step4"
```
### Self-hosted functional tests
* To run the functional tests in self-hosted mode, you specify `mal`
as the test implementation and use the `MAL_IMPL` make variable
to change the underlying host language (default is JavaScript):
```
make MAL_IMPL=IMPL "test^mal^step2"
# e.g.
make "test^mal^step2" # js is default
make MAL_IMPL=ruby "test^mal^step2"
make MAL_IMPL=python3 "test^mal^step2"
```
### Starting the REPL
* To start the REPL of an implementation in a specific step:
```
make "repl^IMPL^stepX"
# e.g
make "repl^ruby^step3"
make "repl^ps^step4"
```
* If you omit the step, then `stepA` is used:
```
make "repl^IMPL"
# e.g
make "repl^ruby"
make "repl^ps"
```
* To start the REPL of the self-hosted implementation, specify `mal` as the
REPL implementation and use the `MAL_IMPL` make variable to change the
underlying host language (default is JavaScript):
```
make MAL_IMPL=IMPL "repl^mal^stepX"
# e.g.
make "repl^mal^step2" # js is default
make MAL_IMPL=ruby "repl^mal^step2"
make MAL_IMPL=python3 "repl^mal"
```
### Performance tests
Warning: These performance tests are neither statistically valid nor
comprehensive; runtime performance is a not a primary goal of mal. If
you draw any serious conclusions from these performance tests, then
please contact me about some amazing oceanfront property in Kansas
that I'm willing to sell you for cheap.
* To run performance tests against a single implementation:
```
make "perf^IMPL"
# e.g.
make "perf^js"
```
* To run performance tests against all implementations:
```
make "perf"
```
### Generating language statistics
* To report line and byte statistics for a single implementation:
```
make "stats^IMPL"
# e.g.
make "stats^js"
```
## Dockerized testing
Every implementation directory contains a Dockerfile to create
a docker image containing all the dependencies for that
implementation. In addition, the top-level Makefile contains support
for running the tests target (and perf, stats, repl, etc) within
a docker container for that implementation by passing *"DOCKERIZE=1"*
on the make command line. For example:
```
make DOCKERIZE=1 "test^js^step3"
```
Existing implementations already have docker images built and pushed
to the docker registry. However, if
you wish to build or rebuild a docker image locally, the toplevel
Makefile provides a rule for building docker images:
```
make "docker-build^IMPL"
```
**Notes**:
* Docker images are named *"ghcr.io/kanaka/mal-test-IMPL"*
* JVM-based language implementations (Groovy, Java, Clojure, Scala):
you will probably need to run this command once manually
first `make DOCKERIZE=1 "repl^IMPL"` before you can run tests because
runtime dependencies need to be downloaded to avoid the tests timing
out. These dependencies are downloaded to dot-files in the /mal
directory so they will persist between runs.
## License
Mal (make-a-lisp) is licensed under the MPL 2.0 (Mozilla Public
License 2.0). See LICENSE.txt for more details.
================================================
FILE: ci.sh
================================================
#!/usr/bin/env bash
set -ex
ACTION=${1}
IMPL=${2}
die() { local ret=$1; shift; echo >&2 "${*}"; exit $ret; }
# Environment variable configuration
BUILD_IMPL=${BUILD_IMPL:-${IMPL}}
if [ "${DO_SELF_HOST}" ]; then
MAL_IMPL=${IMPL}
IMPL=mal
fi
if [ "${DO_HARD}" ]; then
TEST_OPTS="${TEST_OPTS} --hard"
fi
raw_mode_var=${MAL_IMPL:-${IMPL}}_MODE
mode_var=${raw_mode_var/-/__}
mode_var=${mode_var/./__}
mode_val=${!mode_var}
log_prefix="${ACTION}${REGRESS:+-regress}-${IMPL}${mode_val:+-${mode_val}}${MAL_IMPL:+-${MAL_IMPL}}"
TEST_OPTS="${TEST_OPTS} -vv --debug-file ../../${log_prefix}.debug"
TEST_OPTS="${TEST_OPTS} --continue-after-fail"
step_summary() {
echo "${*}"
if [ "${GITHUB_STEP_SUMMARY}" ]; then
echo "${*}" >> "${GITHUB_STEP_SUMMARY}"
fi
}
img_base="${MAL_IMPL:-${IMPL}}"
img_impl="${img_base%%-mal}"
img_name="mal-test-$(echo "${img_impl}" | tr '[:upper:]' '[:lower:]')"
img_ver=$(./voom-like-version.sh impls/${img_impl}/Dockerfile)
IMAGE="ghcr.io/kanaka/${img_name}:${img_ver}"
# If NO_DOCKER is blank then run make in a docker image
MAKE="make ${mode_val:+${mode_var}=${mode_val}}"
if [ -z "${NO_DOCKER}" ]; then
# We could just use make DOCKERIZE=1 instead but that does add
# non-trivial startup overhead for each step.
MAKE="docker run -i -u $(id -u) -v `pwd`:/mal ${IMAGE} ${MAKE}"
fi
# Log everything below this point:
exec &> >(tee ./${log_prefix}.log)
if [ "${NO_PERF}" -a "${ACTION}" = "perf" ]; then
die 0 "Skipping perf test"
fi
if [ "${NO_SELF_HOST}" -a "${DO_SELF_HOST}" ]; then
die 0 "Skipping ${ACTION} of ${MAL_IMPL} self-host"
fi
if [ "${NO_SELF_HOST_PERF}" -a "${DO_SELF_HOST}" -a "${ACTION}" = "perf" ]; then
die 0 "Skipping only perf test for ${MAL_IMPL} self-host"
fi
echo "ACTION: ${ACTION}"
echo "IMPL: ${IMPL}"
echo "BUILD_IMPL: ${BUILD_IMPL}"
echo "MAL_IMPL: ${MAL_IMPL}"
echo "TEST_OPTS: ${TEST_OPTS}"
echo "IMAGE: ${IMAGE}"
echo "MAKE: ${MAKE}"
case "${ACTION}" in
docker-build-push)
if ! docker pull ${IMAGE}; then
step_summary "${BUILD_IMPL} - building ${IMAGE}"
make "docker-build^${BUILD_IMPL}"
step_summary "${BUILD_IMPL} - built ${IMAGE}"
if [ "${GITHUB_REPOSITORY}" = "kanaka/mal" ] && [ "${GITHUB_REF}" = "refs/heads/master" ]; then
docker push ${IMAGE}
step_summary "${BUILD_IMPL} - pushed ${IMAGE}"
fi
fi
;;
build)
# rpython often fails on step9 in compute_vars_longevity
# so build step9, then continue with the full build
if [ "${BUILD_IMPL}" = "rpython" ]; then
${MAKE} -C "impls/${BUILD_IMPL}" step9_try || true
fi
${MAKE} -C "impls/${BUILD_IMPL}"
;;
test|perf)
[ "${ACTION}" = "perf" ] && STEP=
if ! ${MAKE} TEST_OPTS="${TEST_OPTS}" \
${MAL_IMPL:+MAL_IMPL=${MAL_IMPL}} \
${REGRESS:+REGRESS=${REGRESS}} \
${HARD:+HARD=${HARD}} \
${DEFERRABLE:+DEFERRABLE=${DEFERRABLE}} \
${OPTIONAL:+OPTIONAL=${OPTIONAL}} \
${ACTION}^${IMPL}${STEP:+^${STEP}}; then
# show debug-file path on error
echo "Full debug log is at: ${log_prefix}.debug"
false
fi
;;
esac
================================================
FILE: docs/FAQ.md
================================================
# Mal/Make-a-Lisp FAQ
<a name="why_mal"></a>
### Why did you create mal/make-a-lisp?
### OR Why the name "mal"?
### OR Why?
### OR Wat?
In November of 2013, Alan Dipert gave a [lightning talk at
Clojure/conj](https://www.youtube.com/watch?v=bmHTFo2Rf2w#t=28m55s)
about [gherkin](https://github.com/alandipert/gherkin), a Lisp
implemented in bash. His presentation led me to ask myself the question
of whether a Lisp could be created using the GNU Make macro language.
As you have probably guessed, the answer to that question is yes.
Interestingly, the current pedagogical/educational purpose of mal
happened due to a semantic naming accident (naming is such a fraught
task in computer science). If I am remembering correctly, the name
"mal" original meant "MAke Lisp". I do not remember precisely why
I continued to create more implementations, apart from the fact that
it was a fun challenge, but after the make implementation, many of the
others were relatively easy. At some point during that process,
I realized that the multiple implementations and incremental steps
(which was originally just for my own clarity) was a useful learning
tool and so the "mal" name became a double entendre for "Make, A Lisp"
and "make-a-lisp" (and eventually just the latter given that the make
implementation is now just a small part of the whole).
<a name="code_split"></a>
### Why is some code split into steps and some code not?
The split between code that goes in steps and code that goes into other files
is not completely arbitrary (a bit arbitrary, but not completely). My rule of
thumb is something like this: if the code is specific and necessary for
implementing a Lisp then it belongs in the step files. If the purpose of the
code is for implementing new dynamic data-types/objects and the functions or
methods that operate on those types, then it goes in separate files.
If the target language has types and functions that resemble mal types, then
those files tend to be very small or non-existent. Examples:
* the mal implementation has no types, reader, printer files and
has a trivial core file (just to hoist underlying functions)
* the Clojure implementation has no types file and a fairly trivial
core file
* ruby types and the functions that operate on them are very "Lispy"
so the Ruby types file and core file are very small.
The env file is somewhat more arbitrary, however, it is
a self-contained module that is implemented early and changes very
little after that, so I decided to separate it. Also, for languages
that have hierarchical maps/dictionaries (e.g. Javascript
objects/prototype chain), you do not necessarily need an env file.
Another way of summarizing this answer is that the step files
represent the core of what makes something a Lisp, the rest of the
modules are just language specific details (they may be the harder
than the Lisp part, but that is due to the nature of the target
language not because of Lisp functionality per se).
<a name="steps"></a>
### Why are the mal/make-a-lisp steps structured the way they are?
### OR Why is X functionality in step Y instead of step Z?
There is no single consistent rule that I have used to determine which
functionality goes in which step and the arrangement has changed
numerous times since the beginning of the project. There are several
different goals that I try and balance in determining which
functionality goes into which step:
* **Optimize Lisp learning**: I want developers who are unfamiliar with
Lisp to be able to use the project and guide to learn about Lisp
without becoming overwhelmed. In many Lisp introductions, concepts
like quoting and homoiconicity (i.e. a user exposed eval function)
are introduced early. But these are fairly foreign to most other
languages so they are introduced in later steps in mal. I also try
to not to concentrate too many Lisp concepts in a single step. So
many steps contain one or two Lisp concepts plus some core function
additions that support those concepts.
* **Optimize implementation language learning (equal-ish step
sizing)**: I try to structure the steps so that the target
implementation can be learned incrementally. This goal is the one
that has caused me to refactor the steps the most. Different
languages have different areas that they optimize and make simple
for the developer. For example, in Java (prior to 8) and PostScript
creating the equivalent of anonymous functions and function closures
is painful. In other languages, function closures are trivial, but
IO and error handling are tedious when you are first learning the
language (I am looking at you Haskell). So this goal is really about
trying to balance step size across multiple languages.
* **Practical results early and continuous feedback**: it is
a scientific fact that many small rewards are more motivating than
a single large reward (citation intentionally omitted, get a small
reward by googling it yourself). Each step in mal adds new
functionality that can actually be exercised by the implementer and,
just as importantly, easily tested.
Also, the step structure of mal/make-a-lisp is not perfect. It never
will be perfect, but there are some areas that could be improved. The
most glaring problem is that step1 is on the heavy/large size because
in most languages you have to implement a good portion of the
reader/printer before you can begin using/testing the step. The
compromise I have settled on for now is to put extra detail in the
process guide for step1 and to be clear that many of the types are
deferrable until later. But I am always open to suggestions.
<a name="add_implementation"></a>
### Will you add my new implementation?
Absolutely! I want mal to have a idiomatic implementation in every
programming language.
Here is a quick checklist of what you need to do to merge a new
implementation:
- Follow the incremental layout (no extracted eval code)
- Dockerfile that defines requirements for building and running you
implementation and has this LABEL and
```
LABEL org.opencontainers.image.source=https://github.com/kanaka/mal
```
- Makefile: if it is a compiled/built implementation then add rules
for building each step and a clean rule.
- Add your implementation to IMPLS.yml
- if takes a long time to build add `SLOW: 1`
- Add implemenation to `Makefile.impls`
- Add to `IMPLS` variable (alphabetical order)
- Add a `*_STEP_TO_PROG` line for resolving artifacts to build and
run (if not compiled, just point to the step file itself)
- Update the top-level README.md:
- Increment the implementation and runtime counts
- Add to the table of implementations
- Add a build/run notes sub-section to the `Implementation
Details` section
- Create a pull request (this will trigger CI and allow review)
- Make sure that CI passes for your implementation including
self-hosting (some esoteric languages can have an exception to this)
Here are more detailed guidelines for getting your implementation
accepted into the main repository:
* Your implementation should follow the existing mal steps and
structure: Lisp-centric code (eval, eval_ast, quasiquote,
macroexpand) in the step files, other code in reader, printer, env,
and core files. See [code layout rationale](#code_split) above.
I encourage you to create implementations that take mal in new
directions for your own learning and experimentation, but for it to
be included in the main repository I ask that it follows the steps
and structure.
* Your implementation should stick as much as possible to the accepted
idioms and conventions in that language. Try to create an
implementation that will not make an expert in that language say
"Woah, that's a strange way of doing things". And on that topic,
I make no guarantees that the existing implementations are
particularly idiomatic in their target languages (improvements are
welcome). However, if it is clear to me that your implementation is
not idiomatic in a given language then I will probably ask you to
improve it first.
* Your implementation needs to be complete enough to self-host. This
means that all the mandatory tests should pass in both direct and
self-hosted modes:
```bash
make "test^[IMPL_NAME]"
make MAL_IMPL=[IMPL_NAME] "test^mal"
```
You do not need to pass the final optional tests for stepA that are
marked as optional and not needed for self-hosting (except for the
`time-ms` function which is needed to run the micro-benchmark tests).
* Create a `Dockerfile` in your directory that installs all the
packages necessary to build and run your implementation. In order to
integrate fully with the Github Actions CI workflow, the
`Dockerfile` needs to include the following boilerplate (with your
name, email, and implementation filled in):
```
MAINTAINER Your Name <your@email.com>
LABEL org.opencontainers.image.source=https://github.com/kanaka/mal
LABEL org.opencontainers.image.description="mal test container: Your_Implementation"
```
In addition, the docker image should provide python3 (with a python
symlink to it) to enable running tests using the image. Here is the
typical `Dockerfile` template you should use if your
implementation does not require a special base distro:
```
FROM ubuntu:24.04
MAINTAINER Your Name <your@email.com>
LABEL org.opencontainers.image.source=https://github.com/kanaka/mal
LABEL org.opencontainers.image.description="mal test container: Your_Implementation"
##########################################################
# General requirements for testing or common across many
# implementations
##########################################################
RUN apt-get -y update
# Required for running tests
RUN apt-get -y install make python3
RUN ln -sf /usr/bin/python3 /usr/bin/python
# Some typical implementation and test requirements
RUN apt-get -y install curl libreadline-dev libedit-dev
RUN mkdir -p /mal
WORKDIR /mal
##########################################################
# Specific implementation requirements
##########################################################
... Your packages ...
```
* Build and tag your docker image. The image tag will have the
form `ghcr.io/kanaka/mal-test-[IMPL_NAME]:[VOOM_VERSION]`.
```
make "docker-build^[IMPL_NAME]"
* The top-level Makefile has support for building/testing using
the docker image with the `DOCKERIZE` flag:
```bash
make DOCKERIZE=1 "test^[IMPL_NAME]"
make DOCKERIZE=1 MAL_IMPL=[IMPL_NAME] "test^mal"
```
* Make sure the CI build and test scripts pass locally:
```bash
./ci.sh build [IMPL_NAME]
./ci.sh test [IMPL_NAME]
```
* Push your code to a branch and make sure that the automated Github
Actions CI passes for your implementation.
* If you are creating a new implementation for an existing
implementation (or somebody beats you to the punch while you are
working on it), there is still a chance I will merge your
implementation. If you can make a compelling argument that your
implementation is more idiomatic or significantly better in some way
than the existing implementation then I may replace the existing
one. However, if your approach is different or unique from the
existing implementation, there is still a good chance I will merge
your implementation side-by-side with the existing one. At the very
least, even if I decide not to merge your implementation, I am
certainly willing to link to you implementation once it is
completed.
* You do not need to implement line editing (i.e. readline)
functionality for your implementation, however, it is a nice
convenience for users of your implementation and I personally find
it saves a lot of time when I am creating a new implementation to
have line edit support early in the process.
### Why do some mal forms end in "\*" or "!" (swap!, def!, let\*, etc)?
The forms that end in a bang mutate something:
* **def!** mutates the current environment
* **swap!** and **reset!** mutate an atom to refer to a new value
The forms that end in a star are similar to similar Clojure forms but
are more limited in functionality:
* **fn\*** does not do parameter destructuring and only supports
a single body form.
* **let\*** does not do parameter destructuring
* **try\*** and **catch\*** do not support type matching of
exceptions
================================================
FILE: docs/Hints.md
================================================
# Mal/Make-a-Lisp Implementation Hints
<a name="milliseconds"></a>
### How do I get milliseconds since epoch for the "time-ms" function?
### Does the "time-ms" function have to return millisecond since epoch?
Most languages usually have some way to do this natively even though
it might be buried deeply in the language. If you are having trouble
finding how to do this in your target language, consider asking the
question on stackoverflow (if it has not been asked already) or asking
on a discussion channel for your language because there is a good
chance somebody there knows how and will answer quickly (if there is
a native way at all).
As a last resort you can always shell out and call the date command
like this:
```
date +%s%3N
```
There are currently two implementations where this method was
necessary (probably): bash and make. Unfortunately this method is
limited to Linux/UNIX.
Also, "time-ms" technically just needs to return accurate milliseconds
since some arbitrary point in time (even program start) in order to be
used correctly for timing/benchmarking. For consistency it is best if
it returns epoch milliseconds, but this is not strictly required if
you language limitations make it difficult (e.g. size limit of
integers).
<a name="function_references"></a>
### How do I implement core/native functions if my language does not have any sort of function references (function pointers, closures, lambdas, etc)?
### How do I implement mal functions in step4 if I do not have function references?
There are very few language that do not have any sort of function
references so I suggest asking about the specific problem you are
having on stackoverflow or a discussion channel for your language. In
the rare case where you have a language without some sort of function
reference abstraction, then you may have to implement a single
function with a large switch statement (or equivalent) that calls out
to the appropriate native core function ("+", "list", "throw", etc).
In other words, you create a function that implements "function
references" rather than using a feature of your language. You will
still need to store the symbol names for those function in the base
REPL environment but you will have some sort of tagging or marker that
will indicate to the `EVAL` function that it should call your "big
switch" function.
In addition, if your language has no sort of closure/anonymous
function capability (note that with sufficient object oriented
features you can implement closure like functionality), then in step4
you will need to borrow the way that functions are implemented from
step5. In other words, functions become a normal data type that stores
the function body (AST), the parameter list and the environment at the
time the function is defined. When the function is invoked, `EVAL`
will then evaluate these stored items rather than invoking a function
closure. It is less convenient to have to do this at step4, but the
bright side is that step5 will be simpler because you just have to
implement the TCO loop because you have already refactored how
functions are stored in step4.
<a name="IO"></a>
### How do I implement terminal input and output in a language which does not have standard I/O capabilities?
If your target language has some way to get data in and out while it
is running (even if it is not standard terminal or file I/O) then you
will need to create some sort of wrapper script (see
`vimscript/run_vimscript.sh`) or call out to a shell script (see
`make/readline.mk` and `make/util.mk`) or implement some other
"appropriate" hack to to get the data in and out. As long
as your implementation can be used with the test runner and the hack
is just for working around I/O limitations in your target language,
it is considered legitimate for upstream inclusion.
### How do I read the command-line arguments if my language runtime doesn't support access to them?
Most languages give access to the command-line arguments that were passed to
the program, either as an argument to the `main` function (like `argc` and
`argv` in C) or as a global variable (like `sys.argv` in Python). If your
target language doesn't have such mechanisms, consider adding a wrapper script
that will read the command-line arguments that were passed to the script and
pass them to the program in a way that the program can read. This might be
through an environment variable (if the target language allows reading from
environment variables) or through a temporary file.
<a name="no_reader_object">
### How can I implement the reader without using a mutable object?
You do not need a mutable object, but you do need someway of keeping
track of the current position in the token list. One way to implement
this is to pass both the token list and the current position to the
reader functions (read_form, read_list, read_atom, etc) and return
both the parsed AST and the new token list position. If your language
does not allow multiple values to be returned from functions then you
may need to define a data structure to return both the new position
and the parsed AST together. In other words, the pseudo-code would
look something like this:
```
ast, position = read_list(tokens, position)
```
---
Answers for the following questions are TBD.
### How do I implement slurp in a language without the ability to read raw file data?
<a name="exceptions">
### How do I support raising/throwing arbitrary objects in a language that does not support that?
### What do I do if my implementation language only supports string exceptions?
================================================
FILE: docs/TODO
================================================
General:
* update language graph code and data
- pull from GHA instead of Travis
* Add self-hosted CI mode/variable
* Go through PRs. Close or update.
* Add quick checklist for merging upstream to FAQ:
* Add PR template/checklist.
* Update diagrams to reflect the merged eval-ast/macroexpand
process.
* Check that implementations are actually running self-hosted.
Check for "mal-user>" prompt or something.
* update language graph code and data
* pull from GHA instead of Travis
* update get-changed-files
* use GITHUB_OUTPUT instead of set-output
* update version of node
- Fix self-hosted implementations #662
- Fix wasm modes wax and wace_libc
- Fix wasm perf3 hang/OOM
All/multiple Implementations:
- Add step3 and step4 tests. Fix powershell, jq, and xslt with
binding/closures. https://github.com/kanaka/mal/issues/645
---------------------------------------------
Other ideas for All:
- redefine (defmacro!) as (def! foo (macro*))
- Fix/implement interop in more implementations
- propagate/print errors when self-hosted
- metadata on symbols (as per Clojure)
- metadata as a map only. ^ merges metadata in the reader itself.
Line numbers in metadata from reader.
- protocols!
- https://github.com/pixie-lang/pixie
- http://www.toccata.io/2015/01/Mapping/
- namespaces
- environments first class: *ENV*, *outer* defined by env-new
- namespaces is *namespaces* map in environment which maps namespace
names to other environments.
- def! become an alias for (env-set! *ENV* 'sym value)
- Namespace lookup: go up the environment hierarchy until
a *namespaces* map is found with the namespace name being
looked up. Then the symbol would be looked up starting in
the namespace environment. Need protocols first probably.
- multi-line REPL read
- explicit recur in loops (for error checking)
- gensym reader inside quasiquote
- standalone executables
---------------------------------------------
Bash:
- explore using ${!prefix*} syntax (more like make impl)
- GC
- maybe make it work more like basic/wasm
C:
- come up with better way to do 20 vararg code
C#:
- accumulates line breaks with mal/clojurewest2014.mal
- interop: http://www.ckode.dk/programming/eval-in-c-yes-its-possible/
CoffeeScript:
- make target to compile to JS
Go:
- consider variable arguments in places where it makes sense
https://gobyexample.com/variadic-functions
Haskell:
- TCO using seq/bang patterns:
http://stackoverflow.com/questions/9149183/tail-optimization-guarantee-loop-encoding-in-haskell
- immediately exits mal/clojurewest2014.mal ("\/" exception)
Java:
- build step, don't use mvn in run script
- Use gradle instead of mvn
http://blog.paralleluniverse.co/2014/05/01/modern-java/
Javascript:
- interop: adopt techniques from miniMAL
Make:
- allow '_' in make variable names
- hash-map with space in key string
- errors should propagate up from within load-file
- GC: explore using "undefine" directive in Make 3.82
Mal:
- line numbers in errors
- step5_tco
miniMAL:
- figure out why {} literals are "static"/persistent
ObjPascal:
- verify that GC/reference counting works
- fix comment by itself error at REPL
plpgsql:
- maybe combine wrap.sh and run
Perl:
- fix metadata on native functions
- fix extra line breaks at REPL
Postscript:
- add negative numbers
- fix blank line after comments
- fix command line arg processing (doesn't run file specified)
Powershell:
- convert function with "abc_def" to "abc-def"
- remove extraneous return statements at end of functions
- remove unnecessary semi-colons
- use ArrayList instead of Array for performance
- new test to test Keys/keys as hash-map key
- test *? predicates with nil
R:
- tracebacks in errors
- fix running from different directory
Racket
- metadata on collections
Rust:
- fix 'make all' invocation of cargo build
Scala
- readline
- fix exception when finished running something on command line
VHDL:
- combine run_vhdl.sh and run
vimscript:
- combine run_vimscript.sh and run
================================================
FILE: docs/cheatsheet.html
================================================
<html>
<head>
<style>
h2 {
text-align: center;
}
table {
font-size: 11px;
border-width: 0px;
border-collapse: collapse;
}
table tr {
border: none;
}
table td,th {
border-left: solid 1px #008;
}
table td:first-child, th:first-child {
border-left: none;
}
table td {
vertical-align: top;
padding: 2px;
}
pre {
background: #FCFCF9;
padding: 3px;
border-width: 1px;
border-style: solid;
border-color: lightgrey;
}
.file {
font-weight: 700;
color: #338833;
}
.var {
font-weight: 700;
color: #BB8855;
}
.function {
font-weight: 700;
color: #887744;
}
.object {
font-weight: 700;
color: #DD7744;
}
.malsym {
font-weight: 600;
color: #883333;
}
.string {
font-weight: 400;
color: #994444;
}
</style>
</head>
<body>
<h2>Make-A-Lisp Cheatsheet</h2>
<table align=left>
<tr>
<th>Step 1</th> <th>Step 6</th>
<tr>
<td width=50%>
<!--
<pre><code><span class=file>step0_repl.EXT</span>:
<span class=function>READ</span></span>(<span class=var>ast</span>): passthrough <span class=var>ast</span>
<span class=function>EVAL</span>(<span class=var>ast</span>, <span class=var>env</span>): passthrough <span class=var>ast</span>
<span class=function>PRINT</span>(<span class=var>ast</span>): passthrough <span class=var>ast</span>
<span class=function>main</span>(<span class=var>args</span>): loop: <span class=function>writeline</span> <span class=function>PRINT</span>(<span class=function>EVAL</span>(<span class=function>READ</span>(<span class=function>readline</span>()), <span class=string>""</span>))
</code></pre>
-->
<pre><code><span class=file>reader.EXT</span>:
<span class=object>Reader</span>(<span class=var>tokens</span>) object: <span class=var>position</span>, <span class=function>next</span>(), <span class=function>peek</span>()
<span class=function>tokenize</span>: <span class=string>/[\s,]*(~@|[\[\]{}()'`~^@]|"(?:\\.|[^\\"])*"|;.*|[^\s\[\]{}('"`,;)]*)/</span>
<span class=function>read_atom</span>: int, float, string (escaped), keyword, nil, true, false, symbol
<span class=function>read_list</span>: repeatedly <span class=function>read_form</span> until end token (<span class=object>EOF</span> is error)
<span class=function>read_form</span>: expand reader macros, <span class=function>read_list</span> (vector/maps too), or <span class=function>read_atom</span>
<span class=function>read_str</span>: <span class=function>tokenize</span>, error if no tokens, call <span class=function>read_form</span>(<span class=object>Reader</span>(<span class=var>tokens</span>))
<span class=file>printer.EXT</span>:
<span class=function>pr_str</span>(<span class=var>ast</span>, <span class=var>print_readably</span>):
- map <span class=function>pr_str</span> across collections
- unescape strings if <span class=var>print_readably</span>
<span class=file>step1_read_print.EXT</span>:
<span class=function>main</span>(<span class=var>args</span>): loop: <span class=function>writeline</span> <span class=function>PRINT</span>(<span class=function>EVAL</span>(<span class=function>READ</span>(<span class=function>readline</span>()), <span class=string>""</span>))
</code></pre>
</td>
<td width=50%>
<pre><code><span class=file>core.EXT</span>:
<span class=function>read-string</span>: call <span class=function>reader.read_str</span>
<span class=function>slurp</span>: return file content as a string
<span class=function>atom</span>, <span class=function>atom?</span>, <span class=function>deref</span>, <span class=function>reset!</span>, <span class=function>swap!</span>: atom functions
<span class=file>step6_file.EXT</span>:
<span class=function>main</span>(<span class=var>args</span>):
- add <span class=malsym>eval</span> and <span class=malsym>*ARGV*</span> to <span class=var>repl_env</span>
- define <span class=malsym>load-file</span> using <span class=function>rep</span>
- if <span class=var>args</span>, set <span class=malsym>*ARGV*</span> to rest(<span class=var>args</span>) and call <span class=malsym>load-file</span> with <span class=var>arg</span>s[0]
</code></pre>
</td>
<tr>
<th> </th> <th> </th>
<tr>
<th>Step 2</th> <th>Step 7</th>
<tr>
<td width=50%>
<pre><code><span class=file>step2_eval.EXT</span>:
<span class=function>eval_ast</span>(<span class=var>ast</span>, <span class=var>env</span>): lookup symbols in <span class=var>env</span>, map <span class=function>EVAL</span> across collections
<span class=function>EVAL</span>(<span class=var>ast</span>, <span class=var>env</span>):
- if not list?(<span class=var>ast</span>), return <span class=function>eval_ast</span>(<span class=var>ast</span>, <span class=var>env</span>)
- otherwise apply (<span class=var>ast</span> is a list):
<span class=var>el</span> = <span class=function>eval_ast</span>(<span class=var>ast</span>, <span class=var>env</span>)
return <span class=var>el</span>[0](rest(<span class=var>el</span>))
<span class=function>main</span>(<span class=var>args</span>): loop: <span class=function>writeline</span> <span class=function>PRINT</span>(<span class=function>EVAL</span>(<span class=function>READ</span>(<span class=function>readline</span>()), {<span class=malsym>+</span>: <span class=function>add</span>, ...}))
</code></pre>
</td>
<td width=50%>
<pre><code><span class=file>core.EXT</span>:
<span class=function>cons</span>, <span class=function>concat</span>: sequence functions
<span class=file>step7_quote.EXT</span>:
<span class=function>quasiquote</span>(ast):
- <span class=var>ast</span> is empty or not a list -> (<span class=malsym>quote</span> <span class=var>ast</span>)
- (<span class=malsym>unquote</span> FOO) -> FOO
- ((<span class=malsym>splice-unquote</span> FOO) BAR..) -> (<span class=malsym>concat</span> FOO <span class=function>quasiquote</span>(BAR...))</span>
- (FOO BAR...) -> (<span class=malsym>cons</span> FOO <span class=function>quasiquote</span>(BAR...))</span>
<span class=function>EVAL</span>(<span class=var>ast</span>, <span class=var>env</span>):
- <span class=malsym>quote</span> -> return <span class=var>ast</span>[1]
- <span class=malsym>quasiquote</span> -> set <span class=var>ast</span> to <span class=function>quasiquote</span>(<span class=var>ast</span>[1]), loop
</code></pre>
</td>
<tr>
<th> </th> <th> </th>
<tr>
<th>Step 3</th> <th>Step 8</th>
<tr>
<td width=50%>
<pre><code><span class=file>env.EXT</span>:
<span class=object>Env</span>(<span class=var>outer</span>) object: <span class=var>data</span>, <span class=function>set</span>(<span class=var>k</span>, <span class=var>v</span>), <span class=function>find</span>(<span class=var>k</span>), <span class=function>get</span>(<span class=var>k</span>)
<span class=file>step3_env.EXT</span>:
<span class=function>eval_ast</span>(<span class=var>ast</span>, <span class=var>env</span>): switch to <span class=var>env</span>.<span class=function>get</span> for symbol lookup
<span class=function>EVAL</span>(<span class=var>ast</span>, <span class=var>env</span>):
- <span class=malsym>def!</span> -> return <span class=var>env</span>.<span class=function>set</span>(<span class=var>ast</span>[1], <span class=function>EVAL</span>(<span class=var>ast</span>[2], <span class=var>env</span>))
- <span class=malsym>let*</span> -> create new env <span class=var>let_env</span>
for each ODD/EVEN pair in <span class=var>ast[1]</span>:
<span class=var>let_env</span>.<span class=function>set</span>(ODD, <span class=function>EVAL</span>(EVEN, <span class=var>let_env</span>))
return <span class=function>EVAL</span>(<span class=var>ast</span>[2], <span class=var>let_env</span>)
<span class=function>main</span>(<span class=var>args</span>): populate <span class=var>repl_env</span> with numeric functions using <span class=var>repl_env</span>.<span class=function>set</span>
</code></pre>
</td>
<td width=50%>
<pre><code><span class=file>core.EXT</span>:
<span class=function>nth</span>, <span class=function>first</span>, <span class=function>rest</span>: sequence functions
<span class=file>step8_macros.EXT</span>:
<span class=function>macroexpand</span>(<span class=var>ast</span>, <span class=var>env</span>):
- while <span class=var>env</span>.<span class=function>get</span>(<span class=var>ast</span>[0]) is a macro: <span class=var>ast</span> = <span class=var>env</span>.<span class=function>get</span>(<span class=var>ast</span>[0])(rest(<span class=var>ast</span>))
<span class=function>EVAL</span>(<span class=var>ast</span>, <span class=var>env</span>):
- before apply section, add <span class=var>ast</span> = <span class=function>macroexpand</span>(<span class=var>ast</span>, <span class=var>env</span>)
- <span class=malsym>defmacro!</span> -> same as <span class=malsym>def!</span>, but set mal function macro flag
- <span class=malsym>macroexpand</span> -> return <span class=function>macroexpand</span>(<span class=var>ast</span>[1], <span class=var>env</span>)
</code></pre>
</td>
<tr>
<th> </th> <th> </th>
<tr>
<th>Step 4</th> <th>Step 9</th>
<tr>
<td width=50%>
<pre><code><span class=file>env.EXT</span>:
<span class=object>Env</span>(<span class=var>outer</span>, <span class=var>binds</span>, <span class=var>exprs</span>) object: map <span class=var>binds</span> to <span class=var>exprs</span>, handle <span class=string>"&"</span> as variadic
<span class=file>core.EXT</span>:
<span class=function>=</span>: recursive compare of collections
<span class=function>pr-str</span>, <span class=function>str</span>: return <span class=function>pr_str</span>(<span class=function>arg</span>, true) join <span class=string>" "</span>, <span class=function>pr_str</span>(<span class=function>arg</span>, false) join <span class=string>""</span>
<span class=function>prn</span>, <span class=function>println</span>: print <span class=function>pr_str</span>(<span class=function>arg</span>, true) join <span class=string>""</span>, <span class=function>pr_str</span>(<span class=function>arg</span>, false) join <span class=string>""</span>
<span class=function><</span>, <span class=function><=</span>, <span class=function>></span>, <span class=function>>=</span>, <span class=function>+</span>, <span class=function>-</span>, <span class=function>*</span>, <span class=function>/</span>: numeric comparison and numeric operations
<span class=function>list</span>, <span class=function>list?</span>, <span class=function>empty?</span>, <span class=function>count</span>: sequence functions
<span class=file>step4_do_if_fn.EXT</span>:
<span class=function>EVAL</span>(<span class=var>ast</span>, <span class=var>env</span>):
- <span class=malsym>do</span> -> return last element of <span class=function>eval_ast</span>(<span class=var>ast</span>, <span class=var>env</span>)
- <span class=malsym>if</span> -> if <span class=function>EVAL</span>(<span class=var>ast[1]</span>, <span class=var>env</span>): return <span class=function>EVAL</span>(<span class=var>ast[2]</span>, <span class=var>env</span>)
else : return <span class=function>EVAL</span>(<span class=var>ast[3]</span>, <span class=var>env</span>)
- <span class=malsym>fn*</span> -> return closure:
(<span class=var>args</span>) -> <span class=function>EVAL</span>(<span class=var>ast</span>[2], new <span class=object>Env</span>(<span class=var>env</span>, <span class=var>ast</span>[1], <span class=var>args</span>))
<span class=function>main</span>(<span class=var>args</span>): populate <span class=var>repl_env</span> with core functions, define not using <span class=function>rep</span>()
</code></pre>
</td>
<td width=50%>
<pre><code><span class=file>core.EXT</span>:
<span class=function>throw</span>: raise mal value as exception (maybe wrap in native exception)
<span class=function>vector</span>, <span class=function>vector?</span>: sequence functions
<span class=function>hash-map</span>, <span class=function>get</span>, <span class=function>contains?</span>, <span class=function>keys</span>, <span class=function>vals</span>: hash-map functions
<span class=function>assoc</span>, <span class=function>dissoc</span>: immutable hash-map transform functions
<span class=function>apply</span>(<span class=var>f</span>, <span class=var>args...</span>, <span class=var>last</span>): return <span class=function>f</span>(<span class=function>concat</span>(<span class=var>args</span>, <span class=var>last</span>))
<span class=function>map</span>(<span class=var>f</span>, <span class=var>args</span>): return list of mapping <span class=function>f</span> on each <span class=var>args</span>
<span class=file>step9_try.EXT</span>:
<span class=function>EVAL</span>(<span class=var>ast</span>, <span class=var>env</span>):
- <span class=malsym>try*</span> -> try <span class=function>EVAL</span>(<span class=var>ast</span>[1], <span class=var>env</span>)
catch exception <span class=var>exc</span> (unwrap if necessary):
new <span class=var>err_env</span> with <span class=var>ast</span>[2][1] symbol bound to <span class=var>exc</span>
<span class=function>EVAL</span>(<span class=var>ast</span>[2][2], <span class=var>err_env</span>)
</code></pre>
</td>
<tr>
<th> </th> <th> </th>
<tr>
<th>Step 5</th> <th>Step A</th>
<tr>
<td width=50%>
<pre><code><span class=file>step5_tco.EXT</span>:
<span class=function>EVAL</span>(<span class=var>ast</span>, <span class=var>env</span>):
- top level loop in <span class=function>EVAL</span>
- <span class=malsym>let*</span> -> set <span class=var>env</span> to <span class=var>let_env</span>, set <span class=var>ast</span> to <span class=var>ast</span>[2], loop
- <span class=malsym>do</span> -> <span class=function>eval_ast</span> of middle elements, sets <span class=var>ast</span> to last element, loop
- <span class=malsym>if</span> -> set <span class=var>ast</span> to <span class=var>ast</span>[2] or <span class=var>ast</span>[3] (or <span class=malsym>nil</span>) depending condition, loop
- <span class=malsym>fn*</span> -> return new mal function type <span class=var>f</span> with:
<span class=var>f</span>.<span class=var>ast</span>=<span class=var>ast</span>[2], <span class=var>f</span>.<span class=var>params</span>=<span class=var>ast</span>[1], <span class=var>f</span>.<span class=var>env</span>=<span class=var>env</span>
- apply -> <span class=var>el</span> = <span class=function>eval_ast</span>(<span class=var>ast</span>, <span class=var>env</span>)
<span class=var>f</span> = <span class=var>el</span>[0]
if <span class=var>f</span> is a mal function: <span class=var>ast</span> = <span class=var>f</span>.<span class=var>ast</span> and <span class=var>env</span> = <span class=var>f</span>.<span class=var>env</span>, loop
else : return <span class=var>el</span>[0](rest(<span class=var>el</span>))
</code></pre>
</td>
<td width=50%>
<pre><code><span class=file>core.EXT</span>:
<span class=function>string?</span>: true if string
<span class=function>readline</span>: prompt and read a line of input (synchronous)
<span class=function>time-ms</span>: return milliseconds since epoch (1970-1-1)
<span class=function>conj</span>, <span class=function>seq</span>: type specific sequence functions
<span class=function>meta</span>, <span class=function>with-meta</span>: metadata functions
<span class=file>step9_try.EXT</span>:
<span class=function>EVAL</span>(<span class=var>ast</span>, <span class=var>env</span>):
- set <span class=malsym>*host-language*</span> in <span class=var>repl_env</span> to host language name
<span class=function>main</span>(<span class=var>args</span>): <span class=function>rep</span>(<span class=string>"(println (str \"Mal [\" <span class=malsym>*host-language*</span> \"]\"))"</span>)
</code></pre>
</td>
<tr>
<th> </th> <th> </th>
</table>
</body>
</html>
================================================
FILE: docs/exercises.md
================================================
# Exercises to learn MAL
The process introduces LISP by describing the internals of selected
low-level constructs. As a complementary and more traditional
approach, you may want to solve the following exercises in the MAL
language itself, using any of the existing implementations.
You are encouraged to use the shortcuts defined in the step files
(`not`...) and `the `lib/` subdirectory (`reduce`...) whenever you
find that they increase the readability.
The difficulty is progressive in each section, but they focus on
related topics and it is recommended to start them in parallel.
Some solutions are given in the `examples` directory. Feel free to
submit new solutions, or new exercises.
## Replace parts of the process with native constructs
Once you have a working implementation, you may want to implement
parts of the process inside the MAL language itself. This has no other
purpose than learning the MAL language. Once it exists, a built-in
implementation will always be more efficient than a native
implementation. Also, the functions described in MAL process are
selected for educative purposes, so portability accross
implementations does not matter much.
You may easily check your answers by passing them directly to the
interpreter. They will hide the built-in functions carrying the same
names, and the usual tests will check them.
```
make REGRESS=1 TEST_OPTS='--hard --pre-eval=\(load-file\ \"../answer.mal\"\)' test^IMPL^stepA
```
- Implement `nil?`, `true?`, `false?`, `empty?` and `sequential` with
another built-in function.
- Implement `>`, `<=` and `>=` with `<`.
- Implement `list`, `vec`, `prn`, `hash-map` and `swap!` as non-recursive
functions.
- Implement `count`, `nth`, `map`, `concat` and `conj` with the empty
constructor `()`, `empty?`, `cons`, `first` and `rest`.
You may use `or` to make the definition of `nth` a bit less ugly,
but avoid `cond` because its definition refers to `nth`.
Let `count` and `nth` benefit from tail call optimization.
Try to replace explicit recursions with calls to `reduce` and `foldr`.
Once you have tested your solution, you should comment at least
`nth`. Many implementations, for example `foldr` in `core.mal`,
rely on an efficient `nth` built-in function.
- Implement the `do` special as a non-recursive function. The special
form will hide your implementation, so in order to test it, you will
need to give it another name and adapt the test accordingly.
- Implement quoting with macros.
The same remark applies.
- Implement most of `let*` as a macro that uses `fn*` and recursion.
The same remark applies.
A macro is necessary because a function would attempt to evaluate
the first argument.
Once your answer passes most tests and you understand which part is
tricky, you should search for black magic recipes on the web. Few of
us mortals are known to have invented a full solution on their own.
- Implement `apply`.
- Implement maps using lists.
- Recall how maps must be evaluated.
- In the tests, you may want to replace `{...}` with `(hash-map ...)`.
- An easy solution relies on lists alterning keys and values, so
that the `hash-map` is only a list in reverse order so that the
last definition takes precedence during searches.
- As a more performant solution will use lists to construct trees,
and ideally keep them balanced. You will find examples in most
teaching material about functional languages.
- Recall that `dissoc` is an optional feature. One you can implement
dissoc is by assoc'ing a replacement value that is a magic delete
keyword (e.g.: `__..DELETED..__`) which allows you to shadow
values in the lower levels of the structure. The hash map
functions have to detect that and do the right thing. e.g. `(keys
...)` might have to keep track of deleted values as it is scanning
the tree and not add those keys when it finds them further down
the tree.
- Implement macros within MAL.
## More folds
- Compute the sum of a sequence of numbers.
- Compute the product of a sequence of numbers.
- Compute the logical conjunction ("and") and disjunction ("or") of a
sequence of MAL values interpreted as boolean values. For example,
`(conjunction [true 1 0 "" "a" nil true {}])`
should evaluate to `false` or `nil` because of the `nil` element.
Why are folds not the best solution here, in terms of average
performances?
- Does "-2-3-4" translate to `(reduce - 0 [2 3 4])`?
- Suggest better solutions for
`(reduce str "" xs)` and
`(reduce concat [] xs)`.
- What does `(reduce (fn* [acc _] acc) xs)` nil answer?
- The answer is `(fn* [xs] (reduce (fn* [_ x] x) nil xs))`.
What was the question?
- What is the intent of
`(reduce (fn* [acc x] (if (< acc x) x acc)) 0 xs)`?
Why is it the wrong answer?
- Though `(sum (map count xs))` or `(count (apply concat xs))` can be
considered more readable, implement the same effect with a single loop.
- Compute the maximal length in a list of lists.
- How would you name
`(fn* [& fs] (foldr (fn* [f acc] (fn* [x] (f (acc x)))) identity fs))`?
================================================
FILE: docs/graph/README.md
================================================
# Mal Implementation Stats Graph
## Updating the data
* Install prerequisites:
For ubuntu:
```
sudo apt-get install gh
sudo apt-get golang
```
For macos:
```
brew install gh
brew install go
```
* Create logs dir and enter graph dir:
```
mkdir -p docs/graph/logs
cd docs/graph/logs
```
* Install npm deps
```
npm install
```
* Clone and build loccount:
```
git clone https://gitlab.com/esr/loccount
make -C loccount
```
* Auth with github:
```
gh auth login
```
* Download artifacts from a recent full and successful workflow run:
```
# list workflow runs
$ gh run list --repo kanaka/mal
# Download recent full successful run:
$ gh run download 10598199016 --repo kanaka/mal
```
* Run the [StackOverflow tags
query](https://data.stackexchange.com/stackoverflow/query/edit/1013465)
and then download the CSV link:
```
curl https://data.stackexchange.com/stackoverflow/csv/2267200 -o so-tags.csv
```
* Remove/clean all generated files:
```
( cd ../.. && git ls-files --others impls/ | xargs rm )
```
* Download GitHub and StackOverflow data and generate the final
combined data set:
```
PATH=$PATH:$(pwd)/loccount
time VERBOSE=1 node ./collect_data.js logs/ all_data.json
```
================================================
FILE: docs/graph/all_data.json
================================================
{
"ada": {
"dir": "ada",
"name": "Ada",
"syntax": "Algol",
"type_check": "Static",
"modes": [],
"perf1": 10,
"perf2": 44,
"perf3": 974,
"pull_count": 261,
"pull_rank": 66,
"push_count": 19718,
"push_rank": 60,
"star_count": 554,
"star_rank": 68,
"sloc": 3547,
"files": 19,
"author_name": "Chris Moore",
"author_url": "https://github.com/zmower",
"so_count": 2416,
"so_rank": 57,
"lloc": 2199
},
"ada.2": {
"dir": "ada.2",
"name": "Ada #2",
"syntax": "Algol",
"type_check": "Static",
"modes": [],
"perf1": 1,
"perf2": 1,
"perf3": 84457,
"pull_count": 261,
"pull_rank": 67,
"push_count": 19718,
"push_rank": 61,
"star_count": 554,
"star_rank": 69,
"sloc": 2277,
"files": 30,
"author_name": "Nicolas Boulenguez",
"author_url": "https://github.com/asarhaddon",
"so_count": 2416,
"so_rank": 58,
"lloc": 1437
},
"awk": {
"dir": "awk",
"name": "GNU Awk",
"syntax": "C",
"type_check": "Dynamic",
"modes": [],
"perf1": 7,
"perf2": 24,
"perf3": 1356,
"pull_count": 2,
"pull_rank": 71,
"push_count": null,
"push_rank": null,
"star_count": 13346,
"star_rank": 54,
"sloc": 2203,
"files": 7,
"author_name": "Miutsuru Kariya",
"author_url": "https://github.com/kariya-mitsuru",
"so_count": 33144,
"so_rank": 30,
"lloc": 0
},
"bash": {
"dir": "bash",
"name": "Bash 4",
"syntax": "OTHER",
"type_check": "Dynamic",
"modes": [],
"perf1": 787,
"perf2": 3465,
"perf3": 11,
"pull_count": 921358,
"pull_rank": 16,
"push_count": 3851409,
"push_rank": 16,
"star_count": 2264769,
"star_rank": 18,
"sloc": 1110,
"files": 7,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 156259,
"so_rank": 17,
"lloc": 0
},
"basic": {
"dir": "basic",
"name": "BASIC",
"syntax": "OTHER",
"type_check": "Static",
"modes": [
"cbm",
"qbasic"
],
"perf1": 6,
"perf2": 19,
"perf3": 1675,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 1960,
"files": 13,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 858,
"so_rank": 65,
"lloc": 1697
},
"bbc-basic": {
"dir": "bbc-basic",
"name": "BBC BASIC V",
"syntax": "OTHER",
"type_check": "Static",
"modes": [],
"perf1": 60,
"perf2": 290,
"perf3": 149,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 1355,
"files": 7,
"author_name": "Ben Harris",
"author_url": "https://github.com/bjh21",
"so_count": 9,
"so_rank": 85,
"lloc": 1353
},
"c": {
"dir": "c",
"name": "C",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 0,
"perf2": 1,
"perf3": 36416,
"pull_count": 1411773,
"pull_rank": 13,
"push_count": 5888004,
"push_rank": 11,
"star_count": 4085282,
"star_rank": 10,
"sloc": 1990,
"files": 15,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 405875,
"so_rank": 10,
"lloc": 1069
},
"c.2": {
"dir": "c.2",
"name": "C #2",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 1,
"perf2": 3,
"perf3": 15820,
"pull_count": 1411773,
"pull_rank": 14,
"push_count": 5888004,
"push_rank": 12,
"star_count": 4085282,
"star_rank": 11,
"sloc": 3326,
"files": 16,
"author_name": "Duncan Watts",
"author_url": "https://github.com/fungiblecog",
"so_count": 405875,
"so_rank": 11,
"lloc": 1677
},
"cpp": {
"dir": "cpp",
"name": "C++",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 0,
"perf2": 1,
"perf3": 33490,
"pull_count": 2960837,
"pull_rank": 7,
"push_count": 10016021,
"push_rank": 8,
"star_count": 5571338,
"star_rank": 8,
"sloc": 2021,
"files": 19,
"author_name": "Stephen Thirlwall",
"author_url": "https://github.com/sdt",
"so_count": 887548,
"so_rank": 7,
"lloc": 945
},
"cs": {
"dir": "cs",
"name": "C#",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 4,
"perf2": 5,
"perf3": 24285,
"pull_count": 1264911,
"pull_rank": 15,
"push_count": 4838573,
"push_rank": 14,
"star_count": 2687097,
"star_rank": 17,
"sloc": 1185,
"files": 9,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 1652013,
"so_rank": 5,
"lloc": 582
},
"chuck": {
"dir": "chuck",
"name": "ChucK",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 24,
"perf2": 70,
"perf3": 142,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 2509,
"files": 87,
"author_name": "Vasilij Schneidermann",
"author_url": "https://github.com/wasamasa",
"so_count": 22,
"so_rank": 83,
"lloc": 963
},
"clojure": {
"dir": "clojure",
"name": "Clojure",
"syntax": "Lisp",
"type_check": "Dynamic",
"modes": [
"clj",
"cljs"
],
"perf1": 10,
"perf2": 34,
"perf3": 7675,
"pull_count": 118302,
"pull_rank": 27,
"push_count": 556345,
"push_rank": 26,
"star_count": 296560,
"star_rank": 25,
"sloc": 408,
"files": 9,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 17703,
"so_rank": 37,
"lloc": 0
},
"coffee": {
"dir": "coffee",
"name": "CoffeeScript",
"syntax": "OTHER",
"type_check": "Dynamic",
"modes": [],
"perf1": 2,
"perf2": 6,
"perf3": 33096,
"pull_count": 135423,
"pull_rank": 26,
"push_count": 596268,
"push_rank": 25,
"star_count": 587936,
"star_rank": 21,
"sloc": 447,
"files": 8,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 9742,
"so_rank": 42,
"lloc": 0
},
"common-lisp": {
"dir": "common-lisp",
"name": "Common Lisp",
"syntax": "Lisp",
"type_check": "Dynamic",
"modes": [],
"perf1": 1,
"perf2": 2,
"perf3": 35135,
"pull_count": 9583,
"pull_rank": 49,
"push_count": 85811,
"push_rank": 44,
"star_count": 52545,
"star_rank": 39,
"sloc": 1000,
"files": 11,
"author_name": "Iqbal Ansari",
"author_url": "https://github.com/iqbalansari",
"so_count": 6341,
"so_rank": 49,
"lloc": 0
},
"crystal": {
"dir": "crystal",
"name": "Crystal",
"syntax": "OTHER",
"type_check": "Static",
"modes": [],
"perf1": 1,
"perf2": 1,
"perf3": 64175,
"pull_count": 11247,
"pull_rank": 48,
"push_count": 35005,
"push_rank": 52,
"star_count": 29422,
"star_rank": 47,
"sloc": 944,
"files": 8,
"author_name": "Linda_pp",
"author_url": "https://github.com/rhysd",
"so_count": 662,
"so_rank": 67,
"lloc": 0
},
"d": {
"dir": "d",
"name": "D",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 0,
"perf2": 0,
"perf3": 41431,
"pull_count": 8541,
"pull_rank": 52,
"push_count": 71800,
"push_rank": 49,
"star_count": 23317,
"star_rank": 48,
"sloc": 1281,
"files": 8,
"author_name": "Dov Murik",
"author_url": "https://github.com/dubek",
"so_count": 2644,
"so_rank": 56,
"lloc": 549
},
"dart": {
"dir": "dart",
"name": "Dart",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 5,
"perf2": 10,
"perf3": 17398,
"pull_count": 182518,
"pull_rank": 22,
"push_count": 245271,
"push_rank": 34,
"star_count": 280006,
"star_rank": 26,
"sloc": 935,
"files": 8,
"author_name": "Harry Terkelsen",
"author_url": "https://github.com/hterkelsen",
"so_count": 94667,
"so_rank": 23,
"lloc": 467
},
"elixir": {
"dir": "elixir",
"name": "Elixir",
"syntax": "OTHER",
"type_check": "Dynamic",
"modes": [],
"perf1": 17,
"perf2": 43,
"perf3": 839,
"pull_count": 118076,
"pull_rank": 28,
"push_count": 266735,
"push_rank": 33,
"star_count": 216415,
"star_rank": 27,
"sloc": 669,
"files": 10,
"author_name": "Martin Ek",
"author_url": "https://github.com/ekmartin",
"so_count": 9601,
"so_rank": 44,
"lloc": 0
},
"elm": {
"dir": "elm",
"name": "Elm",
"syntax": "ML",
"type_check": "Static",
"modes": [],
"perf1": 19,
"perf2": 55,
"perf3": 1971,
"pull_count": 12978,
"pull_rank": 46,
"push_count": 59552,
"push_rank": 51,
"star_count": 38261,
"star_rank": 43,
"sloc": 2404,
"files": 13,
"author_name": "Jos van Bakel",
"author_url": "https://github.com/c0deaddict",
"so_count": 1895,
"so_rank": 61,
"lloc": 0
},
"elisp": {
"dir": "elisp",
"name": "Emacs Lisp",
"syntax": "Lisp",
"type_check": "Dynamic",
"modes": [],
"perf1": 1,
"perf2": 14,
"perf3": 5600,
"pull_count": 69374,
"pull_rank": 34,
"push_count": 366344,
"push_rank": 29,
"star_count": 207304,
"star_rank": 30,
"sloc": 725,
"files": 7,
"author_name": "Vasilij Schneidermann",
"author_url": "https://github.com/wasamasa",
"so_count": 3771,
"so_rank": 54,
"lloc": 0
},
"erlang": {
"dir": "erlang",
"name": "Erlang",
"syntax": "OTHER",
"type_check": "Dynamic",
"modes": [],
"perf1": 32,
"perf2": 62,
"perf3": 344,
"pull_count": 79420,
"pull_rank": 31,
"push_count": 285722,
"push_rank": 31,
"star_count": 149139,
"star_rank": 31,
"sloc": 1130,
"files": 8,
"author_name": "Nathan Fiedler",
"author_url": "https://github.com/nlfiedler",
"so_count": 9674,
"so_rank": 43,
"lloc": 0
},
"es6": {
"dir": "es6",
"name": "ES6",
"syntax": "C",
"type_check": "Dynamic",
"modes": [],
"perf1": 1,
"perf2": 3,
"perf3": 30500,
"pull_count": 6754454,
"pull_rank": 2,
"push_count": 24043941,
"push_rank": 2,
"star_count": 25547072,
"star_rank": 2,
"sloc": 474,
"files": 8,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 519108,
"so_rank": 8,
"lloc": 0
},
"fsharp": {
"dir": "fsharp",
"name": "F#",
"syntax": "ML",
"type_check": "Static",
"modes": [],
"perf1": 6,
"perf2": 6,
"perf3": 35952,
"pull_count": 32510,
"pull_rank": 37,
"push_count": 145642,
"push_rank": 38,
"star_count": 44240,
"star_rank": 42,
"sloc": 1074,
"files": 11,
"author_name": "Peter Stephens",
"author_url": "https://github.com/pstephens",
"so_count": 18116,
"so_rank": 36,
"lloc": 2
},
"fennel": {
"dir": "fennel",
"name": "Fennel",
"syntax": "Lisp",
"type_check": "Dynamic",
"modes": [],
"perf1": 2301,
"perf2": 7241,
"perf3": 4,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 1,
"files": 1,
"author_name": "sogaiu",
"author_url": "https://github.com/sogaiu",
"so_count": 3,
"so_rank": 88,
"lloc": 0
},
"factor": {
"dir": "factor",
"name": "Factor",
"syntax": "Stack",
"type_check": "Dynamic",
"modes": [],
"perf1": 1,
"perf2": 2,
"perf3": 40360,
"pull_count": 421,
"pull_rank": 63,
"push_count": 10507,
"push_rank": 66,
"star_count": 100,
"star_rank": 71,
"sloc": 394,
"files": 8,
"author_name": "Jordan Lewis",
"author_url": "https://github.com/jordanlewis",
"so_count": 65,
"so_rank": 78,
"lloc": 0
},
"fantom": {
"dir": "fantom",
"name": "Fantom",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 7,
"perf2": 16,
"perf3": 109845,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 733,
"files": 9,
"author_name": "Dov Murik",
"author_url": "https://github.com/dubek",
"so_count": 63,
"so_rank": 79,
"lloc": 0
},
"forth": {
"dir": "forth",
"name": "Forth",
"syntax": "Stack",
"type_check": "OTHER",
"modes": [],
"perf1": 37,
"perf2": 147,
"perf3": 291,
"pull_count": 32,
"pull_rank": 69,
"push_count": 1926,
"push_rank": 68,
"star_count": 632,
"star_rank": 67,
"sloc": 1415,
"files": 8,
"author_name": "Chris Houser",
"author_url": "https://github.com/chouser",
"so_count": 299,
"so_rank": 72,
"lloc": 0
},
"guile": {
"dir": "guile",
"name": "GNU Guile",
"syntax": "Lisp",
"type_check": "Dynamic",
"modes": [],
"perf1": 1,
"perf2": 2,
"perf3": 15138,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 735,
"files": 9,
"author_name": "Mu Lei",
"author_url": "https://github.com/NalaGinrut",
"so_count": 262,
"so_rank": 73,
"lloc": 0
},
"gnu-smalltalk": {
"dir": "gnu-smalltalk",
"name": "GNU Smalltalk",
"syntax": "OTHER",
"type_check": "Dynamic",
"modes": [],
"perf1": 7,
"perf2": 21,
"perf3": 1709,
"pull_count": 13447,
"pull_rank": 44,
"push_count": 69848,
"push_rank": 50,
"star_count": 4823,
"star_rank": 61,
"sloc": 1005,
"files": 10,
"author_name": "Vasilij Schneidermann",
"author_url": "https://github.com/wasamasa",
"so_count": 115,
"so_rank": 75,
"lloc": 0
},
"go": {
"dir": "go",
"name": "Go",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 0,
"perf2": 0,
"perf3": 72067,
"pull_count": 2795669,
"pull_rank": 8,
"push_count": 5100633,
"push_rank": 13,
"star_count": 7730404,
"star_rank": 7,
"sloc": 1412,
"files": 9,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 73691,
"so_rank": 24,
"lloc": 673
},
"groovy": {
"dir": "groovy",
"name": "Groovy",
"syntax": "C",
"type_check": "Dynamic",
"modes": [],
"perf1": 64,
"perf2": 127,
"perf3": 1685,
"pull_count": 141340,
"pull_rank": 24,
"push_count": 473823,
"push_rank": 28,
"star_count": 148765,
"star_rank": 32,
"sloc": 672,
"files": 8,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 30295,
"so_rank": 31,
"lloc": 0
},
"haskell": {
"dir": "haskell",
"name": "Haskell",
"syntax": "ML",
"type_check": "Static",
"modes": [],
"perf1": 1,
"perf2": 6,
"perf3": 6558,
"pull_count": 114458,
"pull_rank": 29,
"push_count": 732765,
"push_rank": 23,
"star_count": 334357,
"star_rank": 24,
"sloc": 712,
"files": 8,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 51449,
"so_rank": 27,
"lloc": 0
},
"haxe": {
"dir": "haxe",
"name": "Haxe",
"syntax": "C",
"type_check": "Static",
"modes": [
"neko",
"python",
"cpp",
"js"
],
"perf1": 2,
"perf2": 4,
"perf3": 62403,
"pull_count": 13654,
"pull_rank": 43,
"push_count": 74768,
"push_rank": 48,
"star_count": 33782,
"star_rank": 44,
"sloc": 1089,
"files": 11,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 1635,
"so_rank": 62,
"lloc": 454
},
"hy": {
"dir": "hy",
"name": "Hy",
"syntax": "Lisp",
"type_check": "Dynamic",
"modes": [],
"perf1": 10,
"perf2": 37,
"perf3": 1030,
"pull_count": 8,
"pull_rank": 70,
"push_count": null,
"push_rank": null,
"star_count": 308,
"star_rank": 70,
"sloc": 388,
"files": 7,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 101,
"so_rank": 76,
"lloc": 0
},
"io": {
"dir": "io",
"name": "Io",
"syntax": "OTHER",
"type_check": "Dynamic",
"modes": [],
"perf1": 113,
"perf2": 423,
"perf3": 78,
"pull_count": 72,
"pull_rank": 68,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 538,
"files": 7,
"author_name": "Dov Murik",
"author_url": "https://github.com/dubek",
"so_count": 17620,
"so_rank": 38,
"lloc": 0
},
"java": {
"dir": "java",
"name": "Java",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 2,
"perf2": 10,
"perf3": 182169,
"pull_count": 4219162,
"pull_rank": 5,
"push_count": 15173396,
"push_rank": 5,
"star_count": 9695699,
"star_rank": 5,
"sloc": 1511,
"files": 9,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 1919299,
"so_rank": 4,
"lloc": 696
},
"java-truffle": {
"dir": "java-truffle",
"name": "Java Truffle",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 5,
"perf2": 13,
"perf3": 163894,
"pull_count": 4219162,
"pull_rank": 6,
"push_count": 15173396,
"push_rank": 6,
"star_count": 9695699,
"star_rank": 6,
"sloc": 5827,
"files": 12,
"author_name": "Matt McGill",
"author_url": "https://github.com/mmcgill",
"so_count": 897,
"so_rank": 64,
"lloc": 2811
},
"js": {
"dir": "js",
"name": "JavaScript",
"syntax": "C",
"type_check": "Dynamic",
"modes": [],
"perf1": 1,
"perf2": 4,
"perf3": 43462,
"pull_count": 6754454,
"pull_rank": 1,
"push_count": 24043941,
"push_rank": 1,
"star_count": 25547072,
"star_rank": 1,
"sloc": 856,
"files": 10,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 4346255,
"so_rank": 1,
"lloc": 0
},
"jq": {
"dir": "jq",
"name": "jq",
"syntax": "OTHER",
"type_check": "Dynamic",
"modes": [],
"perf1": null,
"perf2": null,
"perf3": 0,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 88,
"files": 2,
"author_name": "Ali MohammadPur",
"author_url": "https://github.com/alimpfard",
"so_count": 6778,
"so_rank": 48,
"lloc": 0
},
"janet": {
"dir": "janet",
"name": "Janet",
"syntax": "Lisp",
"type_check": "Dynamic",
"modes": [],
"perf1": 7,
"perf2": 26,
"perf3": 1846,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 1,
"files": 1,
"author_name": "sogaiu",
"author_url": "https://github.com/sogaiu",
"so_count": 3,
"so_rank": 89,
"lloc": 0
},
"julia": {
"dir": "julia",
"name": "Julia",
"syntax": "Algol",
"type_check": "Dynamic",
"modes": [],
"perf1": 115,
"perf2": 13,
"perf3": 8375,
"pull_count": 41276,
"pull_rank": 36,
"push_count": 174375,
"push_rank": 36,
"star_count": 54307,
"star_rank": 38,
"sloc": 560,
"files": 8,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 12754,
"so_rank": 40,
"lloc": 0
},
"kotlin": {
"dir": "kotlin",
"name": "Kotlin",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 8,
"perf2": 19,
"perf3": 114806,
"pull_count": 368780,
"pull_rank": 20,
"push_count": 853297,
"push_rank": 21,
"star_count": 577249,
"star_rank": 22,
"sloc": 741,
"files": 8,
"author_name": "Javier Fernandez-Ivern",
"author_url": "https://github.com/ivern",
"so_count": 96732,
"so_rank": 21,
"lloc": 0
},
"latex3": {
"dir": "latex3",
"name": "LaTeX3",
"syntax": "Other",
"type_check": "Dynamic",
"modes": [],
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 1131,
"files": 7,
"author_name": "Nicolas Boulenguez",
"author_url": "https://github.com/asarhaddon",
"so_count": 11509,
"so_rank": 41,
"lloc": 0
},
"livescript": {
"dir": "livescript",
"name": "LiveScript",
"syntax": "ML",
"type_check": "Dynamic",
"modes": [],
"perf1": 4,
"perf2": 10,
"perf3": 16804,
"pull_count": 327,
"pull_rank": 64,
"push_count": 8343,
"push_rank": 67,
"star_count": 9631,
"star_rank": 56,
"sloc": 783,
"files": 8,
"author_name": "Jos van Bakel",
"author_url": "https://github.com/c0deaddict",
"so_count": 66,
"so_rank": 77,
"lloc": 0
},
"logo": {
"dir": "logo",
"name": "Logo",
"syntax": "OTHER",
"type_check": "Dynamic",
"modes": [],
"perf1": 179,
"perf2": 777,
"perf3": 48,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 805,
"files": 8,
"author_name": "Dov Murik",
"author_url": "https://github.com/dubek",
"so_count": 47,
"so_rank": 81,
"lloc": 0
},
"lua": {
"dir": "lua",
"name": "Lua",
"syntax": "Algol",
"type_check": "Dynamic",
"modes": [],
"perf1": 3931,
"perf2": 16211,
"perf3": 2,
"pull_count": 149093,
"pull_rank": 23,
"push_count": 765952,
"push_rank": 22,
"star_count": 386542,
"star_rank": 23,
"sloc": 925,
"files": 9,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 22832,
"so_rank": 34,
"lloc": 0
},
"make": {
"dir": "make",
"name": "GNU Make",
"syntax": "OTHER",
"type_check": "OTHER",
"modes": [],
"perf1": 270,
"perf2": 1329,
"perf3": 18,
"pull_count": 97160,
"pull_rank": 30,
"push_count": 286234,
"push_rank": 30,
"star_count": 101953,
"star_rank": 34,
"sloc": 798,
"files": 12,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 25601,
"so_rank": 33,
"lloc": 0
},
"mal": {
"dir": "mal",
"name": "mal itself",
"syntax": "Lisp",
"type_check": "Dynamic",
"modes": [],
"perf1": 72,
"perf2": 321,
"perf3": 156,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 206,
"files": 4,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 0,
"so_rank": 91,
"lloc": 0
},
"matlab": {
"dir": "matlab",
"name": "MATLAB",
"syntax": "Algol",
"type_check": "Dynamic",
"modes": [],
"perf1": 598,
"perf2": 2036,
"perf3": 17,
"pull_count": 6111,
"pull_rank": 54,
"push_count": 130167,
"push_rank": 39,
"star_count": 17596,
"star_rank": 51,
"sloc": 1103,
"files": 17,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 94997,
"so_rank": 22,
"lloc": 0
},
"miniMAL": {
"dir": "miniMAL",
"name": "miniMAL",
"syntax": "JSON",
"type_check": "Dynamic",
"modes": [],
"perf1": 144,
"perf2": 524,
"perf3": 72,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 727,
"files": 9,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 0,
"so_rank": 92,
"lloc": 0
},
"nasm": {
"dir": "nasm",
"name": "NASM",
"syntax": "OTHER",
"type_check": "OTHER",
"modes": [],
"perf1": 1,
"perf2": 3,
"pull_count": 14978,
"pull_rank": 41,
"push_count": 126728,
"push_rank": 40,
"star_count": 54612,
"star_rank": 37,
"sloc": 6166,
"files": 9,
"author_name": "Ben Dudson",
"author_url": "https://github.com/bendudson",
"so_count": 5255,
"so_rank": 52,
"lloc": 0
},
"nim": {
"dir": "nim",
"name": "Nim",
"syntax": "Python",
"type_check": "Static",
"modes": [],
"perf1": 0,
"perf2": 1,
"perf3": 56321,
"pull_count": 5093,
"pull_rank": 55,
"push_count": 17440,
"push_rank": 62,
"star_count": 16110,
"star_rank": 52,
"sloc": 625,
"files": 7,
"author_name": "Dennis Felsing",
"author_url": "https://github.com/def-",
"so_count": 687,
"so_rank": 66,
"lloc": 0
},
"objpascal": {
"dir": "objpascal",
"name": "Object Pascal",
"syntax": "Algol",
"type_check": "Static",
"modes": [],
"perf1": 3,
"perf2": 12,
"perf3": 3596,
"pull_count": 9438,
"pull_rank": 50,
"push_count": 95092,
"push_rank": 42,
"star_count": 48783,
"star_rank": 40,
"sloc": 1553,
"files": 9,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 67138,
"so_rank": 26,
"lloc": 967
},
"objc": {
"dir": "objc",
"name": "Objective C",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 5,
"perf2": 19,
"perf3": 1958,
"pull_count": 290475,
"pull_rank": 21,
"push_count": 1326999,
"push_rank": 19,
"star_count": 3444492,
"star_rank": 14,
"sloc": 1121,
"files": 16,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 292176,
"so_rank": 13,
"lloc": 511
},
"ocaml": {
"dir": "ocaml",
"name": "OCaml",
"syntax": "ML",
"type_check": "Static",
"modes": [],
"perf1": 0,
"perf2": 1,
"perf3": 39621,
"pull_count": 71286,
"pull_rank": 33,
"push_count": 242743,
"push_rank": 35,
"star_count": 131717,
"star_rank": 33,
"sloc": 541,
"files": 7,
"author_name": "Chris Houser",
"author_url": "https://github.com/chouser",
"so_count": 7644,
"so_rank": 47,
"lloc": 0
},
"perl": {
"dir": "perl",
"name": "Perl",
"syntax": "C",
"type_check": "Dynamic",
"modes": [],
"perf1": 3,
"perf2": 12,
"perf3": 3315,
"pull_count": 138992,
"pull_rank": 25,
"push_count": 720857,
"push_rank": 24,
"star_count": 210224,
"star_rank": 29,
"sloc": 836,
"files": 9,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 68197,
"so_rank": 25,
"lloc": 418
},
"perl6": {
"dir": "perl6",
"name": "Perl 6",
"syntax": "C",
"type_check": "Dynamic",
"modes": [],
"perf1": 55,
"perf2": 147,
"perf3": 311,
"pull_count": 4302,
"pull_rank": 56,
"push_count": 24807,
"push_rank": 57,
"star_count": 1314,
"star_rank": 65,
"sloc": 460,
"files": 7,
"author_name": "Hinrik Örn Sigurðsson",
"author_url": "https://github.com/hinrik",
"so_count": 2054,
"so_rank": 60,
"lloc": 155
},
"php": {
"dir": "php",
"name": "PHP",
"syntax": "C",
"type_check": "Dynamic",
"modes": [],
"perf1": 1,
"perf2": 2,
"perf3": 12551,
"pull_count": 2791184,
"pull_rank": 9,
"push_count": 10165121,
"push_rank": 7,
"star_count": 4379644,
"star_rank": 9,
"sloc": 951,
"files": 10,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 1467322,
"so_rank": 6,
"lloc": 524
},
"picolisp": {
"dir": "picolisp",
"name": "Picolisp",
"syntax": "Lisp",
"type_check": "Dynamic",
"modes": [],
"perf1": 1,
"perf2": 3,
"perf3": 10702,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 561,
"files": 9,
"author_name": "Vasilij Schneidermann",
"author_url": "https://github.com/wasamasa",
"so_count": 8,
"so_rank": 86,
"lloc": 0
},
"pike": {
"dir": "pike",
"name": "Pike",
"syntax": "C",
"type_check": "OTHER",
"modes": [],
"perf1": 2,
"perf2": 6,
"perf3": 7568,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 1,
"files": 1,
"author_name": "Dov Murik",
"author_url": "https://github.com/dubek",
"so_count": 14,
"so_rank": 84,
"lloc": 0
},
"plpgsql": {
"dir": "plpgsql",
"name": "PL/pgSQL",
"syntax": "Algol",
"type_check": "Static",
"modes": [],
"perf1": 324,
"perf2": 1673,
"perf3": 28,
"pull_count": 16616,
"pull_rank": 40,
"push_count": 111156,
"push_rank": 41,
"star_count": 29471,
"star_rank": 46,
"sloc": 1883,
"files": 11,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 4386,
"so_rank": 53,
"lloc": 0
},
"plsql": {
"dir": "plsql",
"name": "PL/SQL",
"syntax": "Algol",
"type_check": "Static",
"modes": [],
"perf1": null,
"perf2": null,
"perf3": 0,
"pull_count": 7172,
"pull_rank": 53,
"push_count": 31314,
"push_rank": 55,
"star_count": 6361,
"star_rank": 59,
"sloc": 2223,
"files": 11,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 29113,
"so_rank": 32,
"lloc": 0
},
"powershell": {
"dir": "powershell",
"name": "PowerShell",
"syntax": "OTHER",
"type_check": "Dynamic",
"modes": [],
"perf1": 624,
"perf2": 2076,
"perf3": 17,
"pull_count": 75193,
"pull_rank": 32,
"push_count": 284307,
"push_rank": 32,
"star_count": 210859,
"star_rank": 28,
"sloc": 812,
"files": 7,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 118255,
"so_rank": 19,
"lloc": 0
},
"prolog": {
"dir": "prolog",
"name": "Prolog",
"syntax": "OTHER",
"type_check": "Dynamic",
"modes": [],
"perf1": 15,
"perf2": 68,
"perf3": 648,
"pull_count": 638,
"pull_rank": 62,
"push_count": 34091,
"push_rank": 53,
"star_count": 4179,
"star_rank": 62,
"sloc": 591,
"files": 8,
"author_name": "Nicolas Boulenguez",
"author_url": "https://github.com/asarhaddon",
"so_count": 13462,
"so_rank": 39,
"lloc": 237
},
"ps": {
"dir": "ps",
"name": "PostScript",
"syntax": "Stack",
"type_check": "Dynamic",
"modes": [],
"perf1": 11,
"perf2": 54,
"perf3": 963,
"pull_count": 1816,
"pull_rank": 61,
"push_count": 13598,
"push_rank": 64,
"star_count": 1272,
"star_rank": 66,
"sloc": 1245,
"files": 8,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 535,
"so_rank": 69,
"lloc": 0
},
"purs": {
"dir": "purs",
"name": "PureScript",
"syntax": "ML",
"type_check": "Static",
"modes": [],
"perf1": 41,
"perf2": 110,
"perf3": 1758,
"pull_count": 12980,
"pull_rank": 45,
"push_count": 23297,
"push_rank": 59,
"star_count": 15237,
"star_rank": 53,
"sloc": 13,
"files": 2,
"author_name": "mrsekut",
"author_url": "https://github.com/mrsekut",
"so_count": 601,
"so_rank": 68,
"lloc": 0
},
"python2": {
"dir": "python2",
"name": "Python2",
"syntax": "Python",
"type_check": "Dynamic",
"modes": [],
"perf1": 3,
"perf2": 11,
"perf3": 4088,
"pull_count": 6523874,
"pull_rank": 3,
"push_count": 19048234,
"push_rank": 3,
"star_count": 12495438,
"star_rank": 3,
"sloc": 552,
"files": 8,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 2301019,
"so_rank": 3,
"lloc": 0
},
"python3": {
"dir": "python3",
"name": "Python3",
"syntax": "Python",
"type_check": "Dynamic",
"modes": [],
"perf1": 4,
"perf2": 12,
"perf3": 2834,
"pull_count": 6523874,
"pull_rank": 4,
"push_count": 19048234,
"push_rank": 4,
"star_count": 12495438,
"star_rank": 4,
"sloc": 867,
"files": 7,
"author_name": "Gavin Lewis",
"author_url": "https://github.com/epylar",
"so_count": 2549011,
"so_rank": 2,
"lloc": 0
},
"rpython": {
"dir": "rpython",
"name": "RPython",
"syntax": "Python",
"type_check": "Static",
"modes": [],
"perf1": 0,
"perf2": 1,
"perf3": 219999,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 1004,
"files": 8,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 62,
"so_rank": 80,
"lloc": 0
},
"r": {
"dir": "r",
"name": "R",
"syntax": "C",
"type_check": "Dynamic",
"modes": [],
"perf1": 37,
"perf2": 114,
"perf3": 376,
"pull_count": 53300,
"pull_rank": 35,
"push_count": 522906,
"push_rank": 27,
"star_count": 95252,
"star_rank": 35,
"sloc": 736,
"files": 8,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 508699,
"so_rank": 9,
"lloc": 0
},
"racket": {
"dir": "racket",
"name": "Racket",
"syntax": "Lisp",
"type_check": "Dynamic",
"modes": [],
"perf1": 1,
"perf2": 4,
"perf3": 9695,
"pull_count": 2247,
"pull_rank": 60,
"push_count": 27140,
"push_rank": 56,
"star_count": 8941,
"star_rank": 58,
"sloc": 495,
"files": 8,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 5880,
"so_rank": 50,
"lloc": 0
},
"rexx": {
"dir": "rexx",
"name": "Rexx",
"syntax": "OTHER",
"type_check": "Dynamic",
"modes": [],
"perf1": 81,
"perf2": 340,
"perf3": 121,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 1237,
"files": 8,
"author_name": "Dov Murik",
"author_url": "https://github.com/dubek",
"so_count": 174,
"so_rank": 74,
"lloc": 0
},
"ruby": {
"dir": "ruby",
"name": "Ruby",
"syntax": "OTHER",
"type_check": "Dynamic",
"modes": [],
"perf1": 1,
"perf2": 6,
"perf3": 7021,
"pull_count": 2750926,
"pull_rank": 10,
"push_count": 6646427,
"push_rank": 9,
"star_count": 3577810,
"star_rank": 12,
"sloc": 442,
"files": 8,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 229218,
"so_rank": 15,
"lloc": 0
},
"ruby.2": {
"dir": "ruby.2",
"name": "Ruby #2",
"syntax": "OTHER",
"type_check": "Dynamic",
"modes": [],
"perf1": 7,
"perf2": 28,
"perf3": 1498,
"pull_count": 2750926,
"pull_rank": 11,
"push_count": 6646427,
"push_rank": 10,
"star_count": 3577810,
"star_rank": 13,
"sloc": 1249,
"files": 8,
"author_name": "Ryan Cook",
"author_url": "https://github.com/cookrn",
"so_count": 229218,
"so_rank": 16,
"lloc": 0
},
"rust": {
"dir": "rust",
"name": "Rust",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 0,
"perf2": 1,
"perf3": 66511,
"pull_count": 427223,
"pull_rank": 19,
"push_count": 988782,
"push_rank": 20,
"star_count": 1016188,
"star_rank": 19,
"sloc": 1118,
"files": 7,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 42120,
"so_rank": 28,
"lloc": 212
},
"scala": {
"dir": "scala",
"name": "Scala",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 11,
"perf2": 28,
"perf3": 83454,
"pull_count": 648787,
"pull_rank": 17,
"push_count": 1623883,
"push_rank": 17,
"star_count": 593810,
"star_rank": 20,
"sloc": 829,
"files": 7,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 112669,
"so_rank": 20,
"lloc": 0
},
"scheme": {
"dir": "scheme",
"name": "Scheme (R7RS)",
"syntax": "Lisp",
"type_check": "Dynamic",
"modes": [
"chibi",
"kawa",
"gauche",
"chicken",
"sagittarius",
"cyclone",
"foment"
],
"perf1": 4,
"perf2": 16,
"perf3": 2647,
"pull_count": 3192,
"pull_rank": 58,
"push_count": 89139,
"push_rank": 43,
"star_count": 32255,
"star_rank": 45,
"sloc": 895,
"files": 8,
"author_name": "Vasilij Schneidermann",
"author_url": "https://github.com/wasamasa",
"so_count": 8168,
"so_rank": 45,
"lloc": 0
},
"skew": {
"dir": "skew",
"name": "Skew",
"syntax": "OTHER",
"type_check": "Static",
"modes": [],
"perf1": 2,
"perf2": 6,
"perf3": 68779,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 704,
"files": 8,
"author_name": "Dov Murik",
"author_url": "https://github.com/dubek",
"so_count": 386,
"so_rank": 70,
"lloc": 0
},
"sml": {
"dir": "sml",
"name": "Standard ML",
"syntax": "ML",
"type_check": "Static",
"modes": [],
"perf1": 0,
"perf2": 1,
"perf3": 42241,
"pull_count": 3494,
"pull_rank": 57,
"push_count": 15782,
"push_rank": 63,
"star_count": 3521,
"star_rank": 63,
"sloc": 553,
"files": 10,
"author_name": "Fabian Bergström",
"author_url": "https://github.com/fabjan",
"so_count": 2099,
"so_rank": 59,
"lloc": 0
},
"swift5": {
"dir": "swift5",
"name": "Swift 5",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 5,
"perf2": 22,
"perf3": 1884,
"pull_count": 441064,
"pull_rank": 18,
"push_count": 1361391,
"push_rank": 18,
"star_count": 2778564,
"star_rank": 16,
"sloc": 1232,
"files": 11,
"author_name": "Oleg Montak",
"author_url": "https://github.com/MontakOleg",
"so_count": 343733,
"so_rank": 12,
"lloc": 0
},
"tcl": {
"dir": "tcl",
"name": "Tcl",
"syntax": "OTHER",
"type_check": "Dynamic",
"modes": [],
"perf1": 10,
"perf2": 32,
"perf3": 1057,
"pull_count": 2760,
"pull_rank": 59,
"push_count": 33537,
"push_rank": 54,
"star_count": 6233,
"star_rank": 60,
"sloc": 1083,
"files": 8,
"author_name": "Dov Murik",
"author_url": "https://github.com/dubek",
"so_count": 8074,
"so_rank": 46,
"lloc": 0
},
"ts": {
"dir": "ts",
"name": "TypeScript",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 1,
"perf2": 3,
"perf3": 61159,
"pull_count": 2152989,
"pull_rank": 12,
"push_count": 4497441,
"push_rank": 15,
"star_count": 3141436,
"star_rank": 15,
"sloc": 1244,
"files": 8,
"author_name": "Masahiro Wakame",
"author_url": "https://github.com/vvakame",
"so_count": 239371,
"so_rank": 14,
"lloc": 0
},
"vala": {
"dir": "vala",
"name": "Vala",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 3,
"perf2": 12,
"perf3": 4062,
"pull_count": 12061,
"pull_rank": 47,
"push_count": 80233,
"push_rank": 47,
"star_count": 45712,
"star_rank": 41,
"sloc": 2248,
"files": 8,
"author_name": "Simon Tatham",
"author_url": "https://github.com/sgtatham",
"so_count": 1006,
"so_rank": 63,
"lloc": 1114
},
"vhdl": {
"dir": "vhdl",
"name": "VHDL",
"syntax": "Algol",
"type_check": "Static",
"modes": [],
"perf1": 4,
"perf2": 16,
"perf3": 2593,
"pull_count": 284,
"pull_rank": 65,
"push_count": 23377,
"push_rank": 58,
"star_count": 9567,
"star_rank": 57,
"sloc": 1925,
"files": 9,
"author_name": "Dov Murik",
"author_url": "https://github.com/dubek",
"so_count": 5811,
"so_rank": 51,
"lloc": 0
},
"vimscript": {
"dir": "vimscript",
"name": "Vimscript",
"syntax": "Algol",
"type_check": "Dynamic",
"modes": [],
"perf1": 101,
"perf2": 436,
"perf3": 98,
"pull_count": null,
"pull_rank": null,
"push_count": 965,
"push_rank": 69,
"star_count": 1547,
"star_rank": 64,
"sloc": 969,
"files": 10,
"author_name": "Dov Murik",
"author_url": "https://github.com/dubek",
"so_count": 41,
"so_rank": 82,
"lloc": 12
},
"vb": {
"dir": "vb",
"name": "Visual Basic.NET",
"syntax": "Algol",
"type_check": "Static",
"modes": [],
"perf1": 2,
"perf2": 3,
"perf3": 33311,
"pull_count": 22562,
"pull_rank": 38,
"push_count": 80494,
"push_rank": 46,
"star_count": 19848,
"star_rank": 50,
"sloc": 1451,
"files": 8,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 140396,
"so_rank": 18,
"lloc": 0
},
"vbs": {
"dir": "vbs",
"name": "Visual Basic Script",
"syntax": "Algol",
"type_check": "Dynamic",
"modes": [],
"perf1": 2716,
"perf2": 13072,
"perf3": 3,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 2109,
"files": 8,
"author_name": "刘百超",
"author_url": "https://github.com/OldLiu001",
"so_count": 18658,
"so_rank": 35,
"lloc": 0
},
"wasm": {
"dir": "wasm",
"name": "WebAssembly",
"syntax": "Lisp",
"type_check": "Static",
"modes": [
"wace_libc",
"node",
"warpy"
],
"pull_count": 9341,
"pull_rank": 51,
"push_count": 11939,
"push_rank": 65,
"star_count": 10628,
"star_rank": 55,
"sloc": 3024,
"files": 16,
"author_name": "Joel Martin",
"author_url": "https://github.com/kanaka",
"so_count": 3002,
"so_rank": 55,
"lloc": 0
},
"wren": {
"dir": "wren",
"name": "Wren",
"syntax": "C",
"type_check": "Dynamic",
"modes": [],
"perf1": 2,
"perf2": 5,
"perf3": 7236,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 1,
"files": 1,
"author_name": "Dov Murik",
"author_url": "https://github.com/dubek",
"so_count": 4,
"so_rank": 87,
"lloc": 0
},
"xslt": {
"dir": "xslt",
"name": "XSLT",
"syntax": "OTHER",
"type_check": "Dynamic",
"modes": [],
"perf1": null,
"perf2": null,
"perf3": 0,
"pull_count": 14834,
"pull_rank": 42,
"push_count": 83261,
"push_rank": 45,
"star_count": 22225,
"star_rank": 49,
"sloc": 132,
"files": 1,
"author_name": "Ali MohammadPur",
"author_url": "https://github.com/alimpfard",
"so_count": 38679,
"so_rank": 29,
"lloc": 0
},
"yorick": {
"dir": "yorick",
"name": "Yorick",
"syntax": "C",
"type_check": "Dynamic",
"modes": [],
"perf1": 53,
"perf2": 248,
"perf3": 184,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 1013,
"files": 8,
"author_name": "Dov Murik",
"author_url": "https://github.com/dubek",
"so_count": 1,
"so_rank": 90,
"lloc": 108
},
"zig": {
"dir": "zig",
"name": "Zig",
"syntax": "C",
"type_check": "Static",
"modes": [],
"perf1": 1,
"perf2": 2,
"perf3": 9556,
"pull_count": null,
"pull_rank": null,
"push_count": null,
"push_rank": null,
"star_count": null,
"star_rank": null,
"sloc": 1,
"files": 1,
"author_name": "Josh Tobin",
"author_url": "https://github.com/rjtobin",
"so_count": 378,
"so_rank": 71,
"lloc": 0
}
}
================================================
FILE: docs/graph/base_data.yaml
================================================
headers:
- [dir , name , syntax , type_check , modes]
languages:
- [ada , Ada , Algol , Static , []]
- [ada.2 , "Ada #2" , Algol , Static , []]
- [awk , GNU Awk , C , Dynamic , []]
- [bash , Bash 4 , OTHER , Dynamic , []]
- [basic , BASIC , OTHER , Static , [cbm, qbasic]]
- [bbc-basic , BBC BASIC V , OTHER , Static , []]
- [c , C , C , Static , []]
- [c.2 , "C #2" , C , Static , []]
- [cpp , C++ , C , Static , []]
- [cs , C# , C , Static , []]
- [chuck , ChucK , C , Static , []]
- [clojure , Clojure , Lisp , Dynamic , [clj, cljs]]
- [coffee , CoffeeScript , OTHER , Dynamic , []]
- [common-lisp , Common Lisp , Lisp , Dynamic , []]
- [crystal , Crystal , OTHER , Static , []]
- [d , D , C , Static , []]
- [dart , Dart , C , Static , []]
- [elixir , Elixir , OTHER , Dynamic , []]
- [elm , Elm , ML , Static , []]
- [elisp , Emacs Lisp , Lisp , Dynamic , []]
- [erlang , Erlang , OTHER , Dynamic , []]
- [es6 , ES6 , C , Dynamic , []]
- [fsharp , F# , ML , Static , []]
- [fennel , "Fennel" , Lisp , Dynamic , []]
- [factor , Factor , Stack , Dynamic , []]
- [fantom , Fantom , C , Static , []]
- [forth , Forth , Stack , OTHER , []]
- [guile , GNU Guile , Lisp , Dynamic , []]
- [gnu-smalltalk , GNU Smalltalk , OTHER , Dynamic , []]
- [go , Go , C , Static , []]
- [groovy , Groovy , C , Dynamic , []]
- [haskell , Haskell , ML , Static , []]
- [haxe , Haxe , C , Static , [neko,python,cpp,js]]
- [hy , Hy , Lisp , Dynamic , []]
- [io , Io , OTHER , Dynamic , []]
- [java , Java , C , Static , []]
- [java-truffle , "Java Truffle" , C , Static , []]
- [js , JavaScript , C , Dynamic , []]
- [jq , jq , OTHER , Dynamic , []]
- [janet , "Janet" , Lisp , Dynamic , []]
- [julia , Julia , Algol , Dynamic , []]
- [kotlin , Kotlin , C , Static , []]
- [latex3 , LaTeX3 , Other , Dynamic , []]
- [livescript , LiveScript , ML , Dynamic , []]
- [logo , Logo , OTHER , Dynamic , []]
- [lua , Lua , Algol , Dynamic , []]
- [make , GNU Make , OTHER , OTHER , []]
- [mal , mal itself , Lisp , Dynamic , []]
- [matlab , MATLAB , Algol , Dynamic , []]
- [miniMAL , miniMAL , JSON , Dynamic , []]
- [nasm , NASM , OTHER , OTHER , []]
- [nim , Nim , Python , Static , []]
- [objpascal , Object Pascal , Algol , Static , []]
- [objc , Objective C , C , Static , []]
- [ocaml , OCaml , ML , Static , []]
- [perl , Perl , C , Dynamic , []]
- [perl6 , Perl 6 , C , Dynamic , []]
- [php , PHP , C , Dynamic , []]
- [picolisp , Picolisp , Lisp , Dynamic , []]
- [pike , Pike , C , OTHER , []]
- [plpgsql , PL/pgSQL , Algol , Static , []]
- [plsql , PL/SQL , Algol , Static , []]
- [powershell , PowerShell , OTHER , Dynamic , []]
- [prolog , Prolog , OTHER , Dynamic , []]
- [ps , PostScript , Stack , Dynamic , []]
- [purs , PureScript , ML , Static , []]
- [python2 , Python2 , Python , Dynamic , []]
- [python3 , Python3 , Python , Dynamic , []]
- [rpython , RPython , Python , Static , []]
- [r , R , C , Dynamic , []]
- [racket , Racket , Lisp , Dynamic , []]
- [rexx , Rexx , OTHER , Dynamic , []]
- [ruby , Ruby , OTHER , Dynamic , []]
- [ruby.2 , "Ruby #2" , OTHER , Dynamic , []]
- [rust , Rust , C , Static , []]
- [scala , Scala , C , Static , []]
- [scheme , Scheme (R7RS) , Lisp , Dynamic , [chibi,kawa,gauche,chicken,sagittarius,cyclone,foment]]
- [skew , Skew , OTHER , Static , []]
- [sml , "Standard ML" , ML , Static , []]
- [swift6 , "Swift 6" , C , Static , []]
- [tcl , Tcl , OTHER , Dynamic , []]
- [ts , TypeScript , C , Static , []]
- [vala , Vala , C , Static , []]
- [vhdl , VHDL , Algol , Static , []]
- [vimscript , Vimscript , Algol , Dynamic , []]
- [vb , Visual Basic.NET , Algol , Static , []]
- [vbs , Visual Basic Script , Algol , Dynamic , []]
- [wasm , WebAssembly , Lisp , Static , [wace_libc,node,warpy]]
- [wren , Wren , C , Dynamic , []]
- [xslt , XSLT , OTHER , Dynamic , []]
- [yorick , Yorick , C , Dynamic , []]
- [zig , Zig , C , Static , []]
================================================
FILE: docs/graph/collect_data.js
================================================
#!/usr/bin/env python
const { promisify } = require('util')
const readFile = promisify(require('fs').readFile)
const writeFile = promisify(require('fs').writeFile)
const readdir = promisify(require('fs').readdir)
const path = require('path')
const yaml = require('js-yaml')
const csv = require('csvtojson')
const request = require('request-promise-native')
const exec = promisify(require('child_process').exec)
const VERBOSE = process.env['VERBOSE'] || false
const BASE_PATH = process.env['BASE_PATH'] || 'base_data.yaml'
const README_PATH = process.env['README_PATH'] || '../../README.md'
const MAL_PATH = process.env['MAL_PATH'] || '../../'
// Refresh this file using this Query page:
// https://data.stackexchange.com/stackoverflow/query/edit/1013465
const SO_TAGS_PATH = process.env['SO_TAGS_PATH'] || 'so-tags.csv'
// GitHut 2.0 Pull Requests
const GITHUT_PULL_URL = process.env['GITHUT_PULL_URL'] || 'https://raw.githubusercontent.com/madnight/githut/master/src/data/gh-pull-request.json'
// GitHut 2.0 Pushes
const GITHUT_PUSH_URL = process.env['GITHUT_PUSH_URL'] || 'https://raw.githubusercontent.com/madnight/githut/master/src/data/gh-push-event.json'
// GitHut 2.0 Stars
const GITHUT_STAR_URL = process.env['GITHUT_STAR_URL'] || 'https://raw.githubusercontent.com/madnight/githut/master/src/data/gh-star-event.json'
const ignoreLanguages = {"Swift 2":1, "Swift 3":1, "Swift 4":1}
const githutToNames = {
'Awk': ['GNU Awk'],
'Ada': ['Ada', 'Ada #2'],
'C': ['C', 'C #2'],
'Shell': ['Bash 4'],
'Java': ['Java', 'Java Truffle'],
'JavaScript': ['JavaScript', 'ES6'],
'Makefile': ['GNU Make'],
'Matlab': ['MATLAB'],
'Assembly': ['NASM'],
'Pascal': ['Object Pascal'],
'Objective-C': ['Objective C'],
'PLpgSQL': ['PL/pgSQL'],
'PLSQL': ['PL/SQL'],
'Python': ['Python2', 'Python3'],
'Ruby': ['Ruby', 'Ruby #2'],
'Scheme': ['Scheme (R7RS)'],
'Smalltalk': ['GNU Smalltalk'],
'Swift': ['Swift 5'],
'Vim script': ['Vimscript'],
'Visual Basic': ['Visual Basic.NET'],
}
const dirToSOTags = {
'ada.2': ['ada'],
'bbc-basic': ['bbc-micro'],
'cpp': ['c++', 'c++98', 'c++11', 'c++14', 'c++17'],
'coffee': ['coffeescript'],
'crystal': ['crystal-lang'],
'cs': ['c#', 'c#-2.0', 'c#-3.0', 'c#-4.0'],
'c.2': ['c'],
'es6': ['ecmascript-6', 'es6-promise', 'es6-modules', 'es6-class', 'reactjs'],
'fsharp': ['f#', 'f#-interactive', 'f#-data', 'f#-3.0'],
'factor': ['factor-lang'],
'java-truffle': ['graalvm'],
'js': ['javascript', 'node.js', 'jquery', 'angular'],
'latex3': ['latex'],
'logo': ['logo-lang'],
'make': ['makefile'],
'nim': ['nim-lang'],
'objpascal': ['delphi', 'freepascal', 'delphi-7', 'delphi-2007', 'delphi-2009', 'delphi-2010', 'delphi-xe', 'delphi-xe2', 'delphi-xe3', 'delphi-xe4', 'delphi-xe5', 'delphi-xe7'],
'objc': ['objective-c'],
'perl6': ['raku'],
'purs': ['purescript'],
'python2': ['python', 'python-2.7'],
'python3': ['python', 'python-3.x'],
'ruby.2': ['ruby'],
'swift5': ['swift', 'swift4', 'swift5'],
'ts': ['typescript', 'typescript-generics', 'typescript2.0'],
'vimscript': ['viml'],
'vb': ['vb.net'],
'vbs': ['vbscript'],
'wasm': ['webassembly'],
}
const soMapOverrides = {
'mal': 0, // StackOverflow mal is something else
'miniMAL': 0,
'bbc-micro': 9, // outside 50,000 query limit
'fennel': 3, // outside 50,000 query limit
'janet': 3, // outside 50,000 query limit
'picolisp': 8, // outside 50,000 query limit
'wren': 4, // outside 50,000 query limit
'yorick': 1, // outside 50,000 query limit
}
function vlog(...args) {
if (VERBOSE) {
console.log(...args)
}
}
function die(code, ...args) {
console.error(...args)
process.exit(code)
}
async function main() {
const logsPath = path.resolve(process.argv[2])
const outPath = path.resolve(process.argv[3])
vlog(`Loading base data yaml from '${BASE_PATH}`)
const baseYaml = yaml.safeLoad(await readFile(BASE_PATH, 'utf8'))
vlog(`Loading README text from '${README_PATH}`)
const readmeLines = (await readFile(README_PATH, 'utf8')).split(/\n/)
vlog(`Downloading GitHut Pulls HTML from '${GITHUT_PULL_URL}`)
const githutPullText = (await request(GITHUT_PULL_URL))
vlog(`Downloading GitHut Pushes HTML from '${GITHUT_PUSH_URL}`)
const githutPushText = (await request(GITHUT_PUSH_URL))
vlog(`Downloading GitHut Stars HTML from '${GITHUT_STAR_URL}`)
const githutStarText = (await request(GITHUT_STAR_URL))
vlog(`Loading StackOverflow Tags CSV from '${SO_TAGS_PATH}`)
const soTagList = await csv().fromFile(SO_TAGS_PATH)
vlog(`Loading log data from '${logsPath}'`)
const logDirs = (await readdir(logsPath)).sort()
let logData = []
for (const d of logDirs) {
let dir = /IMPL=([^ ]*)/.exec(d)[1]
if (!dir) { console.log("ignoring log dir:", d); continue }
let logPath = `${logsPath}/${d}`
const logFiles = (await readdir(logPath))
.filter(f => /^perf-.*\.log/.exec(f))
const path = `${logPath}/${logFiles[0]}`
logData.push([await readFile(path, 'utf8'), path, dir])
}
let dirs = []
let names = []
let dataList = []
let dataByDir = {}
let dataByName = {}
vlog(`Processing base data`)
for (let d of baseYaml['languages']) {
let data = {'dir': d[0],
'name': d[1],
'syntax': d[2],
'type_check': d[3],
'modes': d[4],
'perf1': null,
'perf2': null,
'perf3': 0,
'pull_count': null,
'pull_rank': null,
'push_count': null,
'push_rank': null,
'star_count': null,
'star_rank': null,
'sloc': 0,
'files': 0}
dirs.push(d[0])
names.push(d[1])
dataList.push(data)
dataByDir[d[0]] = data
dataByName[d[1]] = data
}
vlog(`Processing README implementations table`)
const readme_re = /^\| \[([^\[]*)\].* \| \[([^|]*)\]\(([^|]*)\) *\| *$/
for (let row of readmeLines.filter(l => /^\| [\[]/.exec(l))) {
t = readme_re.exec(row)
if (t) {
if (t[1] in ignoreLanguages) {
vlog(` ${t[1]}: ignoring (in ignoreLanguages list)`)
} else if (t[1] in dataByName) {
let data = dataByName[t[1]]
data.author_name = t[2]
data.author_url = t[3]
} else {
die(1, `README language '${t[1]}' not found in base data`)
}
} else {
die(1, `No match for README table row: ${row}`)
}
}
vlog(`Processing StackOverflow tag data`)
const soMap = {
...soTagList
.reduce((m,d) => (m[d.TagName] = parseInt(d.Rate), m), {}),
...soMapOverrides
}
for (let dir of dirs) {
if (!('so_count' in dataByDir[dir])) {
dataByDir[dir]['so_count'] = 0
}
let tags = dirToSOTags[dir]
if (!tags) {
if (dir in soMap) {
tags = [dir]
} else {
v
gitextract_0ybyg9g2/ ├── .gitattributes ├── .github/ │ ├── pull_request_template.md │ └── workflows/ │ └── main.yml ├── .gitignore ├── .gitmodules ├── .travis.yml ├── IMPLS.yml ├── LICENSE ├── Makefile ├── Makefile.impls ├── README.md ├── ci.sh ├── docs/ │ ├── FAQ.md │ ├── Hints.md │ ├── TODO │ ├── cheatsheet.html │ ├── exercises.md │ ├── graph/ │ │ ├── README.md │ │ ├── all_data.json │ │ ├── base_data.yaml │ │ ├── collect_data.js │ │ ├── graph_languages.js │ │ ├── index.html │ │ ├── package.json │ │ └── so-tags.csv │ ├── index.html │ ├── notes.md │ ├── step_notes.txt │ └── web/ │ ├── ansi.css │ ├── base.css │ ├── console.css │ ├── himera.css │ ├── layout.css │ ├── mal.js │ └── skeleton.css ├── examples/ │ ├── clojurewest2014.mal │ ├── exercises.mal │ ├── hello.mal │ └── presentation.mal ├── get-ci-matrix.py ├── impls/ │ ├── .gitignore │ ├── ada/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.adb │ │ ├── core.ads │ │ ├── envs.adb │ │ ├── envs.ads │ │ ├── eval_callback.ads │ │ ├── printer.adb │ │ ├── printer.ads │ │ ├── reader.adb │ │ ├── reader.ads │ │ ├── run │ │ ├── smart_pointers.adb │ │ ├── smart_pointers.ads │ │ ├── step0_repl.adb │ │ ├── step1_read_print.adb │ │ ├── step2_eval.adb │ │ ├── step3_env.adb │ │ ├── step4_if_fn_do.adb │ │ ├── step5_tco.adb │ │ ├── step6_file.adb │ │ ├── step7_quote.adb │ │ ├── step8_macros.adb │ │ ├── step9_try.adb │ │ ├── stepa_mal.adb │ │ ├── types-hash_map.adb │ │ ├── types-hash_map.ads │ │ ├── types-vector.adb │ │ ├── types-vector.ads │ │ ├── types.adb │ │ └── types.ads │ ├── ada.2/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── README │ │ ├── core.adb │ │ ├── core.ads │ │ ├── envs.adb │ │ ├── envs.ads │ │ ├── err.adb │ │ ├── err.ads │ │ ├── garbage_collected.adb │ │ ├── garbage_collected.ads │ │ ├── printer.adb │ │ ├── printer.ads │ │ ├── reader.adb │ │ ├── reader.ads │ │ ├── readline.adb │ │ ├── readline.ads │ │ ├── run │ │ ├── step0_repl.adb │ │ ├── step1_read_print.adb │ │ ├── step2_eval.adb │ │ ├── step3_env.adb │ │ ├── step4_if_fn_do.adb │ │ ├── step5_tco.adb │ │ ├── step6_file.adb │ │ ├── step7_quote.adb │ │ ├── step8_macros.adb │ │ ├── step9_try.adb │ │ ├── stepa_mal.adb │ │ ├── types-atoms.adb │ │ ├── types-atoms.ads │ │ ├── types-builtins.adb │ │ ├── types-builtins.ads │ │ ├── types-fns.adb │ │ ├── types-fns.ads │ │ ├── types-maps.adb │ │ ├── types-maps.ads │ │ ├── types-sequences.adb │ │ ├── types-sequences.ads │ │ ├── types-strings.adb │ │ ├── types-strings.ads │ │ ├── types.adb │ │ └── types.ads │ ├── awk/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.awk │ │ ├── env.awk │ │ ├── printer.awk │ │ ├── reader.awk │ │ ├── run │ │ ├── step0_repl.awk │ │ ├── step1_read_print.awk │ │ ├── step2_eval.awk │ │ ├── step3_env.awk │ │ ├── step4_if_fn_do.awk │ │ ├── step5_tco.awk │ │ ├── step6_file.awk │ │ ├── step7_quote.awk │ │ ├── step8_macros.awk │ │ ├── step9_try.awk │ │ ├── stepA_mal.awk │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ └── types.awk │ ├── bash/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.sh │ │ ├── env.sh │ │ ├── printer.sh │ │ ├── reader.sh │ │ ├── run │ │ ├── step0_repl.sh │ │ ├── step1_read_print.sh │ │ ├── step2_eval.sh │ │ ├── step3_env.sh │ │ ├── step4_if_fn_do.sh │ │ ├── step5_tco.sh │ │ ├── step6_file.sh │ │ ├── step7_quote.sh │ │ ├── step8_macros.sh │ │ ├── step9_try.sh │ │ ├── stepA_mal.sh │ │ ├── tests/ │ │ │ └── stepA_mal.mal │ │ └── types.sh │ ├── basic/ │ │ ├── .args.mal │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── basicpp.py │ │ ├── cbmbasic_console.patch │ │ ├── core.in.bas │ │ ├── debug.in.bas │ │ ├── env.in.bas │ │ ├── mem.in.bas │ │ ├── printer.in.bas │ │ ├── reader.in.bas │ │ ├── readline.in.bas │ │ ├── run │ │ ├── step0_repl.in.bas │ │ ├── step1_read_print.in.bas │ │ ├── step2_eval.in.bas │ │ ├── step3_env.in.bas │ │ ├── step4_if_fn_do.in.bas │ │ ├── step5_tco.in.bas │ │ ├── step6_file.in.bas │ │ ├── step7_quote.in.bas │ │ ├── step8_macros.in.bas │ │ ├── step9_try.in.bas │ │ ├── stepA_mal.in.bas │ │ ├── types.in.bas │ │ └── variables.txt │ ├── bbc-basic/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── README.md │ │ ├── core.bas │ │ ├── env.bas │ │ ├── printer.bas │ │ ├── reader.bas │ │ ├── riscos/ │ │ │ ├── .gitignore │ │ │ ├── setup,feb │ │ │ └── tokenize,ffe │ │ ├── run │ │ ├── step0_repl.bas │ │ ├── step1_read_print.bas │ │ ├── step2_eval.bas │ │ ├── step3_env.bas │ │ ├── step4_if_fn_do.bas │ │ ├── step5_tco.bas │ │ ├── step6_file.bas │ │ ├── step7_quote.bas │ │ ├── step8_macros.bas │ │ ├── step9_try.bas │ │ ├── stepA_mal.bas │ │ └── types.bas │ ├── c/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.c │ │ ├── core.h │ │ ├── env.c │ │ ├── interop.c │ │ ├── interop.h │ │ ├── printer.c │ │ ├── printer.h │ │ ├── reader.c │ │ ├── reader.h │ │ ├── readline.c │ │ ├── readline.h │ │ ├── run │ │ ├── step0_repl.c │ │ ├── step1_read_print.c │ │ ├── step2_eval.c │ │ ├── step3_env.c │ │ ├── step4_if_fn_do.c │ │ ├── step5_tco.c │ │ ├── step6_file.c │ │ ├── step7_quote.c │ │ ├── step8_macros.c │ │ ├── step9_try.c │ │ ├── stepA_mal.c │ │ ├── tests/ │ │ │ ├── step5_tco.mal │ │ │ └── stepA_mal.mal │ │ ├── types.c │ │ └── types.h │ ├── c.2/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── README │ │ ├── core.c │ │ ├── core.h │ │ ├── env.c │ │ ├── env.h │ │ ├── error.c │ │ ├── error.h │ │ ├── hashmap.c │ │ ├── hashmap.h │ │ ├── linked_list.c │ │ ├── linked_list.h │ │ ├── printer.c │ │ ├── printer.h │ │ ├── reader.c │ │ ├── reader.h │ │ ├── readline.c │ │ ├── readline.h │ │ ├── run │ │ ├── step0_repl.c │ │ ├── step1_read_print.c │ │ ├── step2_eval.c │ │ ├── step3_env.c │ │ ├── step4_if_fn_do.c │ │ ├── step5_tco.c │ │ ├── step6_file.c │ │ ├── step7_quote.c │ │ ├── step8_macros.c │ │ ├── step9_try.c │ │ ├── stepA_mal.c │ │ ├── tests/ │ │ │ └── stepA_mal.mal │ │ ├── types.c │ │ ├── types.h │ │ ├── vector.c │ │ └── vector.h │ ├── chuck/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── chuck.md │ │ ├── core.ck │ │ ├── env.ck │ │ ├── func.ck │ │ ├── notes.md │ │ ├── printer.ck │ │ ├── reader.ck │ │ ├── readline.ck │ │ ├── run │ │ ├── step0_repl.ck │ │ ├── step1_read_print.ck │ │ ├── step2_eval.ck │ │ ├── step3_env.ck │ │ ├── step4_if_fn_do.ck │ │ ├── step5_tco.ck │ │ ├── step6_file.ck │ │ ├── step7_quote.ck │ │ ├── step8_macros.ck │ │ ├── step9_try.ck │ │ ├── stepA_mal.ck │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ ├── types/ │ │ │ ├── MalObject.ck │ │ │ ├── MalSubr.ck │ │ │ ├── mal/ │ │ │ │ ├── MalAtom.ck │ │ │ │ ├── MalError.ck │ │ │ │ ├── MalFalse.ck │ │ │ │ ├── MalHashMap.ck │ │ │ │ ├── MalInt.ck │ │ │ │ ├── MalKeyword.ck │ │ │ │ ├── MalList.ck │ │ │ │ ├── MalNil.ck │ │ │ │ ├── MalString.ck │ │ │ │ ├── MalSymbol.ck │ │ │ │ ├── MalTrue.ck │ │ │ │ └── MalVector.ck │ │ │ └── subr/ │ │ │ ├── MalAdd.ck │ │ │ ├── MalApply.ck │ │ │ ├── MalAssoc.ck │ │ │ ├── MalAtomify.ck │ │ │ ├── MalConcat.ck │ │ │ ├── MalConj.ck │ │ │ ├── MalCons.ck │ │ │ ├── MalCount.ck │ │ │ ├── MalDeref.ck │ │ │ ├── MalDissoc.ck │ │ │ ├── MalDiv.ck │ │ │ ├── MalDoReset.ck │ │ │ ├── MalDoSwap.ck │ │ │ ├── MalEqual.ck │ │ │ ├── MalFirst.ck │ │ │ ├── MalGet.ck │ │ │ ├── MalGreater.ck │ │ │ ├── MalGreaterEqual.ck │ │ │ ├── MalHashMapify.ck │ │ │ ├── MalIsAtom.ck │ │ │ ├── MalIsContains.ck │ │ │ ├── MalIsEmpty.ck │ │ │ ├── MalIsFalse.ck │ │ │ ├── MalIsFn.ck │ │ │ ├── MalIsHashMap.ck │ │ │ ├── MalIsKeyword.ck │ │ │ ├── MalIsList.ck │ │ │ ├── MalIsMacro.ck │ │ │ ├── MalIsNil.ck │ │ │ ├── MalIsNumber.ck │ │ │ ├── MalIsString.ck │ │ │ ├── MalIsSymbol.ck │ │ │ ├── MalIsTrue.ck │ │ │ ├── MalIsVector.ck │ │ │ ├── MalKeys.ck │ │ │ ├── MalKeywordify.ck │ │ │ ├── MalLess.ck │ │ │ ├── MalLessEqual.ck │ │ │ ├── MalListify.ck │ │ │ ├── MalMap.ck │ │ │ ├── MalMeta.ck │ │ │ ├── MalMul.ck │ │ │ ├── MalNth.ck │ │ │ ├── MalPrStr.ck │ │ │ ├── MalPrintln.ck │ │ │ ├── MalPrn.ck │ │ │ ├── MalReadStr.ck │ │ │ ├── MalReadline.ck │ │ │ ├── MalRest.ck │ │ │ ├── MalSeq.ck │ │ │ ├── MalSequential.ck │ │ │ ├── MalSlurp.ck │ │ │ ├── MalStr.ck │ │ │ ├── MalSub.ck │ │ │ ├── MalSymbolify.ck │ │ │ ├── MalThrow.ck │ │ │ ├── MalTimeMs.ck │ │ │ ├── MalVals.ck │ │ │ ├── MalVec.ck │ │ │ ├── MalVectorify.ck │ │ │ └── MalWithMeta.ck │ │ └── util/ │ │ ├── Constants.ck │ │ ├── String.ck │ │ └── Util.ck │ ├── clojure/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── package.json │ │ ├── project.clj │ │ ├── run │ │ ├── src/ │ │ │ └── mal/ │ │ │ ├── core.cljc │ │ │ ├── env.cljc │ │ │ ├── node_readline.js │ │ │ ├── printer.cljc │ │ │ ├── reader.cljc │ │ │ ├── readline.clj │ │ │ ├── readline.cljs │ │ │ ├── step0_repl.cljc │ │ │ ├── step1_read_print.cljc │ │ │ ├── step2_eval.cljc │ │ │ ├── step3_env.cljc │ │ │ ├── step4_if_fn_do.cljc │ │ │ ├── step5_tco.cljc │ │ │ ├── step6_file.cljc │ │ │ ├── step7_quote.cljc │ │ │ ├── step8_macros.cljc │ │ │ ├── step9_try.cljc │ │ │ └── stepA_mal.cljc │ │ └── tests/ │ │ ├── step5_tco.mal │ │ └── stepA_mal.mal │ ├── coffee/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.coffee │ │ ├── env.coffee │ │ ├── node_readline.coffee │ │ ├── package.json │ │ ├── printer.coffee │ │ ├── reader.coffee │ │ ├── run │ │ ├── step0_repl.coffee │ │ ├── step1_read_print.coffee │ │ ├── step2_eval.coffee │ │ ├── step3_env.coffee │ │ ├── step4_if_fn_do.coffee │ │ ├── step5_tco.coffee │ │ ├── step6_file.coffee │ │ ├── step7_quote.coffee │ │ ├── step8_macros.coffee │ │ ├── step9_try.coffee │ │ ├── stepA_mal.coffee │ │ ├── tests/ │ │ │ ├── step5_tco.mal │ │ │ └── stepA_mal.mal │ │ └── types.coffee │ ├── common-lisp/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── README.org │ │ ├── fake-readline.lisp │ │ ├── hist/ │ │ │ └── .keepdir │ │ ├── run │ │ ├── run-abcl.lisp │ │ ├── run-mkcl.lisp │ │ ├── src/ │ │ │ ├── core.lisp │ │ │ ├── env.lisp │ │ │ ├── printer.lisp │ │ │ ├── reader.lisp │ │ │ ├── step0_repl.lisp │ │ │ ├── step1_read_print.lisp │ │ │ ├── step2_eval.lisp │ │ │ ├── step3_env.lisp │ │ │ ├── step4_if_fn_do.lisp │ │ │ ├── step5_tco.lisp │ │ │ ├── step6_file.lisp │ │ │ ├── step7_quote.lisp │ │ │ ├── step8_macros.lisp │ │ │ ├── step9_try.lisp │ │ │ ├── stepA_mal.lisp │ │ │ ├── types.lisp │ │ │ └── utils.lisp │ │ ├── step0_repl.asd │ │ ├── step1_read_print.asd │ │ ├── step2_eval.asd │ │ ├── step3_env.asd │ │ ├── step4_if_fn_do.asd │ │ ├── step5_tco.asd │ │ ├── step6_file.asd │ │ ├── step7_quote.asd │ │ ├── step8_macros.asd │ │ ├── step9_try.asd │ │ ├── stepA_mal.asd │ │ └── tests/ │ │ └── stepA_mal.mal │ ├── cpp/ │ │ ├── .gitignore │ │ ├── Core.cpp │ │ ├── Debug.h │ │ ├── Dockerfile │ │ ├── Environment.cpp │ │ ├── Environment.h │ │ ├── MAL.h │ │ ├── Makefile │ │ ├── README.md │ │ ├── ReadLine.cpp │ │ ├── ReadLine.h │ │ ├── Reader.cpp │ │ ├── RefCountedPtr.h │ │ ├── StaticList.h │ │ ├── String.cpp │ │ ├── String.h │ │ ├── Types.cpp │ │ ├── Types.h │ │ ├── Validation.cpp │ │ ├── Validation.h │ │ ├── docker.sh │ │ ├── run │ │ ├── step0_repl.cpp │ │ ├── step1_read_print.cpp │ │ ├── step2_eval.cpp │ │ ├── step3_env.cpp │ │ ├── step4_if_fn_do.cpp │ │ ├── step5_tco.cpp │ │ ├── step6_file.cpp │ │ ├── step7_quote.cpp │ │ ├── step8_macros.cpp │ │ ├── step9_try.cpp │ │ ├── stepA_mal.cpp │ │ └── tests/ │ │ └── step5_tco.mal │ ├── crystal/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.cr │ │ ├── env.cr │ │ ├── error.cr │ │ ├── printer.cr │ │ ├── reader.cr │ │ ├── run │ │ ├── shard.yml │ │ ├── step0_repl.cr │ │ ├── step1_read_print.cr │ │ ├── step2_eval.cr │ │ ├── step3_env.cr │ │ ├── step4_if_fn_do.cr │ │ ├── step5_tco.cr │ │ ├── step6_file.cr │ │ ├── step7_quote.cr │ │ ├── step8_macros.cr │ │ ├── step9_try.cr │ │ ├── stepA_mal.cr │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ └── types.cr │ ├── cs/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.cs │ │ ├── env.cs │ │ ├── getline.cs │ │ ├── interop.cs │ │ ├── printer.cs │ │ ├── reader.cs │ │ ├── readline.cs │ │ ├── run │ │ ├── step0_repl.cs │ │ ├── step1_read_print.cs │ │ ├── step2_eval.cs │ │ ├── step3_env.cs │ │ ├── step4_if_fn_do.cs │ │ ├── step5_tco.cs │ │ ├── step6_file.cs │ │ ├── step7_quote.cs │ │ ├── step8_macros.cs │ │ ├── step9_try.cs │ │ ├── stepA_mal.cs │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ └── types.cs │ ├── d/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── env.d │ │ ├── main.di │ │ ├── mal_core.d │ │ ├── printer.d │ │ ├── reader.d │ │ ├── readline.d │ │ ├── run │ │ ├── step0_repl.d │ │ ├── step1_read_print.d │ │ ├── step2_eval.d │ │ ├── step3_env.d │ │ ├── step4_if_fn_do.d │ │ ├── step5_tco.d │ │ ├── step6_file.d │ │ ├── step7_quote.d │ │ ├── step8_macros.d │ │ ├── step9_try.d │ │ ├── stepA_mal.d │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ └── types.d │ ├── dart/ │ │ ├── .analysis_options │ │ ├── .packages │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.dart │ │ ├── env.dart │ │ ├── printer.dart │ │ ├── pubspec.yaml │ │ ├── reader.dart │ │ ├── run │ │ ├── step0_repl.dart │ │ ├── step1_read_print.dart │ │ ├── step2_eval.dart │ │ ├── step3_env.dart │ │ ├── step4_if_fn_do.dart │ │ ├── step5_tco.dart │ │ ├── step6_file.dart │ │ ├── step7_quote.dart │ │ ├── step8_macros.dart │ │ ├── step9_try.dart │ │ ├── stepA_mal.dart │ │ └── types.dart │ ├── elisp/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── mal/ │ │ │ ├── core.el │ │ │ ├── env.el │ │ │ ├── printer.el │ │ │ ├── reader.el │ │ │ └── types.el │ │ ├── run │ │ ├── step0_repl.el │ │ ├── step1_read_print.el │ │ ├── step2_eval.el │ │ ├── step3_env.el │ │ ├── step4_if_fn_do.el │ │ ├── step5_tco.el │ │ ├── step6_file.el │ │ ├── step7_quote.el │ │ ├── step8_macros.el │ │ ├── step9_try.el │ │ ├── stepA_mal.el │ │ └── tests/ │ │ ├── step5_tco.mal │ │ └── stepA_mal.mal │ ├── elixir/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── lib/ │ │ │ ├── mal/ │ │ │ │ ├── atom.ex │ │ │ │ ├── core.ex │ │ │ │ ├── env.ex │ │ │ │ ├── printer.ex │ │ │ │ ├── reader.ex │ │ │ │ └── types.ex │ │ │ ├── mal.ex │ │ │ └── mix/ │ │ │ └── tasks/ │ │ │ ├── step0_repl.ex │ │ │ ├── step1_read_print.ex │ │ │ ├── step2_eval.ex │ │ │ ├── step3_env.ex │ │ │ ├── step4_if_fn_do.ex │ │ │ ├── step5_tco.ex │ │ │ ├── step6_file.ex │ │ │ ├── step7_quote.ex │ │ │ ├── step8_macros.ex │ │ │ ├── step9_try.ex │ │ │ └── stepA_mal.ex │ │ ├── mix.exs │ │ ├── run │ │ └── tests/ │ │ └── step5_tco.mal │ ├── elm/ │ │ ├── .dockerignore │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── bootstrap.js │ │ ├── elm.json │ │ ├── node_readline.js │ │ ├── package.json │ │ ├── run │ │ └── src/ │ │ ├── Core.elm │ │ ├── Env.elm │ │ ├── Eval.elm │ │ ├── IO.elm │ │ ├── Printer.elm │ │ ├── Reader.elm │ │ ├── Step0_repl.elm │ │ ├── Step1_read_print.elm │ │ ├── Step2_eval.elm │ │ ├── Step3_env.elm │ │ ├── Step4_if_fn_do.elm │ │ ├── Step5_tco.elm │ │ ├── Step6_file.elm │ │ ├── Step7_quote.elm │ │ ├── Step8_macros.elm │ │ ├── Step9_try.elm │ │ ├── StepA_mal.elm │ │ ├── Types.elm │ │ └── Utils.elm │ ├── erlang/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── rebar.config │ │ ├── rebar.config.script │ │ ├── run │ │ ├── src/ │ │ │ ├── atom.erl │ │ │ ├── core.erl │ │ │ ├── env.erl │ │ │ ├── mal.app.src │ │ │ ├── printer.erl │ │ │ ├── reader.erl │ │ │ ├── step0_repl.erl │ │ │ ├── step1_read_print.erl │ │ │ ├── step2_eval.erl │ │ │ ├── step3_env.erl │ │ │ ├── step4_if_fn_do.erl │ │ │ ├── step5_tco.erl │ │ │ ├── step6_file.erl │ │ │ ├── step7_quote.erl │ │ │ ├── step8_macros.erl │ │ │ ├── step9_try.erl │ │ │ ├── stepA_mal.erl │ │ │ └── types.erl │ │ └── tests/ │ │ └── step5_tco.mal │ ├── es6/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.mjs │ │ ├── env.mjs │ │ ├── node_readline.mjs │ │ ├── package.json │ │ ├── printer.mjs │ │ ├── reader.mjs │ │ ├── run │ │ ├── step0_repl.mjs │ │ ├── step1_read_print.mjs │ │ ├── step2_eval.mjs │ │ ├── step3_env.mjs │ │ ├── step4_if_fn_do.mjs │ │ ├── step5_tco.mjs │ │ ├── step6_file.mjs │ │ ├── step7_quote.mjs │ │ ├── step8_macros.mjs │ │ ├── step9_try.mjs │ │ ├── stepA_mal.mjs │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ └── types.mjs │ ├── factor/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── lib/ │ │ │ ├── core/ │ │ │ │ ├── core-tests.factor │ │ │ │ └── core.factor │ │ │ ├── env/ │ │ │ │ ├── env-tests.factor │ │ │ │ └── env.factor │ │ │ ├── printer/ │ │ │ │ ├── printer-tests.factor │ │ │ │ └── printer.factor │ │ │ ├── reader/ │ │ │ │ ├── reader-tests.factor │ │ │ │ └── reader.factor │ │ │ └── types/ │ │ │ └── types.factor │ │ ├── run │ │ ├── step0_repl/ │ │ │ ├── deploy.factor │ │ │ └── step0_repl.factor │ │ ├── step1_read_print/ │ │ │ ├── deploy.factor │ │ │ └── step1_read_print.factor │ │ ├── step2_eval/ │ │ │ ├── deploy.factor │ │ │ └── step2_eval.factor │ │ ├── step3_env/ │ │ │ ├── deploy.factor │ │ │ └── step3_env.factor │ │ ├── step4_if_fn_do/ │ │ │ ├── deploy.factor │ │ │ └── step4_if_fn_do.factor │ │ ├── step5_tco/ │ │ │ ├── deploy.factor │ │ │ └── step5_tco.factor │ │ ├── step6_file/ │ │ │ ├── deploy.factor │ │ │ └── step6_file.factor │ │ ├── step7_quote/ │ │ │ ├── deploy.factor │ │ │ └── step7_quote.factor │ │ ├── step8_macros/ │ │ │ ├── deploy.factor │ │ │ └── step8_macros.factor │ │ ├── step9_try/ │ │ │ ├── deploy.factor │ │ │ └── step9_try.factor │ │ ├── stepA_mal/ │ │ │ ├── deploy.factor │ │ │ └── stepA_mal.factor │ │ └── tests/ │ │ └── step5_tco.mal │ ├── fantom/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── run │ │ ├── src/ │ │ │ ├── mallib/ │ │ │ │ ├── build.fan │ │ │ │ └── fan/ │ │ │ │ ├── core.fan │ │ │ │ ├── env.fan │ │ │ │ ├── interop.fan │ │ │ │ ├── reader.fan │ │ │ │ └── types.fan │ │ │ ├── step0_repl/ │ │ │ │ ├── build.fan │ │ │ │ └── fan/ │ │ │ │ └── main.fan │ │ │ ├── step1_read_print/ │ │ │ │ ├── build.fan │ │ │ │ └── fan/ │ │ │ │ └── main.fan │ │ │ ├── step2_eval/ │ │ │ │ ├── build.fan │ │ │ │ └── fan/ │ │ │ │ └── main.fan │ │ │ ├── step3_env/ │ │ │ │ ├── build.fan │ │ │ │ └── fan/ │ │ │ │ └── main.fan │ │ │ ├── step4_if_fn_do/ │ │ │ │ ├── build.fan │ │ │ │ └── fan/ │ │ │ │ └── main.fan │ │ │ ├── step5_tco/ │ │ │ │ ├── build.fan │ │ │ │ └── fan/ │ │ │ │ └── main.fan │ │ │ ├── step6_file/ │ │ │ │ ├── build.fan │ │ │ │ └── fan/ │ │ │ │ └── main.fan │ │ │ ├── step7_quote/ │ │ │ │ ├── build.fan │ │ │ │ └── fan/ │ │ │ │ └── main.fan │ │ │ ├── step8_macros/ │ │ │ │ ├── build.fan │ │ │ │ └── fan/ │ │ │ │ └── main.fan │ │ │ ├── step9_try/ │ │ │ │ ├── build.fan │ │ │ │ └── fan/ │ │ │ │ └── main.fan │ │ │ └── stepA_mal/ │ │ │ ├── build.fan │ │ │ └── fan/ │ │ │ └── main.fan │ │ └── tests/ │ │ ├── step5_tco.mal │ │ └── stepA_mal.mal │ ├── fennel/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.fnl │ │ ├── env.fnl │ │ ├── printer.fnl │ │ ├── reader.fnl │ │ ├── run │ │ ├── step0_repl.fnl │ │ ├── step1_read_print.fnl │ │ ├── step2_eval.fnl │ │ ├── step3_env.fnl │ │ ├── step4_if_fn_do.fnl │ │ ├── step5_tco.fnl │ │ ├── step6_file.fnl │ │ ├── step7_quote.fnl │ │ ├── step8_macros.fnl │ │ ├── step9_try.fnl │ │ ├── stepA_mal.fnl │ │ ├── types.fnl │ │ └── utils.fnl │ ├── forth/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.fs │ │ ├── env.fs │ │ ├── misc-tests.fs │ │ ├── printer.fs │ │ ├── reader.fs │ │ ├── run │ │ ├── step0_repl.fs │ │ ├── step1_read_print.fs │ │ ├── step2_eval.fs │ │ ├── step3_env.fs │ │ ├── step4_if_fn_do.fs │ │ ├── step5_tco.fs │ │ ├── step6_file.fs │ │ ├── step7_quote.fs │ │ ├── step8_macros.fs │ │ ├── step9_try.fs │ │ ├── stepA_mal.fs │ │ ├── str.fs │ │ ├── tests/ │ │ │ ├── step5_tco.mal │ │ │ └── stepA_mal.mal │ │ └── types.fs │ ├── fsharp/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.fs │ │ ├── env.fs │ │ ├── error.fs │ │ ├── node.fs │ │ ├── printer.fs │ │ ├── reader.fs │ │ ├── readline.fs │ │ ├── run │ │ ├── step0_repl.fs │ │ ├── step1_read_print.fs │ │ ├── step2_eval.fs │ │ ├── step3_env.fs │ │ ├── step4_if_fn_do.fs │ │ ├── step5_tco.fs │ │ ├── step6_file.fs │ │ ├── step7_quote.fs │ │ ├── step8_macros.fs │ │ ├── step9_try.fs │ │ ├── stepA_mal.fs │ │ ├── terminal.cs │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ ├── tokenizer.fs │ │ └── types.fs │ ├── gnu-smalltalk/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.st │ │ ├── env.st │ │ ├── func.st │ │ ├── printer.st │ │ ├── reader.st │ │ ├── readline.st │ │ ├── run │ │ ├── step0_repl.st │ │ ├── step1_read_print.st │ │ ├── step2_eval.st │ │ ├── step3_env.st │ │ ├── step4_if_fn_do.st │ │ ├── step5_tco.st │ │ ├── step6_file.st │ │ ├── step7_quote.st │ │ ├── step8_macros.st │ │ ├── step9_try.st │ │ ├── stepA_mal.st │ │ ├── tests/ │ │ │ └── stepA_mal.mal │ │ ├── types.st │ │ └── util.st │ ├── go/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── go.mod │ │ ├── run │ │ ├── src/ │ │ │ ├── core/ │ │ │ │ └── core.go │ │ │ ├── env/ │ │ │ │ └── env.go │ │ │ ├── printer/ │ │ │ │ └── printer.go │ │ │ ├── reader/ │ │ │ │ └── reader.go │ │ │ ├── readline/ │ │ │ │ └── readline.go │ │ │ ├── step0_repl/ │ │ │ │ └── step0_repl.go │ │ │ ├── step1_read_print/ │ │ │ │ └── step1_read_print.go │ │ │ ├── step2_eval/ │ │ │ │ └── step2_eval.go │ │ │ ├── step3_env/ │ │ │ │ └── step3_env.go │ │ │ ├── step4_if_fn_do/ │ │ │ │ └── step4_if_fn_do.go │ │ │ ├── step5_tco/ │ │ │ │ └── step5_tco.go │ │ │ ├── step6_file/ │ │ │ │ └── step6_file.go │ │ │ ├── step7_quote/ │ │ │ │ └── step7_quote.go │ │ │ ├── step8_macros/ │ │ │ │ └── step8_macros.go │ │ │ ├── step9_try/ │ │ │ │ └── step9_try.go │ │ │ ├── stepA_mal/ │ │ │ │ └── stepA_mal.go │ │ │ └── types/ │ │ │ └── types.go │ │ └── tests/ │ │ ├── step2_eval.mal │ │ ├── step4_if_fn_do.mal │ │ └── step5_tco.mal │ ├── groovy/ │ │ ├── Dockerfile │ │ ├── GroovyWrapper.groovy │ │ ├── Makefile │ │ ├── core.groovy │ │ ├── env.groovy │ │ ├── printer.groovy │ │ ├── reader.groovy │ │ ├── run │ │ ├── step0_repl.groovy │ │ ├── step1_read_print.groovy │ │ ├── step2_eval.groovy │ │ ├── step3_env.groovy │ │ ├── step4_if_fn_do.groovy │ │ ├── step5_tco.groovy │ │ ├── step6_file.groovy │ │ ├── step7_quote.groovy │ │ ├── step8_macros.groovy │ │ ├── step9_try.groovy │ │ ├── stepA_mal.groovy │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ └── types.groovy │ ├── guile/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.scm │ │ ├── env.scm │ │ ├── pcre.scm │ │ ├── printer.scm │ │ ├── reader.scm │ │ ├── readline.scm │ │ ├── run │ │ ├── step0_repl.scm │ │ ├── step1_read_print.scm │ │ ├── step2_eval.scm │ │ ├── step3_env.scm │ │ ├── step4_if_fn_do.scm │ │ ├── step5_tco.scm │ │ ├── step6_file.scm │ │ ├── step7_quote.scm │ │ ├── step8_macros.scm │ │ ├── step9_try.scm │ │ ├── stepA_mal.scm │ │ └── types.scm │ ├── hare/ │ │ ├── .gitignore │ │ ├── Dockerfile │ │ ├── makefile │ │ ├── mal/ │ │ │ ├── core.ha │ │ │ ├── env.ha │ │ │ ├── error.ha │ │ │ ├── gc.ha │ │ │ ├── hashmap.ha │ │ │ ├── printer.ha │ │ │ ├── reader.ha │ │ │ ├── tokenizer.ha │ │ │ └── types.ha │ │ ├── run │ │ ├── step0_repl.ha │ │ ├── step1_read_print.ha │ │ ├── step2_eval.ha │ │ ├── step3_env.ha │ │ ├── step4_if_fn_do.ha │ │ ├── step5_tco.ha │ │ ├── step6_file.ha │ │ ├── step7_quote.ha │ │ ├── step8_macros.ha │ │ ├── step9_try.ha │ │ └── stepA_mal.ha │ ├── haskell/ │ │ ├── Core.hs │ │ ├── Dockerfile │ │ ├── Env.hs │ │ ├── Makefile │ │ ├── Printer.hs │ │ ├── Reader.hs │ │ ├── Readline.hs │ │ ├── Types.hs │ │ ├── run │ │ ├── step0_repl.hs │ │ ├── step1_read_print.hs │ │ ├── step2_eval.hs │ │ ├── step3_env.hs │ │ ├── step4_if_fn_do.hs │ │ ├── step5_tco.hs │ │ ├── step6_file.hs │ │ ├── step7_quote.hs │ │ ├── step8_macros.hs │ │ ├── step9_try.hs │ │ ├── stepA_mal.hs │ │ └── tests/ │ │ └── step5_tco.mal │ ├── haxe/ │ │ ├── Compat.hx │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── Step0_repl.hx │ │ ├── Step1_read_print.hx │ │ ├── Step2_eval.hx │ │ ├── Step3_env.hx │ │ ├── Step4_if_fn_do.hx │ │ ├── Step5_tco.hx │ │ ├── Step6_file.hx │ │ ├── Step7_quote.hx │ │ ├── Step8_macros.hx │ │ ├── Step9_try.hx │ │ ├── StepA_mal.hx │ │ ├── core/ │ │ │ └── Core.hx │ │ ├── env/ │ │ │ └── Env.hx │ │ ├── node_readline.js │ │ ├── package.json │ │ ├── printer/ │ │ │ └── Printer.hx │ │ ├── reader/ │ │ │ ├── BlankLine.hx │ │ │ └── Reader.hx │ │ ├── run │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ └── types/ │ │ ├── MalException.hx │ │ └── Types.hx │ ├── hy/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.hy │ │ ├── env.hy │ │ ├── mal_types.hy │ │ ├── printer.hy │ │ ├── reader.hy │ │ ├── run │ │ ├── step0_repl.hy │ │ ├── step1_read_print.hy │ │ ├── step2_eval.hy │ │ ├── step3_env.hy │ │ ├── step4_if_fn_do.hy │ │ ├── step5_tco.hy │ │ ├── step6_file.hy │ │ ├── step7_quote.hy │ │ ├── step8_macros.hy │ │ ├── step9_try.hy │ │ ├── stepA_mal.hy │ │ └── tests/ │ │ └── step5_tco.mal │ ├── io/ │ │ ├── Dockerfile │ │ ├── Env.io │ │ ├── Makefile │ │ ├── MalCore.io │ │ ├── MalReader.io │ │ ├── MalReadline.io │ │ ├── MalTypes.io │ │ ├── run │ │ ├── step0_repl.io │ │ ├── step1_read_print.io │ │ ├── step2_eval.io │ │ ├── step3_env.io │ │ ├── step4_if_fn_do.io │ │ ├── step5_tco.io │ │ ├── step6_file.io │ │ ├── step7_quote.io │ │ ├── step8_macros.io │ │ ├── step9_try.io │ │ ├── stepA_mal.io │ │ └── tests/ │ │ ├── step5_tco.mal │ │ └── stepA_mal.mal │ ├── janet/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.janet │ │ ├── env.janet │ │ ├── printer.janet │ │ ├── reader.janet │ │ ├── run │ │ ├── step0_repl.janet │ │ ├── step1_read_print.janet │ │ ├── step2_eval.janet │ │ ├── step3_env.janet │ │ ├── step4_if_fn_do.janet │ │ ├── step5_tco.janet │ │ ├── step6_file.janet │ │ ├── step7_quote.janet │ │ ├── step8_macros.janet │ │ ├── step9_try.janet │ │ ├── stepA_mal.janet │ │ ├── tests/ │ │ │ └── stepA_mal.mal │ │ ├── types.janet │ │ └── utils.janet │ ├── java/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── pom.xml │ │ ├── run │ │ ├── src/ │ │ │ └── main/ │ │ │ └── java/ │ │ │ └── mal/ │ │ │ ├── core.java │ │ │ ├── env.java │ │ │ ├── printer.java │ │ │ ├── reader.java │ │ │ ├── readline.java │ │ │ ├── step0_repl.java │ │ │ ├── step1_read_print.java │ │ │ ├── step2_eval.java │ │ │ ├── step3_env.java │ │ │ ├── step4_if_fn_do.java │ │ │ ├── step5_tco.java │ │ │ ├── step6_file.java │ │ │ ├── step7_quote.java │ │ │ ├── step8_macros.java │ │ │ ├── step9_try.java │ │ │ ├── stepA_mal.java │ │ │ └── types.java │ │ └── tests/ │ │ └── step5_tco.mal │ ├── java-truffle/ │ │ ├── .gitignore │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── README.md │ │ ├── build.gradle │ │ ├── make-native.sh │ │ ├── run │ │ ├── settings.gradle │ │ └── src/ │ │ └── main/ │ │ └── java/ │ │ └── truffle/ │ │ └── mal/ │ │ ├── Core.java │ │ ├── MalEnv.java │ │ ├── Printer.java │ │ ├── Reader.java │ │ ├── Types.java │ │ ├── step0_repl.java │ │ ├── step1_read_print.java │ │ ├── step2_eval.java │ │ ├── step3_env.java │ │ ├── step4_if_fn_do.java │ │ ├── step5_tco.java │ │ ├── step6_file.java │ │ ├── step7_quote.java │ │ ├── step8_macros.java │ │ ├── step9_try.java │ │ ├── stepA_mal.java │ │ ├── stepB_calls.java │ │ ├── stepC_slots.java │ │ ├── stepD_caching.java │ │ └── stepE_macros.java │ ├── jq/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.jq │ │ ├── docs/ │ │ │ └── impl-notes.md │ │ ├── env.jq │ │ ├── interp.jq │ │ ├── printer.jq │ │ ├── reader.jq │ │ ├── run │ │ ├── step0_repl.jq │ │ ├── step1_read_print.jq │ │ ├── step2_eval.jq │ │ ├── step3_env.jq │ │ ├── step4_if_fn_do.jq │ │ ├── step5_tco.jq │ │ ├── step6_file.jq │ │ ├── step7_quote.jq │ │ ├── step8_macros.jq │ │ ├── step9_try.jq │ │ ├── stepA_mal.jq │ │ └── utils.jq │ ├── js/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.js │ │ ├── env.js │ │ ├── interop.js │ │ ├── jq_readline.js │ │ ├── node_readline.js │ │ ├── package.json │ │ ├── printer.js │ │ ├── reader.js │ │ ├── run │ │ ├── step0_repl.js │ │ ├── step1_read_print.js │ │ ├── step2_eval.js │ │ ├── step3_env.js │ │ ├── step4_if_fn_do.js │ │ ├── step5_tco.js │ │ ├── step6_file.js │ │ ├── step7_quote.js │ │ ├── step8_macros.js │ │ ├── step9_try.js │ │ ├── stepA_mal.js │ │ ├── tests/ │ │ │ ├── common.js │ │ │ ├── reader.js │ │ │ ├── step5_tco.mal │ │ │ ├── stepA_mal.mal │ │ │ └── types.js │ │ └── types.js │ ├── julia/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.jl │ │ ├── env.jl │ │ ├── printer.jl │ │ ├── reader.jl │ │ ├── readline_mod.jl │ │ ├── run │ │ ├── step0_repl.jl │ │ ├── step1_read_print.jl │ │ ├── step2_eval.jl │ │ ├── step3_env.jl │ │ ├── step4_if_fn_do.jl │ │ ├── step5_tco.jl │ │ ├── step6_file.jl │ │ ├── step7_quote.jl │ │ ├── step8_macros.jl │ │ ├── step9_try.jl │ │ ├── stepA_mal.jl │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ └── types.jl │ ├── kotlin/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── run │ │ ├── src/ │ │ │ └── mal/ │ │ │ ├── core.kt │ │ │ ├── env.kt │ │ │ ├── printer.kt │ │ │ ├── reader.kt │ │ │ ├── readline.kt │ │ │ ├── step0_repl.kt │ │ │ ├── step1_read_print.kt │ │ │ ├── step2_eval.kt │ │ │ ├── step3_env.kt │ │ │ ├── step4_if_fn_do.kt │ │ │ ├── step5_tco.kt │ │ │ ├── step6_file.kt │ │ │ ├── step7_quote.kt │ │ │ ├── step8_macros.kt │ │ │ ├── step9_try.kt │ │ │ ├── stepA_mal.kt │ │ │ └── types.kt │ │ └── tests/ │ │ └── step5_tco.mal │ ├── latex3/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.sty │ │ ├── env.sty │ │ ├── printer.sty │ │ ├── reader.sty │ │ ├── run │ │ ├── step0_repl.tex │ │ ├── step1_read_print.tex │ │ ├── step2_eval.tex │ │ ├── step3_env.tex │ │ ├── step4_if_fn_do.tex │ │ ├── step6_file.tex │ │ ├── step7_quote.tex │ │ ├── step8_macros.tex │ │ ├── step9_try.tex │ │ ├── stepA_mal.tex │ │ └── types.sty │ ├── lib/ │ │ ├── README.md │ │ ├── alias-hacks.mal │ │ ├── benchmark.mal │ │ ├── equality.mal │ │ ├── load-file-once.mal │ │ ├── memoize.mal │ │ ├── perf.mal │ │ ├── pprint.mal │ │ ├── protocols.mal │ │ ├── reducers.mal │ │ ├── test_cascade.mal │ │ ├── threading.mal │ │ └── trivial.mal │ ├── livescript/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.ls │ │ ├── env.ls │ │ ├── error.ls │ │ ├── node_readline.js │ │ ├── package.json │ │ ├── printer.ls │ │ ├── reader.ls │ │ ├── run │ │ ├── step0_repl.ls │ │ ├── step1_read_print.ls │ │ ├── step2_eval.ls │ │ ├── step3_env.ls │ │ ├── step4_if_fn_do.ls │ │ ├── step5_tco.ls │ │ ├── step6_file.ls │ │ ├── step7_quote.ls │ │ ├── step8_macros.ls │ │ ├── step9_try.ls │ │ ├── stepA_mal.ls │ │ └── utils.ls │ ├── logo/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.lg │ │ ├── env.lg │ │ ├── examples/ │ │ │ └── tree.mal │ │ ├── printer.lg │ │ ├── reader.lg │ │ ├── readline.lg │ │ ├── run │ │ ├── step0_repl.lg │ │ ├── step1_read_print.lg │ │ ├── step2_eval.lg │ │ ├── step3_env.lg │ │ ├── step4_if_fn_do.lg │ │ ├── step5_tco.lg │ │ ├── step6_file.lg │ │ ├── step7_quote.lg │ │ ├── step8_macros.lg │ │ ├── step9_try.lg │ │ ├── stepA_mal.lg │ │ ├── tests/ │ │ │ └── stepA_mal.mal │ │ └── types.lg │ ├── lua/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.lua │ │ ├── env.lua │ │ ├── printer.lua │ │ ├── reader.lua │ │ ├── readline.lua │ │ ├── run │ │ ├── step0_repl.lua │ │ ├── step1_read_print.lua │ │ ├── step2_eval.lua │ │ ├── step3_env.lua │ │ ├── step4_if_fn_do.lua │ │ ├── step5_tco.lua │ │ ├── step6_file.lua │ │ ├── step7_quote.lua │ │ ├── step8_macros.lua │ │ ├── step9_try.lua │ │ ├── stepA_mal.lua │ │ ├── tests/ │ │ │ ├── step5_tco.mal │ │ │ └── stepA_mal.mal │ │ ├── types.lua │ │ └── utils.lua │ ├── make/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── README │ │ ├── core.mk │ │ ├── env.mk │ │ ├── gmsl.mk │ │ ├── numbers.mk │ │ ├── printer.mk │ │ ├── reader.mk │ │ ├── readline.mk │ │ ├── rules.mk │ │ ├── run │ │ ├── step0_repl.mk │ │ ├── step1_read_print.mk │ │ ├── step2_eval.mk │ │ ├── step3_env.mk │ │ ├── step4_if_fn_do.mk │ │ ├── step6_file.mk │ │ ├── step7_quote.mk │ │ ├── step8_macros.mk │ │ ├── step9_try.mk │ │ ├── stepA_mal.mk │ │ ├── tests/ │ │ │ └── stepA_mal.mal │ │ ├── types.mk │ │ └── util.mk │ ├── matlab/ │ │ ├── +types/ │ │ │ ├── Atom.m │ │ │ ├── Function.m │ │ │ ├── HashMap.m │ │ │ ├── List.m │ │ │ ├── MalException.m │ │ │ ├── Nil.m │ │ │ ├── Reader.m │ │ │ ├── Symbol.m │ │ │ └── Vector.m │ │ ├── .dockerignore │ │ ├── Dict.m │ │ ├── Dockerfile │ │ ├── Env.m │ │ ├── Makefile │ │ ├── core.m │ │ ├── printer.m │ │ ├── reader.m │ │ ├── run │ │ ├── step0_repl.m │ │ ├── step1_read_print.m │ │ ├── step2_eval.m │ │ ├── step3_env.m │ │ ├── step4_if_fn_do.m │ │ ├── step5_tco.m │ │ ├── step6_file.m │ │ ├── step7_quote.m │ │ ├── step8_macros.m │ │ ├── step9_try.m │ │ ├── stepA_mal.m │ │ └── type_utils.m │ ├── miniMAL/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.json │ │ ├── env.json │ │ ├── miniMAL-core.json │ │ ├── node_readline.js │ │ ├── package.json │ │ ├── printer.json │ │ ├── reader.json │ │ ├── run │ │ ├── step0_repl.json │ │ ├── step1_read_print.json │ │ ├── step2_eval.json │ │ ├── step3_env.json │ │ ├── step4_if_fn_do.json │ │ ├── step5_tco.json │ │ ├── step6_file.json │ │ ├── step7_quote.json │ │ ├── step8_macros.json │ │ ├── step9_try.json │ │ ├── stepA_mal.json │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ └── types.json │ ├── nasm/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── README.md │ │ ├── core.asm │ │ ├── env.asm │ │ ├── exceptions.asm │ │ ├── macros.mac │ │ ├── printer.asm │ │ ├── reader.asm │ │ ├── run │ │ ├── step0_repl.asm │ │ ├── step1_read_print.asm │ │ ├── step2_eval.asm │ │ ├── step3_env.asm │ │ ├── step4_if_fn_do.asm │ │ ├── step5_tco.asm │ │ ├── step6_file.asm │ │ ├── step7_quote.asm │ │ ├── step8_macros.asm │ │ ├── step9_try.asm │ │ ├── stepA_mal.asm │ │ ├── system.asm │ │ └── types.asm │ ├── nim/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.nim │ │ ├── env.nim │ │ ├── mal.nimble │ │ ├── nim.cfg │ │ ├── printer.nim │ │ ├── reader.nim │ │ ├── run │ │ ├── step0_repl.nim │ │ ├── step1_read_print.nim │ │ ├── step2_eval.nim │ │ ├── step3_env.nim │ │ ├── step4_if_fn_do.nim │ │ ├── step5_tco.nim │ │ ├── step6_file.nim │ │ ├── step7_quote.nim │ │ ├── step8_macros.nim │ │ ├── step9_try.nim │ │ ├── stepA_mal.nim │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ └── types.nim │ ├── objc/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.h │ │ ├── core.m │ │ ├── env.h │ │ ├── env.m │ │ ├── mal_readline.c │ │ ├── mal_readline.h │ │ ├── malfunc.h │ │ ├── malfunc.m │ │ ├── printer.h │ │ ├── printer.m │ │ ├── reader.h │ │ ├── reader.m │ │ ├── run │ │ ├── step0_repl.m │ │ ├── step1_read_print.m │ │ ├── step2_eval.m │ │ ├── step3_env.m │ │ ├── step4_if_fn_do.m │ │ ├── step5_tco.m │ │ ├── step6_file.m │ │ ├── step7_quote.m │ │ ├── step8_macros.m │ │ ├── step9_try.m │ │ ├── stepA_mal.m │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ ├── types.h │ │ └── types.m │ ├── objpascal/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.pas │ │ ├── mal_env.pas │ │ ├── mal_func.pas │ │ ├── mal_readline.pas │ │ ├── mal_types.pas │ │ ├── printer.pas │ │ ├── reader.pas │ │ ├── regexpr/ │ │ │ └── Source/ │ │ │ └── RegExpr.pas │ │ ├── run │ │ ├── step0_repl.pas │ │ ├── step1_read_print.pas │ │ ├── step2_eval.pas │ │ ├── step3_env.pas │ │ ├── step4_if_fn_do.pas │ │ ├── step5_tco.pas │ │ ├── step6_file.pas │ │ ├── step7_quote.pas │ │ ├── step8_macros.pas │ │ ├── step9_try.pas │ │ ├── stepA_mal.pas │ │ └── tests/ │ │ └── step5_tco.mal │ ├── ocaml/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.ml │ │ ├── env.ml │ │ ├── printer.ml │ │ ├── reader.ml │ │ ├── run │ │ ├── step0_repl.ml │ │ ├── step1_read_print.ml │ │ ├── step2_eval.ml │ │ ├── step3_env.ml │ │ ├── step4_if_fn_do.ml │ │ ├── step6_file.ml │ │ ├── step7_quote.ml │ │ ├── step8_macros.ml │ │ ├── step9_try.ml │ │ ├── stepA_mal.ml │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ └── types.ml │ ├── perl/ │ │ ├── Core.pm │ │ ├── Dockerfile │ │ ├── Env.pm │ │ ├── Interop.pm │ │ ├── Makefile │ │ ├── Printer.pm │ │ ├── README.md │ │ ├── Reader.pm │ │ ├── Readline.pm │ │ ├── Types.pm │ │ ├── run │ │ ├── step0_repl.pl │ │ ├── step1_read_print.pl │ │ ├── step2_eval.pl │ │ ├── step3_env.pl │ │ ├── step4_if_fn_do.pl │ │ ├── step5_tco.pl │ │ ├── step6_file.pl │ │ ├── step7_quote.pl │ │ ├── step8_macros.pl │ │ ├── step9_try.pl │ │ ├── stepA_mal.pl │ │ └── tests/ │ │ ├── step5_tco.mal │ │ └── stepA_mal.mal │ ├── perl6/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.pm │ │ ├── env.pm │ │ ├── printer.pm │ │ ├── reader.pm │ │ ├── run │ │ ├── step0_repl.pl │ │ ├── step1_read_print.pl │ │ ├── step2_eval.pl │ │ ├── step3_env.pl │ │ ├── step4_if_fn_do.pl │ │ ├── step5_tco.pl │ │ ├── step6_file.pl │ │ ├── step7_quote.pl │ │ ├── step8_macros.pl │ │ ├── step9_try.pl │ │ ├── stepA_mal.pl │ │ ├── tests/ │ │ │ └── stepA_mal.mal │ │ └── types.pm │ ├── php/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── README.md │ │ ├── core.php │ │ ├── env.php │ │ ├── interop.php │ │ ├── printer.php │ │ ├── reader.php │ │ ├── readline.php │ │ ├── run │ │ ├── step0_repl.php │ │ ├── step1_read_print.php │ │ ├── step2_eval.php │ │ ├── step3_env.php │ │ ├── step4_if_fn_do.php │ │ ├── step5_tco.php │ │ ├── step6_file.php │ │ ├── step7_quote.php │ │ ├── step8_macros.php │ │ ├── step9_try.php │ │ ├── stepA_mal.php │ │ ├── tests/ │ │ │ ├── step5_tco.mal │ │ │ └── stepA_mal.mal │ │ ├── types.php │ │ └── webrunner.php │ ├── picolisp/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.l │ │ ├── env.l │ │ ├── func.l │ │ ├── printer.l │ │ ├── reader.l │ │ ├── readline.l │ │ ├── run │ │ ├── step0_repl.l │ │ ├── step1_read_print.l │ │ ├── step2_eval.l │ │ ├── step3_env.l │ │ ├── step4_if_fn_do.l │ │ ├── step5_tco.l │ │ ├── step6_file.l │ │ ├── step7_quote.l │ │ ├── step8_macros.l │ │ ├── step9_try.l │ │ ├── stepA_mal.l │ │ ├── tests/ │ │ │ ├── step5_tco.mal │ │ │ └── stepA_mal.mal │ │ └── types.l │ ├── pike/ │ │ ├── Core.pmod │ │ ├── Dockerfile │ │ ├── Env.pmod │ │ ├── Interop.pmod │ │ ├── Makefile │ │ ├── Printer.pmod │ │ ├── Reader.pmod │ │ ├── Readline.pmod │ │ ├── Types.pmod │ │ ├── run │ │ ├── step0_repl.pike │ │ ├── step1_read_print.pike │ │ ├── step2_eval.pike │ │ ├── step3_env.pike │ │ ├── step4_if_fn_do.pike │ │ ├── step5_tco.pike │ │ ├── step6_file.pike │ │ ├── step7_quote.pike │ │ ├── step8_macros.pike │ │ ├── step9_try.pike │ │ ├── stepA_mal.pike │ │ └── tests/ │ │ ├── step5_tco.mal │ │ └── stepA_mal.mal │ ├── plpgsql/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.sql │ │ ├── entrypoint.sh │ │ ├── envs.sql │ │ ├── init.sql │ │ ├── io.sql │ │ ├── printer.sql │ │ ├── reader.sql │ │ ├── run │ │ ├── step0_repl.sql │ │ ├── step1_read_print.sql │ │ ├── step2_eval.sql │ │ ├── step3_env.sql │ │ ├── step4_if_fn_do.sql │ │ ├── step5_tco.sql │ │ ├── step6_file.sql │ │ ├── step7_quote.sql │ │ ├── step8_macros.sql │ │ ├── step9_try.sql │ │ ├── stepA_mal.sql │ │ ├── types.sql │ │ └── wrap.sh │ ├── plsql/ │ │ ├── Dockerfile │ │ ├── Dockerfile-oracle │ │ ├── Dockerfile-postgres │ │ ├── Makefile │ │ ├── core.sql │ │ ├── entrypoint.sh │ │ ├── env.sql │ │ ├── io.sql │ │ ├── login.sql │ │ ├── printer.sql │ │ ├── reader.sql │ │ ├── run │ │ ├── step0_repl.sql │ │ ├── step1_read_print.sql │ │ ├── step2_eval.sql │ │ ├── step3_env.sql │ │ ├── step4_if_fn_do.sql │ │ ├── step5_tco.sql │ │ ├── step6_file.sql │ │ ├── step7_quote.sql │ │ ├── step8_macros.sql │ │ ├── step9_try.sql │ │ ├── stepA_mal.sql │ │ ├── types.sql │ │ └── wrap.sh │ ├── powershell/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.psm1 │ │ ├── env.psm1 │ │ ├── printer.psm1 │ │ ├── reader.psm1 │ │ ├── run │ │ ├── step0_repl.ps1 │ │ ├── step1_read_print.ps1 │ │ ├── step2_eval.ps1 │ │ ├── step3_env.ps1 │ │ ├── step4_if_fn_do.ps1 │ │ ├── step5_tco.ps1 │ │ ├── step6_file.ps1 │ │ ├── step7_quote.ps1 │ │ ├── step8_macros.ps1 │ │ ├── step9_try.ps1 │ │ ├── stepA_mal.ps1 │ │ └── types.psm1 │ ├── prolog/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.pl │ │ ├── env.pl │ │ ├── printer.pl │ │ ├── reader.pl │ │ ├── run │ │ ├── step0_repl.pl │ │ ├── step1_read_print.pl │ │ ├── step2_eval.pl │ │ ├── step3_env.pl │ │ ├── step4_if_fn_do.pl │ │ ├── step6_file.pl │ │ ├── step7_quote.pl │ │ ├── step8_macros.pl │ │ ├── step9_try.pl │ │ ├── stepA_mal.pl │ │ ├── tests/ │ │ │ └── stepA_mal.mal │ │ ├── types.pl │ │ └── utils.pl │ ├── ps/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.ps │ │ ├── env.ps │ │ ├── interop.ps │ │ ├── printer.ps │ │ ├── reader.ps │ │ ├── run │ │ ├── step0_repl.ps │ │ ├── step1_read_print.ps │ │ ├── step2_eval.ps │ │ ├── step3_env.ps │ │ ├── step4_if_fn_do.ps │ │ ├── step5_tco.ps │ │ ├── step6_file.ps │ │ ├── step7_quote.ps │ │ ├── step8_macros.ps │ │ ├── step9_try.ps │ │ ├── stepA_mal.ps │ │ ├── tests/ │ │ │ ├── step5_tco.mal │ │ │ └── stepA_mal.mal │ │ └── types.ps │ ├── purs/ │ │ ├── .gitignore │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── package.json │ │ ├── packages.dhall │ │ ├── run │ │ ├── spago.dhall │ │ └── src/ │ │ ├── Core.purs │ │ ├── Env.purs │ │ ├── Printer.purs │ │ ├── Reader.purs │ │ ├── Readline.js │ │ ├── Readline.purs │ │ ├── Types.purs │ │ ├── step0_repl.purs │ │ ├── step1_read_print.purs │ │ ├── step2_eval.purs │ │ ├── step3_env.purs │ │ ├── step4_if_fn_do.purs │ │ ├── step5_tco.purs │ │ ├── step6_file.purs │ │ ├── step7_quote.purs │ │ ├── step8_macros.purs │ │ ├── step9_try.purs │ │ └── stepA_mal.purs │ ├── python2/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.py │ │ ├── env.py │ │ ├── mal_readline.py │ │ ├── mal_types.py │ │ ├── printer.py │ │ ├── reader.py │ │ ├── run │ │ ├── step0_repl.py │ │ ├── step1_read_print.py │ │ ├── step2_eval.py │ │ ├── step3_env.py │ │ ├── step4_if_fn_do.py │ │ ├── step5_tco.py │ │ ├── step6_file.py │ │ ├── step7_quote.py │ │ ├── step8_macros.py │ │ ├── step9_try.py │ │ ├── stepA_mal.py │ │ └── tests/ │ │ ├── step5_tco.mal │ │ └── stepA_mal.mal │ ├── python3/ │ │ ├── .gitignore │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.py │ │ ├── env.py │ │ ├── mal_readline.py │ │ ├── mal_types.py │ │ ├── reader.py │ │ ├── run │ │ ├── step0_repl.py │ │ ├── step1_read_print.py │ │ ├── step2_eval.py │ │ ├── step3_env.py │ │ ├── step4_if_fn_do.py │ │ ├── step5_tco.py │ │ ├── step6_file.py │ │ ├── step7_quote.py │ │ ├── step8_macros.py │ │ ├── step9_try.py │ │ ├── stepA_mal.py │ │ └── tests/ │ │ ├── __init__.py │ │ ├── step5_tco.mal │ │ ├── stepA_mal.mal │ │ ├── test_step2.py │ │ ├── test_step3.py │ │ ├── test_step4.py │ │ ├── test_step5.py │ │ ├── test_step6.py │ │ ├── test_step7.py │ │ ├── test_step8.py │ │ ├── test_step9.py │ │ └── test_stepA.py │ ├── r/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.r │ │ ├── env.r │ │ ├── printer.r │ │ ├── reader.r │ │ ├── readline.r │ │ ├── run │ │ ├── step0_repl.r │ │ ├── step1_read_print.r │ │ ├── step2_eval.r │ │ ├── step3_env.r │ │ ├── step4_if_fn_do.r │ │ ├── step5_tco.r │ │ ├── step6_file.r │ │ ├── step7_quote.r │ │ ├── step8_macros.r │ │ ├── step9_try.r │ │ ├── stepA_mal.r │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ └── types.r │ ├── racket/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.rkt │ │ ├── env.rkt │ │ ├── printer.rkt │ │ ├── reader.rkt │ │ ├── readline.rkt │ │ ├── run │ │ ├── step0_repl.rkt │ │ ├── step1_read_print.rkt │ │ ├── step2_eval.rkt │ │ ├── step3_env.rkt │ │ ├── step4_if_fn_do.rkt │ │ ├── step5_tco.rkt │ │ ├── step6_file.rkt │ │ ├── step7_quote.rkt │ │ ├── step8_macros.rkt │ │ ├── step9_try.rkt │ │ ├── stepA_mal.rkt │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ └── types.rkt │ ├── rexx/ │ │ ├── .gitignore │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.rexx │ │ ├── env.rexx │ │ ├── printer.rexx │ │ ├── reader.rexx │ │ ├── readline.rexx │ │ ├── run │ │ ├── step0_repl.rexx │ │ ├── step1_read_print.rexx │ │ ├── step2_eval.rexx │ │ ├── step3_env.rexx │ │ ├── step4_if_fn_do.rexx │ │ ├── step5_tco.rexx │ │ ├── step6_file.rexx │ │ ├── step7_quote.rexx │ │ ├── step8_macros.rexx │ │ ├── step9_try.rexx │ │ ├── stepA_mal.rexx │ │ ├── tests/ │ │ │ ├── step5_tco.mal │ │ │ └── stepA_mal.mal │ │ └── types.rexx │ ├── rpython/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.py │ │ ├── env.py │ │ ├── mal_readline.py │ │ ├── mal_types.py │ │ ├── printer.py │ │ ├── reader.py │ │ ├── run │ │ ├── step0_repl.py │ │ ├── step1_read_print.py │ │ ├── step2_eval.py │ │ ├── step3_env.py │ │ ├── step4_if_fn_do.py │ │ ├── step5_tco.py │ │ ├── step6_file.py │ │ ├── step7_quote.py │ │ ├── step8_macros.py │ │ ├── step9_try.py │ │ ├── stepA_mal.py │ │ └── tests/ │ │ └── step5_tco.mal │ ├── ruby/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.rb │ │ ├── env.rb │ │ ├── mal_readline.rb │ │ ├── printer.rb │ │ ├── reader.rb │ │ ├── run │ │ ├── step0_repl.rb │ │ ├── step1_read_print.rb │ │ ├── step2_eval.rb │ │ ├── step3_env.rb │ │ ├── step4_if_fn_do.rb │ │ ├── step5_tco.rb │ │ ├── step6_file.rb │ │ ├── step7_quote.rb │ │ ├── step8_macros.rb │ │ ├── step9_try.rb │ │ ├── stepA_mal.rb │ │ ├── tests/ │ │ │ ├── step5_tco.mal │ │ │ └── stepA_mal.mal │ │ └── types.rb │ ├── ruby.2/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.rb │ │ ├── env.rb │ │ ├── errors.rb │ │ ├── printer.rb │ │ ├── reader.rb │ │ ├── run │ │ ├── step0_repl.rb │ │ ├── step1_read_print.rb │ │ ├── step2_eval.rb │ │ ├── step3_env.rb │ │ ├── step4_if_fn_do.rb │ │ ├── step5_tco.rb │ │ ├── step6_file.rb │ │ ├── step7_quote.rb │ │ ├── step8_macros.rb │ │ ├── step9_try.rb │ │ ├── stepA_mal.rb │ │ └── types.rb │ ├── rust/ │ │ ├── .gitignore │ │ ├── Cargo.toml │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.rs │ │ ├── env.rs │ │ ├── printer.rs │ │ ├── reader.rs │ │ ├── readline.rs │ │ ├── run │ │ ├── step0_repl.rs │ │ ├── step1_read_print.rs │ │ ├── step2_eval.rs │ │ ├── step3_env.rs │ │ ├── step4_if_fn_do.rs │ │ ├── step5_tco.rs │ │ ├── step6_file.rs │ │ ├── step7_quote.rs │ │ ├── step8_macros.rs │ │ ├── step9_try.rs │ │ ├── stepA_mal.rs │ │ └── types.rs │ ├── scala/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── assembly.sbt │ │ ├── build.sbt │ │ ├── core.scala │ │ ├── env.scala │ │ ├── printer.scala │ │ ├── project/ │ │ │ └── assembly.sbt │ │ ├── reader.scala │ │ ├── run │ │ ├── step0_repl.scala │ │ ├── step1_read_print.scala │ │ ├── step2_eval.scala │ │ ├── step3_env.scala │ │ ├── step4_if_fn_do.scala │ │ ├── step5_tco.scala │ │ ├── step6_file.scala │ │ ├── step7_quote.scala │ │ ├── step8_macros.scala │ │ ├── step9_try.scala │ │ ├── stepA_mal.scala │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ └── types.scala │ ├── scheme/ │ │ ├── .gitignore │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── lib/ │ │ │ ├── core.sld │ │ │ ├── env.sld │ │ │ ├── printer.sld │ │ │ ├── reader.sld │ │ │ ├── types.sld │ │ │ └── util.sld │ │ ├── run │ │ ├── step0_repl.scm │ │ ├── step1_read_print.scm │ │ ├── step2_eval.scm │ │ ├── step3_env.scm │ │ ├── step4_if_fn_do.scm │ │ ├── step5_tco.scm │ │ ├── step6_file.scm │ │ ├── step7_quote.scm │ │ ├── step8_macros.scm │ │ ├── step9_try.scm │ │ ├── stepA_mal.scm │ │ └── tests/ │ │ └── stepA_mal.mal │ ├── skew/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.sk │ │ ├── env.sk │ │ ├── printer.sk │ │ ├── reader.sk │ │ ├── run │ │ ├── step0_repl.sk │ │ ├── step1_read_print.sk │ │ ├── step2_eval.sk │ │ ├── step3_env.sk │ │ ├── step4_if_fn_do.sk │ │ ├── step5_tco.sk │ │ ├── step6_file.sk │ │ ├── step7_quote.sk │ │ ├── step8_macros.sk │ │ ├── step9_try.sk │ │ ├── stepA_mal.sk │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ ├── types.sk │ │ └── util.sk │ ├── sml/ │ │ ├── .gitignore │ │ ├── Dockerfile │ │ ├── LargeInt.sml │ │ ├── Makefile │ │ ├── README.md │ │ ├── core.sml │ │ ├── env.sml │ │ ├── main.sml │ │ ├── printer.sml │ │ ├── reader.sml │ │ ├── run │ │ ├── step0_repl.mlb │ │ ├── step0_repl.sml │ │ ├── step1_read_print.mlb │ │ ├── step1_read_print.sml │ │ ├── step2_eval.mlb │ │ ├── step2_eval.sml │ │ ├── step3_env.mlb │ │ ├── step3_env.sml │ │ ├── step4_if_fn_do.mlb │ │ ├── step4_if_fn_do.sml │ │ ├── step6_file.mlb │ │ ├── step6_file.sml │ │ ├── step7_quote.mlb │ │ ├── step7_quote.sml │ │ ├── step8_macros.mlb │ │ ├── step8_macros.sml │ │ ├── step9_try.mlb │ │ ├── step9_try.sml │ │ ├── stepA_mal.mlb │ │ ├── stepA_mal.sml │ │ ├── types.sml │ │ └── util.sml │ ├── swift3/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── Sources/ │ │ │ ├── core.swift │ │ │ ├── env.swift │ │ │ ├── printer.swift │ │ │ ├── reader.swift │ │ │ ├── step0_repl/ │ │ │ │ └── main.swift │ │ │ ├── step1_read_print/ │ │ │ │ └── main.swift │ │ │ ├── step2_eval/ │ │ │ │ └── main.swift │ │ │ ├── step3_env/ │ │ │ │ └── main.swift │ │ │ ├── step4_if_fn_do/ │ │ │ │ └── main.swift │ │ │ ├── step5_tco/ │ │ │ │ └── main.swift │ │ │ ├── step6_file/ │ │ │ │ └── main.swift │ │ │ ├── step7_quote/ │ │ │ │ └── main.swift │ │ │ ├── step8_macros/ │ │ │ │ └── main.swift │ │ │ ├── step9_try/ │ │ │ │ └── main.swift │ │ │ ├── stepA_mal/ │ │ │ │ └── main.swift │ │ │ └── types.swift │ │ ├── run │ │ └── tests/ │ │ └── step5_tco.mal │ ├── swift4/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── Sources/ │ │ │ ├── core.swift │ │ │ ├── env.swift │ │ │ ├── printer.swift │ │ │ ├── reader.swift │ │ │ ├── step0_repl/ │ │ │ │ └── main.swift │ │ │ ├── step1_read_print/ │ │ │ │ └── main.swift │ │ │ ├── step2_eval/ │ │ │ │ └── main.swift │ │ │ ├── step3_env/ │ │ │ │ └── main.swift │ │ │ ├── step4_if_fn_do/ │ │ │ │ └── main.swift │ │ │ ├── step5_tco/ │ │ │ │ └── main.swift │ │ │ ├── step6_file/ │ │ │ │ └── main.swift │ │ │ ├── step7_quote/ │ │ │ │ └── main.swift │ │ │ ├── step8_macros/ │ │ │ │ └── main.swift │ │ │ ├── step9_try/ │ │ │ │ └── main.swift │ │ │ ├── stepA_mal/ │ │ │ │ └── main.swift │ │ │ └── types.swift │ │ └── run │ ├── swift6/ │ │ ├── .gitignore │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── Package.swift │ │ ├── Sources/ │ │ │ ├── core/ │ │ │ │ ├── Core.swift │ │ │ │ ├── Env.swift │ │ │ │ ├── Errors.swift │ │ │ │ ├── Parser.swift │ │ │ │ ├── Printer.swift │ │ │ │ ├── Reader.swift │ │ │ │ ├── Types.swift │ │ │ │ └── Utils.swift │ │ │ ├── step0_repl/ │ │ │ │ └── main.swift │ │ │ ├── step1_read_print/ │ │ │ │ └── main.swift │ │ │ ├── step2_eval/ │ │ │ │ └── main.swift │ │ │ ├── step3_env/ │ │ │ │ └── main.swift │ │ │ ├── step4_if_fn_do/ │ │ │ │ └── main.swift │ │ │ ├── step5_tco/ │ │ │ │ └── main.swift │ │ │ ├── step6_file/ │ │ │ │ └── main.swift │ │ │ ├── step7_quote/ │ │ │ │ └── main.swift │ │ │ ├── step8_macros/ │ │ │ │ └── main.swift │ │ │ ├── step9_try/ │ │ │ │ └── main.swift │ │ │ └── stepA_mal/ │ │ │ └── main.swift │ │ └── run │ ├── tcl/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.tcl │ │ ├── env.tcl │ │ ├── mal_readline.tcl │ │ ├── printer.tcl │ │ ├── reader.tcl │ │ ├── run │ │ ├── step0_repl.tcl │ │ ├── step1_read_print.tcl │ │ ├── step2_eval.tcl │ │ ├── step3_env.tcl │ │ ├── step4_if_fn_do.tcl │ │ ├── step5_tco.tcl │ │ ├── step6_file.tcl │ │ ├── step7_quote.tcl │ │ ├── step8_macros.tcl │ │ ├── step9_try.tcl │ │ ├── stepA_mal.tcl │ │ ├── tests/ │ │ │ ├── step5_tco.mal │ │ │ └── stepA_mal.mal │ │ └── types.tcl │ ├── tests/ │ │ ├── busywork.mal │ │ ├── computations.mal │ │ ├── docker/ │ │ │ └── Dockerfile │ │ ├── docker-build.sh │ │ ├── docker-run.sh │ │ ├── fib.mal │ │ ├── inc.mal │ │ ├── incA.mal │ │ ├── incB.mal │ │ ├── incC.mal │ │ ├── lib/ │ │ │ ├── alias-hacks.mal │ │ │ ├── equality.mal │ │ │ ├── load-file-once-inc.mal │ │ │ ├── load-file-once.mal │ │ │ ├── memoize.mal │ │ │ ├── pprint.mal │ │ │ ├── protocols.mal │ │ │ ├── reducers.mal │ │ │ ├── test_cascade.mal │ │ │ ├── threading.mal │ │ │ └── trivial.mal │ │ ├── perf1.mal │ │ ├── perf2.mal │ │ ├── perf3.mal │ │ ├── print_argv.mal │ │ ├── run_argv_test.sh │ │ ├── step0_repl.mal │ │ ├── step1_read_print.mal │ │ ├── step2_eval.mal │ │ ├── step3_env.mal │ │ ├── step4_if_fn_do.mal │ │ ├── step5_tco.mal │ │ ├── step6_file.mal │ │ ├── step7_quote.mal │ │ ├── step8_macros.mal │ │ ├── step9_try.mal │ │ ├── stepA_mal.mal │ │ ├── test.txt │ │ └── travis_trigger.sh │ ├── ts/ │ │ ├── .gitignore │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.ts │ │ ├── env.ts │ │ ├── node_readline.ts │ │ ├── package.json │ │ ├── printer.ts │ │ ├── reader.ts │ │ ├── run │ │ ├── step0_repl.ts │ │ ├── step1_read_print.ts │ │ ├── step2_eval.ts │ │ ├── step3_env.ts │ │ ├── step4_if_fn_do.ts │ │ ├── step5_tco.ts │ │ ├── step6_file.ts │ │ ├── step7_quote.ts │ │ ├── step8_macros.ts │ │ ├── step9_try.ts │ │ ├── stepA_mal.ts │ │ ├── tsconfig.json │ │ └── types.ts │ ├── vala/ │ │ ├── .gitignore │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── README.md │ │ ├── core.vala │ │ ├── env.vala │ │ ├── gc.vala │ │ ├── printer.vala │ │ ├── reader.vala │ │ ├── run │ │ ├── step0_repl.vala │ │ ├── step1_read_print.vala │ │ ├── step2_eval.vala │ │ ├── step3_env.vala │ │ ├── step4_if_fn_do.vala │ │ ├── step5_tco.vala │ │ ├── step6_file.vala │ │ ├── step7_quote.vala │ │ ├── step8_macros.vala │ │ ├── step9_try.vala │ │ ├── stepA_mal.vala │ │ └── types.vala │ ├── vb/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.vb │ │ ├── env.vb │ │ ├── getline.cs │ │ ├── printer.vb │ │ ├── reader.vb │ │ ├── readline.vb │ │ ├── run │ │ ├── step0_repl.vb │ │ ├── step1_read_print.vb │ │ ├── step2_eval.vb │ │ ├── step3_env.vb │ │ ├── step4_if_fn_do.vb │ │ ├── step5_tco.vb │ │ ├── step6_file.vb │ │ ├── step7_quote.vb │ │ ├── step8_macros.vb │ │ ├── step9_try.vb │ │ ├── stepA_mal.vb │ │ ├── tests/ │ │ │ └── step5_tco.mal │ │ └── types.vb │ ├── vbs/ │ │ ├── Makefile │ │ ├── core.vbs │ │ ├── env.vbs │ │ ├── install.vbs │ │ ├── io.vbs │ │ ├── printer.vbs │ │ ├── reader.vbs │ │ ├── run │ │ ├── step0_repl.vbs │ │ ├── step1_read_print.vbs │ │ ├── step2_eval.vbs │ │ ├── step3_env.vbs │ │ ├── step4_if_fn_do.vbs │ │ ├── step5_tco.vbs │ │ ├── step6_file.vbs │ │ ├── step7_quote.vbs │ │ ├── step8_macros.vbs │ │ ├── step9_try.vbs │ │ ├── stepA_mal.vbs │ │ ├── tests/ │ │ │ ├── step4_if_fn_do.mal │ │ │ └── step9_try.mal │ │ └── types.vbs │ ├── vhdl/ │ │ ├── .gitignore │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.vhdl │ │ ├── env.vhdl │ │ ├── pkg_readline.vhdl │ │ ├── printer.vhdl │ │ ├── reader.vhdl │ │ ├── run │ │ ├── run_vhdl.sh │ │ ├── step0_repl.vhdl │ │ ├── step1_read_print.vhdl │ │ ├── step2_eval.vhdl │ │ ├── step3_env.vhdl │ │ ├── step4_if_fn_do.vhdl │ │ ├── step5_tco.vhdl │ │ ├── step6_file.vhdl │ │ ├── step7_quote.vhdl │ │ ├── step8_macros.vhdl │ │ ├── step9_try.vhdl │ │ ├── stepA_mal.vhdl │ │ └── types.vhdl │ ├── vimscript/ │ │ ├── .gitignore │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.vim │ │ ├── env.vim │ │ ├── printer.vim │ │ ├── reader.vim │ │ ├── readline.vim │ │ ├── run │ │ ├── run_vimscript.sh │ │ ├── step0_repl.vim │ │ ├── step1_read_print.vim │ │ ├── step2_eval.vim │ │ ├── step3_env.vim │ │ ├── step4_if_fn_do.vim │ │ ├── step5_tco.vim │ │ ├── step6_file.vim │ │ ├── step7_quote.vim │ │ ├── step8_macros.vim │ │ ├── step9_try.vim │ │ ├── stepA_mal.vim │ │ ├── tests/ │ │ │ ├── step5_tco.mal │ │ │ └── stepA_mal.mal │ │ ├── types.vim │ │ └── vimextras.c │ ├── wasm/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.wam │ │ ├── debug.wam │ │ ├── env.wam │ │ ├── mem.wam │ │ ├── node_readline.js │ │ ├── package.json │ │ ├── platform_direct.wam │ │ ├── platform_libc.wam │ │ ├── platform_wasi.wam │ │ ├── printer.wam │ │ ├── printf.wam │ │ ├── reader.wam │ │ ├── run │ │ ├── run.js │ │ ├── step0_repl.wam │ │ ├── step1_read_print.wam │ │ ├── step2_eval.wam │ │ ├── step3_env.wam │ │ ├── step4_if_fn_do.wam │ │ ├── step5_tco.wam │ │ ├── step6_file.wam │ │ ├── step7_quote.wam │ │ ├── step8_macros.wam │ │ ├── step9_try.wam │ │ ├── stepA_mal.wam │ │ ├── string.wam │ │ └── types.wam │ ├── wren/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── README.md │ │ ├── core.wren │ │ ├── env.wren │ │ ├── interop.wren │ │ ├── printer.wren │ │ ├── reader.wren │ │ ├── readline.wren │ │ ├── run │ │ ├── step0_repl.wren │ │ ├── step1_read_print.wren │ │ ├── step2_eval.wren │ │ ├── step3_env.wren │ │ ├── step4_if_fn_do.wren │ │ ├── step5_tco.wren │ │ ├── step6_file.wren │ │ ├── step7_quote.wren │ │ ├── step8_macros.wren │ │ ├── step9_try.wren │ │ ├── stepA_mal.wren │ │ ├── tests/ │ │ │ ├── step5_tco.mal │ │ │ └── stepA_mal.mal │ │ ├── types.wren │ │ └── wren-add-gettimeofday.patch │ ├── xslt/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.xslt │ │ ├── env.xslt │ │ ├── printer.xslt │ │ ├── reader.xslt │ │ ├── readline.xslt │ │ ├── run │ │ ├── step0_repl.inc.xslt │ │ ├── step0_repl.xslt │ │ ├── step1_read_print.inc.xslt │ │ ├── step1_read_print.xslt │ │ ├── step2_eval.inc.xslt │ │ ├── step2_eval.xslt │ │ ├── step3_env.inc.xslt │ │ ├── step3_env.xslt │ │ ├── step4_if_fn_do.inc.xslt │ │ ├── step4_if_fn_do.xslt │ │ ├── step6_file.inc.xslt │ │ ├── step6_file.xslt │ │ ├── step7_quote.inc.xslt │ │ ├── step7_quote.xslt │ │ ├── step8_macros.inc.xslt │ │ ├── step8_macros.xslt │ │ ├── step9_try.inc.xslt │ │ ├── step9_try.xslt │ │ ├── stepA_mal.inc.xslt │ │ ├── stepA_mal.xslt │ │ └── test.xslt │ ├── yorick/ │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── core.i │ │ ├── env.i │ │ ├── hash.i │ │ ├── printer.i │ │ ├── reader.i │ │ ├── run │ │ ├── step0_repl.i │ │ ├── step1_read_print.i │ │ ├── step2_eval.i │ │ ├── step3_env.i │ │ ├── step4_if_fn_do.i │ │ ├── step5_tco.i │ │ ├── step6_file.i │ │ ├── step7_quote.i │ │ ├── step8_macros.i │ │ ├── step9_try.i │ │ ├── stepA_mal.i │ │ ├── tests/ │ │ │ └── stepA_mal.mal │ │ └── types.i │ └── zig/ │ ├── Dockerfile │ ├── Makefile │ ├── README │ ├── build.zig │ ├── core.zig │ ├── env.zig │ ├── error.zig │ ├── hmap.zig │ ├── linked_list.zig │ ├── printer.zig │ ├── reader.zig │ ├── readline.zig │ ├── run │ ├── step0_repl.zig │ ├── step1_read_print.zig │ ├── step2_eval.zig │ ├── step3_env.zig │ ├── step4_if_fn_do.zig │ ├── step5_tco.zig │ ├── step6_file.zig │ ├── step7_quote.zig │ ├── step8_macros.zig │ ├── step9_try.zig │ ├── stepA_mal.zig │ └── types.zig ├── process/ │ ├── guide.md │ ├── step0_repl.txt │ ├── step1_read_print.txt │ ├── step2_eval.txt │ ├── step3_env.txt │ ├── step4_if_fn_do.txt │ ├── step5_tco.txt │ ├── step6_file.txt │ ├── step7_quote.txt │ ├── step8_macros.txt │ ├── step9_try.txt │ ├── stepA_mal.txt │ └── steps.drawio ├── runtest.py └── voom-like-version.sh
Showing preview only (396K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (5504 symbols across 376 files)
FILE: docs/graph/collect_data.js
constant VERBOSE (line 13) | const VERBOSE = process.env['VERBOSE'] || false
constant BASE_PATH (line 14) | const BASE_PATH = process.env['BASE_PATH'] || 'base_data.yaml'
constant README_PATH (line 15) | const README_PATH = process.env['README_PATH'] || '../../README.md'
constant MAL_PATH (line 16) | const MAL_PATH = process.env['MAL_PATH'] || '../../'
constant SO_TAGS_PATH (line 19) | const SO_TAGS_PATH = process.env['SO_TAGS_PATH'] || 'so-tags.csv'
constant GITHUT_PULL_URL (line 22) | const GITHUT_PULL_URL = process.env['GITHUT_PULL_URL'] || 'https://raw.g...
constant GITHUT_PUSH_URL (line 24) | const GITHUT_PUSH_URL = process.env['GITHUT_PUSH_URL'] || 'https://raw.g...
constant GITHUT_STAR_URL (line 26) | const GITHUT_STAR_URL = process.env['GITHUT_STAR_URL'] || 'https://raw.g...
function vlog (line 95) | function vlog(...args) {
function die (line 101) | function die(code, ...args) {
function main (line 106) | async function main() {
FILE: docs/graph/graph_languages.js
function malExtent (line 48) | function malExtent(data, key) {
function malScale (line 65) | function malScale(log) {
function malTickValues (line 69) | function malTickValues(key, log) {
function malCircleSize (line 77) | function malCircleSize(key, min, max, val) {
function ctlChange (line 113) | function ctlChange(evt) {
function updateGraphData (line 151) | function updateGraphData() {
FILE: docs/web/mal.js
function jq_load_history (line 3) | function jq_load_history(jq) {
function jq_save_history (line 13) | function jq_save_history(jq) {
function _obj_type (line 32) | function _obj_type(obj) {
function _sequential_Q (line 51) | function _sequential_Q(lst) { return _list_Q(lst) || _vector_Q(lst); }
function _equal_Q (line 54) | function _equal_Q (a, b) {
function _clone (line 80) | function _clone (obj) {
function _nil_Q (line 111) | function _nil_Q(a) { return a === null ? true : false; }
function _true_Q (line 112) | function _true_Q(a) { return a === true ? true : false; }
function _false_Q (line 113) | function _false_Q(a) { return a === false ? true : false; }
function _number_Q (line 114) | function _number_Q(obj) { return typeof obj === 'number'; }
function _string_Q (line 115) | function _string_Q(obj) {
function Symbol (line 121) | function Symbol(name) {
function _symbol (line 126) | function _symbol(name) { return new Symbol(name); }
function _symbol_Q (line 127) | function _symbol_Q(obj) { return obj instanceof Symbol; }
function _keyword (line 131) | function _keyword(obj) {
function _keyword_Q (line 138) | function _keyword_Q(obj) {
function _function (line 144) | function _function(Eval, Env, ast, env, params) {
function _function_Q (line 154) | function _function_Q(obj) { return typeof obj == "function"; }
function _fn_Q (line 163) | function _fn_Q(obj) { return _function_Q(obj) && !obj._ismacro_; }
function _macro_Q (line 164) | function _macro_Q(obj) { return _function_Q(obj) && !!obj._ismacro_; }
function _list (line 168) | function _list() { return Array.prototype.slice.call(arguments, 0); }
function _list_Q (line 169) | function _list_Q(obj) { return Array.isArray(obj) && !obj.__isvector__; }
function _vector (line 173) | function _vector() {
function _vector_Q (line 178) | function _vector_Q(obj) { return Array.isArray(obj) && !!obj.__isvector_...
function _hash_map (line 183) | function _hash_map() {
function _hash_map_Q (line 190) | function _hash_map_Q(hm) {
function _assoc_BANG (line 197) | function _assoc_BANG(hm) {
function _dissoc_BANG (line 211) | function _dissoc_BANG(hm) {
function Atom (line 221) | function Atom(val) { this.val = val; }
function _atom (line 222) | function _atom(val) { return new Atom(val); }
function _atom_Q (line 223) | function _atom_Q(atm) { return atm instanceof Atom; }
function Reader (line 261) | function Reader(tokens) {
function tokenize (line 269) | function tokenize(str) {
function read_atom (line 279) | function read_atom (reader) {
function read_list (line 306) | function read_list(reader, start, end) {
function read_vector (line 325) | function read_vector(reader) {
function read_hash_map (line 331) | function read_hash_map(reader) {
function read_form (line 336) | function read_form(reader) {
function BlankException (line 372) | function BlankException(msg) {
function read_str (line 375) | function read_str(str) {
function _pr_str (line 395) | function _pr_str(obj, print_readably) {
function resolve_js (line 442) | function resolve_js(str) {
function js_to_mal (line 452) | function js_to_mal(obj) {
function Env (line 481) | function Env(outer, binds, exprs) {
function mal_throw (line 534) | function mal_throw(exc) { throw exc; }
function pr_str (line 538) | function pr_str() {
function str (line 544) | function str() {
function prn (line 550) | function prn() {
function println (line 556) | function println() {
function slurp (line 562) | function slurp(f) {
function time_ms (line 579) | function time_ms() { return new Date().getTime(); }
function assoc (line 583) | function assoc(src_hm) {
function dissoc (line 589) | function dissoc(src_hm) {
function get (line 595) | function get(hm, key) {
function contains_Q (line 603) | function contains_Q(hm, key) {
function keys (line 607) | function keys(hm) { return Object.keys(hm); }
function vals (line 608) | function vals(hm) { return Object.keys(hm).map(function(k) { return hm[k...
function cons (line 612) | function cons(a, b) { return [a].concat(b); }
function concat (line 614) | function concat(lst) {
function nth (line 619) | function nth(lst, idx) {
function first (line 624) | function first(lst) { return (lst === null) ? null : lst[0]; }
function rest (line 626) | function rest(lst) { return (lst == null) ? [] : lst.slice(1); }
function empty_Q (line 628) | function empty_Q(lst) { return lst.length === 0; }
function count (line 630) | function count(s) {
function conj (line 636) | function conj(lst) {
function seq (line 646) | function seq(obj) {
function apply (line 661) | function apply(f) {
function map (line 666) | function map(f, lst) {
function with_meta (line 672) | function with_meta(obj, m) {
function meta (line 678) | function meta(obj) {
function deref (line 690) | function deref(atm) { return atm.val; }
function reset_BANG (line 691) | function reset_BANG(atm, val) { return atm.val = val; }
function swap_BANG (line 692) | function swap_BANG(atm, f) {
function js_eval (line 698) | function js_eval(str) {
function js_method_call (line 702) | function js_method_call(object_method_str) {
function READ (line 787) | function READ(str) {
function is_pair (line 792) | function is_pair(x) {
function quasiquote (line 796) | function quasiquote(ast) {
function is_macro_call (line 812) | function is_macro_call(ast, env) {
function macroexpand (line 819) | function macroexpand(ast, env) {
function eval_ast (line 827) | function eval_ast(ast, env) {
function _EVAL (line 847) | function _EVAL(ast, env) {
function EVAL (line 926) | function EVAL(ast, env) {
function PRINT (line 932) | function PRINT(exp) {
FILE: get-ci-matrix.py
function eprint (line 15) | def eprint(*args, **kwargs):
function impl_text (line 18) | def impl_text(impl):
FILE: impls/basic/basicpp.py
function debug (line 8) | def debug(*args, **kwargs):
function parse_args (line 11) | def parse_args():
function resolve_includes (line 39) | def resolve_includes(orig_lines, args):
function resolve_mode (line 62) | def resolve_mode(orig_lines, args):
function drop_blank_lines (line 73) | def drop_blank_lines(orig_lines):
function drop_rems (line 81) | def drop_rems(orig_lines):
function remove_indent (line 93) | def remove_indent(orig_lines):
function misc_fixups (line 100) | def misc_fixups(orig_lines):
function finalize (line 129) | def finalize(lines, args):
FILE: impls/c.2/core.c
type ns_s (line 107) | struct ns_s
function ns_make_core (line 197) | void ns_make_core(ns* core, size_t* size) {
function MalType (line 250) | MalType mal_equals(list args) {
function MalType (line 257) | MalType mal_nth(list args) {
function MalType (line 288) | MalType mal_first(list args) {
function MalType (line 312) | MalType mal_rest(list args) {
function MalType (line 338) | MalType mal_cons(list args) {
function MalType (line 359) | MalType mal_concat(list args) {
function MalType (line 388) | MalType mal_count(list args) {
function MalType (line 406) | MalType mal_empty_questionmark(list args) {
function MalType (line 423) | MalType mal_pr_str(list args) {
function MalType (line 428) | MalType mal_str(list args) {
function MalType (line 433) | MalType mal_prn(list args) {
function MalType (line 439) | MalType mal_println(list args) {
function MalType (line 445) | MalType mal_read_string(list args) {
function MalType (line 457) | MalType mal_slurp(list args) {
function MalType (line 488) | MalType mal_atom(list args) {
function MalType (line 492) | MalType mal_deref(list args) {
function MalType (line 500) | MalType mal_reset_bang(list args) {
function MalType (line 509) | MalType mal_swap_bang(list args) {
function MalType (line 531) | MalType mal_throw(list args) {
function MalType (line 541) | MalType mal_apply(list args) {
function MalType (line 577) | MalType mal_map(list args) {
function MalType (line 607) | MalType mal_symbol(list args) {
function MalType (line 617) | MalType mal_keyword(list args) {
function MalType (line 633) | MalType mal_vector(list args) {
function MalType (line 645) | MalType mal_vec(list args) {
function MalType (line 664) | MalType map_assoc_mutate(const char* context, struct map* new_lst, list ...
function MalType (line 675) | MalType mal_hash_map(list args) {
function MalType (line 679) | MalType mal_get(list args) {
function MalType (line 702) | MalType mal_contains_questionmark(list args) {
function MalType (line 721) | MalType mal_assoc(list args) {
function MalType (line 733) | MalType mal_dissoc(list args) {
function MalType (line 760) | MalType mal_keys(list args) {
function MalType (line 779) | MalType mal_vals(list args) {
function MalType (line 798) | MalType mal_time_ms(list args) {
function MalType (line 809) | MalType mal_conj(list args) {
function MalType (line 849) | MalType mal_seq(list args) {
function MalType (line 891) | MalType mal_meta(list args) {
function MalType (line 898) | MalType mal_with_meta(list args) {
function MalType (line 917) | MalType mal_readline(list args) {
function MalType (line 933) | inline MalType make_boolean(bool x) {
type mal_type_t (line 941) | enum mal_type_t
function core_ffi_find (line 954) | size_t core_ffi_find(const char *type) {
function MalType (line 964) | MalType mal_dot(list args) {
FILE: impls/c.2/core.h
type ns_s (line 6) | struct ns_s
type ns_s (line 8) | struct ns_s {
FILE: impls/c.2/env.c
type Env_s (line 6) | struct Env_s {
function Env (line 11) | Env* env_make(const Env* outer) {
function env_set (line 18) | inline void env_set(Env* current, MalType symbol, MalType value) {
function MalType (line 22) | MalType env_get(const Env* current, MalType symbol) {
function hashmap (line 32) | hashmap env_as_map(const Env* current) {
FILE: impls/c.2/hashmap.c
type map (line 30) | struct map {
type map (line 47) | struct map
type map (line 48) | struct map
type bucket (line 48) | struct bucket
type map (line 54) | struct map
type bucket (line 55) | struct bucket
type map (line 56) | struct map
function search (line 61) | size_t search(hashmap map, MalType key) {
function put (line 105) | void put(struct map* map, MalType key, void* value) {
type map (line 115) | struct map
type map (line 115) | struct map
type map (line 120) | struct map
type bucket (line 120) | struct bucket
function map_dissoc_mutate (line 138) | void map_dissoc_mutate(struct map* map, MalType key) {
function map_count (line 145) | inline size_t map_count(hashmap map) {
function map_cursor (line 149) | map_cursor next_valid(hashmap map, size_t i) {
function map_cursor (line 156) | inline map_cursor map_iter(hashmap map) {
function map_cont (line 160) | inline bool map_cont(hashmap map, map_cursor position) {
function MalType (line 164) | inline MalType map_key(hashmap map, map_cursor position) {
function map_cursor (line 180) | inline map_cursor map_next(hashmap map, map_cursor position) {
FILE: impls/c.2/hashmap.h
type map (line 10) | struct map
type map (line 13) | struct map
type map (line 15) | struct map
type map (line 15) | struct map
type map (line 22) | struct map
type map_cursor (line 26) | typedef size_t map_cursor;
FILE: impls/c.2/linked_list.c
function list (line 5) | list list_push(list lst, MalType data_ptr) {
function list_count (line 14) | size_t list_count(list lst) {
FILE: impls/c.2/linked_list.h
type pair_s (line 8) | struct pair_s {
FILE: impls/c.2/printer.c
type printf_info (line 17) | struct printf_info
function print_M (line 27) | int print_M(FILE *stream, const struct printf_info *i, const void *const...
function print_L (line 130) | int print_L(FILE* stream, const struct printf_info *i, const void *const...
function pr_str_vector (line 140) | int pr_str_vector(FILE* stream, const struct printf_info *i, vector_t v) {
function pr_str_map (line 153) | int pr_str_map(FILE* stream, const struct printf_info *i, const void *co...
function escape_string (line 164) | int escape_string(FILE *stream, const char* str) {
function print_T (line 213) | int print_T(FILE *stream, const struct printf_info *, const void *const ...
function printer_init (line 242) | void printer_init() {
FILE: impls/c.2/reader.c
function skip_spaces (line 40) | void skip_spaces(Reader reader) {
function MalType (line 56) | MalType read_str(const char* source) {
function MalType (line 103) | MalType read_form(Reader reader) {
function MalType (line 173) | MalType read_number(Reader reader) {
function MalType (line 207) | MalType read_with_meta(Reader reader) {
function MalType (line 232) | MalType read_list(Reader reader) {
function MalType (line 258) | MalType read_vector(Reader reader) {
function MalType (line 278) | MalType read_map(Reader reader) {
function MalType (line 308) | MalType make_symbol_list(Reader reader, MalType symbol) {
function MalType (line 324) | MalType read_string(Reader reader) {
FILE: impls/c.2/step0_repl.c
function PRINT (line 18) | void PRINT(const char* str) {
function rep (line 23) | void rep(const char* str) {
function main (line 28) | int main() {
FILE: impls/c.2/step1_read_print.c
function MalType (line 12) | MalType READ(const char* str) {
function MalType (line 18) | MalType EVAL(MalType ast) {
function PRINT (line 23) | void PRINT(MalType val) {
function rep (line 28) | void rep(const char* str) {
function main (line 40) | int main() {
FILE: impls/c.2/step2_eval.c
function MalType (line 43) | MalType READ(const char* str) {
function MalType (line 49) | MalType EVAL(MalType ast, hashmap env) {
function PRINT (line 96) | void PRINT(MalType val) {
function rep (line 101) | void rep(const char* str, hashmap env) {
function main (line 116) | int main() {
function list (line 142) | list evaluate_list(list lst, hashmap env) {
function MalType (line 161) | MalType evaluate_vector(vector_t lst, hashmap env) {
function MalType (line 173) | MalType evaluate_hashmap(hashmap lst, hashmap env) {
function MalType (line 185) | MalType apply(MalType fn, list args) {
FILE: impls/c.2/step3_env.c
type MalType (line 24) | typedef MalType (*special_t)(list, Env*);
type map (line 25) | struct map
function MalType (line 49) | MalType READ(const char* str) {
function MalType (line 55) | MalType EVAL(MalType ast, Env* env) {
function PRINT (line 113) | void PRINT(MalType val) {
function rep (line 118) | void rep(const char* str, Env* env) {
function main (line 133) | int main() {
function MalType (line 163) | MalType eval_defbang(list lst, Env* env) {
function MalType (line 176) | MalType eval_letstar(list lst, Env* env) {
function list (line 209) | list evaluate_list(list lst, Env* env) {
function MalType (line 228) | MalType evaluate_vector(vector_t lst, Env* env) {
function MalType (line 240) | MalType evaluate_hashmap(hashmap lst, Env* env) {
function MalType (line 252) | MalType apply(MalType fn, list args) {
FILE: impls/c.2/step4_if_fn_do.c
type MalType (line 28) | typedef MalType (*special_t)(list, Env*);
type map (line 29) | struct map
function MalType (line 31) | MalType READ(const char* str) {
function Env (line 37) | Env* env_apply(MalClosure closure, list args) {
function MalType (line 70) | MalType EVAL(MalType ast, Env* env) {
function PRINT (line 135) | void PRINT(MalType val) {
function rep (line 140) | void rep(const char* str, Env* env) {
function re (line 156) | void re(const char *str, Env* env) {
function main (line 170) | int main() {
function MalType (line 210) | MalType eval_defbang(list lst, Env* env) {
function MalType (line 223) | MalType eval_letstar(list lst, Env* env) {
function MalType (line 256) | MalType eval_if(list lst, Env* env) {
function MalType (line 300) | MalType eval_do(list lst, Env* env) {
function list (line 322) | list evaluate_list(list lst, Env* env) {
function MalType (line 341) | MalType evaluate_vector(vector_t lst, Env* env) {
function MalType (line 353) | MalType evaluate_hashmap(hashmap lst, Env* env) {
function MalType (line 365) | MalType eval_fnstar(list lst, const Env* env) {
function MalType (line 403) | MalType apply(MalType fn, list args) {
FILE: impls/c.2/step5_tco.c
type MalType (line 28) | typedef MalType (*special_t)(list, Env**);
type map (line 29) | struct map
function MalType (line 31) | MalType READ(const char* str) {
function Env (line 37) | Env* env_apply(MalClosure closure, list args) {
function MalType (line 70) | MalType EVAL(MalType ast, Env* env) {
function PRINT (line 145) | void PRINT(MalType val) {
function rep (line 150) | void rep(const char* str, Env* env) {
function re (line 166) | void re(const char *str, Env* env) {
function main (line 180) | int main() {
function MalType (line 220) | MalType eval_defbang(list lst, Env** env) {
function MalType (line 234) | MalType eval_letstar(list lst, Env** env) {
function MalType (line 268) | MalType eval_if(list lst, Env** env) {
function MalType (line 313) | MalType eval_do(list lst, Env** env) {
function list (line 335) | list evaluate_list(list lst, Env* env) {
function MalType (line 354) | MalType evaluate_vector(vector_t lst, Env* env) {
function MalType (line 366) | MalType evaluate_hashmap(hashmap lst, Env* env) {
function MalType (line 378) | MalType eval_fnstar(list lst, Env** env) {
function MalType (line 418) | MalType apply(MalType fn, list args) {
FILE: impls/c.2/step6_file.c
type MalType (line 28) | typedef MalType (*special_t)(list, Env**);
type map (line 29) | struct map
function MalType (line 31) | MalType READ(const char* str) {
function Env (line 37) | Env* env_apply(MalClosure closure, list args) {
function MalType (line 70) | MalType EVAL(MalType ast, Env* env) {
function PRINT (line 145) | void PRINT(MalType val) {
function rep (line 150) | void rep(const char* str, Env* env) {
function re (line 166) | void re(const char *str, Env* env) {
function MalType (line 183) | MalType mal_eval(list args) {
function main (line 190) | int main(int argc, char** argv) {
function MalType (line 250) | MalType eval_defbang(list lst, Env** env) {
function MalType (line 264) | MalType eval_letstar(list lst, Env** env) {
function MalType (line 298) | MalType eval_if(list lst, Env** env) {
function MalType (line 343) | MalType eval_do(list lst, Env** env) {
function list (line 365) | list evaluate_list(list lst, Env* env) {
function MalType (line 384) | MalType evaluate_vector(vector_t lst, Env* env) {
function MalType (line 396) | MalType evaluate_hashmap(hashmap lst, Env* env) {
function MalType (line 408) | MalType eval_fnstar(list lst, Env** env) {
function MalType (line 448) | MalType apply(MalType fn, list args) {
FILE: impls/c.2/step7_quote.c
type MalType (line 34) | typedef MalType (*special_t)(list, Env**);
type map (line 35) | struct map
function MalType (line 37) | MalType READ(const char* str) {
function Env (line 43) | Env* env_apply(MalClosure closure, list args) {
function MalType (line 76) | MalType EVAL(MalType ast, Env* env) {
function PRINT (line 151) | void PRINT(MalType val) {
function rep (line 156) | void rep(const char* str, Env* env) {
function re (line 172) | void re(const char *str, Env* env) {
function MalType (line 189) | MalType mal_eval(list args) {
function main (line 196) | int main(int argc, char** argv) {
function MalType (line 258) | MalType eval_defbang(list lst, Env** env) {
function MalType (line 272) | MalType eval_letstar(list lst, Env** env) {
function MalType (line 306) | MalType eval_if(list lst, Env** env) {
function MalType (line 351) | MalType eval_do(list lst, Env** env) {
function MalType (line 373) | MalType eval_quote(list lst, Env** env) {
function MalType (line 380) | MalType eval_quasiquote(list lst, Env**) {
function MalType (line 386) | MalType quasiquote(MalType ast) {
function MalType (line 427) | MalType quasiquote_vector(vector_t vec) {
function MalType (line 442) | MalType quasiquote_list(list args) {
function MalType (line 459) | MalType quasiquote_folder(MalType first, MalType qq_rest) {
function list (line 483) | list evaluate_list(list lst, Env* env) {
function MalType (line 502) | MalType evaluate_vector(vector_t lst, Env* env) {
function MalType (line 514) | MalType evaluate_hashmap(hashmap lst, Env* env) {
function MalType (line 526) | MalType eval_fnstar(list lst, Env** env) {
function MalType (line 566) | MalType apply(MalType fn, list args) {
FILE: impls/c.2/step8_macros.c
type MalType (line 35) | typedef MalType (*special_t)(list, Env**);
type map (line 36) | struct map
function MalType (line 38) | MalType READ(const char* str) {
function Env (line 44) | Env* env_apply(MalClosure closure, list args) {
function MalType (line 77) | MalType EVAL(MalType ast, Env* env) {
function PRINT (line 157) | void PRINT(MalType val) {
function rep (line 162) | void rep(const char* str, Env* env) {
function re (line 178) | void re(const char *str, Env* env) {
function MalType (line 195) | MalType mal_eval(list args) {
function main (line 202) | int main(int argc, char** argv) {
function MalType (line 266) | MalType eval_defbang(list lst, Env** env) {
function MalType (line 280) | MalType eval_letstar(list lst, Env** env) {
function MalType (line 314) | MalType eval_if(list lst, Env** env) {
function MalType (line 359) | MalType eval_do(list lst, Env** env) {
function MalType (line 381) | MalType eval_quote(list lst, Env** env) {
function MalType (line 388) | MalType eval_quasiquote(list lst, Env**) {
function MalType (line 394) | MalType quasiquote(MalType ast) {
function MalType (line 435) | MalType quasiquote_vector(vector_t vec) {
function MalType (line 450) | MalType quasiquote_list(list args) {
function MalType (line 467) | MalType quasiquote_folder(MalType first, MalType qq_rest) {
function MalType (line 491) | MalType eval_defmacrobang(list lst, Env** env) {
function list (line 510) | list evaluate_list(list lst, Env* env) {
function MalType (line 529) | MalType evaluate_vector(vector_t lst, Env* env) {
function MalType (line 541) | MalType evaluate_hashmap(hashmap lst, Env* env) {
function MalType (line 553) | MalType eval_fnstar(list lst, Env** env) {
function MalType (line 593) | MalType apply(MalType fn, list args) {
FILE: impls/c.2/step9_try.c
type MalType (line 36) | typedef MalType (*special_t)(list, Env**);
type map (line 37) | struct map
function MalType (line 39) | MalType READ(const char* str) {
function Env (line 45) | Env* env_apply(MalClosure closure, list args) {
function MalType (line 78) | MalType EVAL(MalType ast, Env* env) {
function PRINT (line 158) | void PRINT(MalType val) {
function rep (line 163) | void rep(const char* str, Env* env) {
function re (line 179) | void re(const char *str, Env* env) {
function MalType (line 196) | MalType mal_eval(list args) {
function main (line 203) | int main(int argc, char** argv) {
function MalType (line 268) | MalType eval_defbang(list lst, Env** env) {
function MalType (line 282) | MalType eval_letstar(list lst, Env** env) {
function MalType (line 316) | MalType eval_if(list lst, Env** env) {
function MalType (line 361) | MalType eval_do(list lst, Env** env) {
function MalType (line 383) | MalType eval_quote(list lst, Env** env) {
function MalType (line 390) | MalType eval_quasiquote(list lst, Env**) {
function MalType (line 396) | MalType quasiquote(MalType ast) {
function MalType (line 437) | MalType quasiquote_vector(vector_t vec) {
function MalType (line 452) | MalType quasiquote_list(list args) {
function MalType (line 469) | MalType quasiquote_folder(MalType first, MalType qq_rest) {
function MalType (line 493) | MalType eval_defmacrobang(list lst, Env** env) {
function MalType (line 512) | MalType eval_try(list lst, Env** env) {
function list (line 560) | list evaluate_list(list lst, Env* env) {
function MalType (line 579) | MalType evaluate_vector(vector_t lst, Env* env) {
function MalType (line 591) | MalType evaluate_hashmap(hashmap lst, Env* env) {
function MalType (line 603) | MalType eval_fnstar(list lst, Env** env) {
function MalType (line 643) | MalType apply(MalType fn, list args) {
FILE: impls/c.2/stepA_mal.c
type MalType (line 36) | typedef MalType (*special_t)(list, Env**);
type map (line 37) | struct map
function MalType (line 39) | MalType READ(const char* str) {
function Env (line 45) | Env* env_apply(MalClosure closure, list args) {
function MalType (line 78) | MalType EVAL(MalType ast, Env* env) {
function PRINT (line 158) | void PRINT(MalType val) {
function rep (line 163) | void rep(const char* str, Env* env) {
function re (line 179) | void re(const char *str, Env* env) {
function MalType (line 196) | MalType mal_eval(list args) {
function main (line 203) | int main(int argc, char** argv) {
function MalType (line 272) | MalType eval_defbang(list lst, Env** env) {
function MalType (line 286) | MalType eval_letstar(list lst, Env** env) {
function MalType (line 320) | MalType eval_if(list lst, Env** env) {
function MalType (line 365) | MalType eval_do(list lst, Env** env) {
function MalType (line 387) | MalType eval_quote(list lst, Env** env) {
function MalType (line 394) | MalType eval_quasiquote(list lst, Env**) {
function MalType (line 400) | MalType quasiquote(MalType ast) {
function MalType (line 441) | MalType quasiquote_vector(vector_t vec) {
function MalType (line 456) | MalType quasiquote_list(list args) {
function MalType (line 473) | MalType quasiquote_folder(MalType first, MalType qq_rest) {
function MalType (line 497) | MalType eval_defmacrobang(list lst, Env** env) {
function MalType (line 516) | MalType eval_try(list lst, Env** env) {
function list (line 564) | list evaluate_list(list lst, Env* env) {
function MalType (line 583) | MalType evaluate_vector(vector_t lst, Env* env) {
function MalType (line 595) | MalType evaluate_hashmap(hashmap lst, Env* env) {
function MalType (line 607) | MalType eval_fnstar(list lst, Env** env) {
function MalType (line 647) | MalType apply(MalType fn, list args) {
FILE: impls/c.2/types.c
type MalType_s (line 17) | struct MalType_s {
type MalType_s (line 51) | struct MalType_s
type MalType_s (line 52) | struct MalType_s
type MalType_s (line 53) | struct MalType_s
function is_nil (line 55) | bool is_nil(MalType val) { return val == &THE_NIL; }
function is_false (line 56) | bool is_false(MalType val) { return val == &THE_FALSE; }
function is_true (line 57) | bool is_true(MalType val) { return val == &THE_TRUE; }
function is_integer (line 59) | inline bool is_integer(MalType val, long* result) {
function MalType (line 64) | MalType make_integer(long value) {
function is_float (line 70) | inline bool is_float(MalType val, double* result) {
function MalType (line 75) | MalType make_float(double value) {
function hash (line 83) | size_t hash(const char* s) {
function MalType (line 104) | MalType make_string(const char* value) {
function MalType (line 113) | MalType make_keyword(const char* value) {
function MalType (line 122) | MalType make_symbol(const char* value) {
function is_list (line 128) | inline bool is_list(MalType val, list* result) {
function MalType (line 133) | MalType make_list_m(list value, MalType metadata) {
function MalType (line 138) | inline MalType make_list(list value) {
function vector_t (line 142) | inline vector_t is_vector(MalType val) {
function MalType (line 145) | MalType make_vector_m(vector_t value, MalType metadata) {
function MalType (line 150) | inline MalType make_vector(vector_t value) {
function hashmap (line 154) | inline hashmap is_hashmap(MalType val) {
function MalType (line 157) | MalType make_hashmap_m(hashmap value, MalType metadata) {
function MalType (line 162) | inline MalType make_hashmap(hashmap value) {
function function_t (line 166) | inline function_t is_function(MalType val) {
function MalType (line 169) | MalType make_function_m(function_t value, MalType metadata) {
function MalType (line 174) | inline MalType make_function(function_t value) {
function MalClosure (line 178) | inline MalClosure is_closure(MalType val) {
function MalType (line 181) | MalType make_closure_m(const Env* env, list fnstar_args, MalType metadat...
function MalType (line 186) | inline MalType make_closure(const Env* env, list fnstar_args) {
function MalClosure (line 190) | inline MalClosure is_macro(MalType val) {
function MalType (line 193) | MalType make_macro(const Env* env, list fnstar_args) {
function MalType (line 199) | inline MalType* is_atom(MalType val) {
function MalType (line 202) | MalType make_atom(MalType value) {
function MalType (line 208) | MalType meta(MalType form) {
function type (line 219) | inline enum mal_type_t type(MalType val) {
function get_hash (line 223) | inline size_t get_hash(MalType form) {
function equal_forms (line 246) | bool equal_forms(MalType first, MalType second) {
function types_init (line 316) | void types_init() {
function MalType (line 339) | inline MalType make_true() {
function MalType (line 343) | inline MalType make_false() {
function MalType (line 347) | inline MalType make_nil() {
FILE: impls/c.2/types.h
type mal_type_t (line 7) | enum mal_type_t {
type MalType_s (line 25) | struct MalType_s
type MalClosure_s (line 26) | struct MalClosure_s
type pair_s (line 27) | struct pair_s
type MalType (line 28) | typedef MalType(*function_t)(list);
type Env (line 29) | typedef struct Env_s Env;
type map (line 30) | struct map
type vector (line 31) | struct vector
type MalClosure_s (line 33) | struct MalClosure_s {
type mal_type_t (line 81) | enum mal_type_t
FILE: impls/c.2/vector.c
type vector (line 8) | struct vector
type vector (line 9) | struct vector
function vector_append (line 14) | void vector_append(size_t* capacity, struct vector** v, MalType new_item) {
function seq_cursor (line 23) | seq_cursor seq_iter(MalType container) {
function seq_cont (line 34) | bool seq_cont(MalType container, seq_cursor position) {
function seq_cursor (line 45) | seq_cursor seq_next(MalType container, seq_cursor position) {
function MalType (line 57) | MalType seq_item(MalType container, seq_cursor position) {
FILE: impls/c.2/vector.h
type vector (line 9) | struct vector {
type vector (line 14) | struct vector
type vector (line 17) | struct vector
type seq_cursor (line 23) | typedef union seq_cursor {
FILE: impls/c/core.c
function throw (line 16) | void throw(MalVal *obj) {
function MalVal (line 23) | MalVal *equal_Q(MalVal *a, MalVal *b) {
function MalVal (line 31) | MalVal *nil_Q(MalVal *seq) { return seq->type & MAL_NIL ? &mal_true : &m...
function MalVal (line 32) | MalVal *true_Q(MalVal *seq) { return seq->type & MAL_TRUE ? &mal_true : ...
function MalVal (line 33) | MalVal *false_Q(MalVal *seq) { return seq->type & MAL_FALSE ? &mal_true ...
function MalVal (line 34) | MalVal *string_Q(MalVal *seq) {
function MalVal (line 41) | MalVal *number_Q(MalVal *obj) {
function MalVal (line 46) | MalVal *fn_Q(MalVal *obj) {
function MalVal (line 52) | MalVal *macro_Q(MalVal *obj) { return obj->ismacro ? &mal_true : &mal_fa...
function MalVal (line 58) | MalVal *symbol(MalVal *args) {
function MalVal (line 65) | MalVal *symbol_Q(MalVal *seq) {
function MalVal (line 71) | MalVal *keyword(MalVal *args) {
function MalVal (line 81) | MalVal *keyword_Q(MalVal *seq) {
function MalVal (line 92) | MalVal *pr_str(MalVal *args) {
function MalVal (line 100) | MalVal *str(MalVal *args) {
function MalVal (line 108) | MalVal *prn(MalVal *args) {
function MalVal (line 119) | MalVal *println(MalVal *args) {
function MalVal (line 128) | MalVal *mal_readline(MalVal *str) {
function MalVal (line 135) | MalVal *read_string(MalVal *str) {
type stat (line 142) | struct stat
function MalVal (line 159) | MalVal *slurp(MalVal *path) {
type timeval (line 181) | struct timeval
function MalVal (line 216) | MalVal *dissoc(MalVal* args) {
function MalVal (line 222) | MalVal *keys(MalVal *obj) {
function MalVal (line 239) | MalVal *vals(MalVal *obj) {
function MalVal (line 257) | MalVal *get(MalVal *obj, MalVal *key) {
function MalVal (line 277) | MalVal *contains_Q(MalVal *obj, MalVal *key) {
function MalVal (line 299) | MalVal *sequential_Q(MalVal *seq) {
function MalVal (line 303) | MalVal *cons(MalVal *x, MalVal *seq) {
function MalVal (line 316) | MalVal *concat(MalVal *args) {
function MalVal (line 333) | MalVal *vec(MalVal *seq) {
function MalVal (line 351) | MalVal *nth(MalVal *seq, MalVal *idx) {
function MalVal (line 355) | MalVal *empty_Q(MalVal *seq) {
function MalVal (line 361) | MalVal *count(MalVal *seq) {
function MalVal (line 365) | MalVal *apply(MalVal *args) {
function MalVal (line 386) | MalVal *map(MalVal *mvf, MalVal *lst) {
function MalVal (line 411) | MalVal *sconj(MalVal *args) {
function MalVal (line 435) | MalVal *seq(MalVal *obj) {
function MalVal (line 470) | MalVal *with_meta(MalVal *obj, MalVal *meta) {
function MalVal (line 476) | MalVal *meta(MalVal *obj) {
function MalVal (line 490) | MalVal *atom(MalVal *val) {
function MalVal (line 494) | MalVal *atom_Q(MalVal *exp) { return _atom_Q(exp) ? &mal_true : &mal_fal...
function MalVal (line 496) | MalVal *deref(MalVal *atm) {
function MalVal (line 502) | MalVal *reset_BANG(MalVal *atm, MalVal *val) {
function MalVal (line 509) | MalVal *swap_BANG(MalVal *args) {
FILE: impls/c/core.h
type core_ns_entry (line 7) | typedef struct {
FILE: impls/c/env.c
function Env (line 6) | Env *new_env(Env *outer, MalVal* binds, MalVal *exprs) {
function MalVal (line 38) | MalVal *env_get(Env *env, const char *key) {
function env_set (line 49) | void env_set(Env *env, char *key, MalVal *val) {
FILE: impls/c/interop.c
function get_byte_size (line 14) | int get_byte_size(char *type) {
type Raw64 (line 18) | typedef struct Raw64 {
function ffi_type (line 28) | ffi_type *_get_ffi_type(char *type) {
function MalVal (line 49) | MalVal *_malval_new_by_type(char *type) {
function MalVal (line 74) | MalVal *invoke_native(MalVal *call_data) {
FILE: impls/c/reader.c
function Reader (line 15) | Reader *reader_new() {
function reader_append (line 22) | int reader_append(Reader *reader, char* token) {
function reader_free (line 39) | void reader_free(Reader *reader) {
function Reader (line 48) | Reader *tokenize(char *line) {
function MalVal (line 81) | MalVal *read_atom(Reader *reader) {
function MalVal (line 131) | MalVal *read_list(Reader *reader, MalType type, char start, char end) {
function MalVal (line 157) | MalVal *read_hash_map(Reader *reader) {
function MalVal (line 166) | MalVal *read_form(Reader *reader) {
function MalVal (line 249) | MalVal *read_str (char *str) {
FILE: impls/c/reader.h
type Reader (line 9) | typedef struct {
FILE: impls/c/readline.c
function load_history (line 17) | void load_history() {
function append_to_history (line 40) | void append_to_history() {
FILE: impls/c/step0_repl.c
function main (line 28) | int main()
FILE: impls/c/step1_read_print.c
function MalVal (line 11) | MalVal *READ(char prompt[], char *str) {
function MalVal (line 29) | MalVal *EVAL(MalVal *ast, GHashTable *env) {
function MalVal (line 45) | MalVal *RE(GHashTable *env, char *prompt, char *str) {
function main (line 56) | int main()
FILE: impls/c/step2_eval.c
function MalVal (line 14) | MalVal *READ(char prompt[], char *str) {
function MalVal (line 32) | MalVal *EVAL(MalVal *ast, GHashTable *env) {
function MalVal (line 92) | MalVal *RE(GHashTable *env, char *prompt, char *str) {
FILE: impls/c/step3_env.c
function MalVal (line 14) | MalVal *READ(char prompt[], char *str) {
function MalVal (line 32) | MalVal *EVAL(MalVal *ast, Env *env) {
function MalVal (line 124) | MalVal *RE(Env *env, char *prompt, char *str) {
FILE: impls/c/step4_if_fn_do.c
function MalVal (line 15) | MalVal *READ(char prompt[], char *str) {
function MalVal (line 33) | MalVal *EVAL(MalVal *ast, Env *env) {
function MalVal (line 161) | MalVal *RE(Env *env, char *prompt, char *str) {
function init_repl_env (line 175) | void init_repl_env() {
function main (line 189) | int main()
FILE: impls/c/step5_tco.c
function MalVal (line 15) | MalVal *READ(char prompt[], char *str) {
function MalVal (line 33) | MalVal *EVAL(MalVal *ast, Env *env) {
function MalVal (line 174) | MalVal *RE(Env *env, char *prompt, char *str) {
function init_repl_env (line 188) | void init_repl_env() {
function main (line 202) | int main()
FILE: impls/c/step6_file.c
function MalVal (line 15) | MalVal *READ(char prompt[], char *str) {
function MalVal (line 33) | MalVal *EVAL(MalVal *ast, Env *env) {
function MalVal (line 174) | MalVal *RE(Env *env, char *prompt, char *str) {
function MalVal (line 188) | MalVal *do_eval(MalVal *ast) { return EVAL(ast, repl_env); }
function init_repl_env (line 190) | void init_repl_env(int argc, char *argv[]) {
function main (line 215) | int main(int argc, char *argv[])
FILE: impls/c/step7_quote.c
function MalVal (line 16) | MalVal *READ(char prompt[], char *str) {
function starts_with (line 34) | int starts_with(MalVal *ast, const char *sym) {
function MalVal (line 41) | MalVal *qq_iter(GArray *xs) {
function MalVal (line 54) | MalVal *quasiquote(MalVal *ast) {
function MalVal (line 71) | MalVal *EVAL(MalVal *ast, Env *env) {
function MalVal (line 222) | MalVal *RE(Env *env, char *prompt, char *str) {
function MalVal (line 236) | MalVal *do_eval(MalVal *ast) { return EVAL(ast, repl_env); }
function init_repl_env (line 238) | void init_repl_env(int argc, char *argv[]) {
function main (line 263) | int main(int argc, char *argv[])
FILE: impls/c/step8_macros.c
function MalVal (line 16) | MalVal *READ(char prompt[], char *str) {
function starts_with (line 34) | int starts_with(MalVal *ast, const char *sym) {
function MalVal (line 41) | MalVal *qq_iter(GArray *xs) {
function MalVal (line 54) | MalVal *quasiquote(MalVal *ast) {
function MalVal (line 71) | MalVal *EVAL(MalVal *ast, Env *env) {
function MalVal (line 240) | MalVal *RE(Env *env, char *prompt, char *str) {
function MalVal (line 254) | MalVal *do_eval(MalVal *ast) { return EVAL(ast, repl_env); }
function init_repl_env (line 256) | void init_repl_env(int argc, char *argv[]) {
function main (line 282) | int main(int argc, char *argv[])
FILE: impls/c/step9_try.c
function MalVal (line 17) | MalVal *READ(char prompt[], char *str) {
function starts_with (line 35) | int starts_with(MalVal *ast, const char *sym) {
function MalVal (line 42) | MalVal *qq_iter(GArray *xs) {
function MalVal (line 55) | MalVal *quasiquote(MalVal *ast) {
function MalVal (line 72) | MalVal *EVAL(MalVal *ast, Env *env) {
function MalVal (line 265) | MalVal *RE(Env *env, char *prompt, char *str) {
function MalVal (line 279) | MalVal *do_eval(MalVal *ast) { return EVAL(ast, repl_env); }
function init_repl_env (line 281) | void init_repl_env(int argc, char *argv[]) {
function main (line 307) | int main(int argc, char *argv[])
FILE: impls/c/stepA_mal.c
function MalVal (line 17) | MalVal *READ(char prompt[], char *str) {
function starts_with (line 35) | int starts_with(MalVal *ast, const char *sym) {
function MalVal (line 42) | MalVal *qq_iter(GArray *xs) {
function MalVal (line 55) | MalVal *quasiquote(MalVal *ast) {
function MalVal (line 72) | MalVal *EVAL(MalVal *ast, Env *env) {
function MalVal (line 271) | MalVal *RE(Env *env, char *prompt, char *str) {
function MalVal (line 285) | MalVal *do_eval(MalVal *ast) { return EVAL(ast, repl_env); }
function init_repl_env (line 287) | void init_repl_env(int argc, char *argv[]) {
function main (line 314) | int main(int argc, char *argv[])
FILE: impls/c/types.c
function nop_free (line 9) | void nop_free(void* ptr) {
function GC_setup (line 22) | void GC_setup() {
function _error (line 43) | void _error(const char *fmt, ...) {
function g_hash_table_print (line 60) | void g_hash_table_print(GHashTable *hash_table) {
function GHashTable (line 71) | GHashTable *g_hash_table_copy(GHashTable *src_table) {
function min (line 83) | int min(int a, int b) { return a < b ? a : b; }
function max (line 84) | int max(int a, int b) { return a > b ? a : b; }
function _count (line 86) | int _count(MalVal *obj) {
function MalVal (line 100) | MalVal *malval_new(MalType type, MalVal *metadata) {
function malval_free (line 107) | void malval_free(MalVal *mv) {
function MalVal (line 114) | MalVal *malval_new_integer(gint64 val) {
function MalVal (line 120) | MalVal *malval_new_float(gdouble val) {
function MalVal (line 126) | MalVal *malval_new_string(char *val) {
function MalVal (line 132) | MalVal *malval_new_symbol(char *val) {
function MalVal (line 138) | MalVal *malval_new_keyword(char *val) {
function MalVal (line 144) | MalVal *malval_new_list(MalType type, GArray *val) {
function MalVal (line 150) | MalVal *malval_new_hash_map(GHashTable *val) {
function MalVal (line 156) | MalVal *malval_new_atom(MalVal *val) {
function MalVal (line 163) | MalVal *malval_new_function(void *(*func)(void *), int arg_cnt) {
function MalVal (line 227) | MalVal *_apply(MalVal *f, MalVal *args) {
function _equal_Q (line 300) | int _equal_Q(MalVal *a, MalVal *b) {
function MalVal (line 368) | MalVal *_listX(int count, ...) {
function MalVal (line 383) | MalVal *_list(MalVal *args) {
function _list_Q (line 390) | int _list_Q(MalVal *seq) {
function MalVal (line 396) | MalVal *_vector(MalVal *args) {
function _vector_Q (line 403) | int _vector_Q(MalVal *seq) {
function MalVal (line 409) | MalVal *_hash_map(MalVal *args) {
function _hash_map_Q (line 417) | int _hash_map_Q(MalVal *seq) {
function MalVal (line 421) | MalVal *_assoc_BANG(MalVal* hm, MalVal *args) {
function MalVal (line 437) | MalVal *_dissoc_BANG(MalVal* hm, MalVal *args) {
function _atom_Q (line 452) | int _atom_Q(MalVal *exp) {
function MalVal (line 458) | MalVal *_slice(MalVal *seq, int start, int end) {
function _sequential_Q (line 470) | int _sequential_Q(MalVal *seq) {
function MalVal (line 474) | MalVal *_nth(MalVal *seq, int idx) {
function MalVal (line 483) | MalVal *_first(MalVal *seq) {
function MalVal (line 492) | MalVal *_last(MalVal *seq) {
function MalVal (line 502) | MalVal *_rest(MalVal *seq) {
function MalVal (line 507) | MalVal *_map2(MalVal *(*func)(void*, void*), MalVal *lst, void *arg2) {
FILE: impls/c/types.h
type MalVal (line 27) | struct MalVal
type Env (line 32) | typedef struct Env {
type MalVal (line 37) | struct MalVal
type MalVal (line 37) | struct MalVal
type MalVal (line 38) | struct MalVal
type MalVal (line 40) | struct MalVal
type MalVal (line 50) | struct MalVal
type MalType (line 69) | typedef enum {
type MalVal (line 85) | typedef struct MalVal {
FILE: impls/cpp/Core.cpp
function installCore (line 536) | void installCore(malEnvPtr env) {
function String (line 543) | static String printValues(malValueIter begin, malValueIter end,
FILE: impls/cpp/Environment.cpp
function malEnvPtr (line 38) | malEnvPtr malEnv::find(const String& symbol)
function malValuePtr (line 48) | malValuePtr malEnv::get(const String& symbol)
function malValuePtr (line 59) | malValuePtr malEnv::set(const String& symbol, malValuePtr value)
function malEnvPtr (line 65) | malEnvPtr malEnv::getRoot()
FILE: impls/cpp/Environment.h
function class (line 8) | class malEnv : public RefCounted {
FILE: impls/cpp/MAL.h
type RefCountedPtr (line 12) | typedef RefCountedPtr<malValue> malValuePtr;
type std (line 13) | typedef std::vector<malValuePtr> malValueVec;
type malValueVec (line 14) | typedef malValueVec::iterator malValueIter;
type RefCountedPtr (line 17) | typedef RefCountedPtr<malEnv> malEnvPtr;
FILE: impls/cpp/ReadLine.h
function class (line 6) | class ReadLine {
FILE: impls/cpp/Reader.cpp
class Tokeniser (line 19) | class Tokeniser
method String (line 24) | String peek() const {
method String (line 29) | String next() {
method eof (line 36) | bool eof() const {
function malValuePtr (line 121) | malValuePtr readStr(const String& input)
function malValuePtr (line 130) | static malValuePtr readForm(Tokeniser& tokeniser)
function malValuePtr (line 159) | static malValuePtr readAtom(Tokeniser& tokeniser)
function readList (line 212) | static void readList(Tokeniser& tokeniser, malValueVec* items,
function malValuePtr (line 225) | static malValuePtr processMacro(Tokeniser& tokeniser, const String& symbol)
FILE: impls/cpp/RefCountedPtr.h
function class (line 8) | class RefCounted {
function m_object (line 32) | RefCountedPtr(const RefCountedPtr& rhs) : m_object(0)
function operator (line 40) | bool operator == (const RefCountedPtr& rhs) const {
function operator (line 44) | bool operator != (const RefCountedPtr& rhs) const {
function T (line 57) | T* ptr() const { return m_object; }
function release (line 68) | void release() {
FILE: impls/cpp/StaticList.h
function Iterator (line 11) | Iterator begin() { return Iterator(m_head); }
function Iterator (line 12) | Iterator end() { return Iterator(NULL); }
function class (line 14) | class Node {
function class (line 27) | class Iterator {
FILE: impls/cpp/String.cpp
function String (line 10) | String stringPrintf(const char* fmt, ...) {
function String (line 31) | String copyAndFree(char* mallocedString)
function String (line 38) | String escape(const String& in)
function unescape (line 57) | static char unescape(char c)
function String (line 67) | String unescape(const String& in)
FILE: impls/cpp/String.h
type std (line 7) | typedef std::string String;
type std (line 8) | typedef std::vector<String> StringVec;
FILE: impls/cpp/Types.cpp
type mal (line 9) | namespace mal {
function malValuePtr (line 10) | malValuePtr atom(malValuePtr value) {
function malValuePtr (line 14) | malValuePtr boolean(bool value) {
function malValuePtr (line 18) | malValuePtr builtin(const String& name, malBuiltIn::ApplyFunc handler) {
function malValuePtr (line 22) | malValuePtr falseValue() {
function malValuePtr (line 28) | malValuePtr hash(const malHash::Map& map) {
function malValuePtr (line 32) | malValuePtr hash(malValueIter argsBegin, malValueIter argsEnd,
function malValuePtr (line 37) | malValuePtr integer(int64_t value) {
function malValuePtr (line 41) | malValuePtr integer(const String& token) {
function malValuePtr (line 45) | malValuePtr keyword(const String& token) {
function malValuePtr (line 49) | malValuePtr lambda(const StringVec& bindings,
function malValuePtr (line 54) | malValuePtr list(malValueVec* items) {
function malValuePtr (line 58) | malValuePtr list(malValueIter begin, malValueIter end) {
function malValuePtr (line 62) | malValuePtr list(malValuePtr a) {
function malValuePtr (line 68) | malValuePtr list(malValuePtr a, malValuePtr b) {
function malValuePtr (line 75) | malValuePtr list(malValuePtr a, malValuePtr b, malValuePtr c) {
function malValuePtr (line 83) | malValuePtr macro(const malLambda& lambda) {
function malValuePtr (line 87) | malValuePtr nilValue() {
function malValuePtr (line 92) | malValuePtr string(const String& token) {
function malValuePtr (line 96) | malValuePtr symbol(const String& token) {
function malValuePtr (line 100) | malValuePtr trueValue() {
function malValuePtr (line 105) | malValuePtr vector(malValueVec* items) {
function malValuePtr (line 109) | malValuePtr vector(malValueIter begin, malValueIter end) {
function malValuePtr (line 114) | malValuePtr malBuiltIn::apply(malValueIter argsBegin,
function String (line 120) | static String makeHashKey(malValuePtr key)
function addToMap (line 131) | static malHash::Map addToMap(malHash::Map& map,
function createMap (line 143) | static malHash::Map createMap(malValueIter argsBegin, malValueIter argsEnd)
function malValuePtr (line 166) | malValuePtr
function malValuePtr (line 182) | malValuePtr
function malValuePtr (line 193) | malValuePtr malHash::eval(malEnvPtr env)
function malValuePtr (line 206) | malValuePtr malHash::get(malValuePtr key) const
function malValuePtr (line 212) | malValuePtr malHash::keys() const
function malValuePtr (line 227) | malValuePtr malHash::values() const
function String (line 237) | String malHash::print(bool readably) const
function malValuePtr (line 303) | malValuePtr malLambda::apply(malValueIter argsBegin,
function malValuePtr (line 309) | malValuePtr malLambda::doWithMeta(malValuePtr meta) const
function malEnvPtr (line 314) | malEnvPtr malLambda::makeEnv(malValueIter argsBegin, malValueIter argsEn...
function malValuePtr (line 319) | malValuePtr malList::conj(malValueIter argsBegin,
function malValuePtr (line 332) | malValuePtr malList::eval(malEnvPtr env)
function String (line 346) | String malList::print(bool readably) const
function malValuePtr (line 351) | malValuePtr malValue::eval(malEnvPtr env)
function malValuePtr (line 373) | malValuePtr malValue::meta() const
function malValuePtr (line 378) | malValuePtr malValue::withMeta(malValuePtr meta) const
function malValueVec (line 425) | malValueVec* malSequence::evalItems(malEnvPtr env) const
function malValuePtr (line 435) | malValuePtr malSequence::first() const
function String (line 440) | String malSequence::print(bool readably) const
function malValuePtr (line 456) | malValuePtr malSequence::rest() const
function String (line 462) | String malString::escapedValue() const
function String (line 467) | String malString::print(bool readably) const
function malValuePtr (line 472) | malValuePtr malSymbol::eval(malEnvPtr env)
function malValuePtr (line 477) | malValuePtr malVector::conj(malValueIter argsBegin,
function malValuePtr (line 490) | malValuePtr malVector::eval(malEnvPtr env)
function String (line 495) | String malVector::print(bool readably) const
FILE: impls/cpp/Types.h
function class (line 9) | class malEmptyInputException : public std::exception { }
function class (line 11) | class malValue : public RefCounted {
function class (line 76) | class malInteger : public malValue {
function virtual (line 88) | virtual bool doIsEqualTo(const malValue* rhs) const {
function class (line 98) | class malStringBase : public malValue {
function class (line 113) | class malString : public malStringBase {
function class (line 131) | class malKeyword : public malStringBase {
function class (line 145) | class malSymbol : public malStringBase {
function malValuePtr (line 173) | malValuePtr item(int index) const { return (*m_items)[index]; }
function malValuePtr (line 183) | malValuePtr first() const;
function class (line 207) | class malVector : public malSequence {
function class (line 224) | class malApplicable : public malValue {
function class (line 233) | class malHash : public malValue {
function namespace (line 348) | namespace mal {
FILE: impls/cpp/Validation.cpp
function checkArgsIs (line 3) | int checkArgsIs(const char* name, int expected, int got)
function checkArgsBetween (line 11) | int checkArgsBetween(const char* name, int min, int max, int got)
function checkArgsAtLeast (line 19) | int checkArgsAtLeast(const char* name, int min, int got)
function checkArgsEven (line 27) | int checkArgsEven(const char* name, int got)
FILE: impls/cpp/step0_repl.cpp
function main (line 14) | int main(int argc, char* argv[])
function String (line 24) | String rep(const String& input)
function String (line 29) | String READ(const String& input)
function String (line 34) | String EVAL(const String& ast)
function String (line 39) | String PRINT(const String& ast)
FILE: impls/cpp/step1_read_print.cpp
function main (line 17) | int main(int argc, char* argv[])
function String (line 37) | static String rep(const String& input)
function malValuePtr (line 42) | malValuePtr READ(const String& input)
function malValuePtr (line 47) | static malValuePtr EVAL(malValuePtr ast)
function String (line 52) | String PRINT(malValuePtr ast)
function malValuePtr (line 58) | malValuePtr EVAL(malValuePtr ast, malEnvPtr)
function malValuePtr (line 63) | malValuePtr APPLY(malValuePtr ast, malValueIter, malValueIter)
FILE: impls/cpp/step2_eval.cpp
function main (line 17) | int main(int argc, char* argv[])
function String (line 42) | String rep(const String& input, malEnvPtr env)
function malValuePtr (line 47) | malValuePtr READ(const String& input)
function malValuePtr (line 52) | malValuePtr EVAL(malValuePtr ast, malEnvPtr env)
function String (line 59) | String PRINT(malValuePtr ast)
function malValuePtr (line 64) | malValuePtr APPLY(malValuePtr op, malValueIter argsBegin, malValueIter a...
function malValuePtr (line 82) | static malValuePtr builtIn_add(const String& name,
function malValuePtr (line 91) | static malValuePtr builtIn_sub(const String& name,
function malValuePtr (line 103) | static malValuePtr builtIn_mul(const String& name,
function malValuePtr (line 112) | static malValuePtr builtIn_div(const String& name,
FILE: impls/cpp/step3_env.cpp
function main (line 17) | int main(int argc, char* argv[])
function String (line 38) | String rep(const String& input, malEnvPtr env)
function malValuePtr (line 43) | malValuePtr READ(const String& input)
function malValuePtr (line 48) | malValuePtr EVAL(malValuePtr ast, malEnvPtr env)
function String (line 97) | String PRINT(malValuePtr ast)
function malValuePtr (line 102) | malValuePtr APPLY(malValuePtr op, malValueIter argsBegin, malValueIter a...
function malValuePtr (line 112) | malValuePtr readline(const String& prompt)
FILE: impls/cpp/step4_if_fn_do.cpp
function main (line 18) | int main(int argc, char* argv[])
function String (line 40) | String rep(const String& input, malEnvPtr env)
function malValuePtr (line 45) | malValuePtr READ(const String& input)
function malValuePtr (line 50) | malValuePtr EVAL(malValuePtr ast, malEnvPtr env)
function String (line 139) | String PRINT(malValuePtr ast)
function malValuePtr (line 144) | malValuePtr APPLY(malValuePtr op, malValueIter argsBegin, malValueIter a...
function installFunctions (line 157) | static void installFunctions(malEnvPtr env) {
function malValuePtr (line 164) | malValuePtr readline(const String& prompt)
FILE: impls/cpp/step5_tco.cpp
function main (line 18) | int main(int argc, char* argv[])
function String (line 40) | String rep(const String& input, malEnvPtr env)
function malValuePtr (line 45) | malValuePtr READ(const String& input)
function malValuePtr (line 50) | malValuePtr EVAL(malValuePtr ast, malEnvPtr env)
function String (line 146) | String PRINT(malValuePtr ast)
function malValuePtr (line 151) | malValuePtr APPLY(malValuePtr op, malValueIter argsBegin, malValueIter a...
function installFunctions (line 164) | static void installFunctions(malEnvPtr env) {
function malValuePtr (line 171) | malValuePtr readline(const String& prompt)
FILE: impls/cpp/step6_file.cpp
function main (line 21) | int main(int argc, char* argv[])
function String (line 41) | static String safeRep(const String& input, malEnvPtr env)
function makeArgv (line 54) | static void makeArgv(malEnvPtr env, int argc, char* argv[])
function String (line 63) | String rep(const String& input, malEnvPtr env)
function malValuePtr (line 68) | malValuePtr READ(const String& input)
function malValuePtr (line 73) | malValuePtr EVAL(malValuePtr ast, malEnvPtr env)
function String (line 169) | String PRINT(malValuePtr ast)
function malValuePtr (line 174) | malValuePtr APPLY(malValuePtr op, malValueIter argsBegin, malValueIter a...
function installFunctions (line 189) | static void installFunctions(malEnvPtr env) {
function malValuePtr (line 196) | malValuePtr readline(const String& prompt)
FILE: impls/cpp/step7_quote.cpp
function main (line 22) | int main(int argc, char* argv[])
function String (line 42) | static String safeRep(const String& input, malEnvPtr env)
function makeArgv (line 55) | static void makeArgv(malEnvPtr env, int argc, char* argv[])
function String (line 64) | String rep(const String& input, malEnvPtr env)
function malValuePtr (line 69) | malValuePtr READ(const String& input)
function malValuePtr (line 74) | malValuePtr EVAL(malValuePtr ast, malEnvPtr env)
function String (line 181) | String PRINT(malValuePtr ast)
function malValuePtr (line 186) | malValuePtr APPLY(malValuePtr op, malValueIter argsBegin, malValueIter a...
function isSymbol (line 195) | static bool isSymbol(malValuePtr obj, const String& text)
function malValuePtr (line 202) | static malValuePtr starts_with(const malValuePtr ast, const char* sym)
function malValuePtr (line 211) | static malValuePtr quasiquote(malValuePtr obj)
function installFunctions (line 244) | static void installFunctions(malEnvPtr env) {
function malValuePtr (line 251) | malValuePtr readline(const String& prompt)
FILE: impls/cpp/step8_macros.cpp
function main (line 23) | int main(int argc, char* argv[])
function String (line 43) | static String safeRep(const String& input, malEnvPtr env)
function makeArgv (line 56) | static void makeArgv(malEnvPtr env, int argc, char* argv[])
function String (line 65) | String rep(const String& input, malEnvPtr env)
function malValuePtr (line 70) | malValuePtr READ(const String& input)
function malValuePtr (line 75) | malValuePtr EVAL(malValuePtr ast, malEnvPtr env)
function String (line 196) | String PRINT(malValuePtr ast)
function malValuePtr (line 201) | malValuePtr APPLY(malValuePtr op, malValueIter argsBegin, malValueIter a...
function isSymbol (line 210) | static bool isSymbol(malValuePtr obj, const String& text)
function malValuePtr (line 217) | static malValuePtr starts_with(const malValuePtr ast, const char* sym)
function malValuePtr (line 226) | static malValuePtr quasiquote(malValuePtr obj)
function installFunctions (line 260) | static void installFunctions(malEnvPtr env) {
function malValuePtr (line 267) | malValuePtr readline(const String& prompt)
FILE: impls/cpp/step9_try.cpp
function main (line 23) | int main(int argc, char* argv[])
function String (line 43) | static String safeRep(const String& input, malEnvPtr env)
function makeArgv (line 59) | static void makeArgv(malEnvPtr env, int argc, char* argv[])
function String (line 68) | String rep(const String& input, malEnvPtr env)
function malValuePtr (line 73) | malValuePtr READ(const String& input)
function malValuePtr (line 78) | malValuePtr EVAL(malValuePtr ast, malEnvPtr env)
function String (line 245) | String PRINT(malValuePtr ast)
function malValuePtr (line 250) | malValuePtr APPLY(malValuePtr op, malValueIter argsBegin, malValueIter a...
function isSymbol (line 259) | static bool isSymbol(malValuePtr obj, const String& text)
function malValuePtr (line 266) | static malValuePtr starts_with(const malValuePtr ast, const char* sym)
function malValuePtr (line 275) | static malValuePtr quasiquote(malValuePtr obj)
function installFunctions (line 309) | static void installFunctions(malEnvPtr env) {
function malValuePtr (line 316) | malValuePtr readline(const String& prompt)
FILE: impls/cpp/stepA_mal.cpp
function main (line 23) | int main(int argc, char* argv[])
function String (line 44) | static String safeRep(const String& input, malEnvPtr env)
function makeArgv (line 60) | static void makeArgv(malEnvPtr env, int argc, char* argv[])
function String (line 69) | String rep(const String& input, malEnvPtr env)
function malValuePtr (line 74) | malValuePtr READ(const String& input)
function malValuePtr (line 79) | malValuePtr EVAL(malValuePtr ast, malEnvPtr env)
function String (line 246) | String PRINT(malValuePtr ast)
function malValuePtr (line 251) | malValuePtr APPLY(malValuePtr op, malValueIter argsBegin, malValueIter a...
function isSymbol (line 260) | static bool isSymbol(malValuePtr obj, const String& text)
function malValuePtr (line 267) | static malValuePtr starts_with(const malValuePtr ast, const char* sym)
function malValuePtr (line 276) | static malValuePtr quasiquote(malValuePtr obj)
function installFunctions (line 311) | static void installFunctions(malEnvPtr env) {
function malValuePtr (line 318) | malValuePtr readline(const String& prompt)
FILE: impls/cs/core.cs
class core (line 16) | public class core {
FILE: impls/cs/env.cs
class env (line 8) | public class env {
class Env (line 9) | public class Env {
method Env (line 13) | public Env(Env outer) {
method Env (line 16) | public Env(Env outer, MalList binds, MalList exprs) {
method get (line 29) | public MalVal get(string key) {
method set (line 39) | public Env set(MalSymbol key, MalVal value) {
FILE: impls/cs/getline.cs
class LineEditor (line 35) | public class LineEditor {
class Completion (line 37) | public class Completion {
method Completion (line 41) | public Completion (string prefix, string [] result)
type Handler (line 99) | struct Handler {
method Handler (line 103) | public Handler (ConsoleKey key, KeyHandler h)
method Handler (line 109) | public Handler (char c, KeyHandler h)
method Handler (line 116) | public Handler (ConsoleKeyInfo cki, KeyHandler h)
method Control (line 122) | public static Handler Control (char c, KeyHandler h)
method Alt (line 127) | public static Handler Alt (char c, ConsoleKey k, KeyHandler h)
method LineEditor (line 150) | public LineEditor (string name) : this (name, 10) { }
method LineEditor (line 152) | public LineEditor (string name, int histsize)
method CmdDebug (line 201) | void CmdDebug ()
method Render (line 208) | void Render ()
method UpdateHomeRow (line 226) | void UpdateHomeRow (int screenpos)
method RenderFrom (line 236) | void RenderFrom (int pos)
method ComputeRendered (line 253) | void ComputeRendered ()
method TextToRenderPos (line 271) | int TextToRenderPos (int pos)
method TextToScreenPos (line 292) | int TextToScreenPos (int pos)
method ForceCursor (line 308) | void ForceCursor (int newpos)
method UpdateCursor (line 324) | void UpdateCursor (int newpos)
method InsertChar (line 332) | void InsertChar (char c)
method CmdDone (line 352) | void CmdDone ()
method CmdTabOrComplete (line 357) | void CmdTabOrComplete ()
method CmdHome (line 422) | void CmdHome ()
method CmdEnd (line 427) | void CmdEnd ()
method CmdLeft (line 432) | void CmdLeft ()
method CmdBackwardWord (line 440) | void CmdBackwardWord ()
method CmdForwardWord (line 448) | void CmdForwardWord ()
method CmdRight (line 456) | void CmdRight ()
method RenderAfter (line 464) | void RenderAfter (int p)
method CmdBackspace (line 471) | void CmdBackspace ()
method CmdDeleteChar (line 481) | void CmdDeleteChar ()
method WordForward (line 498) | int WordForward (int p)
method WordBackward (line 524) | int WordBackward (int p)
method CmdDeleteWord (line 556) | void CmdDeleteWord ()
method CmdDeleteBackword (line 575) | void CmdDeleteBackword ()
method HistoryUpdateLine (line 596) | void HistoryUpdateLine ()
method CmdHistoryPrev (line 601) | void CmdHistoryPrev ()
method CmdHistoryNext (line 611) | void CmdHistoryNext ()
method CmdKillToEOF (line 621) | void CmdKillToEOF ()
method CmdYank (line 629) | void CmdYank ()
method InsertTextAtCursor (line 634) | void InsertTextAtCursor (string str)
method SetSearchPrompt (line 652) | void SetSearchPrompt (string s)
method ReverseSearch (line 657) | void ReverseSearch ()
method CmdReverseSearch (line 695) | void CmdReverseSearch ()
method SearchAppend (line 717) | void SearchAppend (char c)
method CmdRefresh (line 734) | void CmdRefresh ()
method InterruptEdit (line 742) | void InterruptEdit (object sender, ConsoleCancelEventArgs a)
method HandleChar (line 751) | void HandleChar (char c)
method EditLoop (line 759) | void EditLoop ()
method InitText (line 806) | void InitText (string initial)
method SetText (line 815) | void SetText (string newtext)
method SetPrompt (line 821) | void SetPrompt (string newprompt)
method Edit (line 829) | public string Edit (string prompt, string initial)
method SaveHistory (line 873) | public void SaveHistory ()
class History (line 886) | class History {
method History (line 892) | public History (string app, int size)
method Close (line 927) | public void Close ()
method Append (line 948) | public void Append (string s)
method Update (line 965) | public void Update (string s)
method RemoveLast (line 970) | public void RemoveLast ()
method Accept (line 977) | public void Accept (string s)
method PreviousAvailable (line 986) | public bool PreviousAvailable ()
method NextAvailable (line 1001) | public bool NextAvailable ()
method Previous (line 1016) | public string Previous ()
method Next (line 1028) | public string Next ()
method CursorToEnd (line 1037) | public void CursorToEnd ()
method Dump (line 1045) | public void Dump ()
method SearchBackward (line 1054) | public string SearchBackward (string term)
class Demo (line 1075) | class Demo {
method Main (line 1076) | static void Main ()
FILE: impls/cs/interop.cs
class EvalProvider (line 8) | public static class EvalProvider
method CreateEvalMethod (line 10) | public static Func<T, TResult> CreateEvalMethod<T, TResult>(string cod...
method GetUsing (line 56) | private static string GetUsing(HashSet<string> usingStatements)
FILE: impls/cs/printer.cs
class printer (line 9) | public class printer {
method join (line 10) | public static string join(List<MalVal> value,
method join (line 19) | public static string join(Dictionary<string,MalVal> value,
method _pr_str (line 35) | public static string _pr_str(MalVal mv, bool print_readably) {
method _pr_str_args (line 39) | public static string _pr_str_args(MalList args, String sep,
method escapeString (line 44) | public static string escapeString(string str) {
FILE: impls/cs/reader.cs
class reader (line 15) | public class reader {
class ParseError (line 16) | public class ParseError : MalThrowable {
method ParseError (line 17) | public ParseError(string msg) : base(msg) { }
class Reader (line 20) | public class Reader {
method Reader (line 23) | public Reader(List<string> t) {
method peek (line 28) | public string peek() {
method next (line 35) | public string next() {
method tokenize (line 40) | public static List<string> tokenize(string str) {
method read_atom (line 54) | public static MalVal read_atom(Reader rdr) {
method read_list (line 90) | public static MalVal read_list(Reader rdr, MalList lst, char start, ch...
method read_hash_map (line 108) | public static MalVal read_hash_map(Reader rdr) {
method read_form (line 114) | public static MalVal read_form(Reader rdr) {
method read_str (line 155) | public static MalVal read_str(string str) {
FILE: impls/cs/readline.cs
class readline (line 5) | public class readline {
type Mode (line 6) | public enum Mode { Terminal, Raw };
method Readline (line 11) | public static string Readline(string prompt) {
FILE: impls/cs/step0_repl.cs
class step0_repl (line 6) | class step0_repl {
method READ (line 8) | static string READ(string str) {
method EVAL (line 13) | static string EVAL(string ast, string env) {
method PRINT (line 18) | static string PRINT(string exp) {
method RE (line 23) | static string RE(string env, string str) {
method Main (line 27) | static void Main(string[] args) {
FILE: impls/cs/step1_read_print.cs
class step1_read_print (line 7) | class step1_read_print {
method READ (line 9) | static MalVal READ(string str) {
method EVAL (line 14) | static MalVal EVAL(MalVal ast, string env) {
method PRINT (line 19) | static string PRINT(MalVal exp) {
method Main (line 24) | static void Main(string[] args) {
FILE: impls/cs/step2_eval.cs
class step2_eval (line 15) | class step2_eval {
method READ (line 17) | static MalVal READ(string str) {
method EVAL (line 22) | static MalVal EVAL(MalVal orig_ast, Dictionary<string, MalVal> env) {
method PRINT (line 63) | static string PRINT(MalVal exp) {
method Main (line 68) | static void Main(string[] args) {
FILE: impls/cs/step3_env.cs
class step3_env (line 16) | class step3_env {
method READ (line 18) | static MalVal READ(string str) {
method EVAL (line 23) | static MalVal EVAL(MalVal orig_ast, Env env) {
method PRINT (line 92) | static string PRINT(MalVal exp) {
method Main (line 97) | static void Main(string[] args) {
FILE: impls/cs/step4_if_fn_do.cs
class step4_if_fn_do (line 16) | class step4_if_fn_do {
method READ (line 18) | static MalVal READ(string str) {
method EVAL (line 23) | static MalVal EVAL(MalVal orig_ast, Env env) {
method PRINT (line 117) | static string PRINT(MalVal exp) {
method Main (line 122) | static void Main(string[] args) {
FILE: impls/cs/step5_tco.cs
class step5_tco (line 16) | class step5_tco {
method READ (line 18) | static MalVal READ(string str) {
method EVAL (line 23) | static MalVal EVAL(MalVal orig_ast, Env env) {
method PRINT (line 130) | static string PRINT(MalVal exp) {
method Main (line 135) | static void Main(string[] args) {
FILE: impls/cs/step6_file.cs
class step6_file (line 17) | class step6_file {
method READ (line 19) | static MalVal READ(string str) {
method EVAL (line 24) | static MalVal EVAL(MalVal orig_ast, Env env) {
method PRINT (line 131) | static string PRINT(MalVal exp) {
method Main (line 136) | static void Main(string[] args) {
FILE: impls/cs/step7_quote.cs
class step7_quote (line 17) | class step7_quote {
method READ (line 19) | static MalVal READ(string str) {
method starts_with (line 24) | public static bool starts_with(MalVal ast, string sym) {
method qq_loop (line 35) | public static MalVal qq_loop(MalList ast) {
method quasiquote (line 47) | public static MalVal quasiquote(MalVal ast) {
method EVAL (line 62) | static MalVal EVAL(MalVal orig_ast, Env env) {
method PRINT (line 174) | static string PRINT(MalVal exp) {
method Main (line 179) | static void Main(string[] args) {
FILE: impls/cs/step8_macros.cs
class step8_macros (line 17) | class step8_macros {
method READ (line 19) | static MalVal READ(string str) {
method starts_with (line 24) | public static bool starts_with(MalVal ast, string sym) {
method qq_loop (line 35) | public static MalVal qq_loop(MalList ast) {
method quasiquote (line 47) | public static MalVal quasiquote(MalVal ast) {
method EVAL (line 62) | static MalVal EVAL(MalVal orig_ast, Env env) {
method PRINT (line 186) | static string PRINT(MalVal exp) {
method Main (line 191) | static void Main(string[] args) {
FILE: impls/cs/step9_try.cs
class step9_try (line 17) | class step9_try {
method READ (line 19) | static MalVal READ(string str) {
method starts_with (line 24) | public static bool starts_with(MalVal ast, string sym) {
method qq_loop (line 35) | public static MalVal qq_loop(MalList ast) {
method quasiquote (line 47) | public static MalVal quasiquote(MalVal ast) {
method EVAL (line 62) | static MalVal EVAL(MalVal orig_ast, Env env) {
method PRINT (line 207) | static string PRINT(MalVal exp) {
method Main (line 212) | static void Main(string[] args) {
FILE: impls/cs/stepA_mal.cs
class stepA_mal (line 17) | class stepA_mal {
method READ (line 19) | static MalVal READ(string str) {
method starts_with (line 24) | public static bool starts_with(MalVal ast, string sym) {
method qq_loop (line 35) | public static MalVal qq_loop(MalList ast) {
method quasiquote (line 47) | public static MalVal quasiquote(MalVal ast) {
method EVAL (line 62) | static MalVal EVAL(MalVal orig_ast, Env env) {
method PRINT (line 207) | static string PRINT(MalVal exp) {
method Main (line 212) | static void Main(string[] args) {
FILE: impls/cs/types.cs
class types (line 6) | public class types {
class MalThrowable (line 10) | public class MalThrowable : Exception {
method MalThrowable (line 11) | public MalThrowable() : base() { }
method MalThrowable (line 12) | public MalThrowable(string msg) : base(msg) { }
class MalError (line 14) | public class MalError : MalThrowable {
method MalError (line 15) | public MalError(string msg) :base(msg) { }
class MalContinue (line 17) | public class MalContinue : MalThrowable { }
class MalException (line 20) | public class MalException : MalThrowable {
method MalException (line 23) | public MalException(MalVal value) {
method MalException (line 26) | public MalException(string value) :base(value) {
method getValue (line 29) | public MalVal getValue() { return value; }
method _equal_Q (line 36) | public static bool _equal_Q(MalVal a, MalVal b) {
class MalVal (line 81) | public abstract class MalVal {
method copy (line 83) | public virtual MalVal copy() {
method ToString (line 88) | public virtual string ToString(bool print_readably) {
method getMeta (line 91) | public MalVal getMeta() { return meta; }
method setMeta (line 92) | public MalVal setMeta(MalVal m) { meta = m; return this; }
method list_Q (line 93) | public virtual bool list_Q() { return false; }
class MalConstant (line 96) | public class MalConstant : MalVal {
method MalConstant (line 98) | public MalConstant(string name) { value = name; }
method copy (line 99) | public new MalConstant copy() { return this; }
method ToString (line 101) | public override string ToString() {
method ToString (line 104) | public override string ToString(bool print_readably) {
class MalInt (line 113) | public class MalInt : MalVal {
method MalInt (line 115) | public MalInt(Int64 v) { value = v; }
method copy (line 116) | public new MalInt copy() { return this; }
method getValue (line 118) | public Int64 getValue() { return value; }
method ToString (line 119) | public override string ToString() {
method ToString (line 122) | public override string ToString(bool print_readably) {
class MalSymbol (line 151) | public class MalSymbol : MalVal {
method MalSymbol (line 153) | public MalSymbol(string v) { value = v; }
method MalSymbol (line 154) | public MalSymbol(MalString v) { value = v.getValue(); }
method copy (line 155) | public new MalSymbol copy() { return this; }
method getName (line 157) | public string getName() { return value; }
method ToString (line 158) | public override string ToString() {
method ToString (line 161) | public override string ToString(bool print_readably) {
class MalString (line 166) | public class MalString : MalVal {
method MalString (line 168) | public MalString(string v) { value = v; }
method copy (line 169) | public new MalString copy() { return this; }
method getValue (line 171) | public string getValue() { return value; }
method ToString (line 172) | public override string ToString() {
method ToString (line 175) | public override string ToString(bool print_readably) {
class MalList (line 190) | public class MalList : MalVal {
method MalList (line 193) | public MalList() {
method MalList (line 196) | public MalList(List<MalVal> val) {
method MalList (line 199) | public MalList(params MalVal[] mvs) {
method getValue (line 204) | public List<MalVal> getValue() { return value; }
method list_Q (line 205) | public override bool list_Q() { return true; }
method ToString (line 207) | public override string ToString() {
method ToString (line 210) | public override string ToString(bool print_readably) {
method conj_BANG (line 214) | public MalList conj_BANG(params MalVal[] mvs) {
method size (line 221) | public int size() { return value.Count; }
method nth (line 222) | public MalVal nth(int idx) {
method rest (line 228) | public MalList rest() {
method slice (line 235) | public virtual MalList slice(int start) {
method slice (line 238) | public virtual MalList slice(int start, int end) {
class MalVector (line 244) | public class MalVector : MalList {
method MalVector (line 246) | public MalVector() :base() {
method MalVector (line 250) | public MalVector(List<MalVal> val)
method list_Q (line 256) | public override bool list_Q() { return false; }
method slice (line 258) | public override MalList slice(int start, int end) {
class MalHashMap (line 264) | public class MalHashMap : MalVal {
method MalHashMap (line 266) | public MalHashMap(Dictionary<string, MalVal> val) {
method MalHashMap (line 269) | public MalHashMap(MalList lst) {
method copy (line 273) | public new MalHashMap copy() {
method getValue (line 279) | public Dictionary<string, MalVal> getValue() { return value; }
method ToString (line 281) | public override string ToString() {
method ToString (line 284) | public override string ToString(bool print_readably) {
method assoc_BANG (line 288) | public MalHashMap assoc_BANG(MalList lst) {
method dissoc_BANG (line 295) | public MalHashMap dissoc_BANG(MalList lst) {
class MalAtom (line 303) | public class MalAtom : MalVal {
method MalAtom (line 305) | public MalAtom(MalVal value) { this.value = value; }
method getValue (line 307) | public MalVal getValue() { return value; }
method setValue (line 308) | public MalVal setValue(MalVal value) { return this.value = value; }
method ToString (line 309) | public override string ToString() {
method ToString (line 312) | public override string ToString(Boolean print_readably) {
class MalFunc (line 317) | public class MalFunc : MalVal {
method MalFunc (line 323) | public MalFunc(Func<MalList, MalVal> fn) {
method MalFunc (line 326) | public MalFunc(MalVal ast, Mal.env.Env env, MalList fparams,
method ToString (line 334) | public override string ToString() {
method apply (line 343) | public MalVal apply(MalList args) {
method getAst (line 347) | public MalVal getAst() { return ast; }
method getEnv (line 348) | public Mal.env.Env getEnv() { return env; }
method getFParams (line 349) | public MalList getFParams() { return fparams; }
method genEnv (line 350) | public Mal.env.Env genEnv(MalList args) {
method isMacro (line 353) | public bool isMacro() { return macro; }
method setMacro (line 354) | public void setMacro() { macro = true; }
FILE: impls/dart/env.dart
class Env (line 3) | class Env {
method set (line 24) | void set(String key, MalType value)
method get (line 28) | MalType get(String key)
class NotFoundException (line 40) | class NotFoundException implements Exception {
method toString (line 46) | String toString()
FILE: impls/dart/printer.dart
function pr_str (line 3) | String pr_str(MalType data, {bool print_readably: true})
FILE: impls/dart/reader.dart
class Reader (line 8) | class Reader {
method next (line 14) | String next()
method peek (line 20) | String peek()
class ParseException (line 26) | class ParseException implements Exception {
class NoInputException (line 32) | class NoInputException implements Exception {}
function read_str (line 34) | MalType read_str(String code)
function tokenizer (line 43) | List<String> tokenizer(String code)
function read_form (line 51) | MalType read_form(Reader reader)
function read_sequence (line 91) | List<MalType> read_sequence(Reader reader, String open, String close)
function read_atom (line 111) | MalType read_atom(Reader reader)
FILE: impls/dart/step0_repl.dart
function READ (line 3) | String READ(String x)
function EVAL (line 5) | String EVAL(String x)
function PRINT (line 7) | String PRINT(String x)
function rep (line 9) | String rep(String x)
function main (line 12) | main()
FILE: impls/dart/step1_read_print.dart
function READ (line 7) | MalType READ(String x)
function EVAL (line 9) | MalType EVAL(MalType x)
function PRINT (line 11) | String PRINT(MalType x)
function rep (line 13) | String rep(String x)
function main (line 18) | main()
FILE: impls/dart/step2_eval.dart
function READ (line 30) | MalType READ(String x)
class NotFoundException (line 32) | class NotFoundException implements Exception {
function EVAL (line 39) | MalType EVAL(MalType ast, Map<String, MalType> env)
function PRINT (line 72) | String PRINT(MalType x)
function rep (line 74) | String rep(String x)
function main (line 79) | main()
FILE: impls/dart/step3_env.dart
function setupEnv (line 10) | void setupEnv()
function READ (line 33) | MalType READ(String x)
function EVAL (line 35) | MalType EVAL(MalType ast, Env env)
function pairs (line 76) | Iterable<List<MalType>> pairs(List<MalType> elements)
function PRINT (line 98) | String PRINT(MalType x)
function rep (line 100) | String rep(String x)
function main (line 105) | main()
FILE: impls/dart/step4_if_fn_do.dart
function setupEnv (line 11) | void setupEnv()
function READ (line 17) | MalType READ(String x)
function EVAL (line 19) | MalType EVAL(MalType ast, Env env)
function pairs (line 60) | Iterable<List<MalType>> pairs(List<MalType> elements)
function PRINT (line 112) | String PRINT(MalType x)
function rep (line 114) | String rep(String x)
function main (line 119) | main()
FILE: impls/dart/step5_tco.dart
function setupEnv (line 11) | void setupEnv()
function READ (line 17) | MalType READ(String x)
function EVAL (line 19) | MalType EVAL(MalType ast, Env env)
function pairs (line 62) | Iterable<List<MalType>> pairs(List<MalType> elements)
function PRINT (line 127) | String PRINT(MalType x)
function rep (line 129) | String rep(String x)
function main (line 134) | main()
FILE: impls/dart/step6_file.dart
function setupEnv (line 11) | void setupEnv(List<String> argv)
function READ (line 26) | MalType READ(String x)
function EVAL (line 28) | MalType EVAL(MalType ast, Env env)
function pairs (line 71) | Iterable<List<MalType>> pairs(List<MalType> elements)
function PRINT (line 136) | String PRINT(MalType x)
function rep (line 138) | String rep(String x)
function main (line 143) | main(List<String> args)
FILE: impls/dart/step7_quote.dart
function setupEnv (line 11) | void setupEnv(List<String> argv)
function starts_with (line 26) | bool starts_with(MalType ast, String sym)
function qq_loop (line 30) | MalType qq_loop(List<MalType> xs)
function quasiquote (line 42) | MalType quasiquote(MalType ast)
function READ (line 56) | MalType READ(String x)
function EVAL (line 58) | MalType EVAL(MalType ast, Env env)
function pairs (line 101) | Iterable<List<MalType>> pairs(List<MalType> elements)
function PRINT (line 171) | String PRINT(MalType x)
function rep (line 173) | String rep(String x)
function main (line 178) | main(List<String> args)
FILE: impls/dart/step8_macros.dart
function setupEnv (line 11) | void setupEnv(List<String> argv)
function starts_with (line 32) | bool starts_with(MalType ast, String sym)
function qq_loop (line 36) | MalType qq_loop(List<MalType> xs)
function quasiquote (line 48) | MalType quasiquote(MalType ast)
function READ (line 62) | MalType READ(String x)
function EVAL (line 64) | MalType EVAL(MalType ast, Env env)
function pairs (line 113) | Iterable<List<MalType>> pairs(List<MalType> elements)
function PRINT (line 186) | String PRINT(MalType x)
function rep (line 188) | String rep(String x)
function main (line 193) | main(List<String> args)
FILE: impls/dart/step9_try.dart
function setupEnv (line 11) | void setupEnv(List<String> argv)
function starts_with (line 32) | bool starts_with(MalType ast, String sym)
function qq_loop (line 36) | MalType qq_loop(List<MalType> xs)
function quasiquote (line 48) | MalType quasiquote(MalType ast)
function READ (line 62) | MalType READ(String x)
function EVAL (line 64) | MalType EVAL(MalType ast, Env env)
function pairs (line 113) | Iterable<List<MalType>> pairs(List<MalType> elements)
function PRINT (line 211) | String PRINT(MalType x)
function rep (line 213) | String rep(String x)
function main (line 218) | main(List<String> args)
FILE: impls/dart/stepA_mal.dart
function setupEnv (line 11) | void setupEnv(List<String> argv)
function starts_with (line 34) | bool starts_with(MalType ast, String sym)
function qq_loop (line 38) | MalType qq_loop(List<MalType> xs)
function quasiquote (line 50) | MalType quasiquote(MalType ast)
function READ (line 64) | MalType READ(String x)
function EVAL (line 66) | MalType EVAL(MalType ast, Env env)
function pairs (line 115) | Iterable<List<MalType>> pairs(List<MalType> elements)
function PRINT (line 213) | String PRINT(MalType x)
function rep (line 215) | String rep(String x)
function main (line 220) | main(List<String> args)
FILE: impls/dart/types.dart
class MalType (line 4) | abstract class MalType {
method clone (line 8) | MalType clone()
class MalIterable (line 11) | abstract class MalIterable extends MalType
method clone (line 42) | MalIterable clone()
class MalList (line 45) | class MalList extends MalIterable {
method clone (line 49) | MalList clone()
class MalVector (line 54) | class MalVector extends MalIterable {
method clone (line 58) | MalVector clone()
class MalHashMap (line 63) | class MalHashMap extends MalType {
method _mapFromSequence (line 71) | Map<MalType, MalType> _mapFromSequence(List<MalType> elements)
method clone (line 104) | MalHashMap clone()
class MalInt (line 109) | class MalInt extends MalType {
method clone (line 120) | MalInt clone()
class MalSymbol (line 125) | class MalSymbol extends MalType {
method clone (line 138) | MalSymbol clone()
class MalKeyword (line 143) | class MalKeyword extends MalType {
method clone (line 156) | MalKeyword clone()
class MalString (line 161) | class MalString extends MalType {
method clone (line 174) | MalString clone()
class MalBool (line 179) | class MalBool extends MalType {
method clone (line 190) | MalBool clone()
class MalNil (line 195) | class MalNil extends MalIterable {
method clone (line 201) | MalNil clone()
class MalAtom (line 206) | class MalAtom extends MalType {
method clone (line 212) | MalAtom clone()
class MalCallable (line 217) | abstract class MalCallable extends MalType {
method call (line 218) | MalType call(List<MalType> args)
type MalType (line 223) | typedef MalType BuiltinFunc(List<MalType> args);
method clone (line 8) | MalType clone()
class MalBuiltin (line 225) | class MalBuiltin extends MalCallable {
method call (line 230) | MalType call(List<MalType> args)
method clone (line 235) | MalBuiltin clone()
type MalType (line 240) | typedef MalType EvalFun(MalType ast, Env env);
method clone (line 8) | MalType clone()
class MalClosure (line 242) | class MalClosure extends MalCallable {
method call (line 253) | MalType call(List<MalType> args)
method clone (line 258) | MalClosure clone()
class MalException (line 266) | class MalException implements Exception {
FILE: impls/elixir/lib/mal.ex
class Mal (line 1) | defmodule Mal
FILE: impls/elixir/lib/mal/atom.ex
class Mal.Atom (line 1) | defmodule Mal.Atom
method new (line 4) | def new(value) do
method deref (line 9) | def deref({:atom, pid}) do
method reset! (line 13) | def reset!({:atom, pid}, new_value) do
method swap! (line 18) | def swap!({:atom, pid}, %Function{value: func}, args) do
FILE: impls/elixir/lib/mal/core.ex
class Mal.Core (line 1) | defmodule Mal.Core
method namespace (line 5) | def namespace do
method convert (line 73) | defp convert(map) do
method readline (line 79) | def readline(prompt) do
method convert_vector (line 95) | defp convert_vector(other), do: other
method equal (line 97) | defp equal([a, b]) do
method empty? (line 101) | defp empty?([{_type, [], _meta}]), do: true
method empty? (line 102) | defp empty?(_), do: false
method count (line 104) | defp count([{_type, ast, _meta}]), do: length(ast)
method count (line 105) | defp count(_), do: 0
method pr_str (line 107) | defp pr_str(args) do
method str (line 113) | defp str(args) do
method prn (line 119) | defp prn(args) do
method println (line 126) | defp println(args) do
method slurp (line 134) | defp slurp([file_name]) do
method nth (line 144) | defp nth([{_type, ast, _meta}, index]) do
method first (line 151) | defp first([{_type, [head | _tail], _}]), do: head
method first (line 152) | defp first(_), do: nil
method rest (line 154) | defp rest([{_type, [_head | tail], _}]), do: list(tail)
method rest (line 155) | defp rest([{_type, [], _}]), do: list([])
method rest (line 156) | defp rest([nil]), do: list([])
method map (line 158) | defp map([%Function{value: function}, ast]), do: do_map(function, ast)
method map (line 159) | defp map([function, ast]), do: do_map(function, ast)
method do_map (line 161) | defp do_map(function, {_type, ast, _meta}) do
method apply (line 167) | defp apply([%Function{value: function} | tail]), do: do_apply(function...
method apply (line 168) | defp apply([function | tail]), do: do_apply(function, tail)
method do_apply (line 170) | defp do_apply(function, tail) do
method keyword (line 178) | defp keyword([atom]), do: String.to_atom(atom)
method cons (line 180) | defp cons([prepend, {_type, ast, meta}]), do: {:list, [prepend | ast],...
method concat (line 182) | defp concat(args) do
method vec (line 189) | defp vec([{:list, xs, _}]), do: vector(xs)
method vec (line 190) | defp vec([{:vector, xs, _}]), do: vector(xs)
method vec (line 191) | defp vec([_]), do: throw({:error, "vec: arg type"})
method vec (line 192) | defp vec(_), do: throw({:error, "vec: arg count"})
method assoc (line 194) | defp assoc([{:map, hash_map, meta} | pairs]) do
method dissoc (line 199) | defp dissoc([{:map, hash_map, meta} | keys]) do
method get (line 203) | defp get([{:map, map, _}, key]), do: Map.get(map, key, nil)
method get (line 204) | defp get(_), do: nil
method meta (line 206) | defp meta([{_type, _ast, meta}]), do: meta
method meta (line 207) | defp meta([%Function{meta: meta}]), do: meta
method meta (line 208) | defp meta(_), do: nil
method with_meta (line 210) | defp with_meta([{type, ast, _old_meta}, meta]), do: {type, ast, meta}
method with_meta (line 211) | defp with_meta([%Function{} = func, meta]), do: %{func | meta: meta}
method with_meta (line 212) | defp with_meta(_), do: nil
method deref (line 214) | defp deref(args) do
method reset! (line 218) | defp reset!(args) do
method swap! (line 222) | defp swap!([atom, function | args]) do
method conj (line 226) | defp conj([{:list, ast, meta} | args]) do
method conj (line 231) | defp conj([{:vector, ast, meta} | args]) do
method seq (line 235) | defp seq([nil]), do: nil
method seq (line 236) | defp seq([{:list, [], _meta}]), do: nil
method seq (line 237) | defp seq([{:list, ast, meta}]), do: {:list, ast, meta}
method seq (line 238) | defp seq([{:vector, [], _meta}]), do: nil
method seq (line 239) | defp seq([{:vector, ast, meta}]), do: {:list, ast, meta}
method seq (line 240) | defp seq([""]), do: nil
method seq (line 241) | defp seq([s]), do: {:list, String.split(s, "", trim: true), nil}
method seq (line 242) | defp seq(_), do: nil
method fn? (line 244) | defp fn?([%Function{macro: false}]), do: true
method fn? (line 245) | defp fn?(_), do: false
method macro? (line 247) | defp macro?([%Function{macro: true}]), do: true
method macro? (line 248) | defp macro?(_), do: false
FILE: impls/elixir/lib/mal/env.ex
class Mal.Env (line 1) | defmodule Mal.Env
method new (line 4) | def new(outer \\ nil, binds \\ [], exprs \\ [])
method new (line 5) | def new(outer, binds, exprs) do
method set_bindings (line 13) | defp set_bindings(pid, [], []), do: pid
method set_bindings (line 14) | defp set_bindings(pid, ["&", key], exprs) do
method set_bindings (line 19) | defp set_bindings(pid, [key | binds], [value | exprs]) do
method set (line 24) | def set(pid, key, value) do
method merge (line 30) | def merge(pid, env_values) do
method find (line 36) | def find(pid, key) do
method retrieve_key (line 45) | def retrieve_key(pid, key) do
method get (line 54) | def get(pid, key) do
FILE: impls/elixir/lib/mal/printer.ex
class Mal.Printer (line 1) | defmodule Mal.Printer
method print_str (line 4) | def print_str(mal, print_readably \\ true)
method print_str (line 8) | def print_str(%Function{value: mal, macro: true}, _), do: "#Macro<#{in...
method print_str (line 9) | def print_str(%Function{value: mal}, _), do: inspect(mal)
method print_str (line 10) | def print_str({:symbol, value}, _), do: value
method print_str (line 11) | def print_str({:exception, exception}, print_readably) do
method print_str (line 17) | def print_str({:atom, _pid} = atom, print_readably) do
method print_str (line 25) | def print_str({:map, mal, _}, print_readably) do
method print_str (line 37) | def print_str({:vector, vector, _}, print_readably) do
method print_str (line 41) | def print_str({:list, mal, _}, print_readably) do
method print_list (line 45) | defp print_list(list, print_readably) do
FILE: impls/elixir/lib/mal/reader.ex
class Mal.Reader (line 1) | defmodule Mal.Reader
method read_str (line 4) | def read_str(input) do
method tokenize (line 13) | def tokenize(input) do
method read_form (line 21) | defp read_form([next | rest] = tokens) do
method create_meta (line 41) | defp create_meta(tokens) do
method create_quote (line 48) | defp create_quote(quote_type, tokens) do
method read_list (line 54) | defp read_list([_ | tokens]) do
method read_vector (line 59) | defp read_vector([_ | tokens]) do
method read_hash_map (line 64) | defp read_hash_map([_ | tokens]) do
method do_read_sequence (line 69) | defp do_read_sequence([], _acc, _start_sep, end_sep), do: throw({:erro...
method do_read_sequence (line 70) | defp do_read_sequence([head | tail] = tokens, acc, start_sep, end_sep) do
method read_atom (line 80) | defp read_atom("nil"), do: nil
method read_atom (line 81) | defp read_atom("true"), do: true
method read_atom (line 82) | defp read_atom("false"), do: false
method read_atom (line 83) | defp read_atom(":" <> rest), do: String.to_atom(rest)
method read_atom (line 84) | defp read_atom(token) do
FILE: impls/elixir/lib/mal/types.ex
class Mal.Types (line 1) | defmodule Mal.Types
method integer? (line 2) | def integer?(input) do
method hash_map (line 6) | def hash_map(ast) do
method map? (line 15) | def map?([{:map, _ast, _meta}]), do: true
method map? (line 16) | def map?(_), do: false
method list (line 18) | def list(ast), do: {:list, ast, nil}
method list? (line 20) | def list?([{:list, _, _}]), do: true
method list? (line 21) | def list?(_), do: false
method vector (line 23) | def vector(ast), do: {:vector, ast, nil}
method vector? (line 25) | def vector?([{:vector, _ast, _meta}]), do: true
method vector? (line 26) | def vector?(_), do: false
method symbol? (line 28) | def symbol?([{:symbol, _}]), do: true
method symbol? (line 29) | def symbol?(_), do: false
method atom (line 31) | def atom([value]) do
method atom? (line 36) | def atom?([{:atom, _}]), do: true
method atom? (line 37) | def atom?(_), do: false
class Mal.Function (line 40) | defmodule Mal.Function
FILE: impls/elixir/lib/mix/tasks/step0_repl.ex
class Mix.Tasks.Step0Repl (line 1) | defmodule Mix.Tasks.Step0Repl
method run (line 2) | def run(_), do: loop()
method loop (line 4) | defp loop do
method read (line 12) | defp read(input) do
method eval (line 16) | defp eval(input) do
method print (line 20) | defp print(input) do
method read_eval_print (line 24) | defp read_eval_print(:eof), do: exit(:normal)
method read_eval_print (line 25) | defp read_eval_print(line) do
FILE: impls/elixir/lib/mix/tasks/step1_read_print.ex
class Mix.Tasks.Step1ReadPrint (line 1) | defmodule Mix.Tasks.Step1ReadPrint
method run (line 2) | def run(_), do: loop()
method loop (line 4) | defp loop do
method read (line 12) | defp read(input) do
method eval (line 16) | defp eval(ast), do: ast
method print (line 18) | defp print(value) do
method read_eval_print (line 22) | defp read_eval_print(:eof), do: exit(:normal)
method read_eval_print (line 23) | defp read_eval_print(line) do
FILE: impls/elixir/lib/mix/tasks/step2_eval.ex
class Mix.Tasks.Step2Eval (line 1) | defmodule Mix.Tasks.Step2Eval
method run (line 9) | def run(_), do: loop()
method loop (line 11) | defp loop do
method eval_ast (line 24) | defp eval_ast({:map, ast, meta}, env) do
method eval_ast (line 32) | defp eval_ast({:vector, ast, meta}, env) do
method eval_ast (line 36) | defp eval_ast({:symbol, symbol}, env) do
method eval_ast (line 43) | defp eval_ast(ast, _env), do: ast
method read (line 45) | defp read(input) do
method eval (line 49) | defp eval(ast, env) do
method eval_list (line 54) | defp eval_list([a0 | args], env, _meta) do
method eval_list (line 60) | defp eval_list([], _env, meta), do: {:list, [], meta}
method print (line 62) | defp print(value) do
method read_eval_print (line 66) | defp read_eval_print(:eof), do: exit(:normal)
method read_eval_print (line 67) | defp read_eval_print(line) do
FILE: impls/elixir/lib/mix/tasks/step3_env.ex
class Mix.Tasks.Step3Env (line 1) | defmodule Mix.Tasks.Step3Env
method run (line 9) | def run(_) do
method loop (line 15) | defp loop(env) do
method eval_ast (line 28) | defp eval_ast({:map, ast, meta}, env) do
method eval_ast (line 36) | defp eval_ast({:vector, ast, meta}, env) do
method eval_ast (line 40) | defp eval_ast({:symbol, symbol}, env) do
method eval_ast (line 47) | defp eval_ast(ast, _env), do: ast
method read (line 49) | defp read(input) do
method eval_bindings (line 53) | defp eval_bindings([], env), do: env
method eval_bindings (line 54) | defp eval_bindings([{:symbol, key}, binding | tail], env) do
method eval_bindings (line 59) | defp eval_bindings(_bindings, _env), do: throw({:error, "Unbalanced le...
method eval (line 61) | defp eval(ast, env) do
method eval_list (line 71) | defp eval_list([{:symbol, "def!"}, {:symbol, key}, value], env, _) do
method eval_list (line 84) | defp eval_list([a0 | args], env, _meta) do
method eval_list (line 90) | defp eval_list([], _env, meta), do: {:list, [], meta}
method print (line 92) | defp print(value) do
method read_eval_print (line 96) | defp read_eval_print(:eof, _env), do: exit(:normal)
method read_eval_print (line 97) | defp read_eval_print(line, env) do
FILE: impls/elixir/lib/mix/tasks/step4_if_fn_do.ex
class Mix.Tasks.Step4IfFnDo (line 1) | defmodule Mix.Tasks.Step4IfFnDo
method run (line 5) | def run(_) do
method bootstrap (line 12) | defp bootstrap(env) do
method loop (line 24) | defp loop(env) do
method eval_ast (line 37) | defp eval_ast({:map, ast, meta}, env) do
method eval_ast (line 45) | defp eval_ast({:vector, ast, meta}, env) do
method eval_ast (line 49) | defp eval_ast({:symbol, symbol}, env) do
method eval_ast (line 56) | defp eval_ast(ast, _env), do: ast
method read (line 58) | defp read(input) do
method eval_bindings (line 62) | defp eval_bindings([], env), do: env
method eval_bindings (line 63) | defp eval_bindings([{:symbol, key}, binding | tail], env) do
method eval_bindings (line 68) | defp eval_bindings(_bindings, _env), do: throw({:error, "Unbalanced le...
method eval (line 70) | defp eval(ast, env) do
method eval_list (line 80) | defp eval_list([{:symbol, "if"}, condition, if_true | if_false], env, ...
method eval_list (line 92) | defp eval_list([{:symbol, "do"} | ast], env, _) do
method eval_list (line 99) | defp eval_list([{:symbol, "def!"}, {:symbol, key}, value], env, _) do
method eval_list (line 124) | defp eval_list([a0 | args], env, _meta) do
method eval_list (line 130) | defp eval_list([], _env, meta), do: {:list, [], meta}
method print (line 132) | defp print(value) do
method read_eval_print (line 136) | defp read_eval_print(:eof, _env), do: exit(:normal)
method read_eval_print (line 137) | defp read_eval_print(line, env) do
FILE: impls/elixir/lib/mix/tasks/step5_tco.ex
class Mix.Tasks.Step5Tco (line 1) | defmodule Mix.Tasks.Step5Tco
method run (line 5) | def run(_) do
method bootstrap (line 12) | defp bootstrap(env) do
method loop (line 24) | defp loop(env) do
method eval_ast (line 37) | defp eval_ast({:map, ast, meta}, env) do
method eval_ast (line 45) | defp eval_ast({:vector, ast, meta}, env) do
method eval_ast (line 49) | defp eval_ast({:symbol, symbol}, env) do
method eval_ast (line 56) | defp eval_ast(ast, _env), do: ast
method read (line 58) | defp read(input) do
method eval_bindings (line 62) | defp eval_bindings([], env), do: env
method eval_bindings (line 63) | defp eval_bindings([{:symbol, key}, binding | tail], env) do
method eval_bindings (line 68) | defp eval_bindings(_bindings, _env), do: throw({:error, "Unbalanced le...
method eval (line 70) | defp eval(ast, env) do
method eval_list (line 80) | defp eval_list([{:symbol, "if"}, condition, if_true | if_false], env, ...
method eval_list (line 92) | defp eval_list([{:symbol, "do"} | ast], env, _) do
method eval_list (line 99) | defp eval_list([{:symbol, "def!"}, {:symbol, key}, value], env, _) do
method eval_list (line 124) | defp eval_list([a0 | args], env, _meta) do
method eval_list (line 133) | defp eval_list([], _env, meta), do: {:list, [], meta}
method print (line 135) | defp print(value) do
method read_eval_print (line 139) | defp read_eval_print(:eof, _env), do: exit(:normal)
method read_eval_print (line 140) | defp read_eval_print(line, env) do
FILE: impls/elixir/lib/mix/tasks/step6_file.ex
class Mix.Tasks.Step6File (line 1) | defmodule Mix.Tasks.Step6File
method run (line 5) | def run(args) do
method load_file (line 12) | defp load_file(file_name, env) do
method bootstrap (line 19) | defp bootstrap(args, env) do
method loop (line 47) | defp loop(env) do
method eval_ast (line 60) | defp eval_ast({:map, ast, meta}, env) do
method eval_ast (line 68) | defp eval_ast({:vector, ast, meta}, env) do
method eval_ast (line 72) | defp eval_ast({:symbol, symbol}, env) do
method eval_ast (line 79) | defp eval_ast(ast, _env), do: ast
method read (line 81) | defp read(input) do
method eval_bindings (line 85) | defp eval_bindings([], env), do: env
method eval_bindings (line 86) | defp eval_bindings([{:symbol, key}, binding | tail], env) do
method eval_bindings (line 91) | defp eval_bindings(_bindings, _env), do: throw({:error, "Unbalanced le...
method eval (line 93) | defp eval(ast, env) do
method eval_list (line 103) | defp eval_list([{:symbol, "if"}, condition, if_true | if_false], env, ...
method eval_list (line 115) | defp eval_list([{:symbol, "do"} | ast], env, _) do
method eval_list (line 122) | defp eval_list([{:symbol, "def!"}, {:symbol, key}, value], env, _) do
method eval_list (line 147) | defp eval_list([a0 | args], env, _meta) do
method eval_list (line 153) | defp eval_list([], _env, meta), do: {:list, [], meta}
method print (line 155) | defp print(value) do
method read_eval_print (line 159) | defp read_eval_print(:eof, _env), do: exit(:normal)
method read_eval_print (line 160) | defp read_eval_print(line, env) do
FILE: impls/elixir/lib/mix/tasks/step7_quote.ex
class Mix.Tasks.Step7Quote (line 1) | defmodule Mix.Tasks.Step7Quote
method run (line 5) | def run(args) do
method load_file (line 12) | defp load_file(file_name, env) do
method bootstrap (line 19) | defp bootstrap(args, env) do
method loop (line 47) | defp loop(env) do
method eval_ast (line 60) | defp eval_ast({:map, ast, meta}, env) do
method eval_ast (line 68) | defp eval_ast({:vector, ast, meta}, env) do
method eval_ast (line 72) | defp eval_ast({:symbol, symbol}, env) do
method eval_ast (line 79) | defp eval_ast(ast, _env), do: ast
method read (line 81) | defp read(input) do
method eval_bindings (line 85) | defp eval_bindings([], env), do: env
method eval_bindings (line 86) | defp eval_bindings([{:symbol, key}, binding | tail], env) do
method eval_bindings (line 91) | defp eval_bindings(_bindings, _env), do: throw({:error, "Unbalanced le...
method quasiquote (line 93) | defp quasiquote({:list, [{:symbol, "unquote"}, arg], _}), do: arg
method quasiquote (line 94) | defp quasiquote({:list, [{:symbol, "unquote"}| _], _}), do: throw({:...
method quasiquote (line 95) | defp quasiquote({:list, xs, _}), do: qq_fold...
method quasiquote (line 96) | defp quasiquote({:vector, xs, _}), do: list([{:symbol, "vec"}, qq_fold...
method quasiquote (line 97) | defp quasiquote({:symbol, sym}), do: list([{:symbol, "quote"}, {:sy...
method quasiquote (line 98) | defp quasiquote({:map, ast, meta}), do: list([{:symbol, "quote"}, {:ma...
method quasiquote (line 99) | defp quasiquote(ast), do: ast
method qq_foldr (line 101) | defp qq_foldr([]), do: list([])
method qq_foldr (line 102) | defp qq_foldr([x|xs]), do: qq_loop(x, qq_foldr xs)
method qq_loop (line 104) | defp qq_loop({:list, [{:symbol, "splice-unquote"}, arg], _}, acc), do:...
method qq_loop (line 105) | defp qq_loop({:list, [{:symbol, "splice-unquote"}| _], _}, _), do:...
method qq_loop (line 106) | defp qq_loop(elt, acc), do: list([{:symbol, "cons"}, quasiquote(elt), ...
method eval (line 108) | defp eval(ast, env) do
method eval_list (line 118) | defp eval_list([{:symbol, "if"}, condition, if_true | if_false], env, ...
method eval_list (line 130) | defp eval_list([{:symbol, "do"} | ast], env, _) do
method eval_list (line 137) | defp eval_list([{:symbol, "def!"}, {:symbol, key}, value], env, _) do
method eval_list (line 162) | defp eval_list([{:symbol, "quote"}, arg], _env, _), do: arg
method eval_list (line 164) | defp eval_list([{:symbol, "quasiquote"}, ast], env, _) do
method eval_list (line 169) | defp eval_list([a0 | args], env, _meta) do
method eval_list (line 175) | defp eval_list([], _env, meta), do: {:list, [], meta}
method print (line 177) | defp print(value) do
method read_eval_print (line 181) | defp read_eval_print(:eof, _env), do: exit(:normal)
method read_eval_print (line 182) | defp read_eval_print(line, env) do
FILE: impls/elixir/lib/mix/tasks/step8_macros.ex
class Mix.Tasks.Step8Macros (line 1) | defmodule Mix.Tasks.Step8Macros
method run (line 5) | def run(args) do
method load_file (line 12) | defp load_file(file_name, env) do
method bootstrap (line 19) | defp bootstrap(args, env) do
method loop (line 59) | defp loop(env) do
method eval_ast (line 72) | defp eval_ast({:map, ast, meta}, env) do
method eval_ast (line 80) | defp eval_ast({:vector, ast, meta}, env) do
method eval_ast (line 84) | defp eval_ast({:symbol, symbol}, env) do
method eval_ast (line 91) | defp eval_ast(ast, _env), do: ast
method read (line 93) | defp read(input) do
method eval_bindings (line 97) | defp eval_bindings([], env), do: env
method eval_bindings (line 98) | defp eval_bindings([{:symbol, key}, binding | tail], env) do
method eval_bindings (line 103) | defp eval_bindings(_bindings, _env), do: throw({:error, "Unbalanced le...
method quasiquote (line 105) | defp quasiquote({:list, [{:symbol, "unquote"}, arg], _}), do: arg
method quasiquote (line 106) | defp quasiquote({:list, [{:symbol, "unquote"}| _], _}), do: throw({:...
method quasiquote (line 107) | defp quasiquote({:list, xs, _}), do: qq_fold...
method quasiquote (line 108) | defp quasiquote({:vector, xs, _}), do: list([{:symbol, "vec"}, qq_fold...
method quasiquote (line 109) | defp quasiquote({:symbol, sym}), do: list([{:symbol, "quote"}, {:sy...
method quasiquote (line 110) | defp quasiquote({:map, ast, meta}), do: list([{:symbol, "quote"}, {:ma...
method quasiquote (line 111) | defp quasiquote(ast), do: ast
method qq_foldr (line 113) | defp qq_foldr([]), do: list([])
method qq_foldr (line 114) | defp qq_foldr([x|xs]), do: qq_loop(x, qq_foldr xs)
method qq_loop (line 116) | defp qq_loop({:list, [{:symbol, "splice-unquote"}, arg], _}, acc), do:...
method qq_loop (line 117) | defp qq_loop({:list, [{:symbol, "splice-unquote"}| _], _}, _), do:...
method qq_loop (line 118) | defp qq_loop(elt, acc), do: list([{:symbol, "cons"}, quasiquote(elt), ...
method eval (line 120) | defp eval(ast, env) do
method eval_list (line 130) | defp eval_list([{:symbol, "if"}, condition, if_true | if_false], env, ...
method eval_list (line 142) | defp eval_list([{:symbol, "do"} | ast], env, _) do
method eval_list (line 149) | defp eval_list([{:symbol, "def!"}, {:symbol, key}, value], env, _) do
method eval_list (line 155) | defp eval_list([{:symbol, "defmacro!"}, {:symbol, key}, function], env...
method eval_list (line 180) | defp eval_list([{:symbol, "quote"}, arg], _env, _), do: arg
method eval_list (line 182) | defp eval_list([{:symbol, "quasiquote"}, ast], env, _) do
method eval_list (line 187) | defp eval_list([a0 | args], env, _meta) do
method eval_list (line 195) | defp eval_list([], _env, meta), do: {:list, [], meta}
method print (line 197) | defp print(value) do
method read_eval_print (line 201) | defp read_eval_print(:eof, _env), do: exit(:normal)
method read_eval_print (line 202) | defp read_eval_print(line, env) do
FILE: impls/elixir/lib/mix/tasks/step9_try.ex
class Mix.Tasks.Step9Try (line 1) | defmodule Mix.Tasks.Step9Try
method run (line 5) | def run(args) do
method load_file (line 12) | defp load_file(file_name, env) do
method bootstrap (line 19) | defp bootstrap(args, env) do
method loop (line 59) | defp loop(env) do
method eval_ast (line 72) | defp eval_ast({:map, ast, meta}, env) do
method eval_ast (line 80) | defp eval_ast({:vector, ast, meta}, env) do
method eval_ast (line 84) | defp eval_ast({:symbol, symbol}, env) do
method eval_ast (line 91) | defp eval_ast(ast, _env), do: ast
method read (line 93) | defp read(input) do
method eval_bindings (line 97) | defp eval_bindings([], env), do: env
method eval_bindings (line 98) | defp eval_bindings([{:symbol, key}, binding | tail], env) do
method eval_bindings (line 103) | defp eval_bindings(_bindings, _env), do: throw({:error, "Unbalanced le...
method quasiquote (line 105) | defp quasiquote({:list, [{:symbol, "unquote"}, arg], _}), do: arg
method quasiquote (line 106) | defp quasiquote({:list, [{:symbol, "unquote"}| _], _}), do: throw({:...
method quasiquote (line 107) | defp quasiquote({:list, xs, _}), do: qq_fold...
method quasiquote (line 108) | defp quasiquote({:vector, xs, _}), do: list([{:symbol, "vec"}, qq_fold...
method quasiquote (line 109) | defp quasiquote({:symbol, sym}), do: list([{:symbol, "quote"}, {:sy...
method quasiquote (line 110) | defp quasiquote({:map, ast, meta}), do: list([{:symbol, "quote"}, {:ma...
method quasiquote (line 111) | defp quasiquote(ast), do: ast
method qq_foldr (line 113) | defp qq_foldr([]), do: list([])
method qq_foldr (line 114) | defp qq_foldr([x|xs]), do: qq_loop(x, qq_foldr xs)
method qq_loop (line 116) | defp qq_loop({:list, [{:symbol, "splice-unquote"}, arg], _}, acc), do:...
method qq_loop (line 117) | defp qq_loop({:list, [{:symbol, "splice-unquote"}| _], _}, _), do:...
method qq_loop (line 118) | defp qq_loop(elt, acc), do: list([{:symbol, "cons"}, quasiquote(elt), ...
method eval (line 120) | defp eval(ast, env) do
method eval_list (line 130) | defp eval_list([{:symbol, "if"}, condition, if_true | if_false], env, ...
method eval_list (line 142) | defp eval_list([{:symbol, "do"} | ast], env, _) do
method eval_list (line 149) | defp eval_list([{:symbol, "def!"}, {:symbol, key}, value], env, _) do
method eval_list (line 155) | defp eval_list([{:symbol, "defmacro!"}, {:symbol, key}, function], env...
method eval_list (line 180) | defp eval_list([{:symbol, "quote"}, arg], _env, _), do: arg
method eval_list (line 182) | defp eval_list([{:symbol, "quasiquote"}, ast], env, _) do
method eval_list (line 188) | defp eval_list([{:symbol, "try*"}, try_form, {:list, catch_list, _meta...
method eval_list (line 191) | defp eval_list([{:symbol, "try*"}, try_form], env, _) do
method eval_list (line 194) | defp eval_list([{:symbol, "try*"}, _try_form, _], _env, _) do
method eval_list (line 198) | defp eval_list([a0 | args], env, _meta) do
method eval_list (line 206) | defp eval_list([], _env, meta), do: {:list, [], meta}
method eval_try (line 208) | defp eval_try(try_form,
method eval_try (line 219) | defp eval_try(_try_form, _catch_list, _env) do
method print (line 223) | defp print(value) do
method read_eval_print (line 227) | defp read_eval_print(:eof, _env), do: exit(:normal)
method read_eval_print (line 228) | defp read_eval_print(line, env) do
FILE: impls/elixir/lib/mix/tasks/stepA_mal.ex
class Mix.Tasks.StepAMal (line 1) | defmodule Mix.Tasks.StepAMal
method main (line 6) | def main(args) do
method run (line 10) | def run(args) do
method load_file (line 17) | defp load_file(file_name, env) do
method bootstrap (line 24) | defp bootstrap(args, env) do
method loop (line 68) | defp loop(env) do
method eval_ast (line 81) | defp eval_ast({:map, ast, meta}, env) do
method eval_ast (line 89) | defp eval_ast({:vector, ast, meta}, env) do
method eval_ast (line 93) | defp eval_ast({:symbol, symbol}, env) do
method eval_ast (line 100) | defp eval_ast(ast, _env), do: ast
method read (line 102) | defp read(input) do
method eval_bindings (line 106) | defp eval_bindings([], env), do: env
method eval_bindings (line 107) | defp eval_bindings([{:symbol, key}, binding | tail], env) do
method eval_bindings (line 112) | defp eval_bindings(_bindings, _env), do: throw({:error, "Unbalanced le...
method quasiquote (line 114) | defp quasiquote({:list, [{:symbol, "unquote"}, arg], _}), do: arg
method quasiquote (line 115) | defp quasiquote({:list, [{:symbol, "unquote"}| _], _}), do: throw({:...
method quasiquote (line 116) | defp quasiquote({:list, xs, _}), do: qq_fold...
method quasiquote (line 117) | defp quasiquote({:vector, xs, _}), do: list([{:symbol, "vec"}, qq_fold...
method quasiquote (line 118) | defp quasiquote({:symbol, sym}), do: list([{:symbol, "quote"}, {:sy...
method quasiquote (line 119) | defp quasiquote({:map, ast, meta}), do: list([{:symbol, "quote"}, {:ma...
method quasiquote (line 120) | defp quasiquote(ast), do: ast
method qq_foldr (line 122) | defp qq_foldr([]), do: list([])
method qq_foldr (line 123) | defp qq_foldr([x|xs]), do: qq_loop(x, qq_foldr xs)
method qq_loop (line 125) | defp qq_loop({:list, [{:symbol, "splice-unquote"}, arg], _}, acc), do:...
method qq_loop (line 126) | defp qq_loop({:list, [{:symbol, "splice-unquote"}| _], _}, _), do:...
method qq_loop (line 127) | defp qq_loop(elt, acc), do: list([{:symbol, "cons"}, quasiquote(elt), ...
method eval (line 129) | defp eval(ast, env) do
method eval_list (line 139) | defp eval_list([{:symbol, "if"}, condition, if_true | if_false], env, ...
method eval_list (line 151) | defp eval_list([{:symbol, "do"} | ast], env, _) do
method eval_list (line 158) | defp eval_list([{:symbol, "def!"}, {:symbol, key}, value], env, _) do
method eval_list (line 164) | defp eval_list([{:symbol, "defmacro!"}, {:symbol, key}, function], env...
method eval_list (line 189) | defp eval_list([{:symbol, "quote"}, arg], _env, _), do: arg
method eval_list (line 191) | defp eval_list([{:symbol, "quasiquote"}, ast], env, _) do
method eval_list (line 197) | defp eval_list([{:symbol, "try*"}, try_form, {:list, catch_list, _meta...
method eval_list (line 200) | defp eval_list([{:symbol, "try*"}, try_form], env, _) do
method eval_list (line 203) | defp eval_list([{:symbol, "try*"}, _try_form, _], _env, _) do
method eval_list (line 207) | defp eval_list([a0 | args], env, _meta) do
method eval_list (line 215) | defp eval_list([], _env, meta), do: {:list, [], meta}
method eval_try (line 217) | defp eval_try(try_form,
method eval_try (line 228) | defp eval_try(_try_form, _catch_list, _env) do
method print (line 232) | defp print(value) do
method read_eval_print (line 236) | defp read_eval_print(:eof, _env), do: exit(:normal)
method read_eval_print (line 237) | defp read_eval_print(line, env) do
FILE: impls/elixir/mix.exs
class Mal.Mixfile (line 1) | defmodule Mal.Mixfile
method project (line 4) | def project do
method escript (line 15) | def escript do
method application (line 22) | def application do
method deps (line 35) | defp deps do
FILE: impls/es6/core.mjs
function _error (line 9) | function _error(e) { throw new Error(e) }
function slurp (line 12) | function slurp(f) {
function seq (line 27) | function seq(obj) {
FILE: impls/es6/env.mjs
function new_env (line 1) | function new_env(outer={}, binds=[], exprs=[]) {
FILE: impls/es6/node_readline.mjs
constant RL_LIB (line 2) | const RL_LIB = "libreadline.so.8";
constant HISTORY_FILE (line 10) | const HISTORY_FILE = path.join(process.env.HOME, '.mal-history');
function readline (line 17) | function readline(prompt) {
FILE: impls/es6/printer.mjs
function pr_str (line 3) | function pr_str(obj, print_readably) {
FILE: impls/es6/reader.mjs
class BlankException (line 3) | class BlankException extends Error {}
class Reader (line 5) | class Reader {
method constructor (line 6) | constructor(tokens) {
method next (line 10) | next() { return this.tokens[this.position++] }
method peek (line 11) | peek() { return this.tokens[this.position] }
function tokenize (line 14) | function tokenize(str) {
function read_atom (line 25) | function read_atom (reader) {
function read_list (line 51) | function read_list(reader, start, end) {
function read_vector (line 70) | function read_vector(reader) {
function read_hash_map (line 75) | function read_hash_map(reader) {
function read_form (line 79) | function read_form(reader) {
function read_str (line 115) | function read_str(str) {
FILE: impls/es6/types.mjs
function _equal_Q (line 2) | function _equal_Q (a, b) {
function _clone (line 20) | function _clone(obj, new_meta) {
function _malfunc (line 39) | function _malfunc(f, ast, env, params, meta=null, ismacro=false) {
class Vector (line 53) | class Vector extends Array { }
function _assoc_BANG (line 56) | function _assoc_BANG(hm, ...args) {
class Atom (line 66) | class Atom {
method constructor (line 67) | constructor(val) { this.val = val }
FILE: impls/fsharp/terminal.cs
class LineEditor (line 35) | public class LineEditor {
class Completion (line 37) | public class Completion {
method Completion (line 41) | public Completion (string prefix, string [] result)
type Handler (line 99) | struct Handler {
method Handler (line 103) | public Handler (ConsoleKey key, KeyHandler h)
method Handler (line 109) | public Handler (char c, KeyHandler h)
method Handler (line 116) | public Handler (ConsoleKeyInfo cki, KeyHandler h)
method Control (line 122) | public static Handler Control (char c, KeyHandler h)
method Alt (line 127) | public static Handler Alt (char c, ConsoleKey k, KeyHandler h)
method LineEditor (line 150) | public LineEditor (string name) : this (name, 10) { }
method LineEditor (line 152) | public LineEditor (string name, int histsize)
method CmdDebug (line 201) | void CmdDebug ()
method Render (line 208) | void Render ()
method UpdateHomeRow (line 226) | void UpdateHomeRow (int screenpos)
method RenderFrom (line 236) | void RenderFrom (int pos)
method ComputeRendered (line 253) | void ComputeRendered ()
method TextToRenderPos (line 271) | int TextToRenderPos (int pos)
method TextToScreenPos (line 292) | int TextToScreenPos (int pos)
method ForceCursor (line 308) | void ForceCursor (int newpos)
method UpdateCursor (line 324) | void UpdateCursor (int newpos)
method InsertChar (line 332) | void InsertChar (char c)
method CmdDone (line 352) | void CmdDone ()
method CmdTabOrComplete (line 357) | void CmdTabOrComplete ()
method CmdHome (line 422) | void CmdHome ()
method CmdEnd (line 427) | void CmdEnd ()
method CmdLeft (line 432) | void CmdLeft ()
method CmdBackwardWord (line 440) | void CmdBackwardWord ()
method CmdForwardWord (line 448) | void CmdForwardWord ()
method CmdRight (line 456) | void CmdRight ()
method RenderAfter (line 464) | void RenderAfter (int p)
method CmdBackspace (line 471) | void CmdBackspace ()
method CmdDeleteChar (line 481) | void CmdDeleteChar ()
method WordForward (line 498) | int WordForward (int p)
method WordBackward (line 524) | int WordBackward (int p)
method CmdDeleteWord (line 556) | void CmdDeleteWord ()
method CmdDeleteBackword (line 575) | void CmdDeleteBackword ()
method HistoryUpdateLine (line 596) | void HistoryUpdateLine ()
method CmdHistoryPrev (line 601) | void CmdHistoryPrev ()
method CmdHistoryNext (line 611) | void CmdHistoryNext ()
method CmdKillToEOF (line 621) | void CmdKillToEOF ()
method CmdYank (line 629) | void CmdYank ()
method InsertTextAtCursor (line 634) | void InsertTextAtCursor (string str)
method SetSearchPrompt (line 652) | void SetSearchPrompt (string s)
method ReverseSearch (line 657) | void ReverseSearch ()
method CmdReverseSearch (line 695) | void CmdReverseSearch ()
method SearchAppend (line 717) | void SearchAppend (char c)
method CmdRefresh (line 734) | void CmdRefresh ()
method InterruptEdit (line 742) | void InterruptEdit (object sender, ConsoleCancelEventArgs a)
method HandleChar (line 751) | void HandleChar (char c)
method EditLoop (line 759) | void EditLoop ()
method InitText (line 806) | void InitText (string initial)
method SetText (line 815) | void SetText (string newtext)
method SetPrompt (line 821) | void SetPrompt (string newprompt)
method Edit (line 829) | public string Edit (string prompt, string initial)
method SaveHistory (line 873) | public void SaveHistory ()
class History (line 886) | class History {
method History (line 892) | public History (string app, int size)
method Close (line 929) | public void Close ()
method Append (line 950) | public void Append (string s)
method Update (line 967) | public void Update (string s)
method RemoveLast (line 972) | public void RemoveLast ()
method Accept (line 979) | public void Accept (string s)
method PreviousAvailable (line 988) | public bool PreviousAvailable ()
method NextAvailable (line 1003) | public bool NextAvailable ()
method Previous (line 1018) | public string Previous ()
method Next (line 1030) | public string Next ()
method CursorToEnd (line 1039) | public void CursorToEnd ()
method Dump (line 1047) | public void Dump ()
method SearchBackward (line 1056) | public string SearchBackward (string term)
class Demo (line 1077) | class Demo {
method Main (line 1078) | static void Main ()
FILE: impls/go/src/core/core.go
function throw (line 19) | func throw(a []MalType) (MalType, error) {
function fn_q (line 23) | func fn_q(a []MalType) (MalType, error) {
function pr_str (line 38) | func pr_str(a []MalType) (MalType, error) {
function str (line 42) | func str(a []MalType) (MalType, error) {
function prn (line 46) | func prn(a []MalType) (MalType, error) {
function println (line 51) | func println(a []MalType) (MalType, error) {
function slurp (line 56) | func slurp(a []MalType) (MalType, error) {
function time_ms (line 65) | func time_ms(a []MalType) (MalType, error) {
function copy_hash_map (line 70) | func copy_hash_map(hm HashMap) HashMap {
function assoc (line 78) | func assoc(a []MalType) (MalType, error) {
function dissoc (line 99) | func dissoc(a []MalType) (MalType, error) {
function get (line 117) | func get(a []MalType) (MalType, error) {
function contains_Q (line 130) | func contains_Q(hm MalType, key MalType) (MalType, error) {
function keys (line 144) | func keys(a []MalType) (MalType, error) {
function vals (line 155) | func vals(a []MalType) (MalType, error) {
function cons (line 168) | func cons(a []MalType) (MalType, error) {
function concat (line 177) | func concat(a []MalType) (MalType, error) {
function vec (line 195) | func vec(a []MalType) (MalType, error) {
function nth (line 206) | func nth(a []MalType) (MalType, error) {
function first (line 219) | func first(a []MalType) (MalType, error) {
function rest (line 236) | func rest(a []MalType) (MalType, error) {
function empty_Q (line 250) | func empty_Q(a []MalType) (MalType, error) {
function count (line 263) | func count(a []MalType) (MalType, error) {
function apply (line 278) | func apply(a []MalType) (MalType, error) {
function do_map (line 295) | func do_map(a []MalType) (MalType, error) {
function conj (line 312) | func conj(a []MalType) (MalType, error) {
function seq (line 345) | func seq(a []MalType) (MalType, error) {
function with_meta (line 374) | func with_meta(a []MalType) (MalType, error) {
function meta (line 395) | func meta(a []MalType) (MalType, error) {
function deref (line 414) | func deref(a []MalType) (MalType, error) {
function reset_BANG (line 421) | func reset_BANG(a []MalType) (MalType, error) {
function swap_BANG (line 429) | func swap_BANG(a []MalType) (MalType, error) {
function call0e (line 517) | func call0e(f func([]MalType) (MalType, error)) func([]MalType) (MalType...
function call1e (line 526) | func call1e(f func([]MalType) (MalType, error)) func([]MalType) (MalType...
function call2e (line 535) | func call2e(f func([]MalType) (MalType, error)) func([]MalType) (MalType...
function callNe (line 544) | func callNe(f func([]MalType) (MalType, error)) func([]MalType) (MalType...
function call1b (line 551) | func call1b(f func(MalType) bool) func([]MalType) (MalType, error) {
function call2b (line 560) | func call2b(f func(MalType, MalType) bool) func([]MalType) (MalType, err...
FILE: impls/go/src/env/env.go
type Env (line 12) | type Env struct
method Find (line 44) | func (e Env) Find(key Symbol) EnvType {
method Set (line 54) | func (e Env) Set(key Symbol, value MalType) MalType {
method Get (line 59) | func (e Env) Get(key Symbol) (MalType, error) {
function NewEnv (line 17) | func NewEnv(outer EnvType, binds_mt MalType, exprs_mt MalType) (EnvType,...
FILE: impls/go/src/printer/printer.go
function Pr_list (line 12) | func Pr_list(lst []types.MalType, pr bool,
function Pr_str (line 21) | func Pr_str(obj types.MalType, print_readably bool) string {
FILE: impls/go/src/reader/reader.go
type Reader (line 15) | type Reader interface
type TokenReader (line 20) | type TokenReader struct
method next (line 25) | func (tr *TokenReader) next() *string {
method peek (line 34) | func (tr *TokenReader) peek() *string {
function tokenize (line 41) | func tokenize(str string) []string {
function read_atom (line 56) | func read_atom(rdr Reader) (MalType, error) {
function read_list (line 94) | func read_list(rdr Reader, start string, end string) (MalType, error) {
function read_vector (line 122) | func read_vector(rdr Reader) (MalType, error) {
function read_hash_map (line 131) | func read_hash_map(rdr Reader) (MalType, error) {
function read_form (line 139) | func read_form(rdr Reader) (MalType, error) {
function Read_str (line 216) | func Read_str(str string) (MalType, error) {
FILE: impls/go/src/readline/readline.go
function loadHistory (line 31) | func loadHistory(filename string) error {
function init (line 49) | func init() {
function Readline (line 54) | func Readline(prompt string) (string, error) {
FILE: impls/go/src/step0_repl/step0_repl.go
function READ (line 13) | func READ(str string) string {
function EVAL (line 18) | func EVAL(ast string, env string) string {
function PRINT (line 23) | func PRINT(exp string) string {
function rep (line 28) | func rep(str string) string {
function main (line 32) | func main() {
FILE: impls/go/src/step1_read_print/step1_read_print.go
function READ (line 16) | func READ(str string) (MalType, error) {
function EVAL (line 21) | func EVAL(ast MalType, env string) (MalType, error) {
function PRINT (line 26) | func PRINT(exp MalType) (string, error) {
function rep (line 31) | func rep(str string) (MalType, error) {
function main (line 47) | func main() {
FILE: impls/go/src/step2_eval/step2_eval.go
function READ (line 17) | func READ(str string) (MalType, error) {
function eval_ast (line 22) | func eval_ast(ast MalType, env map[string]MalType) (MalType, error) {
function EVAL (line 67) | func EVAL(ast MalType, env map[string]MalType) (MalType, error) {
function PRINT (line 92) | func PRINT(exp MalType) (string, error) {
function assertArgNum (line 123) | func assertArgNum(a []MalType, n int) error {
function rep (line 131) | func rep(str string) (MalType, error) {
function main (line 147) | func main() {
FILE: impls/go/src/step3_env/step3_env.go
function READ (line 18) | func READ(str string) (MalType, error) {
function eval_ast (line 23) | func eval_ast(ast MalType, env EnvType) (MalType, error) {
function EVAL (line 63) | func EVAL(ast MalType, env EnvType) (MalType, error) {
function PRINT (line 135) | func PRINT(exp MalType) (string, error) {
function rep (line 142) | func rep(str string) (MalType, error) {
function main (line 158) | func main() {
function assertArgNum (line 204) | func assertArgNum(a []MalType, n int) error {
FILE: impls/go/src/step4_if_fn_do/step4_if_fn_do.go
function READ (line 19) | func READ(str string) (MalType, error) {
function eval_ast (line 24) | func eval_ast(ast MalType, env EnvType) (MalType, error) {
function EVAL (line 64) | func EVAL(ast MalType, env EnvType) (MalType, error) {
function PRINT (line 168) | func PRINT(exp MalType) (string, error) {
function rep (line 175) | func rep(str string) (MalType, error) {
function main (line 191) | func main() {
FILE: impls/go/src/step5_tco/step5_tco.go
function READ (line 19) | func READ(str string) (MalType, error) {
function eval_ast (line 24) | func eval_ast(ast MalType, env EnvType) (MalType, error) {
function EVAL (line 64) | func EVAL(ast MalType, env EnvType) (MalType, error) {
function PRINT (line 178) | func PRINT(exp MalType) (string, error) {
function rep (line 185) | func rep(str string) (MalType, error) {
function main (line 201) | func main() {
FILE: impls/go/src/step6_file/step6_file.go
function READ (line 20) | func READ(str string) (MalType, error) {
function eval_ast (line 25) | func eval_ast(ast MalType, env EnvType) (MalType, error) {
function EVAL (line 65) | func EVAL(ast MalType, env EnvType) (MalType, error) {
function PRINT (line 179) | func PRINT(exp MalType) (string, error) {
function rep (line 186) | func rep(str string) (MalType, error) {
function main (line 202) | func main() {
FILE: impls/go/src/step7_quote/step7_quote.go
function READ (line 20) | func READ(str string) (MalType, error) {
function starts_with (line 25) | func starts_with(xs []MalType, sym string) bool {
function qq_loop (line 36) | func qq_loop(xs []MalType) MalType {
function quasiquote (line 53) | func quasiquote(ast MalType) MalType {
function eval_ast (line 70) | func eval_ast(ast MalType, env EnvType) (MalType, error) {
function EVAL (line 110) | func EVAL(ast MalType, env EnvType) (MalType, error) {
function PRINT (line 230) | func PRINT(exp MalType) (string, error) {
function rep (line 237) | func rep(str string) (MalType, error) {
function main (line 253) | func main() {
FILE: impls/go/src/step8_macros/step8_macros.go
function READ (line 20) | func READ(str string) (MalType, error) {
function starts_with (line 25) | func starts_with(xs []MalType, sym string) bool {
function qq_loop (line 36) | func qq_loop(xs []MalType) MalType {
function quasiquote (line 53) | func quasiquote(ast MalType) MalType {
function is_macro_call (line 70) | func is_macro_call(ast MalType, env EnvType) bool {
function macroexpand (line 90) | func macroexpand(ast MalType, env EnvType) (MalType, error) {
function eval_ast (line 109) | func eval_ast(ast MalType, env EnvType) (MalType, error) {
function EVAL (line 149) | func EVAL(ast MalType, env EnvType) (MalType, error) {
function PRINT (line 286) | func PRINT(exp MalType) (string, error) {
function rep (line 293) | func rep(str string) (MalType, error) {
function main (line 309) | func main() {
FILE: impls/go/src/step9_try/step9_try.go
function READ (line 20) | func READ(str string) (MalType, error) {
function starts_with (line 25) | func starts_with(xs []MalType, sym string) bool {
function qq_loop (line 36) | func qq_loop(xs []MalType) MalType {
function quasiquote (line 53) | func quasiquote(ast MalType) MalType {
function is_macro_call (line 70) | func is_macro_call(ast MalType, env EnvType) bool {
function macroexpand (line 90) | func macroexpand(ast MalType, env EnvType) (MalType, error) {
function eval_ast (line 109) | func eval_ast(ast MalType, env EnvType) (MalType, error) {
function EVAL (line 149) | func EVAL(ast MalType, env EnvType) (MalType, error) {
function PRINT (line 314) | func PRINT(exp MalType) (string, error) {
function rep (line 321) | func rep(str string) (MalType, error) {
function main (line 337) | func main() {
FILE: impls/go/src/stepA_mal/stepA_mal.go
function READ (line 20) | func READ(str string) (MalType, error) {
function starts_with (line 25) | func starts_with(xs []MalType, sym string) bool {
function qq_loop (line 36) | func qq_loop(xs []MalType) MalType {
function quasiquote (line 53) | func quasiquote(ast MalType) MalType {
function map_eval (line 70) | func map_eval(xs []MalType, env EnvType) ([]MalType, error) {
function EVAL (line 82) | func EVAL(ast MalType, env EnvType) (MalType, error) {
function PRINT (line 263) | func PRINT(exp MalType) (string, error) {
function rep (line 270) | func rep(str string) (MalType, error) {
function main (line 286) | func main() {
FILE: impls/go/src/types/types.go
type MalError (line 11) | type MalError struct
method Error (line 15) | func (e MalError) Error() string {
type MalType (line 20) | type MalType interface
type EnvType (line 23) | type EnvType interface
function Nil_Q (line 30) | func Nil_Q(obj MalType) bool {
function True_Q (line 34) | func True_Q(obj MalType) bool {
function False_Q (line 39) | func False_Q(obj MalType) bool {
function Number_Q (line 44) | func Number_Q(obj MalType) bool {
type Symbol (line 50) | type Symbol struct
function Symbol_Q (line 54) | func Symbol_Q(obj MalType) bool {
function NewKeyword (line 60) | func NewKeyword(s string) (MalType, error) {
function Keyword_Q (line 64) | func Keyword_Q(obj MalType) bool {
function String_Q (line 70) | func String_Q(obj MalType) bool {
type Func (line 76) | type Func struct
function Func_Q (line 81) | func Func_Q(obj MalType) bool {
type MalFunc (line 86) | type MalFunc struct
method SetMacro (line 101) | func (f MalFunc) SetMacro() MalType {
method GetMacro (line 106) | func (f MalFunc) GetMacro() bool {
function MalFunc_Q (line 96) | func MalFunc_Q(obj MalType) bool {
function Apply (line 112) | func Apply(f_mt MalType, a []MalType) (MalType, error) {
type List (line 130) | type List struct
function NewList (line 135) | func NewList(a ...MalType) MalType {
function List_Q (line 139) | func List_Q(obj MalType) bool {
type Vector (line 145) | type Vector struct
function Vector_Q (line 150) | func Vector_Q(obj MalType) bool {
function GetSlice (line 155) | func GetSlice(seq MalType) ([]MalType, error) {
type HashMap (line 167) | type HashMap struct
function NewHashMap (line 172) | func NewHashMap(seq MalType) (MalType, error) {
function HashMap_Q (line 191) | func HashMap_Q(obj MalType) bool {
type Atom (line 197) | type Atom struct
method Set (line 202) | func (a *Atom) Set(val MalType) MalType {
function Atom_Q (line 207) | func Atom_Q(obj MalType) bool {
function _obj_type (line 214) | func _obj_type(obj MalType) string {
function Sequential_Q (line 221) | func Sequential_Q(seq MalType) bool {
function Equal_Q (line 229) | func Equal_Q(a MalType, b MalType) bool {
FILE: impls/java-truffle/src/main/java/truffle/mal/Core.java
class Core (line 29) | class Core {
method newGlobalEnv (line 103) | static MalEnv newGlobalEnv(Class<? extends TruffleLanguage<?>> languag...
class AbstractInvokeNode (line 119) | abstract class AbstractInvokeNode extends Node {
method invoke (line 120) | abstract Object invoke(CallTarget target, Object[] args);
type IMalLanguage (line 124) | interface IMalLanguage {
method evalForm (line 125) | CallTarget evalForm(Object form);
method invokeNode (line 126) | AbstractInvokeNode invokeNode();
method out (line 127) | PrintStream out();
method in (line 128) | BufferedReader in();
class BuiltinNode (line 131) | abstract class BuiltinNode extends Node {
method setLanguage (line 134) | protected void setLanguage(IMalLanguage language) {
method illegalArgumentException (line 138) | @TruffleBoundary
method BuiltinNode (line 145) | protected BuiltinNode(String name) {
method executeGeneric (line 149) | abstract Object executeGeneric(VirtualFrame frame);
method executeLong (line 151) | long executeLong(VirtualFrame frame) throws UnexpectedResultException {
method executeBoolean (line 159) | boolean executeBoolean(VirtualFrame frame) throws UnexpectedResultExce...
class ReadArgNode (line 168) | class ReadArgNode extends Node {
method ReadArgNode (line 171) | ReadArgNode(int argNum) {
method executeGeneric (line 175) | Object executeGeneric(VirtualFrame frame) {
class ReadArgsNode (line 180) | class ReadArgsNode extends Node {
method ReadArgsNode (line 183) | ReadArgsNode(int argPos) {
method executeGeneric (line 187) | Object executeGeneric(VirtualFrame frame) {
class BuiltinRootNode (line 196) | class BuiltinRootNode extends RootNode {
method BuiltinRootNode (line 200) | public BuiltinRootNode(TruffleLanguage<?> lang, NodeFactory<? extends ...
method getNumArgs (line 221) | public int getNumArgs() {
method execute (line 225) | @Override
method toString (line 230) | @Override
class AddBuiltin (line 238) | @NodeChild(value="lhs", type=ReadArgNode.class)
method AddBuiltin (line 243) | protected AddBuiltin() { super("+"); }
method add (line 245) | @Specialization
class SubtractBuiltin (line 251) | @NodeChild(value="lhs", type=ReadArgNode.class)
method SubtractBuiltin (line 256) | protected SubtractBuiltin() { super("-"); }
method subtract (line 258) | @Specialization
class MultiplyBuiltin (line 265) | @NodeChild(value="lhs", type=ReadArgNode.class)
method MultiplyBuiltin (line 270) | protected MultiplyBuiltin() { super("*"); }
method multiply (line 272) | @Specialization
class DivideBuiltin (line 278) | @NodeChild(value="lhs", type=ReadArgNode.class)
method DivideBuiltin (line 282) | protected DivideBuiltin() { super("/"); }
method divide (line 284) | @Specialization
class PrnBuiltin (line 292) | @NodeChild(value="args", type=ReadArgsNode.class)
method PrnBuiltin (line 295) | protected PrnBuiltin() { super("prn"); }
method prn (line 297) | @Specialization
class PrStrBuiltin (line 313) | @NodeChild(value="args", type=ReadArgsNode.class)
method PrStrBuiltin (line 317) | protected PrStrBuiltin() { super("pr-str"); }
method prStr (line 319) | @Specialization
class StrBuiltin (line 334) | @NodeChild(value="args", type=ReadArgsNode.class)
method StrBuiltin (line 338) | protected StrBuiltin() { super("str"); }
method prStr (line 340) | @Specialization
class PrintlnBuiltin (line 351) | @NodeChild(value="args", type=ReadArgsNode.class)
method PrintlnBuiltin (line 355) | protected PrintlnBuiltin() { super("println"); }
method println (line 357) | @Specialization
class ReadStringBuiltin (line 376) | @NodeChild(value="arg", type=ReadArgNode.class)
method ReadStringBuiltin (line 380) | protected ReadStringBuiltin() { super("read-string"); }
method readString (line 382) | @TruffleBoundary
class SlurpBuiltin (line 389) | @NodeChild(value="arg", type=ReadArgNode.class)
method SlurpBuiltin (line 393) | protected SlurpBuiltin() { super("slurp"); }
method slurp (line 395) | @TruffleBoundary
class ListBuiltin (line 417) | @NodeChild(value="args", type=ReadArgsNode.class)
method ListBuiltin (line 421) | protected ListBuiltin() { super("list"); }
method list (line 423) | @Specialization
class IsListBuiltin (line 433) | @NodeChild(value = "list", type = ReadArgNode.class)
method IsListBuiltin (line 437) | protected IsListBuiltin() { super("list?"); }
method isList (line 439) | @Specialization
method isList (line 444) | @Fallback
class IsEmptyBuiltin (line 450) | @NodeChild(value="arg", type=ReadArgNode.class)
method IsEmptyBuiltin (line 454) | protected IsEmptyBuiltin() { super("empty?"); }
method isEmpty (line 456) | @Specialization
method isEmpty (line 461) | @Specialization
method typeError (line 466) | @Fallback
class CountBuiltin (line 472) | @NodeChild(value="arg", type=ReadArgNode.class)
method CountBuiltin (line 476) | protected CountBuiltin() { super("count"); }
method count (line 478) | @Specialization
method count (line 483) | @Specialization
method count (line 488) | @Specialization
method count (line 493) | @Fallback
class ConsBuiltin (line 499) | @NodeChild(value="obj", type=ReadArgNode.class)
method ConsBuiltin (line 504) | protected ConsBuiltin() { super("cons"); }
method cons (line 506) | @Specialization
method cons (line 512) | @Specialization
class ConcatBuiltin (line 519) | @NodeChild(value="args", type=ReadArgsNode.class)
method ConcatBuiltin (line 523) | protected ConcatBuiltin() { super("concat"); }
method concat1 (line 525) | private MalList concat1(MalList a, MalList b) {
method concat1 (line 536) | private MalList concat1(MalVector a, MalList b) {
method concat (line 543) | @Specialization
class VecBuiltin (line 568) | @NodeChild(value="arg", type=ReadArgNode.class)
method VecBuiltin (line 572) | protected VecBuiltin() { super("vec"); }
method vec (line 574) | @Specialization
method vec (line 579) | @Specialization
class NthBuiltin (line 585) | @NodeChild(value="list", type=ReadArgNode.class)
method NthBuiltin (line 590) | protected NthBuiltin() { super("nth"); }
method nth (line 592) | @Specialization
method throwInvalidArgument (line 601) | private void throwInvalidArgument() {
method nth (line 605) | @Specialization
class FirstBuiltin (line 617) | @GenerateNodeFactory
method FirstBuiltin (line 620) | protected FirstBuiltin() { super("first"); }
method first (line 622) | @Specialization
method first (line 627) | @Specialization
method first (line 634) | @Specialization
class RestBuiltin (line 643) | @NodeChild(value="arg", type=ReadArgNode.class)
method RestBuiltin (line 647) | protected RestBuiltin() { super("rest"); }
method rest (line 649) | @Specialization
method rest (line 654) | @Specialization
method rest (line 660) | @Specialization
class ApplyBuiltin (line 669) | @NodeChild(value="fn", type=ReadArgNode.class)
method ApplyBuiltin (line 675) | protected ApplyBuiltin() {
method setLanguage (line 679) | @Override
method getArgs (line 685) | @TruffleBoundary
method apply (line 711) | @Specialization
class MapBuiltin (line 719) | @NodeChild(value="fn", type=ReadArgNode.class)
method MapBuiltin (line 725) | protected MapBuiltin() {
method setLanguage (line 729) | @Override
method doMap (line 735) | @TruffleBoundary
method map (line 747) | @Specialization
method map (line 752) | @Specialization
class VectorBuiltin (line 758) | @NodeChild(value="args", type=ReadArgsNode.class)
method VectorBuiltin (line 762) | protected VectorBuiltin() { super("vector"); }
method vector (line 764) | @TruffleBoundary
class ConjBuiltin (line 775) | @NodeChild(value="col", type=ReadArgNode.class)
method ConjBuiltin (line 780) | protected ConjBuiltin() { super("conj"); }
method conj (line 782) | @Specialization
method conj (line 790) | @Specialization
class SeqBuiltin (line 799) | @NodeChild(value="arg", type=ReadArgNode.class)
method SeqBuiltin (line 803) | protected SeqBuiltin() { super("seq"); }
method seq (line 805) | @Specialization
method seq (line 812) | @Specialization
method seq (line 819) | @Specialization
method seq (line 830) | @Specialization
class HashMapBuiltin (line 838) | @NodeChild(value="args", type=ReadArgsNode.class)
method HashMapBuiltin (line 842) | protected HashMapBuiltin() { super("hash-map"); }
method hashMap (line 844) | @Specialization
class AssocBuiltin (line 855) | @NodeChild(value="map", type=ReadArgNode.class)
method AssocBuiltin (line 860) | protected AssocBuiltin() { super("assoc"); }
method assoc (line 862) | @Specialization
class DissocBuiltin (line 871) | @NodeChild(value="map", type=ReadArgNode.class)
method DissocBuiltin (line 876) | protected DissocBuiltin() { super("dissoc"); }
method dissoc (line 878) | @Specialization
class GetBuiltin (line 887) | @NodeChild(value="map", type=ReadArgNode.class)
method GetBuiltin (line 892) | protected GetBuiltin() { super("get"); }
method get (line 894) | @Specialization
method get (line 900) | @Specialization
class ContainsBuiltin (line 906) | @NodeChild(value="map", type=ReadArgNode.class)
method ContainsBuiltin (line 911) | protected ContainsBuiltin() { super("contains?"); }
method contains (line 913) | @Specialization
class KeysBuiltin (line 920) | @NodeChild(value="map", type=ReadArgNode.class)
method KeysBuiltin (line 924) | protected KeysBuiltin() { super("keys"); }
method keys (line 926) | @Specialization
class ValsBuiltin (line 938) | @NodeChild(value="map", type=ReadArgNode.class)
method ValsBuiltin (line 942) | protected ValsBuiltin() { super("vals"); }
method vals (line 944) | @Specialization
class EqualsBuiltin (line 958) | @NodeChild(value="lhs", type=ReadArgNode.class)
method EqualsBuiltin (line 963) | protected EqualsBuiltin() { super("="); }
method equals (line 965) | @Specialization
method equals (line 970) | @Specialization
method equals (line 975) | @TruffleBoundary
method equals (line 981) | @Specialization
method equals (line 986) | @Specialization
method equals (line 991) | @TruffleBoundary
method equals (line 1001) | @Fallback
class GreaterThanBuiltin (line 1007) | @NodeChild(value="lhs", type=ReadArgNode.class)
method GreaterThanBuiltin (line 1012) | protected GreaterThanBuiltin() { super(">"); }
method greaterThan (line 1014) | @Specialization
method typeError (line 1019) | @Specialization
method typeError (line 1024) | @Fallback
class GreaterThanEqualBuiltin (line 1030) | @NodeChild(value="lhs", type=ReadArgNode.class)
method GreaterThanEqualBuiltin (line 1035) | protected GreaterThanEqualBuiltin() { super(">="); }
method greaterThanEqual (line 1037) | @Specialization
method typeError (line 1042) | @Specialization
method typeError (line 1047) | @Fallback
class LessThanBuiltin (line 1053) | @NodeChild(value="lhs", type=ReadArgNode.class)
method LessThanBuiltin (line 1058) | protected LessThanBuiltin() { super("<"); }
method lessThan (line 1060) | @Specialization
method typeError (line 1065) | @Specialization
method typeError (line 1070) | @Fallback
class LessThanEqualBuiltin (line 1076) | @NodeChild(value="lhs", type=ReadArgNode.class)
method LessThanEqualBuiltin (line 1081) | protected LessThanEqualBuiltin() { super("<="); }
method lessThanEqual (line 1083) | @Specialization
method typeError (line 1088) | @Specialization
method typeError (line 1093) | @Fallback
class AtomBuiltin (line 1101) | @NodeChild(value="val", type=ReadArgNode.class)
method AtomBuiltin (line 1104) | protected AtomBuiltin() { super("atom"); }
method atom (line 1106) | @Specialization
class IsAtomBuiltin (line 1112) | @NodeChild(value="val", type=ReadArgNode.class)
method IsAtomBuiltin (line 1116) | protected IsAtomBuiltin() { super("atom?"); }
method isAtom (line 1118) | @Specialization
class DerefBuiltin (line 1124) | @NodeChild(value="arg", type=ReadArgNode.class)
method DerefBuiltin (line 1128) | protected DerefBuiltin() { super("deref"); }
method deref (line 1130) | @Specialization
class ResetBuiltin (line 1136) | @NodeChild(value="atom", type=ReadArgNode.class)
method ResetBuiltin (line 1141) | protected ResetBuiltin() { super("reset!"); }
method reset (line 1143) | @Specialization
class SwapBuiltin (line 1150) | @NodeChild(value="atom", type=ReadArgNode.class)
method SwapBuiltin (line 1157) | protected SwapBuiltin() {
method setLanguage (line 1161) | @Override
method swap (line 1167) | @Specialization
class IsNilBuiltin (line 1185) | @NodeChild(value="arg", type=ReadArgNode.class)
method IsNilBuiltin (line 1188) | protected IsNilBuiltin() { super("nil?"); }
method isNil (line 1190) | @Specialization
method isNil (line 1195) | @Fallback
class IsTrueBuiltin (line 1201) | @NodeChild(value="arg", type=ReadArgNode.class)
method IsTrueBuiltin (line 1204) | protected IsTrueBuiltin() { super("true?"); }
method isTrue (line 1206) | @Specialization
method isTrue (line 1211) | @Fallback
class IsFalseBuiltin (line 1217) | @NodeChild(value="arg", type=ReadArgNode.class)
method IsFalseBuiltin (line 1220) | protected IsFalseBuiltin() { super("false?"); }
method isFalse (line 1222) | @Specialization
method isFalse (line 1227) | @Fallback
class IsSymbolBuiltin (line 1233) | @NodeChild(value="arg", type=ReadArgNode.class)
method IsSymbolBuiltin (line 1236) | protected IsSymbolBuiltin() { super("symbol?"); }
method isSymbol (line 1238) | @Specialization
method isSymbol (line 1243) | @Fallback
class IsKeywordBuiltin (line 1249) | @NodeChild(value="arg", type=ReadArgNode.class)
method IsKeywordBuiltin (line 1253) | protected IsKeywordBuiltin() { super("keyword?"); }
method isKeyword (line 1255) | @Specialization
method isKeyword (line 1260) | @Fallback
class IsVectorBuiltin (line 1266) | @NodeChild(value="arg", type=ReadArgNode.class)
method IsVectorBuiltin (line 1270) | protected IsVectorBuiltin() { super("vector?"); }
method isVector (line 1272) | @Specialization
method isVector (line 1277) | @Fallback
class IsSequentialBuiltin (line 1283) | @NodeChild(value="arg", type=ReadArgNode.class)
method IsSequentialBuiltin (line 1287) | protected IsSequentialBuiltin() { super("sequential?"); }
method isSequential (line 1289) | @Specialization
method isSequential (line 1293) | @Specialization
method isSequential (line 1297) | @Fallback
class IsMapBuiltin (line 1303) | @NodeChild(value="arg", type=ReadArgNode.class)
method IsMapBuiltin (line 1307) | protected IsMapBuiltin() { super("map?"); }
method isMap (line 1309) | @Specialization
method isMap (line 1313) | @Fallback
class IsStringBuiltin (line 1319) | @NodeChild(value="arg", type=ReadArgNode.class)
method IsStringBuiltin (line 1323) | protected IsStringBuiltin() { super("string?"); }
method isString (line 1325) | @Specialization
method isString (line 1330) | @Fallback
class IsNumberBuiltin (line 1336) | @NodeChild(value="arg", type=ReadArgNode.class)
method IsNumberBuiltin (line 1340) | protected IsNumberBuiltin() { super("number?"); }
method isNumber (line 1342) | @Specialization
method isNumber (line 1347) | @Fallback
class IsFnBuiltin (line 1353) | @NodeChild(value="arg", type=ReadArgNode.class)
method IsFnBuiltin (line 1357) | protected IsFnBuiltin() { super("fn?"); }
method isFn (line 1359) | @Specialization
method isFn (line 1364) | @Fallback
class IsMacroBuiltin (line 1370) | @NodeChild(value="arg", type=ReadArgNode.class)
method IsMacroBuiltin (line 1374) | protected IsMacroBuiltin() { super("macro?"); }
method isMacro (line 1376) | @Specialization
method isMacro (line 1381) | @Fallback
class EvalBuiltin (line 1389) | @NodeChild(value="ast", type=ReadArgNode.class)
method EvalBuiltin (line 1393) | protected EvalBuiltin() { super("eval"); }
method eval (line 1395) | @Specialization
class ThrowBuiltin (line 1402) | @NodeChild(value="obj", type=ReadArgNode.class)
method ThrowBuiltin (line 1406) | protected ThrowBuiltin() { super("throw"); }
method throwException (line 1408) | @TruffleBoundary
method throwException (line 1414) | @TruffleBoundary
class SymbolBuiltin (line 1421) | @NodeChild(value="arg", type=ReadArgNode.class)
method SymbolBuiltin (line 1425) | protected SymbolBuiltin() { super("symbol"); }
method symbol (line 1427) | @Specialization
method symbol (line 1432) | @Specialization
class KeywordBuiltin (line 1438) | @GenerateNodeFactory
method KeywordBuiltin (line 1442) | protected KeywordBuiltin() { super("keyword"); }
method keyword (line 1444) | @Specialization
method keyword (line 1449) | @Specialization
class ReadlineBuiltin (line 1455) | @NodeChild(value="prompt", type=ReadArgNode.class)
method ReadlineBuiltin (line 1459) | protected ReadlineBuiltin() { super("readline"); }
method readline (line 1461) | @Specialization
class MetaBuiltin (line 1475) | @NodeChild(value="arg", type=ReadArgNode.class)
method MetaBuiltin (line 1479) | protected MetaBuiltin() { super("meta"); }
method meta (line 1481) | @Specialization
method meta (line 1486) | @Fallback
class WithMetaBuiltin (line 1492) | @NodeChild(value="arg", type=ReadArgNode.class)
method WithMetaBuiltin (line 1497) | protected WithMetaBuiltin() { super("with-meta"); }
method withMeta (line 1499) | @Specialization
class TimeMsBuiltin (line 1505) | @GenerateNodeFactory
method TimeMsBuiltin (line 1508) | protected TimeMsBuiltin() { super("time-ms"); }
method timeMs (line 1510) | @TruffleBoundary
FILE: impls/java-truffle/src/main/java/truffle/mal/MalEnv.java
class MalEnv (line 21) | @ExportLibrary(InteropLibrary.class)
method MalEnv (line 32) | private MalEnv(Class<? extends TruffleLanguage<?>> language, MalEnv ou...
method MalEnv (line 39) | MalEnv(Class<? extends TruffleLanguage<?>> language) {
method MalEnv (line 43) | MalEnv(MalEnv outer) {
method MalEnv (line 47) | MalEnv(Class<? extends TruffleLanguage<?>> language, LexicalScope scop...
method MalEnv (line 51) | MalEnv(MalEnv outer, LexicalScope scope) {
method set (line 61) | @TruffleBoundary
method set (line 83) | void set(EnvSlot slot, Object value) {
method get (line 97) | @TruffleBoundary
method get (line 121) | @TruffleBoundary
method cachedGet (line 136) | @TruffleBoundary
method get (line 162) | @ExplodeLoop
method hasLanguage (line 171) | @ExportMessage
method getLanguage (line 176) | @ExportMessage
method hasMembers (line 181) | @ExportMessage
method readMember (line 186) | @ExportMessage
method isMemberReadable (line 192) | @ExportMessage
method toDisplayString (line 198) | @ExportMessage
method isMemberInsertable (line 204) | @ExportMessage
method isMemberModifiable (line 210) | @ExportMessage
method writeMember (line 216) | @ExportMessage
method getMembers (line 222) | @ExportMessage
class CachedResult (line 233) | static class CachedResult {
method CachedResult (line 237) | CachedResult(Object result) {
class EnvMembersObject (line 243) | @ExportLibrary(InteropLibrary.class)
method EnvMembersObject (line 247) | EnvMembersObject(Object[] names) {
method hasArrayElements (line 250) | @ExportMessage
method isArrayElementReadable (line 254) | @ExportMessage
method getArraySize (line 258) | @ExportMessage
method readArrayElement (line 262) | @ExportMessage
class LexicalScope (line 276) | class LexicalScope {
method LexicalScope (line 283) | LexicalScope() {
method LexicalScope (line 287) | LexicalScope(LexicalScope parent) {
method getNotDynamicallyBound (line 295) | private Assumption getNotDynamicallyBound(MalSymbol symbol) {
method allocateSlot (line 310) | @TruffleBoundary
method getSlot (line 325) | @TruffleBoundary
method wasDynamicallyBound (line 351) | @TruffleBoundary
method getStaticBindingCount (line 359) | public int getStaticBindingCount() {
class EnvSlot (line 363) | static class EnvSlot {
method EnvSlot (line 368) | private EnvSlot(int height, int slotNum, Assumption notDynamicallyBo...
FILE: impls/java-truffle/src/main/java/truffle/mal/Printer.java
class Printer (line 3) | public class Printer {
method prStr (line 5) | public static String prStr(Object form, boolean printReadably) {
method prStr (line 11) | public static void prStr(StringBuilder buf, Object form, boolean print...
FILE: impls/java-truffle/src/main/java/truffle/mal/Reader.java
class Reader (line 7) | public class Reader {
method tokenize (line 10) | public static List<String> tokenize(String s) {
method readStr (line 22) | public static Object readStr(String s) {
method Reader (line 29) | private Reader(List<String> tokens) {
method hasNext (line 33) | private boolean hasNext() {
method peek (line 37) | private String peek() {
method next (line 44) | private String next() {
method readForm (line 51) | private Object readForm() {
method readVector (line 96) | private MalVector readVector() {
method readList (line 106) | private MalList readList() {
method readMap (line 121) | private MalMap readMap() {
method readAtom (line 131) | private Object readAtom() {
FILE: impls/java-truffle/src/main/java/truffle/mal/Types.java
class Types (line 18) | public class Types {
type MetaHolder (line 21) | interface MetaHolder<T> {
method getMeta (line 22) | Object getMeta();
method withMeta (line 23) | T withMeta(Object meta);
class MalException (line 26) | @SuppressWarnings("serial")
method MalException (line 30) | MalException(String message) {
method MalException (line 35) | MalException(Object obj) {
method fillInStackTrace (line 40) | @Override
method getLocation (line 45) | @Override
class MalValue (line 51) | abstract class MalValue {
method toString (line 52) | @Override
class MalNil (line 59) | @ExportLibrary(InteropLibrary.class)
method MalNil (line 63) | private MalNil() {}
method toDisplayString (line 65) | @ExportMessage
class MalList (line 71) | @ExportLibrary(InteropLibrary.class)
method from (line 75) | @TruffleBoundary
method computeHash (line 86) | private static int computeHash(Object head, MalList tail) {
method MalList (line 101) | @TruffleBoundary
method MalList (line 110) | @TruffleBoundary
method MalList (line 119) | @TruffleBoundary
method isEmpty (line 128) | public boolean isEmpty() {
method cons (line 132) | @TruffleBoundary
method hashCode (line 137) | @Override
method equals (line 142) | @Override
method toDisplayString (line 181) | @ExportMessage
method iterator (line 186) | @Override
class MalListIterator (line 191) | private static class MalListIterator implements Iterator<Object> {
method MalListIterator (line 194) | MalListIterator(MalList list) {
method hasNext (line 198) | @Override
method next (line 203) | @Override
method getMeta (line 211) | @Override
method withMeta (line 216) | @Override
class MalVector (line 222) | @ExportLibrary(InteropLibrary.class)
method MalVector (line 229) | private MalVector() {
method MalVector (line 234) | private MalVector(PersistentVector<Object> vector, Object meta) {
method append (line 239) | @TruffleBoundary
method concat (line 244) | @TruffleBoundary
method concat (line 253) | @TruffleBoundary
method size (line 258) | public int size() {
method get (line 262) | public Object get(int i) {
method hashCode (line 266) | @Override
method equals (line 271) | @Override
method iterator (line 286) | @Override
method toList (line 291) | @TruffleBoundary
method toDisplayString (line 300) | @ExportMessage
method getMeta (line 305) | @Override
method withMeta (line 310) | @Override
class MalMap (line 316) | @ExportLibrary(InteropLibrary.class)
method MalMap (line 323) | private MalMap() {
method MalMap (line 328) | private MalMap(PersistentHashMap<Object,Object> map, Object meta) {
method assoc (line 333) | @TruffleBoundary
method dissoc (line 338) | @TruffleBoundary
method get (line 343) | @TruffleBoundary
method hashCode (line 352) | @TruffleBoundary
method equals (line 358) | @TruffleBoundary
method toDisplayString (line 371) | @ExportMessage
method getMeta (line 376) | @Override
method withMeta (line 381) | @Override
class MalKeyword (line 387) | @ExportLibrary(InteropLibrary.class)
method get (line 393) | public static MalKeyword get(String keyword) {
method MalKeyword (line 397) | private MalKeyword(String keyword) {
method hashCode (line 401) | @Override
method equals (line 406) | @Override
method toDisplayString (line 417) | @ExportMessage
class MalSymbol (line 423) | @ExportLibrary(InteropLibrary.class)
method get (line 425) | public static MalSymbol get(String symbol) {
method MalSymbol (line 447) | private MalSymbol(String symbol) {
method hashCode (line 451) | @Override
method equals (line 456) | @Override
method toDisplayString (line 473) | @ExportMessage
class MalFunction (line 479) | @ExportLibrary(InteropLibrary.class)
method MalFunction (line 488) | MalFunction(RootCallTarget callTarget, MalEnv closedOverEnv, int numAr...
method MalFunction (line 497) | MalFunction(RootCallTarget callTarget, MalEnv closedOverEnv, int numAr...
method MalFunction (line 501) | MalFunction(MalFunction f, boolean isMacro) {
method MalFunction (line 505) | MalFunction(MalFunction f, Object meta, boolean isMacro) {
method MalFunction (line 509) | MalFunction(MalFunction f, Object meta, boolean isMacro, boolean canBe...
method toDisplayString (line 518) | @ExportMessage
method getMeta (line 523) | @Override
method withMeta (line 528) | @Override
class MalAtom (line 534) | @ExportLibrary(InteropLibrary.class)
method MalAtom (line 538) | public MalAtom(Object initialValue) {
method deref (line 542) | public Object deref() {
method reset (line 546) | public Object reset(Object newValue) {
method toDisplayString (line 551) | @ExportMessage
FILE: impls/java-truffle/src/main/java/truffle/mal/step0_repl.java
class step0_repl (line 7) | public class step0_repl {
method READ (line 8) | private static String READ(String s) {
method PRINT (line 12) | private static void PRINT(String s) {
method rep (line 16) | private static void rep(String s) {
method main (line 20) | public static void main(String[] args) throws IOException {
FILE: impls/java-truffle/src/main/java/truffle/mal/step1_read_print.java
class step1_read_print (line 7) | public class step1_read_print {
method main (line 9) | public static void main(String[] args) throws IOException {
FILE: impls/java-truffle/src/main/java/truffle/mal/step2_eval.java
class step2_eval (line 26) | public class step2_eval {
method main (line 29) | public static void main(String[] args) throws IOException {
class BuiltinFn (line 53) | static class BuiltinFn implements TruffleObject {
method BuiltinFn (line 55) | BuiltinFn(Function<Object[], Object> fn) {
class MalNode (line 67) | static abstract class MalNode extends Node {
method MalNode (line 69) | protected MalNode(Object form) {
method executeGeneric (line 73) | public abstract Object executeGeneric(VirtualFrame frame);
method executeLong (line 75) | public long executeLong(VirtualFrame frame) throws UnexpectedResultE...
method executeBoolean (line 83) | public boolean executeBoolean(VirtualFrame frame) throws UnexpectedR...
method formToNode (line 92) | private static MalNode formToNode(Object form) {
class LiteralNode (line 116) | static class LiteralNode extends MalNode {
method LiteralNode (line 117) | LiteralNode(Object form) {
method executeGeneric (line 121) | @Override
class VectorNode (line 127) | static class VectorNode extends MalNode {
method VectorNode (line 130) | VectorNode(MalVector vector) {
method executeGeneric (line 138) | @Override
class MapNode (line 148) | static class MapNode extends MalNode {
method MapNode (line 150) | MapNode(MalMap map) {
method executeGeneric (line 159) | @Override
class LookupNode (line 169) | static class LookupNode extends MalNode {
method LookupNode (line 172) | LookupNode(MalSymbol symbol) {
method lookup (line 177) | @TruffleBoundary
method executeGeneric (line 186) | @Override
class ApplyNode (line 192) | static class ApplyNode extends MalNode {
method ApplyNode (line 196) | ApplyNode(MalList list) {
method executeGeneric (line 208) | @Override
class MalRootNode (line 219) | static class MalRootNode extends RootNode {
method MalRootNode (line 223) | MalRootNode(TruffleLanguage<?> language, Object form) {
method execute (line 229) | @Override
class MalContext (line 235) | public final static class MalContext {
class MalLanguage (line 239) | @TruffleLanguage.Registration(
method createContext (line 245) | @Override
method parse (line 250) | @Override
FILE: impls/java-truffle/src/main/java/truffle/mal/step3_env.java
class step3_env (line 25) | public class step3_env {
method main (line 28) | public static void main(String[] args) throws IOException {
class BuiltinFn (line 52) | static class BuiltinFn implements TruffleObject {
method BuiltinFn (line 54) | BuiltinFn(Function<Object[], Object> fn) {
class MalNode (line 59) | static abstract class MalNode extends Node {
method MalNode (line 61) | protected MalNode(Object form) {
method executeGeneric (line 65) | public abstract Object executeGeneric(VirtualFrame frame, MalEnv env);
method executeLong (line 67) | public long executeLong(VirtualFrame frame, MalEnv env) throws Unexp...
method executeBoolean (line 75) | public boolean executeBoolean(VirtualFrame frame, MalEnv env) throws...
method formToNode (line 84) | private static MalNode formToNode(Object form) {
class LiteralNode (line 106) | static class LiteralNode extends MalNode {
method LiteralNode (line 107) | LiteralNode(Object form) {
method executeGeneric (line 111) | @Override
class VectorNode (line 117) | static class VectorNode extends MalNode {
method VectorNode (line 120) | VectorNode(MalVector vector) {
method executeGeneric (line 128) | @Override
class MapNode (line 138) | static class MapNode extends MalNode {
method MapNode (line 140) | MapNode(MalMap map) {
method executeGeneric (line 149) | @Override
class LookupNode (line 159) | static class LookupNode extends MalNode {
method LookupNode (line 162) | LookupNode(MalSymbol symbol) {
method executeGeneric (line 167) | @Override
class ApplyNode (line 177) | static class ApplyNode extends MalNode {
method ApplyNode (line 181) | ApplyNode(MalList list) {
method executeGeneric (line 193) | @Override
class DefNode (line 204) | static class DefNode extends MalNode {
method DefNode (line 208) | DefNode(MalList list) {
method executeGeneric (line 214) | @Override
class LetBindingNode (line 222) | static class LetBindingNode extends Node {
method LetBindingNode (line 225) | LetBindingNode(MalSymbol symbol, Object valueForm) {
method executeGeneric (line 230) | public void executeGeneric(VirtualFrame frame, MalEnv env) {
class LetNode (line 235) | static class LetNode extends MalNode {
method LetNode (line 239) | LetNode(MalList form) {
method executeGeneric (line 251) | @ExplodeLoop
class MalRootNode (line 262) | static class MalRootNode extends RootNode {
method MalRootNode (line 266) | MalRootNode(TruffleLanguage<?> language, Object form) {
method execute (line 272) | @Override
class MalContext (line 279) | final static class MalContext {
class MalLanguage (line 283) | @TruffleLanguage.Registration(
method createContext (line 289) | @Override
method parse (line 299) | @Override
FILE: impls/java-truffle/src/main/java/truffle/mal/step4_if_fn_do.java
class step4_if_fn_do (line 31) | public class step4_if_fn_do {
method main (line 34) | public static void main(String[] args) throws IOException {
class BuiltinFn (line 60) | static class BuiltinFn implements TruffleObject {
method BuiltinFn (line 62) | BuiltinFn(Function<Object[], Object> fn) {
class MalNode (line 67) | static abstract class MalNode extends Node {
method MalNode (line 69) | protected MalNode(Object form) {
method executeGeneric (line 73) | public abstract Object executeGeneric(VirtualFrame frame, MalEnv env);
method executeLong (line 75) | public long executeLong(VirtualFrame frame, MalEnv env) throws Unexp...
method executeBoolean (line 83) | public boolean executeBoolean(VirtualFrame frame, MalEnv env) throws...
method formToNode (line 92) | private static MalNode formToNode(MalLanguage language, Object form) {
class LiteralNode (line 120) | static class LiteralNode extends MalNode {
method LiteralNode (line 121) | LiteralNode(Object form) {
method executeGeneric (line 125) | @Override
class VectorNode (line 131) | static class VectorNode extends MalNode {
method VectorNode (line 134) | VectorNode(MalLanguage language, MalVector vector) {
method executeGeneric (line 142) | @Override
class MapNode (line 152) | static class MapNode extends MalNode {
method MapNode (line 154) | MapNode(MalLanguage language, MalMap map) {
method executeGeneric (line 163) | @Override
class LookupNode (line 173) | static class LookupNode extends MalNode {
method LookupNode (line 176) | LookupNode(MalSymbol symbol) {
method executeGeneric (line 181) | @Override
class InvokeNode (line 191) | static class InvokeNode extends AbstractInvokeNode {
method InvokeNode (line 194) | InvokeNode() {
method invoke (line 197) | Object invoke(CallTarget target, Object[] args) {
class ApplyNode (line 202) | static class ApplyNode extends MalNode {
method ApplyNode (line 207) | ApplyNode(MalLanguage language, MalList list) {
method executeGeneric (line 219) | @Override
class DefNode (line 231) | static class DefNode extends MalNode {
method DefNode (line 235) | DefNode(MalLanguage language, MalList list) {
method executeGeneric (line 241) | @Override
class LetBindingNode (line 249) | static class LetBindingNode extends Node {
method LetBindingNode (line 253) | LetBindingNode(MalLanguage language, MalSymbol symbol, Object valueF...
method executeGeneric (line 258) | public void executeGeneric(VirtualFrame frame, MalEnv env) {
class LetNode (line 263) | static class LetNode extends MalNode {
method LetNode (line 267) | LetNode(MalLanguage language, MalList form) {
method executeGeneric (line 279) | @ExplodeLoop
class MalRootNode (line 290) | static class MalRootNode extends RootNode {
method MalRootNode (line 294) | MalRootNode(MalLanguage language, Object form) {
method execute (line 300) | @Override
method toString (line 306) | @Override
class DoNode (line 312) | static class DoNode extends MalNode {
method DoNode (line 315) | DoNode(MalLanguage language, MalList form) {
method executeGeneric (line 324) | @ExplodeLoop
class IfNode (line 338) | static class IfNode extends MalNode {
method IfNode (line 343) | IfNode(MalLanguage language, MalList form) {
method executeGeneric (line 351) | @Override
class AbstractBindArgNode (line 366) | static abstract class AbstractBindArgNode extends Node {
method AbstractBindArgNode (line 370) | protected AbstractBindArgNode(MalSymbol symbol, int argPos) {
method execute (line 375) | public abstract void execute(VirtualFrame frame, MalEnv env);
class BindArgNode (line 378) | static class BindArgNode extends AbstractBindArgNode {
method BindArgNode (line 380) | public BindArgNode(MalSymbol symbol, int argPos) {
method execute (line 384) | @Override
class BindVarargsNode (line 390) | static class BindVarargsNode extends BindArgNode {
method BindVarargsNode (line 391) | public BindVarargsNode(MalSymbol symbol, int argPos) {
method buildVarArgsList (line 395) | @TruffleBoundary
method execute (line 404) | @Override
class FnRootNode (line 413) | static class FnRootNode extends RootNode {
method FnRootNode (line 419) | FnRootNode(MalLanguage language, MalList form) {
method execute (line 444) | @ExplodeLoop
class FnNode (line 458) | static class FnNode extends MalNode {
method FnNode (line 462) | FnNode(MalLanguage language, MalList form) {
method executeGeneric (line 468) | @Override
class MalContext (line 474) | final static class MalContext {
method MalContext (line 480) | MalContext(MalLanguage language) {
class MalLanguage (line 488) | @TruffleLanguage.Registration(
method createContext (line 494) | @Override
method evalForm (line 499) | @Override
method invokeNode (line 505) | @Override
method parse (line 510) | @Override
method findTopScopes (line 517) | @Override
method out (line 522) | @Override
method in (line 527) | @Override
FILE: impls/java-truffle/src/main/java/truffle/mal/step5_tco.java
class step5_tco (line 32) | public class step5_tco {
method main (line 35) | public static void main(String[] args) throws IOException {
class BuiltinFn (line 61) | static class BuiltinFn implements TruffleObject {
method BuiltinFn (line 63) | BuiltinFn(Function<Object[], Object> fn) {
class MalNode (line 68) | static abstract class MalNode extends Node {
method MalNode (line 70) | protected MalNode(Object form) {
method executeGeneric (line 74) | public abstract Object executeGeneric(VirtualFrame frame, MalEnv env);
method executeLong (line 76) | public long executeLong(VirtualFrame frame, MalEnv env) throws Unexp...
method executeBoolean (line 84) | public boolean executeBoolean(VirtualFrame frame, MalEnv env) throws...
method formToNode (line 93) | private static MalNode formToNode(MalLanguage language, Object form, b...
class LiteralNode (line 121) | static class LiteralNode extends MalNode {
method LiteralNode (line 122) | LiteralNode(Object form) {
method executeGeneric (line 126) | @Override
class VectorNode (line 132) | static class VectorNode extends MalNode {
method VectorNode (line 135) | VectorNode(MalLanguage language, MalVector vector) {
method executeGeneric (line 143) | @Override
class MapNode (line 153) | static class MapNode extends MalNode {
method MapNode (line 155) | MapNode(MalLanguage language, MalMap map) {
method executeGeneric (line 164) | @Override
class LookupNode (line 174) | static class LookupNode extends MalNode {
method LookupNode (line 177) | LookupNode(MalSymbol symbol) {
method executeGeneric (line 182) | @Override
class TailCallException (line 192) | @SuppressWarnings("serial")
method TailCallException (line 196) | TailCallException(CallTarget target, Object[] args) {
class InvokeNode (line 202) | static class InvokeNode extends AbstractInvokeNode {
method InvokeNode (line 206) | InvokeNode(boolean tailPosition) {
method invoke (line 210) | Object invoke(CallTarget target, Object[] args) {
class ApplyNode (line 226) | static class ApplyNode extends MalNode {
method ApplyNode (line 231) | ApplyNode(MalLanguage language, MalList list, boolean tailPosition) {
method executeGeneric (line 244) | @Override
class DefNode (line 256) | static class DefNode extends MalNode {
method DefNode (line 260) | DefNode(MalLanguage language, MalList list) {
method executeGeneric (line 266) | @Override
class LetBindingNode (line 274) | static class LetBindingNode extends Node {
method LetBindingNode (line 278) | LetBindingNode(MalLanguage language, MalSymbol symbol, Object valueF...
method executeGeneric (line 283) | public void executeGeneric(VirtualFrame frame, MalEnv env) {
class LetNode (line 288) | static class LetNode extends MalNode {
method LetNode (line 292) | LetNode(MalLanguage language, MalList form, boolean tailPosition) {
method executeGeneric (line 304) | @ExplodeLoop
class MalRootNode (line 318) | static class MalRootNode extends RootNode {
method MalRootNode (line 322) | MalRootNode(MalLanguage language, Object form) {
method execute (line 330) | @Override
method toString (line 336) | @Override
class DoNode (line 342) | static class DoNode extends MalNode {
method DoNode (line 345) | DoNode(MalLanguage language, MalList form, boolean tailPosition) {
method executeGeneric (line 354) | @ExplodeLoop
class IfNode (line 368) | static class IfNode extends MalNode {
method IfNode (line 373) | IfNode(MalLanguage language, MalList form, boolean tailPosition) {
method executeGeneric (line 381) | @Override
class AbstractBindArgNode (line 396) | static abstract class AbstractBindArgNode extends Node {
method AbstractBindArgNode (line 400) | protected AbstractBindArgNode(MalSymbol symbol, int argPos) {
method execute (line 405) | public abstract void execute(VirtualFrame frame, MalEnv env);
class BindArgNode (line 408) | static class BindArgNode extends AbstractBindArgNode {
method BindArgNode (line 410) | public BindArgNode(MalSymbol symbol, int argPos) {
method execute (line 414) | @Override
class BindVarargsNode (line 420) | static class BindVarargsNode extends BindArgNode {
method BindVarargsNode (line 421) | public BindVarargsNode(MalSymbol symbol, int argPos) {
method buildVarArgsList (line 425) | @TruffleBoundary
method execute (line 434) | @Override
class FnRootNode (line 443) | static class FnRootNode extends RootNode {
method FnRootNode (line 449) | FnRootNode(MalLanguage language, MalList form) {
method execute (line 474) | @ExplodeLoop
class FnNode (line 488) | static class FnNode extends MalNode {
method FnNode (line 492) | FnNode(MalLanguage language, MalList form) {
method executeGeneric (line 498) | @Override
class MalContext (line 504) | final static class MalContext {
method MalContext (line 510) | MalContext(MalLanguage language) {
class MalLanguage (line 518) | @TruffleLanguage.Registration(
method createContext (line 524) | @Override
method evalForm (line 529) | @Override
method invokeNode (line 535) | @Override
method parse (line 540) | @Override
method findTopScopes (line 547) | @Override
method out (line 552) | @Override
method in (line 557) | @Override
FILE: impls/java-truffle/src/main/java/truffle/mal/step6_file.java
class step6_file (line 32) | public class step6_file {
method main (line 35) | public static void main(String[] args) throws IOException {
class BuiltinFn (line 78) | static class BuiltinFn implements TruffleObject {
method BuiltinFn (line 80) | BuiltinFn(Function<Object[], Object> fn) {
class MalNode (line 85) | static abstract class MalNode extends Node {
method MalNode (line 87) | protected MalNode(Object form) {
method executeGeneric (line 91) | public abstract Object executeGeneric(VirtualFrame frame, MalEnv env);
method executeLong (line 93) | public long executeLong(VirtualFrame frame, MalEnv env) throws Unexp...
method executeBoolean (line 101) | public boolean executeBoolean(VirtualFrame frame, MalEnv env) throws...
method formToNode (line 110) | private static MalNode formToNode(MalLanguage language, Object form, b...
class LiteralNode (line 138) | static class LiteralNode extends MalNode {
method LiteralNode (line 139) | LiteralNode(Object form) {
method executeGeneric (line 143) | @Override
class VectorNode (line 149) | static class VectorNode extends MalNode {
method VectorNode (line 152) | VectorNode(MalLanguage language, MalVector vector) {
method executeGeneric (line 160) | @Override
class MapNode (line 170) | static class MapNode extends MalNode {
method MapNode (line 172) | MapNode(MalLanguage language, MalMap map) {
method executeGeneric (line 181) | @Override
class LookupNode (line 191) | static class LookupNode extends MalNode {
method LookupNode (line 194) | LookupNode(MalSymbol symbol) {
method executeGeneric (line 199) | @Override
class TailCallException (line 209) | @SuppressWarnings("serial")
method TailCallException (line 213) | TailCallException(CallTarget target, Object[] args) {
class InvokeNode (line 219) | static class InvokeNode extends AbstractInvokeNode {
method InvokeNode (line 223) | InvokeNode(boolean tailPosition) {
method invoke (line 227) | Object invoke(CallTarget target, Object[] args) {
class ApplyNode (line 243) | static class ApplyNode extends MalNode {
method ApplyNode (line 248) | ApplyNode(MalLanguage language, MalList list, boolean tailPosition) {
method executeGeneric (line 261) | @Override
class DefNode (line 273) | static class DefNode extends MalNode {
method DefNode (line 277) | DefNode(MalLanguage language, MalList list) {
method executeGeneric (line 283) | @Override
class LetBindingNode (line 291) | static class LetBindingNode extends Node {
method LetBindingNode (line 295) | LetBindingNode(MalLanguage language, MalSymbol symbol, Object valueF...
method executeGeneric (line 300) | public void executeGeneric(VirtualFrame frame, MalEnv env) {
class LetNode (line 305) | static class LetNode extends MalNode {
method LetNode (line 309) | LetNode(MalLanguage language, MalList form, boolean tailPosition) {
method executeGeneric (line 321) | @ExplodeLoop
class MalRootNode (line 335) | static class MalRootNode extends RootNode {
method MalRootNode (line 339) | MalRootNode(MalLanguage language, Object form) {
method execute (line 347) | @Override
method toString (line 353) | @Override
class DoNode (line 359) | static class DoNode extends MalNode {
method DoNode (line 362) | DoNode(MalLanguage language, MalList form, boolean tailPosition) {
method executeGeneric (line 371) | @ExplodeLoop
class IfNode (line 385) | static class IfNode extends MalNode {
method IfNode (line 390) | IfNode(MalLanguage language, MalList form, boolean tailPosition) {
method executeGeneric (line 398) | @Override
class AbstractBindArgNode (line 413) | static abstract class AbstractBindArgNode extends Node {
method AbstractBindArgNode (line 417) | protected AbstractBindArgNode(MalSymbol symbol, int argPos) {
method execute (line 422) | public abstract void execute(VirtualFrame frame, MalEnv env);
class BindArgNode (line 425) | static class BindArgNode extends AbstractBindArgNode {
method BindArgNode (line 427) | public BindArgNode(MalSymbol symbol, int argPos) {
method execute (line 431) | @Override
class BindVarargsNode (line 437) | static class BindVarargsNode extends BindArgNode {
method BindVarargsNode (line 438) | public BindVarargsNode(MalSymbol symbol, int argPos) {
method buildVarArgsList (line 442) | @TruffleBoundary
method execute (line 451) | @Override
class FnRootNode (line 460) | static class FnRootNode extends RootNode {
method FnRootNode (line 466) | FnRootNode(MalLanguage language, MalList form) {
method execute (line 491) | @ExplodeLoop
class FnNode (line 505) | static class FnNode extends MalNode {
method FnNode (line 509) | FnNode(MalLanguage language, MalList form) {
method executeGeneric (line 515) | @Override
class MalContext (line 521) | final static class MalContext {
method MalContext (line 527) | MalContext(MalLanguage language) {
class MalLanguage (line 535) | @TruffleLanguage.Registration(
method createContext (line 541) | @Override
method evalForm (line 546) | @Override
method invokeNode (line 552) | @Override
method parse (line 557) | @Override
method findTopScopes (line 564) | @Override
method out (line 569) | @Override
method in (line 574) | @Override
FILE: impls/java-truffle/src/main/java/truffle/mal/step7_quote.java
class step7_quote (line 32) | public class step7_quote {
method main (line 35) | public static void main(String[] args) throws IOException {
class BuiltinFn (line 78) | static class BuiltinFn implements TruffleObject {
method BuiltinFn (line 80) | BuiltinFn(Function<Object[], Object> fn) {
class MalNode (line 85) | static abstract class MalNode extends Node {
method MalNode (line 87) | protected MalNode(Object form) {
method executeGeneric (line 91) | public abstract Object executeGeneric(VirtualFrame frame, MalEnv env);
method executeLong (line 93) | public long executeLong(VirtualFrame frame, MalEnv env) throws Unexp...
method executeBoolean (line 101) | public boolean executeBoolean(VirtualFrame frame, MalEnv env) throws...
method isPair (line 110) | private static boolean isPair(Object obj) {
method quasiquote (line 116) | private static Object quasiquote(Object form) {
method formToNode (line 136) | private static MalNode formToNode(MalLanguage language, Object form, b...
class LiteralNode (line 168) | static class LiteralNode extends MalNode {
method LiteralNode (line 169) | LiteralNode(Object form) {
method executeGeneric (line 173) | @Override
class VectorNode (line 179) | static class VectorNode extends MalNode {
method VectorNode (line 182) | VectorNode(MalLanguage language, MalVector vector) {
method executeGeneric (line 190) | @Override
class MapNode (line 200) | static class MapNode extends MalNode {
method MapNode (line 202) | MapNode(MalLanguage language, MalMap map) {
method executeGeneric (line 211) | @Override
class LookupNode (line 221) | static class LookupNode extends MalNode {
method LookupNode (line 224) | LookupNode(MalSymbol symbol) {
method executeGeneric (line 229) | @Override
class TailCallException (line 239) | @SuppressWarnings("serial")
method TailCallException (line 243) | TailCallException(CallTarget target, Object[] args) {
class InvokeNode (line 249) | static class InvokeNode extends AbstractInvokeNode {
method InvokeNode (line 253) | InvokeNode(boolean tailPosition) {
method invoke (line 257) | Object invoke(CallTarget target, Object[] args) {
class ApplyNode (line 273) | static class ApplyNode extends MalNode {
method ApplyNode (line 278) | ApplyNode(MalLanguage language, MalList list, boolean tailPosition) {
method executeGeneric (line 291) | @Override
class DefNode (line 303) | static class DefNode extends MalNode {
method DefNode (line 307) | DefNode(MalLanguage language, MalList list) {
method executeGeneric (line 313) | @Override
class LetBindingNode (line 321) | static class LetBindingNode extends Node {
method LetBindingNode (line 325) | LetBindingNode(MalLanguage language, MalSymbol symbol, Object valueF...
method executeGeneric (line 330) | public void executeGeneric(VirtualFrame frame, MalEnv env) {
class LetNode (line 335) | static class LetNode extends MalNode {
method LetNode (line 339) | LetNode(MalLanguage language, MalList form, boolean tailPosition) {
method executeGeneric (line 351) | @ExplodeLoop
class MalRootNode (line 365) | static class MalRootNode extends RootNode {
method MalRootNode (line 369) | MalRootNode(MalLanguage language, Object form) {
method execute (line 377) | @Override
method toString (line 383) | @Override
class DoNode (line 389) | static class DoNode extends MalNode {
method DoNode (line 392) | DoNode(MalLanguage language, MalList form, boolean tailPosition) {
method executeGeneric (line 401) | @ExplodeLoop
class IfNode (line 415) | static class IfNode extends MalNode {
method IfNode (line 420) | IfNode(MalLanguage language, MalList form, boolean tailPosition) {
method executeGeneric (line 428) | @Override
class AbstractBindArgNode (line 443) | static abstract class AbstractBindArgNode extends Node {
method AbstractBindArgNode (line 447) | protected AbstractBindArgNode(MalSymbol symbol, int argPos) {
method execute (line 452) | public abstract void execute(VirtualFrame frame, MalEnv env);
class BindArgNode (line 455) | static class BindArgNode extends AbstractBindArgNode {
method BindArgNode (line 457) | public BindArgNode(MalSymbol symbol, int argPos) {
method execute (line 461) | @Override
class BindVarargsNode (line 467) | static class BindVarargsNode extends BindArgNode {
method BindVarargsNode (line 468) | public BindVarargsNode(MalSymbol symbol, int argPos) {
method buildVarArgsList (line 472) | @TruffleBoundary
method execute (line 481) | @Override
class FnRootNode (line 490) | static class FnRootNode extends RootNode {
method FnRootNode (line 496) | FnRootNode(MalLanguage language, MalList form) {
method execute (line 521) | @ExplodeLoop
class FnNode (line 535) | static class FnNode extends MalNode {
method FnNode (line 539) | FnNode(MalLanguage language, MalList form) {
method executeGeneric (line 545) | @Override
class QuoteNode (line 551) | static class QuoteNode extends MalNode {
method QuoteNode (line 554) | QuoteNode(MalLanguage language, MalList form) {
method executeGeneric (line 559) | @Override
class MalContext (line 565) | final static class MalContext {
method MalContext (line 571) | MalContext(MalLanguage language) {
class MalLanguage (line 579) | @TruffleLanguage.Registration(
method createContext (line 585) | @Override
method evalForm (line 590) | @Override
method invokeNode (line 596) | @Override
method parse (line 601) | @Override
method findTopScopes (line 608) | @Override
method out (line 613) | @Override
method in (line 618) | @Override
FILE: impls/java-truffle/src/main/java/truffle/mal/step8_macros.java
class step8_macros (line 32) | public class step8_macros {
method main (line 35) | public static void main(String[] args) throws IOException {
class BuiltinFn (line 79) | static class BuiltinFn implements TruffleObject {
method BuiltinFn (line 81) | BuiltinFn(Function<Object[], Object> fn) {
class MalNode (line 86) | static abstract class MalNode extends Node {
method MalNode (line 88) | protected MalNode(Object form) {
method executeGeneric (line 92) | public abstract Object executeGeneric(VirtualFrame frame, MalEnv env);
method executeLong (line 94) | public long executeLong(VirtualFrame frame, MalEnv env) throws Unexp...
method executeBoolean (line 102) | public boolean executeBoolean(VirtualFrame frame, MalEnv env) throws...
method isPair (line 111) | private static boolean isPair(Object obj) {
method quasiquote (line 117) | private static Object quasiquote(Object form) {
method formToNode (line 137) | private static MalNode formToNode(MalLanguage language, Object form, b...
class LiteralNode (line 171) | static class LiteralNode extends MalNode {
method LiteralNode (line 172) | LiteralNode(Object form) {
method executeGeneric (line 176) | @Override
class VectorNode (line 182) | static class VectorNode extends MalNode {
method VectorNode (line 185) | VectorNode(MalLanguage language, MalVector vector) {
method executeGeneric (line 193) | @Override
class MapNode (line 203) | static class MapNode extends MalNode {
method MapNode (line 205) | MapNode(MalLanguage language, MalMap map) {
method executeGeneric (line 214) | @Override
class LookupNode (line 224) | static class LookupNode extends MalNode {
method LookupNode (line 227) | LookupNode(MalSymbol symbol) {
method executeGeneric (line 232) | @Override
class TailCallException (line 242) | @SuppressWarnings("serial")
method TailCallException (line 246) | TailCallException(CallTarget target, Object[] args) {
class InvokeNode (line 252) | static class InvokeNode extends AbstractInvokeNode {
method InvokeNode (line 256) | InvokeNode(boolean tailPosition) {
method invoke (line 260) | Object invoke(CallTarget target, Object[] args) {
method invoke (line 264) | Object invoke(CallTarget target, Object[] args, boolean allowTailCal...
method getMacroFn (line 280) | private static MalFunction getMacroFn(MalEnv env, Object form) {
method macroexpand (line 296) | static Object macroexpand(InvokeNode invokeNode, MalEnv env, Object fo...
class MacroexpandNode (line 314) | static class MacroexpandNode extends MalNode {
method MacroexpandNode (line 318) | MacroexpandNode(MalList form) {
method executeGeneric (line 323) | @Override
class ApplyNode (line 329) | static class ApplyNode extends MalNode {
method ApplyNode (line 335) | ApplyNode(MalLanguage language, MalList list, boolean tailPosition) {
method applyMacro (line 349) | @TruffleBoundary
method executeGeneric (line 362) | @ExplodeLoop
class DefNode (line 385) | static class DefNode extends MalNode {
method DefNode (line 390) | DefNode(MalLanguage language, MalList list) {
method executeGeneric (line 397) | @Override
class LetBindingNode (line 408) | static class LetBindingNode extends Node {
method LetBindingNode (line 412) | LetBindingNode(MalLanguage language, MalSymbol symbol, Object valueF...
method executeGeneric (line 417) | public void executeGeneric(VirtualFrame frame, MalEnv env) {
class LetNode (line 422) | static class LetNode extends MalNode {
method LetNode (line 426) | LetNode(MalLanguage language, MalList form, boolean tailPosition) {
method executeGeneric (line 438) | @ExplodeLoop
class MalRootNode (line 452) | static class MalRootNode extends RootNode {
method MalRootNode (line 457) | MalRootNode(MalLanguage language, Object form, MalEnv env, boolean t...
method execute (line 466) | @Override
method toString (line 471) | @Override
class DoNode (line 477) | static class DoNode extends MalNode {
method DoNode (line 480) | DoNode(MalLanguage language, MalList form, boolean tailPosition) {
method executeGeneric (line 489) | @ExplodeLoop
class IfNode (line 503) | static class IfNode extends MalNode {
method IfNode (line 508) | IfNode(MalLanguage language, MalList form, boolean tailPosition) {
method executeGeneric (line 516) | @Override
class AbstractBindArgNode (line 531) | static abstract class AbstractBindArgNode extends Node {
method AbstractBindArgNode (
Copy disabled (too large)
Download .json
Condensed preview — 2441 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (12,685K chars).
[
{
"path": ".gitattributes",
"chars": 48,
"preview": "* text=auto eol=lf\nimpls/vbs/*.vbs text eol=crlf"
},
{
"path": ".github/pull_request_template.md",
"chars": 570,
"preview": "Pull request requirements:\n\n- [ ] Commits are well written and well organized.\n- [ ] Commits for a specific implementati"
},
{
"path": ".github/workflows/main.yml",
"chars": 6686,
"preview": "name: Build and Test\n\npermissions:\n contents: read\n packages: write\n\non:\n push: {}\n pull_request: {}\n workflow_disp"
},
{
"path": ".gitignore",
"chars": 221,
"preview": ".DS_Store\n.bash_history\n.cache\n.cargo\n.config\n.mal-history\n.mal_history\n.crystal\n.lein\n.local\n.m2\n.ivy2\n.sbt\n.npm\n.node-"
},
{
"path": ".gitmodules",
"chars": 0,
"preview": ""
},
{
"path": ".travis.yml",
"chars": 665,
"preview": "sudo: required\n\n# matrix layout based on:\n# https://github.com/libressl-portable/portable/blob/9e090286b55def5ca2c0cc375"
},
{
"path": "IMPLS.yml",
"chars": 4246,
"preview": "IMPL:\n - {IMPL: ada}\n - {IMPL: ada.2}\n - {IMPL: awk}\n - {IMPL: bash, NO_SELF_HOST: 1} # step8 timeout\n - {IMPL: ba"
},
{
"path": "LICENSE",
"chars": 17215,
"preview": "Copyright (C) 2015 Joel Martin <github@martintribe.org>\n\nMal (make-a-lisp) is licensed under the MPL 2.0 (Mozilla Public"
},
{
"path": "Makefile",
"chars": 13517,
"preview": "# Usage/help\nall help:\n\t@echo\n\t@echo 'USAGE:'\n\t@echo\n\t@echo 'Rules/Targets:'\n\t@echo\n\t@echo 'make \"IMPL\" "
},
{
"path": "Makefile.impls",
"chars": 9422,
"preview": "# HOWTO add a new implementation (named \"foo\"):\n# - Add \"foo\" to the IMPLS variable (alphabetical order)\n# - Add a new \""
},
{
"path": "README.md",
"chars": 36980,
"preview": "# mal - Make a Lisp\n\n[](https://git"
},
{
"path": "ci.sh",
"chars": 3187,
"preview": "#!/usr/bin/env bash\n\nset -ex\n\nACTION=${1}\nIMPL=${2}\n\ndie() { local ret=$1; shift; echo >&2 \"${*}\"; exit $ret; }\n\n# Envir"
},
{
"path": "docs/FAQ.md",
"chars": 12470,
"preview": "# Mal/Make-a-Lisp FAQ\n\n<a name=\"why_mal\"></a>\n\n### Why did you create mal/make-a-lisp?\n### OR Why the name \"mal\"?\n### OR"
},
{
"path": "docs/Hints.md",
"chars": 5588,
"preview": "# Mal/Make-a-Lisp Implementation Hints\n\n<a name=\"milliseconds\"></a>\n\n### How do I get milliseconds since epoch for the \""
},
{
"path": "docs/TODO",
"chars": 4398,
"preview": "General:\n * update language graph code and data\n - pull from GHA instead of Travis\n\n * Add self-hosted CI m"
},
{
"path": "docs/cheatsheet.html",
"chars": 16632,
"preview": "<html>\n<head>\n <style>\n h2 {\n text-align: center;\n }\n table {\n font-size: 11px;\n border-w"
},
{
"path": "docs/exercises.md",
"chars": 5118,
"preview": "# Exercises to learn MAL\n\nThe process introduces LISP by describing the internals of selected\nlow-level constructs. As a"
},
{
"path": "docs/graph/README.md",
"chars": 1197,
"preview": "# Mal Implementation Stats Graph\n\n\n## Updating the data\n\n* Install prerequisites:\n\nFor ubuntu:\n```\nsudo apt-get install "
},
{
"path": "docs/graph/all_data.json",
"chars": 45350,
"preview": "{\n \"ada\": {\n \"dir\": \"ada\",\n \"name\": \"Ada\",\n \"syntax\": \"Algol\",\n \"type_check\": \"Static\",\n \"modes\": [],\n "
},
{
"path": "docs/graph/base_data.yaml",
"chars": 6275,
"preview": "headers:\n - [dir , name , syntax , type_check , modes]\n\nlanguages:\n - [ada , Ada "
},
{
"path": "docs/graph/collect_data.js",
"chars": 11917,
"preview": "#!/usr/bin/env python\n\nconst { promisify } = require('util')\nconst readFile = promisify(require('fs').readFile)\nconst wr"
},
{
"path": "docs/graph/graph_languages.js",
"chars": 10512,
"preview": "const malColors = [\n \"#1f77b4\",\"#bf7f0e\",\"#4cb00c\",\"#b62728\",\"#9467bd\",\"#bc664b\",\"#b377c2\",\"#0fbf6f\",\"#bcbd22\",\"#17be"
},
{
"path": "docs/graph/index.html",
"chars": 6447,
"preview": "<html>\n<head>\n <meta charset=\"utf-8\">\n <link href=\"https://cdnjs.cloudflare.com/ajax/libs/nvd3/1.8.6/nv.d3.min.css\" re"
},
{
"path": "docs/graph/package.json",
"chars": 253,
"preview": "{\n \"name\": \"mal_graph\",\n \"version\": \"0.0.1\",\n \"description\": \"Graph Mal Languages\",\n \"dependencies\": {\n "
},
{
"path": "docs/graph/so-tags.csv",
"chars": 1001478,
"preview": "Rate,TagName\n\"2532623\",\"javascript\"\n\"2205901\",\"python\"\n\"1919299\",\"java\"\n\"1620836\",\"c#\"\n\"1467322\",\"php\"\n\"1419124\",\"androi"
},
{
"path": "docs/index.html",
"chars": 9906,
"preview": "<!DOCTYPE html>\n<!--\nCopyright (c) 2019 Joel Martin\nCopyright (c) 2012 Fogus, Jen Myers and Relevance Inc.\nAll rights re"
},
{
"path": "docs/notes.md",
"chars": 550,
"preview": "## Counting languages, implementations, and runtimes/MODES\n\n```\n# languages\n$ egrep -v \"\\-mal\\>|IMPL: mal,.*nim\" IMPLS.y"
},
{
"path": "docs/step_notes.txt",
"chars": 15404,
"preview": "Step Notes:\n\n- step0_repl\n - prompt, input, READ, EVAL, PRINT, output\n - readline module\n - display prompt,"
},
{
"path": "docs/web/ansi.css",
"chars": 3654,
"preview": ".jqconsole-ansi-bold {\n font-weight: bold!important;\n}\n\n.jqconsole-ansi-lighter {\n font-weight: lighter!important;\n}\n\n"
},
{
"path": "docs/web/base.css",
"chars": 6026,
"preview": "/* \n* Skeleton V1.0.2\n* Copyright 2011, Dave Gamache\n* www.getskeleton.com\n* Free to use under the MIT license.\n* http:/"
},
{
"path": "docs/web/console.css",
"chars": 1026,
"preview": "/* Outer console element */\n#console {\n}\n/* The inner console element. */\n.jqconsole {\n background-color: black;;\n}\n.jq"
},
{
"path": "docs/web/himera.css",
"chars": 4893,
"preview": "/* Additional Classes --------------------------------------------- */\n\n.source {\n font-family: \"ExoRegular\";\n font-s"
},
{
"path": "docs/web/layout.css",
"chars": 2801,
"preview": "/* \n* Skeleton V1.0.2\n* Copyright 2011, Dave Gamache\n* www.getskeleton.com\n* Free to use under the MIT license.\n* http:/"
},
{
"path": "docs/web/mal.js",
"chars": 27903,
"preview": "var max_history_length = 1000;\n\nfunction jq_load_history(jq) {\n if (localStorage['mal_history']) {\n var lines "
},
{
"path": "docs/web/skeleton.css",
"chars": 7878,
"preview": "/* \n* Skeleton V1.0.2\n* Copyright 2011, Dave Gamache\n* www.getskeleton.com\n* Free to use under the MIT license.\n* http:/"
},
{
"path": "examples/clojurewest2014.mal",
"chars": 3244,
"preview": ";; Mal Presentation\n\n(def! clear\n (fn* ()\n (str \"\u001b[2J\u001b[;H\")))\n\n(def! bold\n (fn* (s)\n (str \"\u001b[1m\" s \"\u001b[0m\")))\n\n(d"
},
{
"path": "examples/exercises.mal",
"chars": 5685,
"preview": ";; These are the answers to the questions in ../docs/exercise.md.\n\n;; In order to avoid unexpected circular dependencies"
},
{
"path": "examples/hello.mal",
"chars": 69,
"preview": "(println \"hello world\\n\\nanother line\")\n(println \"and another line\")\n"
},
{
"path": "examples/presentation.mal",
"chars": 3108,
"preview": ";; Mal Presentation\n\n(def! clear\n (fn* ()\n (str \"\u001b[2J\u001b[;H\")))\n\n(def! bold\n (fn* (s)\n (str \"\u001b[1m\" s \"\u001b[0m\")))\n\n(d"
},
{
"path": "get-ci-matrix.py",
"chars": 2477,
"preview": "#!/usr/bin/env python3\n\nimport json\nimport os\nimport re\nimport sys\nimport yaml\n\nIMPLS_FILE = \"IMPLS.yml\"\nRE_IGNORE = re."
},
{
"path": "impls/.gitignore",
"chars": 2004,
"preview": ".DS_Store\n.bash_history\n.cache\n.cargo\n.config\n.mal-history\n.crystal\n.lein\n.m2\n.ivy2\n.sbt\n.npm\n.node-gyp\n.elm\n*/experimen"
},
{
"path": "impls/ada/Dockerfile",
"chars": 774,
"preview": "FROM ubuntu:20.04\nMAINTAINER Joel Martin <github@martintribe.org>\nLABEL org.opencontainers.image.source=https://github.c"
},
{
"path": "impls/ada/Makefile",
"chars": 450,
"preview": "PROGS=step0_repl step1_read_print step2_eval step3_env step4_if_fn_do \\\n step5_tco step6_file step7_quote step8_mac"
},
{
"path": "impls/ada/core.adb",
"chars": 37177,
"preview": "with Ada.Calendar;\nwith Ada.Characters.Latin_1;\nwith Ada.Strings.Unbounded;\nwith Ada.Text_IO;\nwith Eval_Callback;\nwith R"
},
{
"path": "impls/ada/core.ads",
"chars": 169,
"preview": "with Envs;\n\npackage Core is\n\n -- Init puts core functions into a new Env.\n procedure Init (Repl_Env : Envs.Env_Handl"
},
{
"path": "impls/ada/envs.adb",
"chars": 3751,
"preview": "with Ada.Text_IO;\nwith Types;\nwith Unchecked_Deallocation;\n\npackage body Envs is\n\n\n function Is_Null (E : Env_Handle) "
},
{
"path": "impls/ada/envs.ads",
"chars": 1890,
"preview": "with Ada.Containers.Hashed_Maps;\nwith Ada.Strings.Unbounded.Hash;\nwith Smart_Pointers;\nlimited with Types;\n\npackage Envs"
},
{
"path": "impls/ada/eval_callback.ads",
"chars": 206,
"preview": "with Envs;\nwith Types;\n\npackage Eval_Callback is\n\n type Eval_Func is access\n function (MH : Types.Mal_Handle; Env "
},
{
"path": "impls/ada/printer.adb",
"chars": 249,
"preview": "package body Printer is\n\n function Pr_Str (M : Types.Mal_Handle) return String is\n begin\n if Types.Is_Null (M) t"
},
{
"path": "impls/ada/printer.ads",
"chars": 104,
"preview": "with Types;\n\npackage Printer is\n\n function Pr_Str (M : Types.Mal_Handle) return String;\n\nend Printer;\n"
},
{
"path": "impls/ada/reader.adb",
"chars": 11064,
"preview": "with Ada.IO_Exceptions;\nwith Ada.Characters.Latin_1;\nwith Ada.Exceptions;\nwith Ada.Strings.Maps.Constants;\nwith Ada.Stri"
},
{
"path": "impls/ada/reader.ads",
"chars": 240,
"preview": "with Types;\n\npackage Reader is\n\n -- This is the Parser (returns an AST)\n function Read_Str (S : String) return Types"
},
{
"path": "impls/ada/run",
"chars": 65,
"preview": "#!/usr/bin/env bash\nexec $(dirname $0)/${STEP:-stepA_mal} \"${@}\"\n"
},
{
"path": "impls/ada/smart_pointers.adb",
"chars": 1231,
"preview": "with Ada.Unchecked_Deallocation;\n\npackage body Smart_Pointers is\n\n\n function New_Ptr (Base_Class : Base_Class_Accessor"
},
{
"path": "impls/ada/smart_pointers.ads",
"chars": 989,
"preview": "with Ada.Finalization;\n\npackage Smart_Pointers is\n\n -- Classes we want to track derrive from Base Class.\n type Base_"
},
{
"path": "impls/ada/step0_repl.adb",
"chars": 730,
"preview": "with Ada.Text_IO;\n\nprocedure Step0_Repl is\n\n function Read (Param : String) return String is\n begin\n return Par"
},
{
"path": "impls/ada/step1_read_print.adb",
"chars": 932,
"preview": "with Ada.Text_IO;\nwith Printer;\nwith Reader;\nwith Types;\n\nprocedure Step1_Read_Print is\n\n function Read (Param : Strin"
},
{
"path": "impls/ada/step2_eval.adb",
"chars": 6308,
"preview": "with Ada.Containers.Hashed_Maps;\nwith Ada.Strings.Unbounded.Hash;\nwith Ada.Text_IO;\nwith Ada.Exceptions;\nwith Printer;\nw"
},
{
"path": "impls/ada/step3_env.adb",
"chars": 7290,
"preview": "with Ada.Command_Line;\nwith Ada.Exceptions;\nwith Ada.Text_IO;\nwith Envs;\nwith Eval_Callback;\nwith Printer;\nwith Reader;\n"
},
{
"path": "impls/ada/step4_if_fn_do.adb",
"chars": 9129,
"preview": "with Ada.Command_Line;\nwith Ada.Exceptions;\nwith Ada.Text_IO;\nwith Core;\nwith Envs;\nwith Eval_Callback;\nwith Printer;\nwi"
},
{
"path": "impls/ada/step5_tco.adb",
"chars": 10463,
"preview": "with Ada.Command_Line;\nwith Ada.Exceptions;\nwith Ada.Text_IO;\nwith Core;\nwith Envs;\nwith Eval_Callback;\nwith Printer;\nwi"
},
{
"path": "impls/ada/step6_file.adb",
"chars": 11629,
"preview": "with Ada.Command_Line;\nwith Ada.Exceptions;\nwith Ada.Text_IO;\nwith Core;\nwith Envs;\nwith Eval_Callback;\nwith Printer;\nwi"
},
{
"path": "impls/ada/step7_quote.adb",
"chars": 14322,
"preview": "with Ada.Command_Line;\nwith Ada.Exceptions;\nwith Ada.Text_IO;\nwith Core;\nwith Envs;\nwith Eval_Callback;\nwith Printer;\nwi"
},
{
"path": "impls/ada/step8_macros.adb",
"chars": 15567,
"preview": "with Ada.Command_Line;\nwith Ada.Exceptions;\nwith Ada.Text_IO;\nwith Core;\nwith Envs;\nwith Eval_Callback;\nwith Printer;\nwi"
},
{
"path": "impls/ada/step9_try.adb",
"chars": 17230,
"preview": "with Ada.Command_Line;\nwith Ada.Exceptions;\nwith Ada.Text_IO;\nwith Core;\nwith Envs;\nwith Eval_Callback;\nwith Printer;\nwi"
},
{
"path": "impls/ada/stepa_mal.adb",
"chars": 17291,
"preview": "with Ada.Command_Line;\nwith Ada.Exceptions;\nwith Ada.Text_IO;\nwith Core;\nwith Envs;\nwith Eval_Callback;\nwith Printer;\nwi"
},
{
"path": "impls/ada/types-hash_map.adb",
"chars": 8604,
"preview": "with Ada.Strings.Unbounded.Hash;\nwith Smart_Pointers;\n\npackage body Types.Hash_Map is\n\n function \"=\" (A, B : Hash_Map_"
},
{
"path": "impls/ada/types-hash_map.ads",
"chars": 2601,
"preview": "with Ada.Containers.Hashed_Maps;\nwith Smart_Pointers;\nwith Envs;\n\npackage Types.Hash_Map is\n\n type Hash_Map_Mal_Type i"
},
{
"path": "impls/ada/types-vector.adb",
"chars": 5456,
"preview": "with Ada.Strings.Unbounded;\nwith Ada.Text_IO;\nwith Eval_Callback;\n\npackage body Types.Vector is\n\n\n function New_Vector"
},
{
"path": "impls/ada/types-vector.ads",
"chars": 1903,
"preview": "with Ada.Containers.Vectors;\nwith Ada.Strings.Unbounded;\nwith Smart_Pointers;\nwith Envs;\n\npackage Types.Vector is\n\n ty"
},
{
"path": "impls/ada/types.adb",
"chars": 31977,
"preview": "with Ada.Characters.Latin_1;\nwith Ada.Strings.Fixed;\nwith Ada.Strings.Maps.Constants;\nwith Ada.Text_IO;\nwith Ada.Uncheck"
},
{
"path": "impls/ada/types.ads",
"chars": 13000,
"preview": "-- This started out as a simple public variant record.\n-- Then smart pointers were added. They were part of the Mal_Typ"
},
{
"path": "impls/ada.2/Dockerfile",
"chars": 653,
"preview": "FROM ubuntu:24.04\nMAINTAINER Joel Martin <github@martintribe.org>\n\n#####################################################"
},
{
"path": "impls/ada.2/Makefile",
"chars": 1866,
"preview": "ifdef DEBUG\n ADAFLAGS := -Wall -Wextra -gnatw.eH.Y -gnatySdouxy -gnatVa -g -gnataEfoqQ \\\n -fstack-check -pg\n LDFLAG"
},
{
"path": "impls/ada.2/README",
"chars": 2164,
"preview": "Comparison with the first Ada implementation.\n--\n\nThe first implementation was deliberately compatible with all Ada\ncomp"
},
{
"path": "impls/ada.2/core.adb",
"chars": 17843,
"preview": "with Ada.Calendar;\nwith Ada.Characters.Latin_1;\nwith Ada.Strings.Unbounded;\nwith Ada.Text_IO.Unbounded_IO;\n\nwith Err;\nwi"
},
{
"path": "impls/ada.2/core.ads",
"chars": 121,
"preview": "with Envs;\n\npackage Core is\n\n procedure NS_Add_To_Repl (Repl : in Envs.Ptr);\n -- Add built-in functions.\n\nend Core;"
},
{
"path": "impls/ada.2/envs.adb",
"chars": 4175,
"preview": "with Ada.Text_IO.Unbounded_IO;\n\nwith Err;\nwith Printer;\nwith Types.Sequences;\n\npackage body Envs is\n\n use all type Typ"
},
{
"path": "impls/ada.2/envs.ads",
"chars": 1983,
"preview": "private with Ada.Containers.Hashed_Maps;\n\nwith Garbage_Collected;\nwith Types.Strings;\n\npackage Envs is\n\n -- This pack"
},
{
"path": "impls/ada.2/err.adb",
"chars": 1969,
"preview": "with Ada.Characters.Latin_1;\n\nwith Printer;\nwith Types.Strings;\n\npackage body Err is\n\n use Ada.Strings.Unbounded;\n\n "
},
{
"path": "impls/ada.2/err.ads",
"chars": 1574,
"preview": "with Ada.Exceptions;\nwith Ada.Strings.Unbounded;\n\nwith Types;\n-- We declare a variable of type Types.T.\npragma Elaborat"
},
{
"path": "impls/ada.2/garbage_collected.adb",
"chars": 1362,
"preview": "with Ada.Unchecked_Deallocation;\n\npackage body Garbage_Collected is\n\n procedure Free is new Ada.Unchecked_Deallocation"
},
{
"path": "impls/ada.2/garbage_collected.ads",
"chars": 1620,
"preview": "package Garbage_Collected is\n\n -- A generic would not be convenient for lists. We want the\n -- extended type to be"
},
{
"path": "impls/ada.2/printer.adb",
"chars": 5613,
"preview": "with Ada.Characters.Latin_1;\n\nwith Types.Atoms;\nwith Types.Fns;\nwith Types.Maps;\npragma Warnings (Off, \"unit \"\"Types.Seq"
},
{
"path": "impls/ada.2/printer.ads",
"chars": 547,
"preview": "with Ada.Strings.Unbounded;\n\nwith Types;\n\npackage Printer is\n\n procedure Pr_Str\n (Buffer : in out Ada.Strings.Un"
},
{
"path": "impls/ada.2/reader.adb",
"chars": 9309,
"preview": "with Ada.Characters.Handling;\nwith Ada.Characters.Latin_1;\nwith Ada.Environment_Variables;\nwith Ada.Strings.Maps.Constan"
},
{
"path": "impls/ada.2/reader.ads",
"chars": 281,
"preview": "with Types;\n\npackage Reader is\n\n function Read_Str (Source : in String) return Types.T_Array;\n -- The language does"
},
{
"path": "impls/ada.2/readline.adb",
"chars": 895,
"preview": "with Interfaces.C.Strings;\n\npackage body Readline is\n\n function Input (Prompt : in String) return String is\n\n use"
},
{
"path": "impls/ada.2/readline.ads",
"chars": 119,
"preview": "package Readline is\n\n function Input (Prompt : in String) return String;\n\n End_Of_File : exception;\n\nend Readline;\n"
},
{
"path": "impls/ada.2/run",
"chars": 55,
"preview": "#!/bin/sh\nexec $(dirname $0)/${STEP:-stepA_mal} \"${@}\"\n"
},
{
"path": "impls/ada.2/step0_repl.adb",
"chars": 909,
"preview": "with Ada.Text_IO;\n\nwith Readline;\n\nprocedure Step0_Repl is\n\n function Read return String with Inline;\n\n function Eva"
},
{
"path": "impls/ada.2/step1_read_print.adb",
"chars": 1666,
"preview": "with Ada.Text_IO.Unbounded_IO;\n\nwith Err;\nwith Garbage_Collected;\nwith Printer;\nwith Reader;\nwith Readline;\nwith Types;\n"
},
{
"path": "impls/ada.2/step2_eval.adb",
"chars": 6044,
"preview": "with Ada.Containers.Indefinite_Hashed_Maps;\nwith Ada.Strings.Hash;\nwith Ada.Text_IO.Unbounded_IO;\n\nwith Err;\nwith Garbag"
},
{
"path": "impls/ada.2/step3_env.adb",
"chars": 7469,
"preview": "with Ada.Text_IO.Unbounded_IO;\n\nwith Envs;\nwith Err;\nwith Garbage_Collected;\nwith Printer;\nwith Reader;\nwith Readline;\nw"
},
{
"path": "impls/ada.2/step4_if_fn_do.adb",
"chars": 8653,
"preview": "with Ada.Text_IO.Unbounded_IO;\n\nwith Core;\nwith Envs;\nwith Err;\nwith Garbage_Collected;\nwith Printer;\nwith Reader;\nwith "
},
{
"path": "impls/ada.2/step5_tco.adb",
"chars": 9805,
"preview": "with Ada.Text_IO.Unbounded_IO;\n\nwith Core;\nwith Envs;\nwith Err;\nwith Garbage_Collected;\nwith Printer;\nwith Reader;\nwith "
},
{
"path": "impls/ada.2/step6_file.adb",
"chars": 11080,
"preview": "with Ada.Command_Line;\nwith Ada.Text_IO.Unbounded_IO;\n\nwith Core;\nwith Envs;\nwith Err;\nwith Garbage_Collected;\nwith Prin"
},
{
"path": "impls/ada.2/step7_quote.adb",
"chars": 13670,
"preview": "with Ada.Command_Line;\nwith Ada.Text_IO.Unbounded_IO;\n\nwith Core;\nwith Envs;\nwith Err;\nwith Garbage_Collected;\nwith Prin"
},
{
"path": "impls/ada.2/step8_macros.adb",
"chars": 14984,
"preview": "with Ada.Command_Line;\nwith Ada.Text_IO.Unbounded_IO;\n\nwith Core;\nwith Envs;\nwith Err;\nwith Garbage_Collected;\nwith Prin"
},
{
"path": "impls/ada.2/step9_try.adb",
"chars": 16173,
"preview": "with Ada.Command_Line;\nwith Ada.Text_IO.Unbounded_IO;\n\nwith Core;\nwith Envs;\nwith Err;\nwith Garbage_Collected;\nwith Prin"
},
{
"path": "impls/ada.2/stepa_mal.adb",
"chars": 16472,
"preview": "with Ada.Command_Line;\nwith Ada.Text_IO.Unbounded_IO;\n\nwith Core;\nwith Envs;\nwith Err;\nwith Garbage_Collected;\nwith Prin"
},
{
"path": "impls/ada.2/types-atoms.adb",
"chars": 2014,
"preview": "with Err;\nwith Types.Builtins;\nwith Types.Fns;\n\npackage body Types.Atoms is\n\n function Atom (Args : in T_Array) return"
},
{
"path": "impls/ada.2/types-atoms.ads",
"chars": 638,
"preview": "with Garbage_Collected;\n\npackage Types.Atoms is\n\n type Instance (<>) is abstract new Garbage_Collected.Instance with p"
},
{
"path": "impls/ada.2/types-builtins.adb",
"chars": 986,
"preview": "package body Types.Builtins is\n\n function Builtin (Item : in Instance) return Builtin_Ptr\n is (Item.F_Builtin);\n\n "
},
{
"path": "impls/ada.2/types-builtins.ads",
"chars": 923,
"preview": "with Garbage_Collected;\n\npackage Types.Builtins is\n\n -- Types.Mal.Builtin_Ptr is efficient and sufficient for most\n "
},
{
"path": "impls/ada.2/types-fns.adb",
"chars": 1907,
"preview": "with Err;\npragma Warnings (Off, \"unit \"\"Types.Sequences\"\" is not referenced\");\nwith Types.Sequences;\npragma Warnings (On"
},
{
"path": "impls/ada.2/types-fns.ads",
"chars": 1450,
"preview": "with Envs;\nwith Garbage_Collected;\n\npackage Types.Fns is\n\n Eval_Cb : access function (Ast : in T;\n "
},
{
"path": "impls/ada.2/types-maps.adb",
"chars": 6228,
"preview": "with Err;\nwith Types.Sequences;\nwith Types.Strings;\n\npackage body Types.Maps is\n\n use type HM.Map;\n\n function Assoc "
},
{
"path": "impls/ada.2/types-maps.ads",
"chars": 2403,
"preview": "private with Ada.Containers.Hashed_Maps;\n\nwith Garbage_Collected;\n\npackage Types.Maps is\n\n -- All function receiving "
},
{
"path": "impls/ada.2/types-sequences.adb",
"chars": 7537,
"preview": "with Err;\nwith Types.Fns;\nwith Types.Builtins;\n\npackage body Types.Sequences is\n\n function \"=\" (Left, Right : in Insta"
},
{
"path": "impls/ada.2/types-sequences.ads",
"chars": 1464,
"preview": "with Garbage_Collected;\n\npackage Types.Sequences is\n\n -- Hiding the implementation would either cause a significative"
},
{
"path": "impls/ada.2/types-strings.adb",
"chars": 984,
"preview": "with Ada.Strings.Hash;\n\npackage body Types.Strings is\n\n function \"=\" (Left : in Instance;\n Right : in"
},
{
"path": "impls/ada.2/types-strings.ads",
"chars": 1582,
"preview": "with Ada.Containers;\n\nwith Garbage_Collected;\n\npackage Types.Strings is\n\n ------------------------------------\n -- "
},
{
"path": "impls/ada.2/types.adb",
"chars": 2088,
"preview": "pragma Warnings (Off, \"no entities of \"\"Types.*\"\" are referenced\");\nwith Types.Atoms;\nwith Types.Builtins;\nwith Types.Fn"
},
{
"path": "impls/ada.2/types.ads",
"chars": 3333,
"preview": "limited with Types.Atoms;\nlimited with Types.Builtins;\nlimited with Types.Fns;\nlimited with Types.Maps;\nlimited with Typ"
},
{
"path": "impls/awk/Dockerfile",
"chars": 628,
"preview": "FROM ubuntu:20.04\nMAINTAINER Joel Martin <github@martintribe.org>\n\n#####################################################"
},
{
"path": "impls/awk/Makefile",
"chars": 397,
"preview": "SOURCES_BASE = types.awk reader.awk printer.awk\nSOURCES_LISP = env.awk core.awk stepA_mal.awk\nSOURCES = $(SOURCES_BASE) "
},
{
"path": "impls/awk/core.awk",
"chars": 37029,
"preview": "@load \"readfile\"\n@load \"time\"\n\nfunction core_eq_sub(lhs, rhs, i, len)\n{\n\tif (lhs ~ /^[([]/ && rhs ~ /^[([]/) {\n\t\tlhs "
},
{
"path": "impls/awk/env.awk",
"chars": 2747,
"preview": "function env_new(outer, params, args, idx, len, i, j, lst, param)\n{\n\tif (params != \"\") {\n\t\tparams = substr(params, 2)"
},
{
"path": "impls/awk/printer.awk",
"chars": 1863,
"preview": "function printer_pr_list(expr, print_readably, idx, len, i, str)\n{\n\tidx = substr(expr, 2)\n\tlen = types_heap[idx][\"len"
},
{
"path": "impls/awk/reader.awk",
"chars": 4007,
"preview": "function reader_read_string(token, v, r)\n{\n\ttoken = substr(token, 1, length(token) - 1)\n\tgsub(/\\\\\\\\/, \"\\xf7\", token)\n"
},
{
"path": "impls/awk/run",
"chars": 79,
"preview": "#!/usr/bin/env bash\nexec awk -O -f $(dirname $0)/${STEP:-stepA_mal}.awk \"${@}\"\n"
},
{
"path": "impls/awk/step0_repl.awk",
"chars": 307,
"preview": "function READ(str)\n{\n\treturn str\n}\n\nfunction EVAL(ast)\n{\n\treturn ast\n}\n\nfunction PRINT(expr)\n{\n\treturn expr\n}\n\nfunction "
},
{
"path": "impls/awk/step1_read_print.awk",
"chars": 623,
"preview": "@include \"types.awk\"\n@include \"reader.awk\"\n@include \"printer.awk\"\n\nfunction READ(str)\n{\n\treturn reader_read_str(str)\n}\n\n"
},
{
"path": "impls/awk/step2_eval.awk",
"chars": 5437,
"preview": "@include \"types.awk\"\n@include \"reader.awk\"\n@include \"printer.awk\"\n\nfunction READ(str)\n{\n\treturn reader_read_str(str)\n}\n\n"
},
{
"path": "impls/awk/step3_env.awk",
"chars": 7885,
"preview": "@include \"types.awk\"\n@include \"reader.awk\"\n@include \"printer.awk\"\n@include \"env.awk\"\n\nfunction READ(str)\n{\n\treturn reade"
},
{
"path": "impls/awk/step4_if_fn_do.awk",
"chars": 8507,
"preview": "@include \"types.awk\"\n@include \"reader.awk\"\n@include \"printer.awk\"\n@include \"env.awk\"\n@include \"core.awk\"\n\nfunction READ("
},
{
"path": "impls/awk/step5_tco.awk",
"chars": 8716,
"preview": "@include \"types.awk\"\n@include \"reader.awk\"\n@include \"printer.awk\"\n@include \"env.awk\"\n@include \"core.awk\"\n\nfunction READ("
},
{
"path": "impls/awk/step6_file.awk",
"chars": 9391,
"preview": "@include \"types.awk\"\n@include \"reader.awk\"\n@include \"printer.awk\"\n@include \"env.awk\"\n@include \"core.awk\"\n\nfunction READ("
},
{
"path": "impls/awk/step7_quote.awk",
"chars": 11937,
"preview": "@include \"types.awk\"\n@include \"reader.awk\"\n@include \"printer.awk\"\n@include \"env.awk\"\n@include \"core.awk\"\n\nfunction READ("
},
{
"path": "impls/awk/step8_macros.awk",
"chars": 14041,
"preview": "@include \"types.awk\"\n@include \"reader.awk\"\n@include \"printer.awk\"\n@include \"env.awk\"\n@include \"core.awk\"\n\nfunction READ("
},
{
"path": "impls/awk/step9_try.awk",
"chars": 15916,
"preview": "@include \"types.awk\"\n@include \"reader.awk\"\n@include \"printer.awk\"\n@include \"env.awk\"\n@include \"core.awk\"\n\nfunction READ("
},
{
"path": "impls/awk/stepA_mal.awk",
"chars": 16088,
"preview": "@include \"types.awk\"\n@include \"reader.awk\"\n@include \"printer.awk\"\n@include \"env.awk\"\n@include \"core.awk\"\n\nfunction READ("
},
{
"path": "impls/awk/tests/step5_tco.mal",
"chars": 69,
"preview": ";; awk: skipping non-TCO recursion\n;; Reason: completes up to 50,000\n"
},
{
"path": "impls/awk/types.awk",
"chars": 4604,
"preview": "\n# string\"\n# symbol '\n# keyword :\n# number +\n# nil #\n# true #\n# false #\n# list (\n# vector [\n# hash {\n#"
},
{
"path": "impls/bash/Dockerfile",
"chars": 627,
"preview": "FROM ubuntu:20.04\nMAINTAINER Joel Martin <github@martintribe.org>\n\n#####################################################"
},
{
"path": "impls/bash/Makefile",
"chars": 313,
"preview": "SOURCES_BASE = types.sh reader.sh printer.sh\nSOURCES_LISP = env.sh core.sh stepA_mal.sh\nSOURCES = $(SOURCES_BASE) $(SOUR"
},
{
"path": "impls/bash/core.sh",
"chars": 9033,
"preview": "#\n# mal (Make a Lisp) object types\n#\n\nif [ -z \"${__mal_core_included__}\" ]; then\n__mal_core_included=true\n\nsource $(dirn"
},
{
"path": "impls/bash/env.sh",
"chars": 1967,
"preview": "#\n# mal (Make a Lisp) environment definition\n#\n\nif [ -z \"${__mal_env_included__}\" ]; then\n__mal_env_included=true\n\nsourc"
},
{
"path": "impls/bash/printer.sh",
"chars": 2142,
"preview": "#\n# mal (Make a Lisp) printer\n#\n\nif [ -z \"${__mal_printer_included__}\" ]; then\n__mal_printer_included=true\n\nsource $(dir"
},
{
"path": "impls/bash/reader.sh",
"chars": 5233,
"preview": "#\n# mal (Make Lisp) Parser/Reader\n#\n\nif [ -z \"${__mal_readerr_included__}\" ]; then\n__mal_readerr_included=true\n\nsource $"
},
{
"path": "impls/bash/run",
"chars": 73,
"preview": "#!/usr/bin/env bash\nexec bash $(dirname $0)/${STEP:-stepA_mal}.sh \"${@}\"\n"
},
{
"path": "impls/bash/step0_repl.sh",
"chars": 196,
"preview": "#!/usr/bin/env bash\n\nREAD () {\n read -u 0 -e -p \"user> \" r\n}\n\nEVAL () {\n r=\"${1}\"\n}\n\nPRINT () {\n r=\"${1}\"\n}\n\nwh"
},
{
"path": "impls/bash/step1_read_print.sh",
"chars": 634,
"preview": "#!/usr/bin/env bash\n\nsource $(dirname $0)/reader.sh\nsource $(dirname $0)/printer.sh\n\n# read\nREAD () {\n [ \"${1}\" ] && "
},
{
"path": "impls/bash/step2_eval.sh",
"chars": 2102,
"preview": "#!/usr/bin/env bash\n\nsource $(dirname $0)/reader.sh\nsource $(dirname $0)/printer.sh\n\n# read\nREAD () {\n [ \"${1}\" ] && "
},
{
"path": "impls/bash/step3_env.sh",
"chars": 3248,
"preview": "#!/usr/bin/env bash\n\nsource $(dirname $0)/reader.sh\nsource $(dirname $0)/printer.sh\nsource $(dirname $0)/env.sh\n\n# read\n"
},
{
"path": "impls/bash/step4_if_fn_do.sh",
"chars": 3955,
"preview": "#!/usr/bin/env bash\n\nsource $(dirname $0)/reader.sh\nsource $(dirname $0)/printer.sh\nsource $(dirname $0)/env.sh\nsource $"
},
{
"path": "impls/bash/step5_tco.sh",
"chars": 4494,
"preview": "#!/usr/bin/env bash\n\nsource $(dirname $0)/reader.sh\nsource $(dirname $0)/printer.sh\nsource $(dirname $0)/env.sh\nsource $"
},
{
"path": "impls/bash/step6_file.sh",
"chars": 4922,
"preview": "#!/usr/bin/env bash\n\nsource $(dirname $0)/reader.sh\nsource $(dirname $0)/printer.sh\nsource $(dirname $0)/env.sh\nsource $"
},
{
"path": "impls/bash/step7_quote.sh",
"chars": 6075,
"preview": "#!/usr/bin/env bash\n\nsource $(dirname $0)/reader.sh\nsource $(dirname $0)/printer.sh\nsource $(dirname $0)/env.sh\nsource $"
},
{
"path": "impls/bash/step8_macros.sh",
"chars": 6963,
"preview": "#!/usr/bin/env bash\n\nsource $(dirname $0)/reader.sh\nsource $(dirname $0)/printer.sh\nsource $(dirname $0)/env.sh\nsource $"
},
{
"path": "impls/bash/step9_try.sh",
"chars": 7574,
"preview": "#!/usr/bin/env bash\n\nsource $(dirname $0)/reader.sh\nsource $(dirname $0)/printer.sh\nsource $(dirname $0)/env.sh\nsource $"
},
{
"path": "impls/bash/stepA_mal.sh",
"chars": 8040,
"preview": "#!/usr/bin/env bash\n\nsource $(dirname $0)/reader.sh\nsource $(dirname $0)/printer.sh\nsource $(dirname $0)/env.sh\nsource $"
},
{
"path": "impls/bash/tests/stepA_mal.mal",
"chars": 545,
"preview": ";; Testing basic bash interop\n\n(sh* \"echo 7\")\n;=>\"7\"\n\n(sh* \"echo >&2 hello\")\n;/hello\n;=>\"\"\n\n(sh* \"foo=8; echo ${foo}\")\n;"
},
{
"path": "impls/bash/types.sh",
"chars": 7454,
"preview": "#\n# mal (Make a Lisp) object types\n#\n\nif [ -z \"${__mal_types_included__}\" ]; then\n__mal_types_included=true\n\ndeclare -A "
},
{
"path": "impls/basic/.args.mal",
"chars": 24,
"preview": "(def! -*ARGS*- (list ))\n"
},
{
"path": "impls/basic/Dockerfile",
"chars": 1494,
"preview": "FROM ubuntu:24.04\nMAINTAINER Joel Martin <github@martintribe.org>\n\n#####################################################"
},
{
"path": "impls/basic/Makefile",
"chars": 1407,
"preview": "basic_MODE = cbm\nBASICPP_OPTS = --mode $(basic_MODE)\n\nFBC = fbc -lang qb\n\nSTEPS4_A = step4_if_fn_do.bas step5_tco.bas st"
},
{
"path": "impls/basic/basicpp.py",
"chars": 11630,
"preview": "#!/usr/bin/env python\n\nfrom __future__ import print_function\nimport argparse\nimport re\nimport sys\n\ndef debug(*args, **kw"
},
{
"path": "impls/basic/cbmbasic_console.patch",
"chars": 966,
"preview": "diff --git a/runtime.c b/runtime.c\nindex 3066580..c635bd4 100644\n--- a/runtime.c\n+++ b/runtime.c\n@@ -535,7 +535,8 @@ pri"
},
{
"path": "impls/basic/core.in.bas",
"chars": 16194,
"preview": "REM APPLY should really be in types.in.bas but it is here because it\nREM calls DO_TCO_FUNCTION so it will cause syntax e"
},
{
"path": "impls/basic/debug.in.bas",
"chars": 6810,
"preview": "REM CHECK_FREE_LIST() -> P2\nCHECK_FREE_LIST:\n REM start and accumulator\n P1=ZK\n P2=0\n CHECK_FREE_LIST_LOOP:\n IF P"
},
{
"path": "impls/basic/env.in.bas",
"chars": 1677,
"preview": "\nREM ENV_NEW(C) -> R\nENV_NEW:\n REM allocate the data hashmap\n GOSUB HASHMAP\n AY=R\n\n REM set the outer and data point"
},
{
"path": "impls/basic/mem.in.bas",
"chars": 10823,
"preview": "REM Memory layout:\nREM\nREM type bytes\nREM ---------- ----------\nREM nil ref/ 0 | 0 "
},
{
"path": "impls/basic/printer.in.bas",
"chars": 3122,
"preview": "REM PR_STR(AZ, B) -> R$\nPR_STR:\n R$=\"\"\n PR_STR_RECUR:\n T=Z%(AZ)AND 31\n U=Z%(AZ+1)\n REM PRINT \"AZ: \"+STR$(AZ)+\", T: "
},
{
"path": "impls/basic/reader.in.bas",
"chars": 7595,
"preview": "REM READ_TOKEN(RF=0, A$, RI) -> T$\nREM READ_TOKEN(RF=1) -> T$\nREAD_TOKEN:\n IF RF=1 THEN RF=2:T$=\"(\":RETURN\n IF RF=2 TH"
},
{
"path": "impls/basic/readline.in.bas",
"chars": 789,
"preview": "REM READLINE(A$) -> R$\nREADLINE:\n EZ=0\n PRINT A$;\n C$=\"\":R$=\"\":C=0\n READCH:\n #cbm GET C$\n #qbasic C$=INKEY$\n "
},
{
"path": "impls/basic/run",
"chars": 333,
"preview": "#!/usr/bin/env bash\ncd $(dirname $0)\n(echo \"(def! -*ARGS*- (list $(for a in \"${@}\"; do echo -n \" \\\"${a}\\\"\"; done)))\") > "
},
{
"path": "impls/basic/step0_repl.in.bas",
"chars": 628,
"preview": "GOTO MAIN\n\nREM $INCLUDE: 'mem.in.bas'\nREM $INCLUDE: 'readline.in.bas'\n\nREM $INCLUDE: 'debug.in.bas'\n\nREM READ is inlined"
},
{
"path": "impls/basic/step1_read_print.in.bas",
"chars": 1298,
"preview": "GOTO MAIN\n\nREM $INCLUDE: 'mem.in.bas'\nREM $INCLUDE: 'types.in.bas'\nREM $INCLUDE: 'readline.in.bas'\nREM $INCLUDE: 'reader"
},
{
"path": "impls/basic/step2_eval.in.bas",
"chars": 5559,
"preview": "GOTO MAIN\n\nREM $INCLUDE: 'mem.in.bas'\nREM $INCLUDE: 'types.in.bas'\nREM $INCLUDE: 'readline.in.bas'\nREM $INCLUDE: 'reader"
},
{
"path": "impls/basic/step3_env.in.bas",
"chars": 7304,
"preview": "GOTO MAIN\n\nREM $INCLUDE: 'mem.in.bas'\nREM $INCLUDE: 'types.in.bas'\nREM $INCLUDE: 'readline.in.bas'\nREM $INCLUDE: 'reader"
},
{
"path": "impls/basic/step4_if_fn_do.in.bas",
"chars": 9026,
"preview": "GOTO MAIN\n\nREM $INCLUDE: 'mem.in.bas'\nREM $INCLUDE: 'types.in.bas'\nREM $INCLUDE: 'readline.in.bas'\nREM $INCLUDE: 'reader"
},
{
"path": "impls/basic/step5_tco.in.bas",
"chars": 9796,
"preview": "GOTO MAIN\n\nREM $INCLUDE: 'mem.in.bas'\nREM $INCLUDE: 'types.in.bas'\nREM $INCLUDE: 'readline.in.bas'\nREM $INCLUDE: 'reader"
},
{
"path": "impls/basic/step6_file.in.bas",
"chars": 10538,
"preview": "GOTO MAIN\n\nREM $INCLUDE: 'mem.in.bas'\nREM $INCLUDE: 'types.in.bas'\nREM $INCLUDE: 'readline.in.bas'\nREM $INCLUDE: 'reader"
},
{
"path": "impls/basic/step7_quote.in.bas",
"chars": 13474,
"preview": "GOTO MAIN\n\nREM $INCLUDE: 'mem.in.bas'\nREM $INCLUDE: 'types.in.bas'\nREM $INCLUDE: 'readline.in.bas'\nREM $INCLUDE: 'reader"
},
{
"path": "impls/basic/step8_macros.in.bas",
"chars": 15055,
"preview": "GOTO MAIN\n\nREM $INCLUDE: 'mem.in.bas'\nREM $INCLUDE: 'types.in.bas'\nREM $INCLUDE: 'readline.in.bas'\nREM $INCLUDE: 'reader"
},
{
"path": "impls/basic/step9_try.in.bas",
"chars": 16068,
"preview": "GOTO MAIN\n\nREM $INCLUDE: 'mem.in.bas'\nREM $INCLUDE: 'types.in.bas'\nREM $INCLUDE: 'readline.in.bas'\nREM $INCLUDE: 'reader"
},
{
"path": "impls/basic/stepA_mal.in.bas",
"chars": 16467,
"preview": "GOTO MAIN\n\nREM $INCLUDE: 'mem.in.bas'\nREM $INCLUDE: 'types.in.bas'\nREM $INCLUDE: 'readline.in.bas'\nREM $INCLUDE: 'reader"
},
{
"path": "impls/basic/types.in.bas",
"chars": 6902,
"preview": "REM general functions\n\nREM TYPE_A(A) -> T\nTYPE_A:\n T=Z%(A)AND 31\n RETURN\n\nREM TYPE_F(F) -> T\nTYPE_F:\n T=Z%(F)AND 31\n "
},
{
"path": "impls/basic/variables.txt",
"chars": 3296,
"preview": "Global Unique:\n\nZ% : boxed memory values\nZ1 : Z% size\nZ2 : S$ size\nZ3 : stack start address (cbm) or X% size (qbasic"
},
{
"path": "impls/bbc-basic/Dockerfile",
"chars": 620,
"preview": "FROM ubuntu:24.04\nMAINTAINER Joel Martin <github@martintribe.org>\n\n#####################################################"
},
{
"path": "impls/bbc-basic/Makefile",
"chars": 28,
"preview": "all:\n\n.PHONY: clean\n\nclean:\n"
},
{
"path": "impls/bbc-basic/README.md",
"chars": 3013,
"preview": "# Introduction\n\nThis is an implementation of mal in BBC BASIC V. While there\nis already an implementation of mal in BAS"
},
{
"path": "impls/bbc-basic/core.bas",
"chars": 15395,
"preview": "REM > core function library for mal in BBC BASIC\n\nREM BBC BASIC doesn't have function pointers. There are essentially\n"
},
{
"path": "impls/bbc-basic/env.bas",
"chars": 1052,
"preview": "REM > env library for mal in BBC BASIC\n\nDEF FNnew_env(outer%, binds%, exprs%)\n LOCAL env%, key$\n env% = FNalloc_enviro"
},
{
"path": "impls/bbc-basic/printer.bas",
"chars": 2276,
"preview": "REM > printer library for mal in BBC BASIC\n\nDEF FNpr_str(val%, print_readably%)\n LOCAL ret%, term$, val$, keys%, vals%\n"
},
{
"path": "impls/bbc-basic/reader.bas",
"chars": 6992,
"preview": "REM > reader library for mal in BBC BASIC\n\nREM ** Reader **\n\nREM The Reader object is implemented as an array and a mu"
},
{
"path": "impls/bbc-basic/riscos/.gitignore",
"chars": 6,
"preview": "*,ffb\n"
},
{
"path": "impls/bbc-basic/riscos/setup,feb",
"chars": 90,
"preview": "| This Obey file sets up the environment for running mal on RISC OS.\nBASIC { < tokenize }\n"
},
{
"path": "impls/bbc-basic/riscos/tokenize,ffe",
"chars": 775,
"preview": "REM Tokenizing libraries...\nTEXTLOAD \"^.core/bas\"\nSAVE \"core\"\nTEXTLOAD \"^.env/bas\"\nSAVE \"env\"\nTEXTLOAD \"^.printer/bas\"\nS"
},
{
"path": "impls/bbc-basic/run",
"chars": 133,
"preview": "#!/usr/bin/env bash\nexec \"${BRANDY:-sbrandy}\" -size 1024k \\\n -path ../bbc-basic -quit $(dirname $0)/${STEP:-stepA_mal"
},
{
"path": "impls/bbc-basic/step0_repl.bas",
"chars": 279,
"preview": "REM Step 0 of mal in BBC BASIC\n\nREPEAT\n PRINT \"user> \";\n LINE INPUT \"\" line$\n PRINT FNrep(line$)\nUNTIL FALSE\n\nEND\n\nDE"
},
{
"path": "impls/bbc-basic/step1_read_print.bas",
"chars": 592,
"preview": "REM Step 1 of mal in BBC BASIC\n\nLIBRARY \"types\"\nLIBRARY \"reader\"\nLIBRARY \"printer\"\n\nPROCtypes_init\n\nsav% = FNgc_save\nREP"
},
{
"path": "impls/bbc-basic/step2_eval.bas",
"chars": 2378,
"preview": "REM Step 2 of mal in BBC BASIC\n\nLIBRARY \"types\"\nLIBRARY \"reader\"\nLIBRARY \"printer\"\n\nPROCtypes_init\n\nREM These correspon"
},
{
"path": "impls/bbc-basic/step3_env.bas",
"chars": 3133,
"preview": "REM Step 3 of mal in BBC BASIC\n\nLIBRARY \"types\"\nLIBRARY \"reader\"\nLIBRARY \"printer\"\nLIBRARY \"env\"\n\nPROCtypes_init\n\nREM T"
},
{
"path": "impls/bbc-basic/step4_if_fn_do.bas",
"chars": 3407,
"preview": "REM Step 4 of mal in BBC BASIC\n\nLIBRARY \"types\"\nLIBRARY \"reader\"\nLIBRARY \"printer\"\nLIBRARY \"env\"\nLIBRARY \"core\"\n\nPROCtyp"
},
{
"path": "impls/bbc-basic/step5_tco.bas",
"chars": 3981,
"preview": "REM Step 5 of mal in BBC BASIC\n\nLIBRARY \"types\"\nLIBRARY \"reader\"\nLIBRARY \"printer\"\nLIBRARY \"env\"\nLIBRARY \"core\"\n\nPROCtyp"
},
{
"path": "impls/bbc-basic/step6_file.bas",
"chars": 5951,
"preview": "REM Step 6 of mal in BBC BASIC\n\nLIBRARY \"types\"\nLIBRARY \"reader\"\nLIBRARY \"printer\"\nLIBRARY \"env\"\nLIBRARY \"core\"\n\nPROCtyp"
},
{
"path": "impls/bbc-basic/step7_quote.bas",
"chars": 6918,
"preview": "REM Step 7 of mal in BBC BASIC\n\nLIBRARY \"types\"\nLIBRARY \"reader\"\nLIBRARY \"printer\"\nLIBRARY \"env\"\nLIBRARY \"core\"\n\nPROCtyp"
}
]
// ... and 2241 more files (download for full content)
About this extraction
This page contains the full source code of the kanaka/mal GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 2441 files (11.2 MB), approximately 3.1M tokens, and a symbol index with 5504 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.