unisonweb/unison

Features

• 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.
• Head and Tail Decompositions - Provides head/tail list decomposition syntax for pattern matching.
• Pattern Matching - Evaluate a scrutinee against a sequence of patterns and execute the first matching branch's body.
• As-Pattern Bindings - Provides as-pattern syntax for simultaneous whole-and-part binding during pattern matching.
• List Decompositions - Decompose lists by matching on head/tail, init/last, literal elements, or concatenation splits.
• Pattern Guards - Add a Boolean guard expression to a pattern that must evaluate to true for the match to succeed.
• Fixed-Length Segment Matches - Supports matching lists with exact element counts using constructor syntax.
• Remote Project Downloads - Enables downloading any project or branch from the hosting service for local development.
• Release Snapshots - Provides a mechanism to create immutable, versioned snapshots of a branch for use as stable library dependencies.
• Content-Addressable Storage - Stores all code as ASTs in a content-addressed database keyed by hash.
• Literal - Create a comma-separated sequence of values of the same type enclosed in square brackets.
• Remote Task Forkers - Forks tasks to execute remotely and awaits their results using the Remote ability without external frameworks.
• Immutable Field Setters - Supports immutable field setting that returns a new record copy.
• 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.
• Functional Field Modifications - Provides immutable field modification by applying functions to record fields.
• Non-Breaking Name Rebindings - Changes which hash a human-readable name points to while keeping all existing definitions runnable.
• Branch Creation - Duplicate the current branch into a new child branch and switch to it, optionally specifying a source branch.
• Code Sharing Utilities - Pushes code to a hosted repository for sharing and pulls from it to access others' code.
• Delayed IO Executions - Executes programs that perform IO and raise exceptions directly from the command line.
• Compiler Caches - Compiles only changed definitions and caches results permanently by hash.
• HTTP Request - Ships a built-in ability for making HTTP requests with effect handlers.
• Effectful HTTP Requests - Provides a core mechanism for making HTTP requests within the Unison effect system.
• Definition Updates with Propagation - Updates definitions from scratch files and automatically propagates changes to dependents.
• Dependent-Aware Definition Updates - Replaces existing definitions with newer versions and automatically updates all transitive dependents in the codebase.
• Pull Request Review Interfaces - Provides a web interface for inspecting changes and merging pull requests.
• 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.
• Local-Remote Branch Synchronizers - Synchronizes local branches with remote counterparts on the hosting service.
• Effect Composition Signatures - Allows combining multiple effect requirements in a single type signature.
• 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.
• Data Constructor Decompositions - Provides constructor pattern matching to decompose data types and bind fields.
• Numeric Literals - Define integer and floating-point values directly in source code using standard numeric syntax.
• Pattern Bindings - Capture matched values into named variables that are accessible within the match body.
• Type Constructor Applications - Apply a type constructor to a type argument, analogous to function application at the term level.
• Effect-Oriented Languages - An effect-oriented language with content-addressed storage enabling semantic version control and distributed computation.
• Tuple Destructuring - Deconstruct tuples by matching each element against a corresponding sub-pattern.
• Tuple Literals - Group multiple values of possibly different types inside parentheses, including the unit tuple ().
• Structural Type Equivalences - Supports structural type equivalence based on identical constructors and arguments.
• Effect Signature Annotations - Exposes effect requirements in function signatures using curly brace annotations.
• Auto-Generated Accessors and Mutators - Automatically generates getter, setter, and modifier functions for record fields.
• 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.
• Serialization-Free Persistences - Stores and retrieves values directly without requiring serialization or translation code.
• 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.
• Literal Element Sequence Matches - Match a list only when its length and each element match a fixed sequence of patterns.
• 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.

Historial de estrellas