1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

use crate::domains::Domain;
use crate::state::IterResolved;
use crate::ReifyIn;

/** Derive [reified](crate::value::ReifyIn) [values](crate::value) potential
resolved states.

[Query] is implemented for [`Goals`](crate::goals) and
[`States`](crate::State) (and other types), meaning you can call
[`.query()`](Query::query()) on them with any type that implements
[ReifyIn](crate::value::ReifyIn) for a matching [Domain].

This is a convenient wrapper around the pattern of iterating over a sequence
of [`ResolvedStates`](crate::ResolvedState) and calling
[`state.reify(query)`](crate::ResolvedState::reify()) and returning only the
valid, fully resolved results. Query is implemented on a variety of
[`State`](crate::State) related types, allowing it to be used in many
contexts.

A blanket impl covers anything that implements [`IterResolved`], so many
types including [`Goal`](crate::goals) and [`State`](crate::State) are
queryable.
*/
pub trait Query<'a, D: Domain<'a> + 'a> {
    /** Get [reified](crate::value::ReifyIn) results from an iterator of
    [`ResolvedStates`](crate::ResolvedState).

    # Examples:

    ## Goals
    ```
    use canrun::{Goal, unify, var, State};
    use canrun::example::I32;

    let x = var();
    let goal: Goal<I32> = unify(x, 1);
    let result: Vec<_> = goal.query(x).collect();
    assert_eq!(result, vec![1])
    ```

    ## States
    ```
    use canrun::{State, IterResolved, Query, val, var};
    use canrun::example::I32;
    let x = var();

    let state: State<I32> = State::new();
    let result: Vec<_> = state.query(x).collect();
    assert_eq!(result, vec![]) // Nothing has been added to the State
    ```

    ### `Option<State<D>>`
    Note that most of the lower level [`State`](crate::State) update methods
    return an `Option<State<D>>`. Since [`IterResolved`] is implemented for
    this type, Query is as well!
    ```
    # use canrun::{State, IterResolved, Query, val, var};
    # use canrun::example::I32;
    # let x = var();
    let state: Option<State<I32>> = State::new().unify(&val!(x), &val!(1));
    let result: Vec<_> = state.query(x).collect();
    assert_eq!(result, vec![1])
    ```
    */
    fn query<Q>(self, query: Q) -> Box<dyn Iterator<Item = Q::Reified> + 'a>
    where
        Q: ReifyIn<'a, D> + 'a;
}

impl<'a, D: Domain<'a> + 'a, S: IterResolved<'a, D>> Query<'a, D> for S {
    fn query<Q>(self, query: Q) -> Box<dyn Iterator<Item = Q::Reified> + 'a>
    where
        Q: ReifyIn<'a, D> + 'a,
    {
        Box::new(
            self.iter_resolved()
                .filter_map(move |resolved| query.reify_in(&resolved)),
        )
    }
}