Struct LookupSet 

pub struct LookupSet<'s, 'i, T: Hash + Eq, V = &'s T> { /* private fields */ }

Result of a lookup by name in a Scope.

Elements represented by a LookupSet can be filtered and transformed using the filter(), map(), filter_map(), and filter_map_ok() functions, which work similarly to their counterpart on iterators. LookupSet<T, V> represents elements coming from a Scope<T> and transformed (by map() or filter_map()) into elements of type V.

The difference from a standard iterator is that LookupSet remembers enough information to allow the one() method to emit detailed error diagnostics. See one() for details.

Implementations

impl<'s, 'i, T: 's + Hash + Eq, V: 's> LookupSet<'s, 'i, T, V>

pub fn name(&self) -> &Identifier<'_>

Get the Identifier the LookupSet was looked up for.

pub fn is_empty(&self) -> bool

Tell if the LookupSet is empty.

pub fn filter_map_ok<R: 's>( self, f: impl 's + Fn(V) -> Result<Option<R>>, ) -> LookupSet<'s, 'i, T, R>

Get a LookupSet of only the elements of self transformed by the function f for only the elements v where f(v) returns Ok(Some(_)). If f returns Err(_), the whole LookupSet becomes erroneous and any call to all() or one() will return the same Err(_).

pub fn filter_map<R: 's>( self, f: impl 's + Fn(V) -> Option<R>, ) -> LookupSet<'s, 'i, T, R>

Get a LookupSet of the elements of self transformed by the function f for only the elements v where f(v) returns Some(_).

pub fn filter(self, f: impl 's + Fn(&V) -> bool) -> Self

Get a LookupSet of only the elements of self that satisfy the predicate f.

pub fn filter_ok(self, f: impl 's + Fn(&V) -> Result<bool>) -> Self

Get a LookupSet of only the elements v of self such that f(v) returns Ok(true). If Ok(false) is returned, the element is discarded. If Err(_) is returned, the whole LookupSet becomes erroneous and any call to all() or one() will return the same Err(_).

pub fn map<R: 's>(self, f: impl 's + Fn(V) -> R) -> LookupSet<'s, 'i, T, R>

Get a LookupSet of the elements of self transformed by the function f

pub fn all(self) -> Result<Vec<V>>

Get an iterator of all the elements in the LookupSet.

pub fn or_else( self, other: impl 's + FnOnce() -> LookupSet<'s, 'i, T, V>, ) -> Self

If the current LookupSet is not empty, return it as-is, otherwise call the other closure and return its result.

impl<'s, 'i, T: 's + Clone + Hash + Eq + Located, V: 's> LookupSet<'s, 'i, T, V>

pub fn one(self) -> Result<V>

Return the single element in this LookupSet if only one exist, otherwise produce detailed error diagnostics.

The one() method assumes its usage is within name lookup for a typical statically scoped language (this includes quantifiers or other similar constructs in most logics). By calling this method one asserts that only a single result of the previous call to lookup() is required. If this is the case, the single result is returned. Otherwise, error diagnostics are produced.

The diagnostics are produced after checking further conditions. If there were more than one element the lookup is treated as ambiguous (as if you asked for the name of an overloaded function in some C++-like language without specifying its argument types) and a list of matching symbols is produced as attached notes. If the LookupSet is empty the lookup is treated as a reference to an undefined symbol, but if it was filtered (see filter()), then a list of non-matching symbols is produced as attached notes.