Struct Accessor 

pub struct Accessor<T, F> { /* private fields */ }

A small, copyable accessor that focuses into a field F inside a root T.

Representation: a byte offset from the start of T to the field F. This allows cheap composition by offset addition. All operations are implemented via unsafe pointer arithmetic but expose a safe API.

Implementations

impl<T, F> Accessor<T, F>

pub const unsafe fn from_offset(offset: isize) -> Self

Construct from a precomputed byte offset.

Safety

The offset must satisfy all of the following conditions for every valid instance of T:

• It is the exact byte distance from the start of T to the target field F within the same allocation (i.e., derived from an actual field projection of T).
• The resulting pointer computed as (&T as *const u8).offset(offset) as *const F is properly aligned for F and points to initialized memory owned by the same T object.
• The accessor will only ever be used with values of type T that have the same layout with respect to the field F (e.g., not a different type or transmuted layout).

Violating any of these preconditions is undefined behavior. Prefer constructing accessors via #[derive(Accessor)] or Accessor::from_fns, which compute valid offsets for you.

pub fn from_fns(get_ref: fn(&T) -> &F, _get_mut: fn(&mut T) -> &mut F) -> Self

Runtime constructor from field-selection functions. Computes the offset using raw pointer projection without dereferencing invalid memory.

pub fn get<'a>(&self, root: &'a T) -> &'a F

Borrow the focused field immutably.

pub fn get_mut<'a>(&self, root: &'a mut T) -> &'a mut F

Borrow the focused field mutably.

pub fn set(&self, root: &mut T, value: F)

Set by moving a new value into the focused location.

pub fn set_mut(&self, root: &mut T, f: impl FnOnce(&mut F))

Mutate the focused location in-place using the provided closure.

pub fn set_clone(&self, root: &mut T, value: &F)

where F: Clone,

Set by cloning the provided value into the focused location.

MVP semantics:

• The caller provides a shared reference to the value, and we perform a top-level Clone of that value, then move it into the field.
• Only F: Clone is required; the root type T does not need to implement Clone.
• This behavior composes: for a composed accessor focusing T -> ... -> V, calling set_clone only requires V: Clone.

pub fn compose<V>(self, next: Accessor<F, V>) -> Accessor<T, V>

Compose this accessor with another, yielding an accessor from T to V.

Given self: Accessor<T, U> and next: Accessor<U, V>, returns Accessor<T, V> that focuses by first going through self then next.

Trait Implementations

impl<T: Clone, F: Clone> Clone for Accessor<T, F>

fn clone(&self) -> Accessor<T, F>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, F: Debug> Debug for Accessor<T, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, E> Indexing<T, E> for Accessor<T, Vec<E>>

fn get_at<'a>(&self, root: &'a T, idx: usize) -> &'a E

Borrow the element at idx immutably.

fn get_mut_at<'a>(&self, root: &'a mut T, idx: usize) -> &'a mut E

Borrow the element at idx mutably.

fn set_at(&self, root: &mut T, idx: usize, value: E)

Set the element at idx by moving value in.

fn set_mut_at(&self, root: &mut T, idx: usize, f: impl FnOnce(&mut E))

Mutate the element at idx in-place using the closure.

fn set_clone_at(&self, root: &mut T, idx: usize, value: &E)

where E: Clone,

Set the element at idx by cloning from value.

impl<T: Copy, F: Copy> Copy for Accessor<T, F>