Crate canrun[][src]

Expand description

GitHub Workflow Status Coverage Crate Documentation

Canrun is a logic programming library inspired by the *Kanren family of language DSLs.

Status: Exploratory and Highly Experimental

I’m still quite new to both Rust and logic programming, so there are likely to be rough edges. At best it may be a useful implementation of something that resembles the core concepts of a Kanren while being idiomatically Rusty. At worst it may just be a poor misinterpretation with fatal flaws.

Quick Start

use canrun::{domain, var, Goal, both, unify};

domain! {
    pub I32 { i32 }

let x = var();
let y = var();
let goal: Goal<I32> = both(unify(x, y), unify(1, x));

let result: Vec<_> = goal.query(y).collect();

assert_eq!(result, vec![1])

What’s next? Go read a breakdown of this example in the deeper Quick Start explanation.


pub use collections::*;
pub use domains::*;
pub use goals::*;
pub use state::*;
pub use value::*;


Collections and related goal functions.

Tutorials and other more in-depth documentation (mostly WIP).

Constrain the set of types that you can reason about in a particular context.

Basic domains for simple use cases.

Make declarative assertions about the relationships between values.

Track value bindings and constraints during the evaluation process.

Assorted helpers, especially for testing.

Contain individual resolved values or variables that can be bound through unification.


Create a goal that only succeeds if all sub-goals succeed.

Create a goal that yields a state for every successful sub-goal.

Create an LMap with automatic key/value IntoVal wrapping.

Create a tuple of logical values with automatic IntoVal wrapping.

Create an LVec<T> with automatic value IntoVal wrapping.

Easy conversion of LVar<T> and T values into Val<T>.


Derive reified values potential resolved states.

Extract a fully resolved T from a Val<T>.

How compatible values are matched with each other.