carp-lang/Carp

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.

Star history