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) -> Accessor<T, F>

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, ) -> Accessor<T, F>

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.

Examples found in repository

examples/derive_deep.rs (line 58)

fn main() {
    let mut user = User {
        profile: Profile {
            address: Address {
                city: "berlin".into(),
                zip: 10115,
            },
            stats: Stats { logins: 1 },
        },
        settings: Settings {
            theme: Theme {
                name: "light".into(),
            },
        },
    };

    // Compose a deep accessor: User -> Profile -> Address -> city
    let acc_city = User::acc_profile()
        .compose(Profile::acc_address())
        .compose(Address::acc_city());

    println!("city before: {}", acc_city.get(&user));

    // In-place deep mutation via set_mut
    acc_city.set_mut(&mut user, |c| c.make_ascii_uppercase());
    println!("city upper: {}", acc_city.get(&user));

    // Set via cloning only the leaf value
    let new_city = String::from("Lund");
    acc_city.set_clone(&mut user, &new_city);
    println!("city after set_clone: {}", acc_city.get(&user));

    // Compose another deep accessor: User -> Settings -> Theme -> name
    let acc_theme_name = User::acc_settings()
        .compose(Settings::acc_theme())
        .compose(Theme::acc_name());

    acc_theme_name.set(&mut user, "dark".to_string());
    println!("theme after set: {}", acc_theme_name.get(&user));

    // Show a non-string leaf with arithmetic updates
    let acc_zip = User::acc_profile()
        .compose(Profile::acc_address())
        .compose(Address::acc_zip());

    acc_zip.set_mut(&mut user, |z| *z += 5);
    println!("zip after +5: {}", acc_zip.get(&user));
}

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.

Examples found in repository

examples/derive_deep.rs (line 74)

fn main() {
    let mut user = User {
        profile: Profile {
            address: Address {
                city: "berlin".into(),
                zip: 10115,
            },
            stats: Stats { logins: 1 },
        },
        settings: Settings {
            theme: Theme {
                name: "light".into(),
            },
        },
    };

    // Compose a deep accessor: User -> Profile -> Address -> city
    let acc_city = User::acc_profile()
        .compose(Profile::acc_address())
        .compose(Address::acc_city());

    println!("city before: {}", acc_city.get(&user));

    // In-place deep mutation via set_mut
    acc_city.set_mut(&mut user, |c| c.make_ascii_uppercase());
    println!("city upper: {}", acc_city.get(&user));

    // Set via cloning only the leaf value
    let new_city = String::from("Lund");
    acc_city.set_clone(&mut user, &new_city);
    println!("city after set_clone: {}", acc_city.get(&user));

    // Compose another deep accessor: User -> Settings -> Theme -> name
    let acc_theme_name = User::acc_settings()
        .compose(Settings::acc_theme())
        .compose(Theme::acc_name());

    acc_theme_name.set(&mut user, "dark".to_string());
    println!("theme after set: {}", acc_theme_name.get(&user));

    // Show a non-string leaf with arithmetic updates
    let acc_zip = User::acc_profile()
        .compose(Profile::acc_address())
        .compose(Address::acc_zip());

    acc_zip.set_mut(&mut user, |z| *z += 5);
    println!("zip after +5: {}", acc_zip.get(&user));
}

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

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

Examples found in repository

examples/derive_deep.rs (line 61)

fn main() {
    let mut user = User {
        profile: Profile {
            address: Address {
                city: "berlin".into(),
                zip: 10115,
            },
            stats: Stats { logins: 1 },
        },
        settings: Settings {
            theme: Theme {
                name: "light".into(),
            },
        },
    };

    // Compose a deep accessor: User -> Profile -> Address -> city
    let acc_city = User::acc_profile()
        .compose(Profile::acc_address())
        .compose(Address::acc_city());

    println!("city before: {}", acc_city.get(&user));

    // In-place deep mutation via set_mut
    acc_city.set_mut(&mut user, |c| c.make_ascii_uppercase());
    println!("city upper: {}", acc_city.get(&user));

    // Set via cloning only the leaf value
    let new_city = String::from("Lund");
    acc_city.set_clone(&mut user, &new_city);
    println!("city after set_clone: {}", acc_city.get(&user));

    // Compose another deep accessor: User -> Settings -> Theme -> name
    let acc_theme_name = User::acc_settings()
        .compose(Settings::acc_theme())
        .compose(Theme::acc_name());

    acc_theme_name.set(&mut user, "dark".to_string());
    println!("theme after set: {}", acc_theme_name.get(&user));

    // Show a non-string leaf with arithmetic updates
    let acc_zip = User::acc_profile()
        .compose(Profile::acc_address())
        .compose(Address::acc_zip());

    acc_zip.set_mut(&mut user, |z| *z += 5);
    println!("zip after +5: {}", acc_zip.get(&user));
}

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.

Examples found in repository

examples/derive_deep.rs (line 66)

fn main() {
    let mut user = User {
        profile: Profile {
            address: Address {
                city: "berlin".into(),
                zip: 10115,
            },
            stats: Stats { logins: 1 },
        },
        settings: Settings {
            theme: Theme {
                name: "light".into(),
            },
        },
    };

    // Compose a deep accessor: User -> Profile -> Address -> city
    let acc_city = User::acc_profile()
        .compose(Profile::acc_address())
        .compose(Address::acc_city());

    println!("city before: {}", acc_city.get(&user));

    // In-place deep mutation via set_mut
    acc_city.set_mut(&mut user, |c| c.make_ascii_uppercase());
    println!("city upper: {}", acc_city.get(&user));

    // Set via cloning only the leaf value
    let new_city = String::from("Lund");
    acc_city.set_clone(&mut user, &new_city);
    println!("city after set_clone: {}", acc_city.get(&user));

    // Compose another deep accessor: User -> Settings -> Theme -> name
    let acc_theme_name = User::acc_settings()
        .compose(Settings::acc_theme())
        .compose(Theme::acc_name());

    acc_theme_name.set(&mut user, "dark".to_string());
    println!("theme after set: {}", acc_theme_name.get(&user));

    // Show a non-string leaf with arithmetic updates
    let acc_zip = User::acc_profile()
        .compose(Profile::acc_address())
        .compose(Address::acc_zip());

    acc_zip.set_mut(&mut user, |z| *z += 5);
    println!("zip after +5: {}", acc_zip.get(&user));
}

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.

Examples found in repository

examples/derive_deep.rs (line 55)

fn main() {
    let mut user = User {
        profile: Profile {
            address: Address {
                city: "berlin".into(),
                zip: 10115,
            },
            stats: Stats { logins: 1 },
        },
        settings: Settings {
            theme: Theme {
                name: "light".into(),
            },
        },
    };

    // Compose a deep accessor: User -> Profile -> Address -> city
    let acc_city = User::acc_profile()
        .compose(Profile::acc_address())
        .compose(Address::acc_city());

    println!("city before: {}", acc_city.get(&user));

    // In-place deep mutation via set_mut
    acc_city.set_mut(&mut user, |c| c.make_ascii_uppercase());
    println!("city upper: {}", acc_city.get(&user));

    // Set via cloning only the leaf value
    let new_city = String::from("Lund");
    acc_city.set_clone(&mut user, &new_city);
    println!("city after set_clone: {}", acc_city.get(&user));

    // Compose another deep accessor: User -> Settings -> Theme -> name
    let acc_theme_name = User::acc_settings()
        .compose(Settings::acc_theme())
        .compose(Theme::acc_name());

    acc_theme_name.set(&mut user, "dark".to_string());
    println!("theme after set: {}", acc_theme_name.get(&user));

    // Show a non-string leaf with arithmetic updates
    let acc_zip = User::acc_profile()
        .compose(Profile::acc_address())
        .compose(Address::acc_zip());

    acc_zip.set_mut(&mut user, |z| *z += 5);
    println!("zip after +5: {}", acc_zip.get(&user));
}

Trait Implementations

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

where T: Clone, F: Clone,

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, F> Debug for Accessor<T, F>

where T: Debug, F: Debug,

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

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

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

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

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

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

where E: Clone,

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

where T: Copy, F: Copy,