kanaka/mal

Features

• Interpreter Implementations - Implements a functional Lisp interpreter from scratch to demonstrate core language design principles.
• Pedagogical Interpreters - Provides a pedagogical implementation of a Lisp interpreter designed to teach core language internals.
• Programming Language Education - Provides a structured technical guide to teach core programming language concepts like ASTs and lexical scoping.
• Language Implementation Frameworks - Provides a framework for implementing a custom programming language with specific syntax and evaluation logic.
• Expression Evaluators - Provides a recursive evaluation engine that processes S-expression abstract syntax trees.
• Function Definitions - Supports the definition of user-created functions and closures that capture the surrounding lexical environment.
• Host Runtime Integration - Provides an execution layer that allows the Lisp interpreter to call JavaScript functions and host objects.
• JavaScript Interoperability - Integrates the Lisp environment with JavaScript to call external methods and exchange data.
• Language Bridges - Provides a bridge for translating data types and function calls between the Lisp environment and the host runtime.
• Metaprogramming - Implements metaprogramming capabilities including macros and quoting to transform expressions during evaluation.
• Metaprogramming & Macros - Utilizes a code-as-data workflow with macros and quoting to generate new expressions during evaluation.
• Macro Expansion Engines - Implements a macro expansion system that transforms unevaluated code into new expressions.
• Metaprogramming Frameworks - Ships a toolkit for implementing macros and code-as-data transformations within a custom language environment.
• LISP Programming Resources - Serves as a comprehensive technical guide for building a functional Lisp language from scratch.
• Quoting & Quasiquoting - Provides quoting and quasiquoting to treat code as data for generating new expressions.
• Lexical Scoping Mechanisms - Implements lexical scoping mechanisms to resolve symbols through hierarchical parent-child environment nesting.
• Abstract Syntax Tree Parsing - Converts raw Lisp source strings into a structured abstract syntax tree via recursive descent parsing.
• Lexical Environment Nesting - Stores symbol-value mappings in nested environments to support local variables and lexical scoping.
• Language Syntax Parsers - Implements a parser that translates Lisp S-expression syntax into abstract syntax trees for evaluation.
• JavaScript Interoperability - Bridges the Lisp environment with JavaScript to invoke external methods and exchange data.
• Dynamic Data Structures - Utilizes dynamic data structures such as maps, lists, vectors, and atoms to manage internal state.
• Read-Eval-Print Loops - Provides an interactive read-eval-print loop for real-time code execution and testing.
• Multi-Language Implementations - Offers reference implementations of the interpreter logic across multiple different programming languages.
• Host-Agnostic Implementations - Allows the interpreter logic to be implemented across diverse programming languages to demonstrate agnostic design principles.
• Tail-Call Optimizations - Implements tail-call optimization to prevent stack overflow during recursive function execution.
• Value Manipulation Utilities - Ships built-in value manipulation utilities for mapping, filtering, and accessing data structure elements.
• Incremental Implementations - Organizes the interpreter build process into a sequence of verifiable, incremental implementation stages.
• Compiler Development - A functional Lisp implementation for learning compiler internals.
• Compilers and Interpreters - Lisp interpreter implemented in many languages.
• Language Implementations - A multi-language implementation of a Clojure-like Lisp.
• Multi-Platform Implementations - Educational Lisp with implementations in dozens of host languages.
• Programming Languages - Multi-language Lisp interpreter implementation guide.
• Rust in practice - Listed in the “Rust in practice” section of the Rust Learning awesome list.

Star history