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::{LVar, Query};
use canrun::goals::{both, unify};

let x = LVar::new();
let y = LVar::new();
let goal = 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 goals::Goal;
• pub use goals::both;
• pub use goals::cmp;
• pub use goals::custom;
• pub use goals::either;
• pub use goals::lazy;
• pub use goals::not;
• pub use goals::ops;
• pub use goals::project;
• pub use goals::unify;
• pub use goals::Fail;
• pub use goals::Succeed;
• pub use crate::core::*;
• pub use collections::*;

Modules

• collections
  Unifiable collections with supporting goal functions.
• core
  Low level implementation with basic unification, forking and constraint tracking.
• docs
  Tutorials and other more in-depth documentation (mostly WIP).
• goals
  Declarative relationships between values.

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 Into<Value<T>> wrapping.
• ltup
  Create a tuple of logical values with automatic Into<Value<T>> wrapping.
• lvec
  Create an LVec<T> with automatic Into<Value<T>> conversion.