Trait interact::Access

pub trait Access {
    fn immut_access(&self) -> ImmutAccess;
    fn mut_access(&mut self) -> MutAccess;

    fn immut_call<'a>(
        &self, 
        _func_name: &'static str, 
        _climber: &mut Climber<'a>, 
        _retcall: RetValCallback<'a>
    ) -> Result<(), CallError> { ... }
    fn mut_call<'a>(
        &mut self, 
        _func_name: &'static str, 
        _climber: &mut Climber<'a>, 
        _retcall: RetValCallback<'a>
    ) -> Result<(), CallError> { ... }
    fn mut_assign<'a, 'b>(
        &mut self, 
        _tokens: &mut Tracker<'a, 'b>, 
        _probe_only: bool
    ) -> Result<(), AssignError> { ... }
}

The Access trait, meant to be used as a trait object, provides methods that dynamically expose read&write access to the underlying objects.

Required methods

fn immut_access(&self) -> ImmutAccess

Expose an immmutable accessor, used when Access is immutable or mutable.

fn mut_access(&mut self) -> MutAccess

Expose a mutable accessor, used when Access is mutable.

Loading content...

Provided methods

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

Perform an optional method call for a certain function, with the return value provided to the callback. The arguments are parsed from the Token tracker in the Climber parameter.

Depending on the state of the Climber, we may just parsing the arguments not not actually calling the function, in order to provide user feedback.

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

Perform an optional method call for a certain function which may modify the underlying value, with the return value provided to the callback. The arguments are parsed from the Token tracker in the Climber parameter.

Depending on the state of the Climber, we may just parsing the arguments not not actually calling the function, in order to provide user feedback.

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

Assign a new value to this object. probe_only determines whether the implementation would only parse the new value and not actually assign it. This is in order to provide user feedback for the parsing bits.

Loading content...

Trait Implementations

impl<'a, K> ReflectIter<&'a (dyn Access + 'a)> for Iter<'a, K> where
    K: Eq + Hash + Access, 

fn reflect_next(&mut self) -> Option<&'a dyn Access>

Implementations on Foreign Types

impl Access for usize

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tracker: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl Access for u64

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tracker: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl Access for u32

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tracker: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl Access for u16

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tracker: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl Access for u8

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tracker: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl Access for isize

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tracker: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl Access for bool

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tracker: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl Access for String

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tracker: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl Access for char

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tracker: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl Access for i64

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tracker: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl Access for i32

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tracker: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl Access for i16

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tracker: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl Access for i8

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tracker: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<K: Access + Deser, V: Access + Deser> Access for BTreeMap<K, V> where
    K: Eq + Ord + Deser, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<'a, T: 'a> Access for &'a T where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn mut_assign<'c, 'b>(
    &mut self,
    _tracker: &mut Tracker<'c, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

impl<'a, T: 'a> Access for &'a mut T where
    T: Access + Deser, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn mut_assign<'x, 'y>(
    &mut self,
    tracker: &mut Tracker<'x, 'y>,
    probe_only: bool
) -> Result<(), AssignError>

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

impl<T> Access for Box<T> where
    T: Access + Deser, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn mut_assign<'x, 'y>(
    &mut self,
    tracker: &mut Tracker<'x, 'y>,
    probe_only: bool
) -> Result<(), AssignError>

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

impl<T> Access for Rc<T> where
    T: Access + Deser, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn mut_assign<'x, 'y>(
    &mut self,
    tracker: &mut Tracker<'x, 'y>,
    probe_only: bool
) -> Result<(), AssignError>

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

impl<T> Access for Arc<T> where
    T: Access + Deser, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn mut_assign<'x, 'y>(
    &mut self,
    tracker: &mut Tracker<'x, 'y>,
    probe_only: bool
) -> Result<(), AssignError>

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

impl<T: Access + Deser> Access for Option<T>

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tracker: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T: Access + Deser, E: Access + Deser> Access for Result<T, E>

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tracker: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<K: Access + Deser, V: Access + Deser, S> Access for HashMap<K, V, S> where
    K: Eq + Hash + Deser,
    S: BuildHasher, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<K: Access + Deser, S> Access for HashSet<K, S> where
    K: Eq + Hash,
    S: BuildHasher, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl Access for Instant

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T: Access + Deser> Access for Mutex<T>

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T: Access + Deser> Access for RefCell<T>

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tracker: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<A> Access for (A,) where
    A: Access + Deser, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn mut_assign<'x, 'y>(
    &mut self,
    tracker: &mut Tracker<'x, 'y>,
    probe_only: bool
) -> Result<(), AssignError>

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

impl Access for ()

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn mut_assign<'x, 'y>(
    &mut self,
    tracker: &mut Tracker<'x, 'y>,
    probe_only: bool
) -> Result<(), AssignError>

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

impl<A, B> Access for (A, B) where
    A: Access + Deser,
    B: Access + Deser, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn mut_assign<'x, 'y>(
    &mut self,
    tracker: &mut Tracker<'x, 'y>,
    probe_only: bool
) -> Result<(), AssignError>

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

impl<A, B, C> Access for (A, B, C) where
    A: Access + Deser,
    B: Access + Deser,
    C: Access + Deser, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn mut_assign<'x, 'y>(
    &mut self,
    tracker: &mut Tracker<'x, 'y>,
    probe_only: bool
) -> Result<(), AssignError>

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

impl<A, B, C, D> Access for (A, B, C, D) where
    A: Access + Deser,
    B: Access + Deser,
    C: Access + Deser,
    D: Access + Deser, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn mut_assign<'x, 'y>(
    &mut self,
    tracker: &mut Tracker<'x, 'y>,
    probe_only: bool
) -> Result<(), AssignError>

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

impl<A, B, C, D, E> Access for (A, B, C, D, E) where
    A: Access + Deser,
    B: Access + Deser,
    C: Access + Deser,
    D: Access + Deser,
    E: Access + Deser, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn mut_assign<'x, 'y>(
    &mut self,
    tracker: &mut Tracker<'x, 'y>,
    probe_only: bool
) -> Result<(), AssignError>

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

impl<A, B, C, D, E, F> Access for (A, B, C, D, E, F) where
    A: Access + Deser,
    B: Access + Deser,
    C: Access + Deser,
    D: Access + Deser,
    E: Access + Deser,
    F: Access + Deser, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn mut_assign<'x, 'y>(
    &mut self,
    tracker: &mut Tracker<'x, 'y>,
    probe_only: bool
) -> Result<(), AssignError>

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

impl<A, B, C, D, E, F, G> Access for (A, B, C, D, E, F, G) where
    A: Access + Deser,
    B: Access + Deser,
    C: Access + Deser,
    D: Access + Deser,
    E: Access + Deser,
    F: Access + Deser,
    G: Access + Deser, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn mut_assign<'x, 'y>(
    &mut self,
    tracker: &mut Tracker<'x, 'y>,
    probe_only: bool
) -> Result<(), AssignError>

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

impl<A, B, C, D, E, F, G, H> Access for (A, B, C, D, E, F, G, H) where
    A: Access + Deser,
    B: Access + Deser,
    C: Access + Deser,
    D: Access + Deser,
    E: Access + Deser,
    F: Access + Deser,
    G: Access + Deser,
    H: Access + Deser, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn mut_assign<'x, 'y>(
    &mut self,
    tracker: &mut Tracker<'x, 'y>,
    probe_only: bool
) -> Result<(), AssignError>

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

impl<A, B, C, D, E, F, G, H, I> Access for (A, B, C, D, E, F, G, H, I) where
    A: Access + Deser,
    B: Access + Deser,
    C: Access + Deser,
    D: Access + Deser,
    E: Access + Deser,
    F: Access + Deser,
    G: Access + Deser,
    H: Access + Deser,
    I: Access + Deser, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn mut_assign<'x, 'y>(
    &mut self,
    tracker: &mut Tracker<'x, 'y>,
    probe_only: bool
) -> Result<(), AssignError>

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

impl<A, B, C, D, E, F, G, H, I, J> Access for (A, B, C, D, E, F, G, H, I, J) where
    A: Access + Deser,
    B: Access + Deser,
    C: Access + Deser,
    D: Access + Deser,
    E: Access + Deser,
    F: Access + Deser,
    G: Access + Deser,
    H: Access + Deser,
    I: Access + Deser,
    J: Access + Deser, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn mut_assign<'x, 'y>(
    &mut self,
    tracker: &mut Tracker<'x, 'y>,
    probe_only: bool
) -> Result<(), AssignError>

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

impl<T, '_> Access for &'_ [T] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T, '_> Access for &'_ mut [T] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for Vec<T> where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 1] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 2] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 3] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 4] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 5] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 6] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 7] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 8] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 9] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 10] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 11] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 12] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 13] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 14] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 15] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 16] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 17] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 18] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 19] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 21] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 22] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 23] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 24] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 25] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 27] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 28] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 29] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 31] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

impl<T> Access for [T; 32] where
    T: Access, 

fn immut_access(&self) -> ImmutAccess

fn mut_access(&mut self) -> MutAccess

fn immut_call<'a>(
    &self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_call<'a>(
    &mut self,
    _func_name: &'static str,
    _climber: &mut Climber<'a>,
    _retcall: RetValCallback<'a>
) -> Result<(), CallError>

fn mut_assign<'a, 'b>(
    &mut self,
    _tokens: &mut Tracker<'a, 'b>,
    _probe_only: bool
) -> Result<(), AssignError>

Loading content...

Implementors

Loading content...