package
Embeddable Prolog-style logic engine for JavaScript: declarative rules, unification, backtracking search, and four solver drivers (sync/async × callback/generator). Useful for pattern matching with extraction, constraint search, type inference, planners,
npm install yoplGitHub-flavored package documentation.
Across all versions.
Download trend unavailable.
Runtime metadata.
Tagged topics.
Estimated unpacked size across 2 packages.
308.1 kB
Includes dependencies.
yopl is an ES6 mini-library that implements a Prolog-style logic solver in JavaScript. It provides:
clause\...`) and a strict-Prolog whole-program parser (prolog`...``) — write rules declaratively, catch arity drift at compile time.Its only runtime dependency is deep6, itself a zero-dependency library that provides the unification engine.
yopl lets you describe a problem as a set of rules over JavaScript values and ask the solver to find values that satisfy them. You write declarative rules; the engine handles search, unification, and backtracking. You stay inside JavaScript — there is no embedded DSL to parse, no separate Prolog runtime, and rules can call back into plain JS (sync or async) whenever a piece of logic is easier to express that way.
It is useful when a problem is awkward to express as straight-line code but natural to express as constraints or relations:
If you only need single-direction pattern matching, a regex or a destructuring assignment is simpler. Reach for yopl when you need bidirectional matching (unification), backtracking across alternative rules, or enumeration of all solutions — and you want all of that without leaving your JavaScript codebase.
npm install --save yoplimport {variable} from 'deep6/env.js';
import assemble from 'deep6/traverse/assemble.js';
import solve from 'yopl';
const rules = {
member: [(V, X) => [{args: [{value: V, next: X}, V]}], (V, X) => [{args: [{next: X}, V]}, {name: 'member', args: [X, V]}]]
};
const list = {value: 1, next: {value: 2, next: {value: 3, next: null}}};
const X = variable('X');
solve(rules, 'member', [list, X], env => {
console.log('X =', assemble
| Module | Purpose |
|---|---|
yopl (src/solve.js) | Synchronous callback solver — main entry point. |
yopl/solvers/gen.js | Synchronous generator solver. |
yopl/solvers/async.js | Async callback solver. |
yopl/solvers/asyncGen.js | Async generator solver. |
yopl/compile | IR constructors (Var, Lit, Compound, …) + lowerRule/lowerRules + validate/validateOrThrow + IR symbol + deep6 re-exports. |
yopl/compile/clause | Per-clause tagged-template DSL: rule(name, arity)(clause\...`)`. |
yopl/compile/prolog | Strict-Prolog tagged-template parsers: prolog\...`, prologClause`...``. |
yopl/compile/prolog/file | Filesystem-backed loaders: , (Node / Bun / Deno). |
Per-module documentation lives in the wiki.
yopl ships as ESM only. CommonJS consumers can use Node's built-in dynamic import():
const {default: solve} = await import('yopl');A full CJS interop demo lives in tests/test-cjs.cjs (run it with node tests/test-cjs.cjs).
git clone https://github.com/uhop/yopl.git
cd yopl
npm install
npm testSee CONTRIBUTING.md for the development workflow and AGENTS.md for AI-agent rules.
Array / Map / Set / Date), unifyOpts/3.exports statement.The full release notes are in the wiki: Release notes.
prologFileprologFileAsyncyopl/rules/system.js | Generic logic primitives: helpers + eq, notEq, unifyOpts, not, map, filter, type tests, … |
yopl/rules/native.js | JS-native bridges: Array / Map / Set / Date predicates + type tests (isArray, isMap, …). |
yopl/rules/comp.js | Comparisons: lt, le, gt, ge, nz. |
yopl/rules/math.js | Arithmetic: add, sub, mul, div, neg (each reversible); is/2 arithmetic-expression evaluator; =:=/=\= arithmetic comparison. |
yopl/rules/bits.js | Bitwise: bitAnd, bitOr, bitXor, bitNot. |
yopl/rules/logic.js | Boolean logic: logicalAnd, logicalOr, logicalXor, logicalNot. |