proto-vulcan 0.1.5

A miniKanren-family relational logic programming language embedded in Rust
Documentation

proto-vulcan

A miniKanren-family relational logic programming language embedded in Rust.

In addition to core miniKanren language, proto-vulcan currently provides support for:

  • Disequality constraints CLP(Tree)
  • Finite-domain constraints CLP(FD)
  • Various operators: anyo, conda, condu, onceo, project
  • Pattern matching: matche, matcha, matchu
  • Writing goals in Rust embedded inline within proto-vulcan
  • User extension interface

The language is embedded into Rust with macros which parse the language syntax and convert it into Rust.

Example

extern crate proto_vulcan;
use proto_vulcan::prelude::*;

fn main() {
    let query = proto_vulcan_query!(|q| {
        conde {
            q == 1,
            q == 2,
            q == 3,
        }
    });

    for result in query.run() {
        println!("q = {}", result.q);
    }
}

The example program produces three solutions:

q = 1
q = 2
q = 3

New relations can be defined as Rust-functions using proto_vulcan! and proto_vulcan_closure!-macros. Expressions within proto_vulcan! are evaluated immediately, whereas expressions within proto_vulcan_closure! are stored into a closure and evaluated later. Recursive relations must use the latter variant.

use proto_vulcan::prelude::*;

pub fn appendo(l: LTerm, s: LTerm, ls: LTerm) -> Goal {
    proto_vulcan_closure!(
        match [l, s, ls] {
            [[], x, x] => ,
            [[x | l1], l2, [x | l3]] => appendo(l1, l2, l3),
        }
    )
}

More examples in documentation.

License

Licensed under either of

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.