koka-lang/koka
Koka
Koka is a statically typed functional programming language featuring an algebraic effect system. It uses a strong type system to verify program correctness and track side effects at compile time.
The language is distinguished by a reference counting compiler that transforms source code into native C code, eliminating the need for a tracing garbage collector. It employs perceive-based in-place updates to reduce memory overhead and utilizes tail recursion modulo cons for constant-space data structure construction.
The system provides a comprehensive standard library covering numeric operations with arbitrary precision arithmetic, string processing with efficient views, and co-inductive data modeling for infinite structures. It also includes built-in support for hardware-sampling execution profiling and a composable mechanism for handling exceptions and asynchronous flows.
Features
- Algebraic Effect Systems - Implements a core algebraic effect system for managing side effects and control flow via composable handlers.
- Compiler-Inserted Reference Countings - Utilizes a compiler that automatically inserts reference counting for memory management without a garbage collector.
- Effect-Based Exception Handling - Implements an algebraic effect system to capture exceptions and transform them into explicit result types.
- Effect Type Signaling - Tags functions with specific effect types to statically signal when a computation performs I/O or allocation.
- Functional Programming Languages - Implements a statically typed functional programming language emphasizing immutability and strong typing.
- Perceive-Based In-Place Updates - Employs perceive-based in-place updates to reduce memory overhead by mutating data structures when safe.
- Statically Typed Languages - Ensures program correctness by verifying types and side effects at compile time through static analysis.
- Native Code Backends - Transforms source code into optimized C code for native execution using a reference counting compiler.
- Algebraic Effect Handlers - Provides algebraic effect handlers to manage computation flows and side effects by capturing execution contexts.
- Implementation Primitives - Translates high-level effect definitions into evidence-based primitives and handler tables to manage side effects.
- Static Effect Tracking - Tags functions with specific effect types to signal when a computation performs I/O or accesses the network.
- Lazy Infinite Sequences - Implements lazy infinite sequences using co-inductive types for head and tail retrieval.
- Effect-Based Allocation Tracking - Signifies when a function may allocate data in a heap through a dedicated effect type.
- Reference Counting - Tracks object lifetimes using reference counting to perform automatic memory reclamation without a garbage collector.
- Co-inductive Data Modeling - Uses lazy evaluation and specialized types to represent and manipulate infinite data structures.
- Exception Triggering - Provides the mechanism for raising exceptions to interrupt program flow with descriptive error information.
- C Code Generators - Transforms source language constructs into optimized C code for native execution.
- Tail Recursion Modulo Cons - Optimizes recursive data structure construction to execute in constant space using tail recursion modulo cons.
- Tail Recursion Modulo Cons - Optimizes recursive data structure construction to execute in constant space by avoiding stack growth.
- Zero-Copy String Views - Implements lightweight, non-owning references to character sequences to eliminate unnecessary memory allocations.
- Arbitrary-Precision Arithmetic - Provides mathematical operations on signed integers of arbitrary size.
- Optional Value Handling - Implements optional value handling using containers to enforce explicit processing of missing data.
- Perceive-Based In-Place Updates - Analyzes data reuse and ownership to transform functional updates into destructive in-place mutations.
- Execution Profiling - Includes built-in hardware-sampling execution profiling to measure function call frequency and identify bottlenecks.
