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
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)), ) } }