Trait At

pub trait At<Index> {
    type View: ?Sized;

    // Required method
    fn access_at<R, F>(&mut self, i: Index, f: F) -> Option<R>
       where F: FnOnce(&mut Self::View) -> R;
}

A smart access protocol.

It is intended to be used through a Cps-bounded type.

Required Associated Types

type View: ?Sized

Required Methods

fn access_at<R, F>(&mut self, i: Index, f: F) -> Option<R>

where F: FnOnce(&mut Self::View) -> R,

Accesses data at a specified index.

If there is some data (or some bidirectional procedure) associated with the index then access_at must apply f to this data.

If the transformation result can be placed back into self then it must be placed back and access_at must return Some(f(data)).

Otherwise None must be returned and self must stay unchanged.

In essence access_at returns None if and only if self has not been touched.

Note

The following two cases are indistinguishable:

• a view couldn’t be obtained (and thus f had not been called)
• f had been called but failed to mutate the view in a meaningful way

If you need to distinguish between these cases you can use some side-effect of f.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<K, V> At<(K, V)> for BTreeMap<K, V>

where K: Ord,

type View = V

fn access_at<R, F>(&mut self, kv: (K, V), f: F) -> Option<R>

where F: FnOnce(&mut V) -> R,

impl<K, V> At<(K, V)> for HashMap<K, V>

where K: Eq + Hash,

type View = V

fn access_at<R, F>(&mut self, kv: (K, V), f: F) -> Option<R>

where F: FnOnce(&mut V) -> R,

impl<K, V, M> At<(K, V, M)> for BTreeMap<K, V>

where K: Ord, M: FnOnce(&mut V),

type View = V

fn access_at<R, F>(&mut self, kvm: (K, V, M), f: F) -> Option<R>

where F: FnOnce(&mut V) -> R,

impl<K, V, M> At<(K, V, M)> for HashMap<K, V>

where K: Eq + Hash, M: FnOnce(&mut V),

type View = V

fn access_at<R, F>(&mut self, kvm: (K, V, M), f: F) -> Option<R>

where F: FnOnce(&mut V) -> R,

impl<Q, K, V> At<&Q> for BTreeMap<K, V>

where K: Borrow<Q> + Ord, Q: ?Sized + Ord,

type View = V

fn access_at<R, F>(&mut self, i: &Q, f: F) -> Option<R>

where F: FnOnce(&mut V) -> R,

impl<Q, K, V> At<&Q> for HashMap<K, V>

where K: Borrow<Q> + Eq + Hash, Q: ?Sized + Eq + Hash,

type View = V

fn access_at<R, F>(&mut self, i: &Q, f: F) -> Option<R>

where F: FnOnce(&mut V) -> R,

impl<Q, T> At<&Q> for BTreeSet<T>

where T: Borrow<Q> + Ord, Q: ?Sized + Ord,

type View = T

fn access_at<R, F>(&mut self, i: &Q, f: F) -> Option<R>

where F: FnOnce(&mut T) -> R,

impl<Q, T> At<&Q> for HashSet<T>

where T: Borrow<Q> + Eq + Hash, Q: ?Sized + Eq + Hash,

type View = T

fn access_at<R, F>(&mut self, i: &Q, f: F) -> Option<R>

where F: FnOnce(&mut T) -> R,

impl<T> At<(T, ())> for BTreeSet<T>

where T: Ord,

type View = T

fn access_at<R, F>(&mut self, item: (T, ()), f: F) -> Option<R>

where F: FnOnce(&mut T) -> R,

impl<T> At<(T, ())> for HashSet<T>

where T: Eq + Hash,

type View = T

fn access_at<R, F>(&mut self, item: (T, ()), f: F) -> Option<R>

where F: FnOnce(&mut T) -> R,

impl<T> At<(T,)> for BTreeSet<T>

where T: Ord,

type View = BTreeSet<T>

fn access_at<R, F>(&mut self, item: (T,), f: F) -> Option<R>

where F: FnOnce(&mut Self) -> R,

impl<T> At<(T,)> for HashSet<T>

where T: Eq + Hash,

type View = HashSet<T>

fn access_at<R, F>(&mut self, item: (T,), f: F) -> Option<R>

where F: FnOnce(&mut Self) -> R,

impl<T> At<()> for Option<T>

type View = T

fn access_at<R, F>(&mut self, _: (), f: F) -> Option<R>

where F: FnOnce(&mut T) -> R,

impl<T> At<()> for Vec<T>

type View = [T]

fn access_at<R, F>(&mut self, _: (), f: F) -> Option<R>

where F: FnOnce(&mut Self::View) -> R,

impl<T> At<usize> for [T]

type View = T

fn access_at<R, F>(&mut self, i: usize, f: F) -> Option<R>

where F: FnOnce(&mut T) -> R,

impl<T> At<usize> for Vec<T>

type View = T

fn access_at<R, F>(&mut self, i: usize, f: F) -> Option<R>

where F: FnOnce(&mut Self::View) -> R,

impl<T> At<Range<usize>> for [T]

type View = [T]

fn access_at<R, F>(&mut self, i: Range<usize>, f: F) -> Option<R>

where F: FnOnce(&mut Self::View) -> R,

impl<T> At<Range<usize>> for Vec<T>

type View = Vec<T>

fn access_at<R, F>(&mut self, i: Range<usize>, f: F) -> Option<R>

where F: FnOnce(&mut Self::View) -> R,

impl<T> At<RangeFrom<usize>> for [T]

type View = [T]

fn access_at<R, F>(&mut self, i: RangeFrom<usize>, f: F) -> Option<R>

where F: FnOnce(&mut Self::View) -> R,

impl<T> At<RangeFrom<usize>> for Vec<T>

type View = Vec<T>

fn access_at<R, F>(&mut self, i: RangeFrom<usize>, f: F) -> Option<R>

where F: FnOnce(&mut Self::View) -> R,

impl<T> At<RangeFull> for [T]

type View = [T]

fn access_at<R, F>(&mut self, _: RangeFull, f: F) -> Option<R>

where F: FnOnce(&mut Self::View) -> R,

impl<T> At<RangeFull> for Vec<T>

type View = Vec<T>

fn access_at<R, F>(&mut self, _: RangeFull, f: F) -> Option<R>

where F: FnOnce(&mut Self::View) -> R,

impl<T> At<RangeInclusive<usize>> for [T]

type View = [T]

fn access_at<R, F>(&mut self, i: RangeInclusive<usize>, f: F) -> Option<R>

where F: FnOnce(&mut Self::View) -> R,

impl<T> At<RangeInclusive<usize>> for Vec<T>

type View = Vec<T>

fn access_at<R, F>(&mut self, i: RangeInclusive<usize>, f: F) -> Option<R>

where F: FnOnce(&mut Self::View) -> R,

impl<T> At<RangeTo<usize>> for [T]

type View = [T]

fn access_at<R, F>(&mut self, i: RangeTo<usize>, f: F) -> Option<R>

where F: FnOnce(&mut Self::View) -> R,

impl<T> At<RangeTo<usize>> for Vec<T>

type View = Vec<T>

fn access_at<R, F>(&mut self, i: RangeTo<usize>, f: F) -> Option<R>

where F: FnOnce(&mut Self::View) -> R,

impl<T> At<RangeToInclusive<usize>> for [T]

type View = [T]

fn access_at<R, F>(&mut self, i: RangeToInclusive<usize>, f: F) -> Option<R>

where F: FnOnce(&mut Self::View) -> R,

impl<T> At<RangeToInclusive<usize>> for Vec<T>

type View = Vec<T>

fn access_at<R, F>(&mut self, i: RangeToInclusive<usize>, f: F) -> Option<R>

where F: FnOnce(&mut Self::View) -> R,

impl<T, S> At<()> for Result<T, S>

type View = T

fn access_at<R, F>(&mut self, _: (), f: F) -> Option<R>

where F: FnOnce(&mut T) -> R,

Implementors

impl<'a, I, B, V> At<Bounds<B>> for I

where I: Iterator<Item = &'a mut V>, [&'a mut V]: At<B, View = [&'a mut V]>, V: 'a + ?Sized,

type View = Slice<V>

impl<T> At<usize> for Slice<T>

type View = T

impl<T> At<Range<usize>> for Slice<T>

type View = Slice<T>

impl<T> At<RangeFrom<usize>> for Slice<T>

type View = Slice<T>

impl<T> At<RangeFull> for Slice<T>

type View = Slice<T>

impl<T> At<RangeInclusive<usize>> for Slice<T>

type View = Slice<T>

impl<T> At<RangeTo<usize>> for Slice<T>

type View = Slice<T>

impl<T> At<RangeToInclusive<usize>> for Slice<T>

type View = Slice<T>