Content-Addressed Code Identifiers - Stores all definitions by their hash, eliminating dependency conflicts and enabling instant non-breaking renames across the entire codebase.
Codebase Stores - Stores all code definitions by their content hash, eliminating dependency conflicts and enabling instant non-breaking renames.
Content-Addressed Incremental Compilations - Store code as its AST in a content-addressed database to eliminate full rebuilds and provide perfect incremental compilation.
Content-Addressed Code Stores - Stores all code as ASTs in a content-addressed database, eliminating builds and enabling instant non-breaking renames.
Ability-Based - Defines the core effect system of the language, using abilities and continuations.
Automatic Dependent Propagation - Automatically updates all transitive dependents of a changed definition when the new type is compatible.
LSP-Integrated Environments - Integrates with an LSP server to provide syntax highlighting, autocomplete, error highlighting, and type-on-hover in editors.
Bytecode Shipping Platforms - Runs computations across remote nodes by shipping bytecode and syncing dependencies automatically.
Serialization-Free Persisters - Provides native typed storage that persists values including functions without serialization code or schema definitions.
Expression Name Bindings - Bind a name to an expression, optionally with parameters, so the expression can be referenced and reused elsewhere in code.
Content-Addressed - Store parsed and type-checked definitions in an append-only codebase so no one ever re-parses or re-type-checks the same hash.
Automatic Dependency Sync - Enables distributed execution by shipping bytecode and syncing dependencies automatically.
Field Accessor Functions - Generates accessor functions for retrieving named fields from record types.
Dependent-Aware Definition Updates - Replaces existing definitions with newer versions and automatically updates all transitive dependents in the codebase.
Text Literals - Embed a sequence of Unicode characters, including multi-line strings with triple quotes and escape sequences.
Character Literals - Represent a single Unicode character prefixed by ?, supporting escape sequences.
Scratch File Editing - Ships a scratch-file editing workflow where definitions are opened, modified, and applied to the codebase with automatic dependent updates.
Typed Transactional Storage - Provides native typed transactional storage for values and functions without serialization.
Semantic Change Trackers - Tracks code changes by meaning rather than text, ignoring formatting and import order while providing perfect incremental compilation and cached test results.
Branch Merging Strategies - Provides built-in commands for merging branches and namespaces to combine work.
Distributed Computing - Runs computations on remote machines by specifying where they should execute, with dependencies deployed automatically.
Ability-Based Distributed Executors - Runs computations across remote nodes using an effect system that handles dependency deployment and execution without external frameworks.
Bytecode Shipping Engines - Ships a function's bytecode tree to a remote location and syncs missing dependencies on the fly for distributed execution.
Type-Safe Remote Calls - Enables type-safe remote service calls without writing encoders or decoders.
Computation Abortions - Ships a language-level abort mechanism that stops function execution on condition.
Anonymous Functions - Define an anonymous function using the syntax p1 p2 … pn -> body.
Boolean Logic Types - Represent truth values directly as true or false in source code.
Binary Data Literals - Embed raw binary data as an even number of hexadecimal digits prefixed by 0xs.
Concurrency Primitives - Provides MVar, TVar, and STM primitives for lock-free concurrent data structures.
Conditional Branching - Choose between code paths using if/else expressions or pattern matching with guards and variable binding.
Continuation Invocation - Optionally call the continuation of an ability constructor to resume the program, possibly with modified arguments.
Custom Infix Operators - Define a binary operator using either prefix or infix notation, with optional qualified names for namespacing.
Scratch File Evaluators - Executes any expression prefixed with > in a .u file and displays the result for interactive development.
External Library Installers - Downloads libraries from the hosting service into the local codebase for use as dependencies.
Continuation Discarding - Ignore the continuation of an ability constructor to abort or short-circuit the program's execution.
Polymorphic Effect Passings - Supports polymorphic effect passing where higher-order functions accept any ability.
Function Definitions - Define a named function with parameters in a scratch file and evaluate it immediately with a watch expression.
Recursive Definitions - Allow a term's definition to refer to itself, enabling computations that repeat until a base case is reached.
List Construction and Transformations - Create lists with square brackets, concatenate them, and apply transformations using pipe operators and lambda functions.
Pattern Matching - Provides pattern matching with variable binding, guards, and as-patterns for branching logic.
IO Program Execution - Executes terms requiring IO and Exception abilities directly from the command-line interface.
Type Annotations - Attach a type constraint to an expression so the compiler verifies the expression's type matches the declared type.
Type-Based Function Discovery - Enables discovering functions by their type signatures directly within the codebase.
Unique Type Identifiers - Assign a universally unique identifier to a type declaration so it is not confused with structurally identical types from other declarations.
Custom Data Type Declarations - Define custom data types as unique or structural, including recursive types with type parameters and record types with named fields.
Scoped Type Variables - Keep type variables from a term's signature in scope throughout its definition, enabling consistent type references across the body.
Sandboxed Execution Environments - Restrict what abilities and resources a computation from a peer can access, enforcing security policies at runtime.
Algebraic Data Types - Defines custom types with named data constructors carrying typed arguments.
Purity Annotations - Marks pure functions with empty brace annotations in type signatures.
Ability Declarations - Implements ability declarations that define effect interfaces with named operations.
Signature Subset Checking - Check that every function call's required abilities are a subset of the abilities declared in the enclosing function's type signature.
Graceful Version Coexistence - Allows multiple versions of the same type or function to coexist in the codebase without breaking builds.
Hash-Based Dependency References - References definitions by content hash, allowing multiple library versions to coexist without name conflicts.
Content-Addressed Renamings - Change a definition's name everywhere at once without breaking references, because functions are identified by their implementation hash.
Pull Request Submissions - Ships a workflow for creating contributor branches and submitting them as pull requests.
Project Initializations - Create an empty project with a default main branch, optionally accepting a custom or random name.
Branch-Based Project Organization - Divides the codebase into separate projects with branches and dependency namespaces to structure libraries and applications.
Side Effect Handlers - Manages side effects like I/O, exceptions, and state through typed abilities and handlers instead of monads or callbacks.
Surgical Code Refactoring - Provides interactive, type-checked refactoring sessions that keep the codebase live and avoid misleading error lists.
Nominal Type Distinctions - Provides nominal type distinction preventing substitution of structurally identical types.
Value Property Assertions - Check conditions like equality, ordering, or truth with functions that provide detailed failure messages.
Unit Testing Frameworks - Execute all tests in a namespace or project, reporting results and caching outcomes for unchanged dependencies.
Constructor Interception - Match ability constructors in a handler to intercept and respond to requests made by a computation.
Pattern-Based Handlers - Match ability requests and pure computations in ability handlers using constructor and continuation patterns.
Global Change Logs - Displays a log of changes across the entire codebase, not limited to a single project or branch.
Interactive Codebase Browsers - Provides a desktop application for clicking through source definitions, searching terms, and reading API documentation.
LSP Integration - Exposes syntax highlighting, autocomplete, and type-on-hover through an LSP interface.
Init and Last Matches - Match a list against all elements except the last and the final element, supporting symmetric decomposition.
List Concatenation Matches - Match a list as the concatenation of two sublists when at least one sublist has a known length.
Text Manipulation - Search and split text strings using built-in functions or flexible regex-like patterns.
Reading and Writing Tools - Provides file read and write operations through standard library functions.
Project Page Hosting - Automatically displays a README document as the project's homepage on the hosting service.
Branch State Rewinding - Rewinds the current branch to a previous state using a specific hash or numbered position.
Parallel Map-Reduce Tools - Performs a distributed map-reduce operation across nodes with minimal code using a remote execution ability.
Definition Deletions - Allows deleting definitions from the codebase by removing them from a scratch file during an update workflow.
Branch Permission Management - Manages branch permissions for collaborative development with contributor branches.
Local Branch Listings - Show all local branches of a project along with their remote mappings on Unison Share.
Ability-Based Delays - Marks blocks of code for deferred execution using do, underscore arguments, or the ' symbol.
Dependency Installers - Downloads the latest release of a library from the hosting service with a single command.
Dependency Installers - Provides a command to add a project to the lib directory for use as a dependency, optionally specifying a version.
Merge Conflict Resolution - Opens conflicting definitions from merged branches in a scratch file for resolution and commits the merged result.
Curated Library Catalogs - Provides a curated catalog for discovering public projects by name, author, or description.
Dependent Review Flagging - Replaces definitions with newer versions and automatically updates dependents, flagging any that require manual review.
Branch Change Logs - Displays a log of changes made to the current branch, showing the command that produced each change.
Cross-Branch Change Logs - Shows a log of changes across all branches in a project, including the names of terms or types that changed.
Cloud Service Deployers - Deploys long-running services, serverless functions, and batch jobs to the cloud by calling a typed function.
Dependency-Aware Test Caches - Rerun only tests whose dependencies changed, reusing cached results for all other tests to speed up test suites.
Dependency Versioning - Installs new library versions and resolves conflicts across dependent code to update project dependencies.
Ability-Based Suspensions - Delays computation execution until the appropriate ability handlers are available for resumption.
File I/O Utilities - Provides standard library functions for reading and writing files under the FilePath and Handle namespaces.
Remote Library Installers - Download the latest or a specific version of a library from Unison Share into the codebase.
Continuation Capturing Handlers - Captures program continuations after effects occur, allowing handlers to run custom behavior and resume execution.
Recursive Handlers - Pass the handler itself as the ability provider for continuations, enabling stateful or iterative handling.
Expression Evaluators - Executes any Unison expression in a scratch file and prints the result to the console.
Watch - Evaluates any Unison expression in a source file and prints the result to the console when the file is saved.
Literal Matching - Check whether a scrutinee equals a specific Boolean, Nat, Int, Char, or Text value and match only on exact equality.
Typed Link Literals - Create a typed reference to a term or type using termLink or typeLink.
Ability-Based Exception Handlers - Implements exception handling where errors are raised as ability requests and caught by dedicated handlers.
Pure Exception Converters - Catches failures raised by abilities and converts them into standard result types like Either.
Abort-Based Handlers - Provides abort-based error handling where failures are silently converted to Optional values through ability handlers.
Failure Value Handlers - Ships exception-based error handling where structured Failure values are raised and can be translated to Either.
Throw-Based Error Handlers - Provides throw-based error handling where typed error values are returned and can be translated to Either.
Namespace-to-Project Conversions - Convert an existing namespace or published library into a project by merging its contents into a new project's branches.
Project Visibility Control - Sets a hosted project as private or public to control access and visibility.
Ability Composition - Composes computations using different abilities like exception handling and I/O without monadic combinators.
Distributed Runtime Simulations - Simulates cloud execution on a single machine using the Cloud client library for testing and development.
Effect-Based Test Backends - Separate business logic from implementation via an effect system, enabling distributed computation to run against test backends for observability or performance.
Property-Based Fuzzing - Generate random or enumerated test cases and check that a property holds for all of them, reporting failures with details.
Random Value Generators - Produce random integers, naturals, or floats for test inputs, including edge cases like zero and boundary values.
More to explore - Programming language with content-addressed code.
