Unison language - content-addressed functional programming with abilities for effects, distributed computing, and structural types. Use for pure functional code, effect management, distributed systems, and refactoring-safe codebases.
/plugin marketplace add plurigrid/asi/plugin install asi-skills@asi-skillsThis skill inherits all available tools. When active, it can use any tool Claude has access to.
Content-addressed functional programming language with first-class effects.
| Concept | Description |
|---|---|
| Content-addressed | Code identified by hash, not name - renames are free |
| Abilities | Algebraic effects for IO, Exception, Random, Remote |
| Structural types | Types with same structure are identical |
| UCM | Unison Codebase Manager - REPL + version control |
# Start UCM
ucm
# Start with specific project
ucm -p myproject/main
# Run compiled program
ucm run.compiled program.uc
# Create codebase at path
ucm -C ./my-codebase
# Project management
project.create myproject
switch myproject/main
# Add code from scratch file
update
add
# Run a function
run helloWorld
# Compile to executable
compile helloWorld output
# Install library from Share
lib.install @unison/http
# Find definitions
find : Text -> Nat
find map
# View definition
view List.map
# Documentation
docs List.map
# Refactoring (rename is instant!)
move.term oldName newName
-- Type signature
double : Nat -> Nat
double x = x * 2
-- Multi-argument
add : Nat -> Nat -> Nat
add x y = x + y
-- Lambda
List.map (x -> x * 2) [1, 2, 3]
-- Pipeline operator
[1, 2, 3] |> List.map (x -> x * 2) |> List.filter Nat.isEven
-- Three equivalent ways to delay
main : '{IO, Exception} ()
main = do printLine "hello"
main : '{IO, Exception} ()
main _ = printLine "hello"
main : '{IO, Exception} ()
main = '(printLine "hello")
-- Force with ! or ()
!main
main()
-- Match expression
isEven num = match num with
n | mod n 2 === 0 -> "even"
_ -> "odd"
-- Cases shorthand
isEven = cases
0 -> "zero"
n | Nat.isEven n -> "even"
_ -> "odd"
-- As-patterns with @
match Some 12 with
opt@(Some n) -> "opt binds whole value"
None -> "none"
-- Sum type (unique by name)
type LivingThings = Animal | Plant | Fungi
-- Recursive type with parameter
structural type Tree a = Empty | Node a (Tree a) (Tree a)
-- Record type (generates accessors)
type Pet = { age: Nat, species: Text, foods: [Text] }
-- Use generated accessors
Pet.age : Pet -> Nat
Pet.age.set : Nat -> Pet -> Pet
Pet.age.modify : (Nat -> Nat) -> Pet -> Pet
-- Literals
[1, 2, 3]
-- Concatenation
[1, 2] List.++ [3, 4]
-- Cons/snoc
use List +: :+
1 +: [2, 3] -- [1, 2, 3]
[1, 2] :+ 3 -- [1, 2, 3]
-- Transformations
Nat.range 0 10
|> List.map (x -> x * 100)
|> List.filter Nat.isEven
|> List.foldLeft (+) 0
-- Filter and split
Text.filter isDigit "abc_123_def" |> Text.split ?0
-- ["1", "2", "3"]
-- Pattern matching (regex-like)
Pattern.run (Pattern.capture (Pattern.many (chars "ab"))) "aabb123"
-- Some (["aabb"], "123")
Abilities are Unison's approach to algebraic effects:
-- Function using abilities
getRandomElem : [a] ->{Abort, Random} a
getRandomElem list =
index = natIn 0 (List.size list)
List.at! index list
-- Handle with splitmix (Random) and toOptional (Abort)
toOptional! do splitmix 42 do getRandomElem [1, 2, 3]
| Ability | Purpose | Handler |
|---|---|---|
IO | File, network, console | Runtime |
Exception | Raise/catch errors | catch, toEither |
Random | Random number generation | splitmix seed |
Abort | Early termination | toOptional! |
Remote | Distributed computation | Cloud runtime |
STM | Software transactional memory | STM.atomically |
nonZero : Nat ->{Exception} Nat
nonZero = cases
0 -> Exception.raise (Generic.failure "Zero found" 0)
n -> n
-- Catch returns Either
catch do nonZero 0
-- Left (Failure ...)
catch do nonZero 5
-- Right 5
forkedTasks : '{Remote} Nat
forkedTasks = do
task1 = Remote.fork here! do 1 + 1
task2 = Remote.fork here! do 2 + 2
Remote.await task1 + Remote.await task2
type STM.TQueue a = TQueue (TVar [a]) (TVar Nat)
TQueue.enqueue : a -> TQueue a ->{STM} ()
TQueue.enqueue a = cases
TQueue elems _ -> TVar.modify elems (es -> a +: es)
-- Atomic block
result = STM.atomically do
queue = TQueue.fromList [1, 2, 3]
TQueue.enqueue 4 queue
TQueue.dequeue queue
-- Read file
content = readFileUtf8 (FilePath "data.txt")
-- Write file
FilePath.writeFile (FilePath "out.txt") (Text.toUtf8 "hello")
-- Rename
renameFile (FilePath "old.txt") (FilePath "new.txt")
myproject/main> lib.install @unison/http
exampleGet : '{IO, Exception, Threads} HttpResponse
exampleGet _ =
uri = net.URI.parse "https://example.com/api"
req = do Http.get uri
Http.run req
-- In scratch.u file
helloWorld : '{IO, Exception} ()
helloWorld = do printLine "Hello World"
scratch/main> project.create hello-world
hello-world/main> update
hello-world/main> run helloWorld
-- Or compile to binary
hello-world/main> compile helloWorld hello
$ ucm run.compiled hello.uc
.u file (scratch file)update or add to add to codebasepush, pull)| Phase | Trit | Unison Pattern |
|---|---|---|
| Validate | -1 | Exception, Abort abilities |
| Coordinate | 0 | STM, handlers, pipelines |
| Generate | +1 | Remote.fork, IO effects |
Skill Name: unison
Type: Functional Programming Language
Trit: 0 (ERGODIC - coordination via abilities)
Version: 0.5.49
Platform: Cross-platform (ucm binary)
This skill connects to the K-Dense-AI/claude-scientific-skills ecosystem:
general: 734 citations in bib.duckdbThis skill maps to Cat# = Comod(P) as a bicomodule in the equipment structure:
Trit: 0 (ERGODIC)
Home: Prof
Poly Op: ⊗
Kan Role: Adj
Color: #26D826
The skill participates in triads satisfying:
(-1) + (0) + (+1) ≡ 0 (mod 3)
This ensures compositional coherence in the Cat# equipment structure.