Crate canrun

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

• Intro blog post: https://esimmler.com/announcing-canrun/
• How it works (part 1): https://esimmler.com/building-canrun-part-1/

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.

Re-exports

pub use collections::*;

pub use domains::*;

pub use goals::*;

pub use state::*;

pub use value::*;

Modules

collections

Collections and related goal functions.

docs

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

domains

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

example

Basic domains for simple use cases.

goals

Make declarative assertions about the relationships between values.

state

Track value bindings and constraints during the evaluation process.

util

Assorted helpers, especially for testing.

value

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

Macros

all

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

any

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

lmap

Create an LMap with automatic key/value IntoVal wrapping.

ltup

Create a tuple of logical values with automatic IntoVal wrapping.

lvec

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

val

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

Traits

Query

Derive reified values potential resolved states.

ReifyIn

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

UnifyIn

How compatible values are matched with each other.