Trait ukanren::Goal

pub trait Goal {
    type Iter: Iterator<Item = State>;
    fn apply(&self, s: &State) -> Self::Iter;

    fn and<G, I>(self, other: G) -> And<Self, G>
    where
        Self: Sized,
        G: Goal<Iter = I>,
        I: Iterator<Item = State>,
    { ... }
    fn or<G, I>(self, other: G) -> Or<Self, G>
    where
        Self: Sized,
        G: Goal<Iter = I>,
        I: Iterator<Item = State>,
    { ... }
    fn boxed(self) -> BoxedGoal<Self::Iter>
    where
        Self: Sized + 'static,
    { ... }
    fn run(&self, k: usize) -> RunStream<Self::Iter> { ... }
}

A goal that can be executed by the relational system.

Associated Types

type Iter: Iterator<Item = State>

The state iterator returned by the goal.

Required methods

fn apply(&self, s: &State) -> Self::Iter

Apply this goal to an initial state, returning a stream of satisfying states.

Provided methods

fn and<G, I>(self, other: G) -> And<Self, G> where
    Self: Sized,
    G: Goal<Iter = I>,
    I: Iterator<Item = State>, 

Take the conjunction of this goal with another.

fn or<G, I>(self, other: G) -> Or<Self, G> where
    Self: Sized,
    G: Goal<Iter = I>,
    I: Iterator<Item = State>, 

Take the disjunction of this goal with another.

fn boxed(self) -> BoxedGoal<Self::Iter> where
    Self: Sized + 'static, 

Box this goal, which simplifies types at the expense of performance.

fn run(&self, k: usize) -> RunStream<Self::Iter>

Evaluate this goal on an empty state, returning a stream of results.

These results contain normalized forms of the first k variables, to avoid including auxiliary data that is not relevant to us.

Implementors

impl<G1, G2, I1, I2> Goal for And<G1, G2> where
    G1: Goal<Iter = I1>,
    G2: Goal<Iter = I2> + Clone + 'static,
    I1: Iterator<Item = State>,
    I2: Iterator<Item = State>, 

type Iter = FlatMap<I1, I2, Box<dyn Fn(State) -> I2>>

impl<G1, G2, I1, I2> Goal for Or<G1, G2> where
    G1: Goal<Iter = I1>,
    G2: Goal<Iter = I2>,
    I1: Iterator<Item = State>,
    I2: Iterator<Item = State>, 

type Iter = Interleave<I1, I2>

impl<G, I> Goal for G where
    G: Fn(&State) -> I,
    I: Iterator<Item = State>, 

type Iter = I

impl<T> Goal for BoxedGoal<T> where
    T: Iterator<Item = State> + 'static, 

type Iter = Box<dyn Iterator<Item = State>>