MAL implementation in Modula-2.

This implementation uses the GNU Modula2 compiler and
it runs all sets and test suites. Dockerfile is availabe for systems without a gm2 compiler.

The implemention was harder than I expected. I worked with modula-2 twice in my early jobs.
And I have fond memories of it. This work has also served as a reminder of those early days
when everything was yet to be built, and we reinvented the wheel continously.

Summary
-------

* All steps implemented, Pass all tests.
* Do not use modula2 ALLOCATE, details below.
* Do not have a garbage collector.

GM2 Compiler
------------
Having a GM2 compiler was the key enabler of this implementation, furthermore it includes the PIM and ISO libraries.

I realized there was a modula-2 compiler two years ago, despite it have been available for more than ten years.
Knowing the compiler was available, the only remaining challenge was finding enough time to dedicate to the project.

GM2 ALLOCATE/NEW
----------------
50% of the project was fighting with the ALLOCATE/NEW to reserve memory. It's slow.
ALLOCATE / NEW also tracks every reserved object in a list. Some of the steps make heavy use of dynamic memory, and the
ALLOCATE is really slow due to the objet tracking management. By step 5 i give up, and started using malloc.
It was soo slow that the TCO test timeout despite the tail call optimization was workin was working..

Garbage collector
-----------------
I intend to implement a Garbage Collector (Mark-and-Sweep or Cheney-style copying), if I can allocate additional time.

Run Suite
---------
$ make "docker-build^modula2"
$ make DOCKERIZE=1 "test^modula2"

Thanks
------
Obviously this implementation wasn't posible without the work of Niklaus Wirth and Gaius Mulley.

Author: zawaza-blog

Makefile.impls

@@ -35,7 +35,7 @@ wasm_MODE = wasmtime
 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 \
+	matlab miniMAL modula2 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
 
@@ -157,6 +157,7 @@ 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
+modula2_STEP_TO_PROG =       impls/modula2/$($(1))
 nasm_STEP_TO_PROG =          impls/nasm/$($(1))
 nim_STEP_TO_PROG =           impls/nim/$($(1))
 objc_STEP_TO_PROG =          impls/objc/$($(1))

README.md

@@ -97,6 +97,7 @@ FAQ](docs/FAQ.md) where I attempt to answer some common questions.
 | [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) |
+| [Modula2](#Modula2) | [Jose Rubio](https://github.com/zawaza-blog) |
 | [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)  |
@@ -764,6 +765,16 @@ cd impls/make
 make -f stepX_YYY.mk
 ```
 
+### Modula2
+
+The Modula-2 implementation of mal is written with the GNU Modula-2.  
+It has been tested with Ubuntu 24 and gm2 13.3
+
+```
+make "docker-build^modula2"
+make DOCKERIZE=1 "test^modula2"
+```
+
 ### NASM
 
 The NASM implementation of mal is written for x86-64 Linux, and has been tested

impls/modula2/Core.def

@@ -0,0 +1,103 @@
+DEFINITION MODULE Core;
+
+(* MAL Core Functions - Definition Module *)
+
+FROM Types IMPORT MalVal;
+FROM Env IMPORT Env;
+
+(* Evaluator procedure type - for passing EVAL to Core *)
+TYPE
+  EvalProc = PROCEDURE(MalVal, Env): MalVal;
+
+(* Arithmetic operations *)
+PROCEDURE Add(args: MalVal): MalVal;
+PROCEDURE Sub(args: MalVal): MalVal;
+PROCEDURE Mul(args: MalVal): MalVal;
+PROCEDURE Div(args: MalVal): MalVal;
+
+(* Comparison operations *)
+PROCEDURE Equal(args: MalVal): MalVal;
+PROCEDURE LessThan(args: MalVal): MalVal;
+PROCEDURE LessThanOrEqual(args: MalVal): MalVal;
+PROCEDURE GreaterThan(args: MalVal): MalVal;
+PROCEDURE GreaterThanOrEqual(args: MalVal): MalVal;
+
+(* Logical operations *)
+PROCEDURE NotFn(args: MalVal): MalVal;
+
+(* List operations *)
+PROCEDURE MakeList(args: MalVal): MalVal;
+PROCEDURE MakeVector(args: MalVal): MalVal;
+PROCEDURE MakeHashMap(args: MalVal): MalVal;
+PROCEDURE NormalizeHashMap(hmap: MalVal): MalVal;
+PROCEDURE GetFn(args: MalVal): MalVal;
+PROCEDURE AssocFn(args: MalVal): MalVal;
+PROCEDURE ContainsFn(args: MalVal): MalVal;
+PROCEDURE DissocFn(args: MalVal): MalVal;
+PROCEDURE KeysFn(args: MalVal): MalVal;
+PROCEDURE ValsFn(args: MalVal): MalVal;
+PROCEDURE IsListFn(args: MalVal): MalVal;
+PROCEDURE IsEmptyFn(args: MalVal): MalVal;
+PROCEDURE CountFn(args: MalVal): MalVal;
+PROCEDURE ConsFn(args: MalVal): MalVal;
+PROCEDURE ConcatFn(args: MalVal): MalVal;
+PROCEDURE VecFn(args: MalVal): MalVal;
+PROCEDURE NthFn(args: MalVal): MalVal;
+PROCEDURE FirstFn(args: MalVal): MalVal;
+PROCEDURE RestFn(args: MalVal): MalVal;
+
+(* Quasiquote support *)
+PROCEDURE Quasiquote(ast: MalVal): MalVal;
+
+(* Atom operations *)
+PROCEDURE AtomFn(args: MalVal): MalVal;
+PROCEDURE IsAtomFn(args: MalVal): MalVal;
+PROCEDURE DerefFn(args: MalVal): MalVal;
+PROCEDURE ResetFn(args: MalVal): MalVal;
+PROCEDURE SwapFn(args: MalVal): MalVal;
+
+(* Macro operations *)
+PROCEDURE IsMacroFn(args: MalVal): MalVal;
+
+(* Exception operations *)
+PROCEDURE ThrowFn(args: MalVal): MalVal;
+
+(* Type predicates *)
+PROCEDURE NilPredFn(args: MalVal): MalVal;
+PROCEDURE TruePredFn(args: MalVal): MalVal;
+PROCEDURE FalsePredFn(args: MalVal): MalVal;
+PROCEDURE SymbolPredFn(args: MalVal): MalVal;
+PROCEDURE KeywordPredFn(args: MalVal): MalVal;
+PROCEDURE SequentialPredFn(args: MalVal): MalVal;
+PROCEDURE VectorPredFn(args: MalVal): MalVal;
+PROCEDURE MapPredFn(args: MalVal): MalVal;
+
+(* Symbol and keyword constructors *)
+PROCEDURE SymbolFn(args: MalVal): MalVal;
+PROCEDURE KeywordFn(args: MalVal): MalVal;
+
+(* Functional programming *)
+PROCEDURE ApplyFn(args: MalVal): MalVal;
+PROCEDURE MapFn(args: MalVal): MalVal;
+
+(* Function parameter binding *)
+PROCEDURE BindFunctionParams(params: MalVal; args: MalVal; env: Env): BOOLEAN;
+
+(* String/IO operations *)
+PROCEDURE ReadStringFn(args: MalVal): MalVal;
+PROCEDURE SlurpFn(args: MalVal): MalVal;
+
+(* Evaluation *)
+PROCEDURE EvalFn(args: MalVal): MalVal;
+
+(* Printing operations *)
+PROCEDURE PrStrFn(args: MalVal): MalVal;
+PROCEDURE StrFn(args: MalVal): MalVal;
+PROCEDURE PrnFn(args: MalVal): MalVal;
+PROCEDURE PrintlnFn(args: MalVal): MalVal;
+
+(* REPL environment initialization *)
+PROCEDURE SetEvaluator(evalProc: EvalProc);
+PROCEDURE InitReplEnv(argc: CARDINAL): Env;
+
+END Core.