ocaml
π―SkillInstallation
npx skills add g1joshi/agent-skills --skill ocamlRun it in a terminal; it asks which AI coding tools to install it for (Claude Code, Codex, Cursor and more).
Uses skills.sh Β· Node.js 22.20+
After installing
Ask for related work and the agent uses it on its own, or call it yourself.
/ocamlInstall by hand
Copy the whole skill folder from GitHub to the place below. Copying only SKILL.md can leave out files the skill uses.
Open the skill folder β- This project
.claude/skills/ocaml/ - All projects
~/.claude/skills/ocaml/
These paths are for Claude Code. For other tools, the command above puts it in the right place.
SKILL.md
View on GitHub βExpert OCaml functional programming assistance covering algebraic data types, pattern matching, modules, and Dune. Use when developing static analysis tools, compilers, theorem provers, or high-assurance software.
OCaml
OCaml v5 brings Multicore support to the language, removing the Global Interpreter Lock (GIL). It combines functional safety with imperative speed.
When to Use
- High-Performance Static Functional Programming: Writing safe, algebraic, strongly-typed systems running at near-C execution speeds.
- Financial Trading Platforms (Jane Street): Building mission-critical quantitative trading infrastructure and order books.
- Static Analysis & Formal Verification Tools: Authoring compilers, linters, and verification suites (Coq, Flow, Infer).
- Multicore Parallelism (OCaml 5): Leveraging OCaml 5's native multicore concurrency, domains, and effect handlers.
Quick Start
(* Define a recursive binary tree and compute depth *)
type 'a tree =
| Leaf
| Node of 'a * 'a tree * 'a tree
let rec depth = function
| Leaf -> 0
| Node (_, left, right) -> 1 + max (depth left) (depth right)
let my_tree = Node ("root", Node ("left", Leaf, Leaf), Leaf)
let () = Printf.printf "Tree depth: %d\n" (depth my_tree)
Core Concepts
Hindley-Milner Type Inference & Pattern Matching
Infers static types globally without requiring verbose type annotations:
(* Algebraic Data Type with Exhaustive Pattern Matching *)
type payment_status =
| Pending of float
| Completed of { id: string; amount: float }
| Failed of string
let summarize_payment = function
| Pending amount -> Printf.sprintf "Pending charge of $%.2f" amount
| Completed { id; amount } -> Printf.sprintf "Completed #%s: $%.2f" id amount
| Failed reason -> Printf.sprintf "Failed: %s" reason
Module System (Signatures & Functors)
Powerful structural module system supporting parameterized modules (Functors):
module type COMPARABLE = sig
type t
val compare : t -> t -> int
end
(* Functor generates a Set for any comparable type *)
module MakeSet (Item : COMPARABLE) = struct
type element = Item.t
(* Internal balanced tree implementation *)
end
OCaml 5 Effect Handlers & Multicore Domains
Native CPU domain parallelism and structured non-blocking effects:
open Domain
let task1 = spawn (fun () -> Array.fold_left (+) 0 (Array.make 1_000_000 1))
let task2 = spawn (fun () -> Array.fold_left (+) 0 (Array.make 1_000_000 2))
let total = join task1 + join task2
Common Patterns
Modular Architecture with Functors
Problem: Writing generic container algorithms independent of concrete key comparison logic.
Solution: Use OCaml Functors (modules parameterized by modules):
module type Comparable = sig
type t
val compare : t -> t -> int
end
module MakeSet (Item : Comparable) = struct
type element = Item.t
type t = element list
let empty = []
let rec insert x = function
| [] -> [x]
| h :: t as l ->
let c = Item.compare x h in
if c = 0 then l
else if c < 0 then x :: l
else h :: (insert x t)
end
Best Practices
Do:
- Use Dune as Standard Build System: Build, test, and manage projects exclusively using
dune buildanddune runtest. - Adopt OCaml 5+: Utilize modern Multicore OCaml with concurrent Domain execution.
- Leverage Jane Street Base & Core: Enhance the standard library using battle-tested
BaseandCore. - Enforce Exhaustive Pattern Matching: Address all compiler warnings (
-w +A) regarding unhandled pattern cases.
Don't:
- Use polymorphic equality (
=) carelessly: Polymorphic equality can crash at runtime on functional closures; use typed comparators. - Rely on unhandled exceptions for control flow: Represent failure explicitly using
Result.torOption.t. - Mutate state across Domains without synchronization: Use atomic variables (
Atomic.t) when sharing memory between threads.
Troubleshooting
| Error | Cause | Solution |
|---|---|---|
Error: This expression has type ... but an expression was expected of type ... | Type mismatch in expression. | Check function argument order; OCaml does not perform implicit casts. |
Warning 8 [partial-match]: this pattern-matching is not exhaustive | Pattern matching missing one or more cases. | Add missing match cases to ensure all possibilities are handled. |
Error: Unbound module ... | Module not installed or missing in Dune libraries stanza. | Add library dependency to dune file and run dune build. |
References
More from this repository10
A template skill providing a starter framework for creating new agent skills with structured sections for triggers, quick start examples, and capability descriptions.
Skill
Skill
Skill
Skill
Skill
Skill
Skill
Skill
Skill