roc-lang/roc

Features

• Platform and Package Declarations - Declares platforms and package dependencies in a header to provide all I/O primitives for executables.
• Pure Computation I/O Abstractions - Separates pure computation from side effects by routing all I/O through a declared platform.
• Block Expression Evaluations - Provides block expressions that group statements and evaluate to the last expression's value.
• Functional Programming Languages - Implements a functional programming language with immutable-by-default semantics and exhaustive pattern matching.
• Immutable Constant Definitions - Enforces immutable-by-default bindings that cannot be reassigned or shadowed in the same scope.
• Immutable Variables - Binds names to immutable values by default, with a special mutable prefix for local reassignment only.
• Exhaustive Pattern Matches - Enforces exhaustive pattern matching on tag unions with compile-time warnings for unhandled cases.
• Compile-Time Type Inference - Infers all types automatically while allowing optional explicit annotations verified by the compiler.
• Pattern Matching - Provides exhaustive pattern matching on tagged unions and records for safe data destructuring.
• Statically Typed Languages - Ships a statically typed language with full compile-time type inference and optional annotations.
• Effectful Function Distinctions - Distinguishes pure from effectful functions using a trailing-bang naming convention for visible side-effect boundaries.
• Nominal Tag Union Types - Core language feature using nominal tag unions for exhaustive pattern matching and error handling.
• Question Mark Error Propagation - Unwraps success values or returns errors early using a single question-mark operator.
• Success and Failure Wrapping - Represents operations that can succeed or fail using Ok and Err tags with pattern matching and no null values.
• Type-Safe Development - Builds reliable programs with optional type annotations, exhaustive pattern matching, and compile-time error handling.
• Source Code Formatters - Applies standard style rules to all source files with a single command and no configuration options.
• Compile-Time Debug Primitives - Ships debug and crash primitives that work inside pure functions for compile-time and runtime diagnostics.
• Scripting Entrypoints - Supports creating executable programs with entrypoints, mutable variables, and imperative loops for side effects.
• Interactive REPLs - Provides an interactive REPL for evaluating expressions and definitions without needing a source file.
• Early Return Patterns - Supports early return from functions with compile-time warnings for unreachable code.
• Custom Tag Wrapping - Allows wrapping values in user-defined tags for type distinction and pattern matching.
• Block Expressions - Implements block expressions that group statements and evaluate to the final expression's value.
• Mutable Local Variables - Provides mutable local variables with a leading dollar sign for controlled reassignment.
• Imperative For Loops - Ships imperative for loops that iterate over collections with mutable variable reassignment.
• Data & Text Processing - Manipulates strings, parses numbers, encodes text formats, and processes collections with built-in functions.
• Array Folding Functions - Offers functional folds to reduce collections to single values without mutating outer scope.
• Record Construction and Updates - Provides record construction and non-destructive update operations for immutable data structures.
• Standard Library Collections - Ships a standard library with built-in collection processing functions like map, filter, and reduce.
• String Concatenation Operations - Provides string concatenation, splitting, and searching operations through the standard library.
• String Manipulation - Ships string manipulation operations including concatenation, splitting, trimming, and replacement.
• Type Annotations - Supports optional explicit type annotations that the compiler verifies against inferred types.
• Method Call Syntax - Resolves dot notation method calls to the corresponding module function at compile time.
• Parameterized Types - Supports parameterized types like List and Try for generic data structures.
• Unrecoverable Error Management - Halts execution using the crash keyword for unrecoverable errors where graceful handling is infeasible.
• Constrained Type Variables - Supports constrained type variables for generic functions that require specific capabilities.
• Code Evaluation Sessions - Evaluates expressions and tests code in a REPL session without needing a source file.
• Conditional Expression Returns - Provides if expressions that evaluate conditions and return values from branches.
• Trailing-Bang Effect Markers - Marks effectful functions with a trailing exclamation mark for syntactic visibility of side-effect boundaries.
• Lightweight Assertions - Ships lightweight assertions with the expect keyword that are skipped in optimized production builds.
• Language Implementations - Functional language compiling to machine code or Wasm.
• Inspired By Elm - Language targeting WebAssembly inspired by Elm.
• Elm Inspired Projects - Language targeting WebAssembly inspired by Elm.

Star history