Clojure and Lisp Programming Resources

ClojureScript is a Lisp-based compiler and runtime that translates Clojure source code into JavaScript. It enables functional programming across different JavaScript engines and platforms, allowing developers to build user interfaces and applications for web browsers and server environments. The project provides a read-eval-print loop for executing code live within a browser or server for immediate feedback. This facilitates an interactive development workflow where code can be written and tested in real time without restarting the application. The system covers a broad capability surface, including JavaScript interoperability, multi-runtime targeting, and the integration of external module systems and package managers. It also includes tooling for source mapping, build analysis caching, and production size optimization.

This project is a Lisp interpreter implementation guide and framework designed to teach the core principles of programming language design. It provides a structured, step-by-step technical framework for building a functional Lisp language from scratch, featuring a specialized interpreter engine and an S-expression parser that converts syntax into abstract syntax trees. The project emphasizes a code-as-data metaprogramming framework, enabling the implementation of macros, quoting, and quasiquoting to transform expressions during evaluation. It is designed with host language agnosticism, allowing the interpreter logic to be implemented across diverse programming languages and runtimes. The implementation covers a broad range of language capabilities, including lexical scope management, tail-call optimization to prevent stack overflow, and a host-language bridge for interoperability. It includes developer tooling such as a programmable read-eval-print loop for real-time execution in consoles or web browsers, as well as a functional test harness for implementation verification.

Copyright 2019, 2020, 2021, 2022, 2023, 2024 Matthew Egan Odendahl SPDX-License-Identifier: Apache-2.0 --> #> (.update (globals) : macro (types..SimpleNamespace : : (vars hissp..macro))) ... macro=import('types').SimpleNamespace( ... vars( ... import('hissp').macro)))

ClojureDart is a recent Clojure dialect to make native mobile and desktop apps using Flutter and the Dart ecosystem.

Hy ==

A Clojure-compatible(-ish) Lisp dialect hosted on Python 3 with seamless Python interop.

Clojure implemented on the Erlang VM.

This project is a comprehensive educational guide and curriculum for applying functional programming principles and category theory within the JavaScript ecosystem. It provides a structured learning path focused on writing predictable and scalable code through the use of pure functions and immutability. The resource includes a dedicated course on algebraic data structures and a functional programming tutorial. To reinforce theoretical concepts, it features a set of interactive coding exercises and runnable programming challenges for hands-on practice. The materials cover a broad range of functional programming topics, including the study of the JavaScript type system and the implementation of categorical constructs and type classes.

A port of Clojure to the CLR, part of the Clojure project

Carp is a statically typed Lisp compiler that compiles Lisp-like syntax directly to C source code, enabling seamless integration with existing C libraries and low-level system programming. It manages memory deterministically at compile time using ownership tracking and linear types, eliminating garbage collection pauses and runtime overhead while ensuring type safety through an inferred static type system. The language distinguishes itself through compile-time macro expansion and metaprogramming capabilities, allowing code generation and transformation before final binary output. It enforces unique ownership of values at compile time through ownership-based borrowing, preventing data races without runtime garbage collection, and supports phantom types for compile-time safety constraints. Carp provides direct interoperability with C code through inline source insertion and explicit library binding, alongside a read-eval-print loop for interactive development and macro expansion. The project includes a module-based namespacing system with explicit import and visibility control, pattern matching control flow for deconstructing data structures, and compile-time execution for metaprogramming and conditional compilation. It offers automatic derivation of interface implementations, quasiquotation for dynamic code template construction, and comprehensive data structures including arrays, lists, maps, strings, and vectors with functional operations. Carp also provides console and file input/output, arithmetic and geometric mathematics, random number generation, descriptive statistics, pointer and raw memory management, benchmarking, and unit testing capabilities.

Ramda is a functional JavaScript standard library and toolset for immutable data transformation and composition. It provides a comprehensive suite of pure utility functions designed to enable declarative data processing pipelines. The library is distinguished by its use of automatic function currying and a data-last argument order. These design patterns allow multi-argument functions to be partially applied, simplifying the construction of processing chains where data is passed through a sequence of operations. The toolkit covers broad data manipulation capabilities, including list processing, complex object transformations such as flattening and renaming keys, and tabular data pivoting. It also supports relational operations like SQL-style object joins and numerical range scaling. The project provides tree-shakable module exports to facilitate bundle size optimization and dead code elimination.

Functional-Light-JS is a JavaScript functional programming library designed to implement functional patterns within JavaScript applications. It serves as a toolkit for declarative data processing, immutable data management, and the construction of complex logic through higher-order functions. The library focuses on a pragmatic implementation of functional programming, providing utilities for curried argument application and function composition. It emphasizes the use of pure functions to calculate state updates and manage application data without side effects. The project covers broad capability areas including modular JavaScript architecture and declarative collection processing. It provides tools to replace imperative loops with map, filter, and reduce methods to transform data while maintaining immutable structures.

This project is a comprehensive Lisp AI implementation library that provides reference implementations for various artificial intelligence paradigms and symbolic algorithms. It functions as a multi-purpose toolkit containing a logic programming engine, a natural language processing suite, and a symbolic mathematics toolkit. The library is distinguished by its diverse architectural frameworks, including a Prolog-style execution engine that uses unification and goal-driven backtracking, and a system for simulating human decision-making through expert system shells and certainty factors. It also includes a specialized game AI implementation featuring alpha-beta pruning and minimax search for board games. The project covers a broad capability surface, including symbolic computation for differentiation and integration, natural language parsing and generation via definite clause grammars, and compiler construction tools for translating symbolic logic into optimized bytecode. It further provides tools for knowledge representation using frames and production rules, as well as constraint satisfaction solvers for diagrammatic labeling. The codebase is written in Common Lisp and includes an interactive read-eval-print loop for real-time expression interpretation.

Julia is a high-performance, dynamic programming language designed for scientific computing, data analysis, and complex mathematical modeling. It provides a specialized runtime environment that manages memory allocation and parallel processing, utilizing a just-in-time compiler to translate high-level source code into optimized machine instructions. This architecture allows the language to achieve execution speeds comparable to statically compiled languages while maintaining the flexibility of a dynamic scripting environment. The language is distinguished by its multiple dispatch system, which selects function implementations based on the run-time types of all arguments to enable flexible polymorphism. It further optimizes performance through type-inference-driven code specialization, which generates machine code tailored to specific input types to eliminate dynamic overhead. Developers can also leverage abstract syntax tree reflection to inspect and modify code structure at runtime, and utilize a foreign function interface to invoke native libraries directly. Beyond its core execution model, the project includes a comprehensive interactive development environment accessible via the terminal. This interface supports real-time code evaluation, variable inspection, and integrated documentation, facilitating rapid prototyping and data exploration. The system also provides tools for cross-platform binary compilation, dependency management, and the creation of custom command-line utilities, allowing for integration with various text editors and development tools.