carp-lang/Carp
Carp
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.
Features
- Statically Typed Lisp Compilers - Compiles Lisp-like syntax with inferred static types directly to C for systems programming.
- C Source Generators - Compiles Lisp-like syntax directly to C source code for native compilation and low-level system programming.
- Pattern Matching - Provides structural pattern matching for deconstructing data structures.
- Value Comparators - Tests whether two values are equal, less than, or greater than each other.
- Standalone Binary Compilation - Compiles Lisp-like syntax directly to standalone C binaries for systems programming.
- C Libraries - Binds directly to existing C libraries with explicit allocation and copying for seamless integration.
- Compile-Time - Manages memory deterministically at compile time using ownership tracking and linear types.
- Ownership-Based Memory Management - Manages memory deterministically at compile time using ownership tracking and linear types.
- First-Class Functions - Treats functions as first-class values that can be created, composed, and applied.
- Pattern Matching - Ships pattern matching as a core control flow construct for branching on data structure shapes.
- Derived Implementations - Automatically generates common trait implementations for custom data types via derivation.
- Metaprogramming & Macros - Provides macros and interfaces for extending the language at compile time.
- Ownership & Borrowing - Enforces unique ownership of values at compile time for safe mutation and data race prevention.
- Native C Interoperability - Provides direct C function calling and inline C code insertion for seamless library integration.
- Quoting & Quasiquoting - Implements quasiquotation with unquoting for constructing code templates in macros.
- Inline C Code Embeddings - Provides direct inline C code insertion for low-level system programming within a Lisp compiler.
- Static Type Inference - Infers static types at compile time from Lisp-like syntax for type safety without runtime errors.
- Statically Typed Compilers - Compiles Lisp-like syntax with inferred static types directly to C source code.
- Memory-Safe Systems Programming - Enforces compile-time ownership tracking and linear types for deterministic memory management without garbage collection.
- Index-Based Element Access - Retrieves the element at a specified numeric index from a list.
- Compile-Time Metaprogramming - Expands macros and evaluates compile-time expressions during compilation for metaprogramming.
- Interface Derivation - Automatically generates interface implementations for custom data types.
- Module Loading Systems - Imports files and activates modules in a single step with matching file and module names.
- Flow Control - Directs execution through conditionals, loops, and branching constructs.
- Interactive REPLs - Provides a read-eval-print loop for live coding, macro expansion, and compile-time scripting.
- Interpolated Code Templates - Provides quasiquotation-based code templates with expression interpolation for metaprogramming.
- Dynamic Memory Allocation - Handles dynamically allocated memory and runtime-sized data structures in a systems language.
- Binding Visibility Controls - Provides private binding declarations to restrict visibility to the current module.
- Compile-Time Assertions - Provides compile-time assertions for verifying conditions during compilation.
- Conditional Logic - Executes code blocks based on boolean conditions with support for chained conditions and short-circuit evaluation.
- Function Currying - Supports function currying for transforming multi-argument functions into chains of single-argument calls.
- Threading Macros - Provides threading macros for concise data transformation pipelines.
- Opaque Type Definitions - Defines abstract data types whose internal structure is hidden from consumers.
- Compile-Time Introspection - Examines type information at compile time for generic programming and type-level computation.
- Compile-Time Functions - Supports defining symbols and functions that execute during compilation and are not present in the final binary.
- Module Namespaces - Organizes code into modules with explicit import and visibility control to prevent naming conflicts.
- Repeated Function Application - Provides a utility for applying a function repeatedly to a value for a fixed number of iterations.
- Splicing Code Templates - Supports splicing evaluated expressions into code templates for metaprogramming.
- Symbolic Identifiers - Represents named identifiers and performs symbolic computation.
- Floating Point Arithmetic - Performs arithmetic and comparisons on 64-bit decimal values for fractional calculations.
- Arithmetic Operations - Adds, subtracts, multiplies, divides, increments, and decrements numeric values.
- N-Dimensional Vector Representations - Stores and manipulates vectors of any fixed dimension using an array-backed data structure.
- Collection Transformations - Provides map, filter, reduce, and pattern matching for transforming arrays, lists, and maps.
- Pointer Allocations - Provides manual pointer allocation for low-level memory management in a systems programming language.
- Until Loop Structures - Implements until-loop semantics for repeating execution until a condition is met.
- Monadic Error Handling - Implements monadic error handling with Result types as a core language feature.
- Conditional Branching - Runs a block of code only when a condition is true or false without requiring an alternative branch.
- Integer Arithmetic - Performs arithmetic and bitwise operations on whole number values.
- Pointer Arithmetic - Provides pointer arithmetic operations for advancing and rewinding memory addresses.
- Code Annotations - Attaches documentation, type signatures, and deprecation notices to named bindings.
- Function Composition - Provides function composition as a built-in operation for combining functions.
- Optional Value Types - Implements optional value types as a core language feature for safe null handling.
- Phantom Types - Uses type parameters that don't correspond to runtime values to enforce compile-time constraints.
- Custom Derivation Mechanisms - Allows users to define custom derivation mechanisms for automatic code generation.
- Update Derivation Mechanisms - Provides a mechanism for building derivers tailored to update-style operations.
- Scheme Implementations - Statically typed Lisp with Rust-like memory management.
- More to explore - Statically typed Lisp for real-time applications.
