Struct Lens 

pub struct Lens<S, T, A, B> { /* private fields */ }

A van Laarhoven–style lens encoded with getter/setter function pointers.

S — source type, T — modified source type, A — focus type, B — replacement type.

For simple (non-polymorphic) lenses, use SimpleLens.

Implementations

impl<S, T, A, B> Lens<S, T, A, B>

pub fn new(getter: fn(&S) -> A, setter: fn(S, B) -> T) -> Lens<S, T, A, B>

Examples found in repository

examples/domain_model_optics.rs (lines 58-61)

fn customer_lens() -> SimpleLens<Order, Customer> {
    Lens::new(
        |o: &Order| o.customer.clone(),
        |o, customer| Order { customer, ..o },
    )
}

fn address_lens() -> SimpleLens<Customer, Address> {
    Lens::new(
        |c: &Customer| c.address.clone(),
        |c, address| Customer { address, ..c },
    )
}

fn city_lens() -> SimpleLens<Address, String> {
    Lens::new(
        |a: &Address| a.city.clone(),
        |a, city| Address { city, ..a },
    )
}

fn zip_lens() -> SimpleLens<Address, String> {
    Lens::new(|a: &Address| a.zip.clone(), |a, zip| Address { zip, ..a })
}

fn name_lens() -> SimpleLens<Customer, String> {
    Lens::new(
        |c: &Customer| c.name.clone(),
        |c, name| Customer { name, ..c },
    )
}

examples/data_transformation.rs (lines 73-76)

fn amount_lens() -> SimpleLens<Transaction, i64> {
    Lens::new(
        |t: &Transaction| t.amount_cents,
        |t, amount_cents| Transaction { amount_cents, ..t },
    )
}

fn name_lens() -> SimpleLens<Transaction, String> {
    Lens::new(
        |t: &Transaction| t.name.clone(),
        |t, name| Transaction { name, ..t },
    )
}

pub fn get(&self, s: &S) -> A

Examples found in repository

examples/domain_model_optics.rs (line 170)

fn main() {
    println!("=== Domain Model with Optics Example ===\n");

    let order = sample_order();

    // 1. Lens: get/set/over
    println!("--- Lens: basic get/set/over ---");
    let customer = customer_lens();
    let address = address_lens();
    let city = city_lens();

    println!("  Customer name: {}", name_lens().get(&order.customer));
    println!("  City: {}", city.get(&address.get(&customer.get(&order))));

    // 2. Composed Lens: deep access with .then()
    println!("\n--- ComposedLens: deep access with .then() ---");
    let order_city = customer_lens().then(address_lens()).then(city_lens());
    let order_zip = customer_lens().then(address_lens()).then(zip_lens());

    println!("  Order city: {}", order_city.get(&order));
    println!("  Order zip:  {}", order_zip.get(&order));

    // Deep set
    let updated = order_city.set(order.clone(), "Shelbyville".into());
    println!("  After city update: {}", order_city.get(&updated));
    println!("  Original unchanged: {}", order_city.get(&order));

    // Deep over (modify)
    let uppercased = order_city.over(order.clone(), |c| c.to_uppercase());
    println!("  Uppercased city: {}", order_city.get(&uppercased));

    // 3. Lens::transform — reusable update function
    println!("\n--- Lens::transform — reusable update function ---");
    let normalize_city: Box<dyn Fn(String) -> String> = Box::new(|c| c.trim().to_uppercase());
    let normalize_order_city = city_lens().transform::<FnP>(normalize_city);
    let addr = Address {
        street: "456 Oak Ave".into(),
        city: "  new york  ".into(),
        zip: "10001".into(),
    };
    let normalized = normalize_order_city(addr);
    println!("  Normalized city: {:?}", normalized.city);

    // 4. Prism: sum type focus
    println!("\n--- Prism: sum type focus ---");
    let cc = credit_card_prism();
    let wallet = wallet_prism();
    let bank = bank_transfer_prism();

    println!("  Credit card last4: {:?}", cc.preview(&order.payment));
    println!("  Wallet preview:    {:?}", wallet.preview(&order.payment));

    // Prism::review — construct a variant
    let new_payment = wallet.review(("PayPal".into(), 5000));
    println!("  New wallet payment: {:?}", new_payment);

    // Prism::over — modify only if matched
    let updated_payment = cc.over(order.payment.clone(), |(last4, _exp)| {
        (last4, "01/28".into())
    });
    println!("  Updated CC expiry: {:?}", updated_payment);

    // Prism on non-matching variant: passes through unchanged
    let unchanged = wallet.over(order.payment.clone(), |(prov, bal)| (prov, bal + 1000));
    println!("  Wallet over on CC (unchanged): {:?}", unchanged);

    // 5. Prism::transform — reusable pattern-matching function
    println!("\n--- Prism::transform — reusable variant modifier ---");
    let add_balance: Box<dyn Fn((String, i64)) -> (String, i64)> =
        Box::new(|(prov, bal)| (prov, bal + 2500));
    let add_wallet_balance = wallet.transform::<FnP>(add_balance);

    let wallet_payment = Payment::Wallet {
        provider: "PayPal".into(),
        balance_cents: 10000,
    };
    let topped_up = add_wallet_balance(wallet_payment);
    println!("  Topped up: {:?}", topped_up);

    // Apply same transform to non-wallet — passes through
    let still_cc = add_wallet_balance(order.payment.clone());
    println!("  CC unchanged: {:?}", still_cc);

    // 6. Summary: combine multiple optics
    println!("\n--- Combining lenses and prisms ---");
    let orders = vec![
        sample_order(),
        Order {
            id: 1002,
            customer: Customer {
                name: "Bob Jones".into(),
                address: Address {
                    street: "789 Elm St".into(),
                    city: "Capital City".into(),
                    zip: "12345".into(),
                },
            },
            items: vec![Item {
                name: "Mouse".into(),
                price_cents: 2999,
                quantity: 1,
            }],
            payment: Payment::Wallet {
                provider: "Stripe".into(),
                balance_cents: 50000,
            },
        },
        Order {
            id: 1003,
            customer: Customer {
                name: "Carol White".into(),
                address: Address {
                    street: "321 Pine Rd".into(),
                    city: "Springfield".into(),
                    zip: "62702".into(),
                },
            },
            items: vec![],
            payment: Payment::BankTransfer {
                iban: "DE89370400440532013000".into(),
            },
        },
    ];

    let order_city_lens = customer_lens().then(address_lens()).then(city_lens());
    println!("  All cities:");
    for o in &orders {
        let payment_type = match &o.payment {
            Payment::CreditCard { .. } => "CC",
            Payment::BankTransfer { .. } => "Bank",
            Payment::Wallet { .. } => "Wallet",
        };
        println!(
            "    Order #{}: {} ({}, pays via {})",
            o.id,
            order_city_lens.get(o),
            name_lens().get(&o.customer),
            payment_type
        );
    }

    // Find all bank IBANs using Prism
    println!("\n  Bank IBANs:");
    for o in &orders {
        if let Some(iban) = bank.preview(&o.payment) {
            println!("    Order #{}: {}", o.id, iban);
        }
    }
}

pub fn set(&self, s: S, b: B) -> T

pub fn then<X, Y>(self, inner: Lens<A, B, X, Y>) -> ComposedLens<S, T, X, Y>

where S: 'static, T: 'static, A: 'static, B: 'static, X: 'static, Y: 'static,

Chain another lens to focus deeper, producing a ComposedLens.

Examples found in repository

examples/domain_model_optics.rs (line 175)

fn main() {
    println!("=== Domain Model with Optics Example ===\n");

    let order = sample_order();

    // 1. Lens: get/set/over
    println!("--- Lens: basic get/set/over ---");
    let customer = customer_lens();
    let address = address_lens();
    let city = city_lens();

    println!("  Customer name: {}", name_lens().get(&order.customer));
    println!("  City: {}", city.get(&address.get(&customer.get(&order))));

    // 2. Composed Lens: deep access with .then()
    println!("\n--- ComposedLens: deep access with .then() ---");
    let order_city = customer_lens().then(address_lens()).then(city_lens());
    let order_zip = customer_lens().then(address_lens()).then(zip_lens());

    println!("  Order city: {}", order_city.get(&order));
    println!("  Order zip:  {}", order_zip.get(&order));

    // Deep set
    let updated = order_city.set(order.clone(), "Shelbyville".into());
    println!("  After city update: {}", order_city.get(&updated));
    println!("  Original unchanged: {}", order_city.get(&order));

    // Deep over (modify)
    let uppercased = order_city.over(order.clone(), |c| c.to_uppercase());
    println!("  Uppercased city: {}", order_city.get(&uppercased));

    // 3. Lens::transform — reusable update function
    println!("\n--- Lens::transform — reusable update function ---");
    let normalize_city: Box<dyn Fn(String) -> String> = Box::new(|c| c.trim().to_uppercase());
    let normalize_order_city = city_lens().transform::<FnP>(normalize_city);
    let addr = Address {
        street: "456 Oak Ave".into(),
        city: "  new york  ".into(),
        zip: "10001".into(),
    };
    let normalized = normalize_order_city(addr);
    println!("  Normalized city: {:?}", normalized.city);

    // 4. Prism: sum type focus
    println!("\n--- Prism: sum type focus ---");
    let cc = credit_card_prism();
    let wallet = wallet_prism();
    let bank = bank_transfer_prism();

    println!("  Credit card last4: {:?}", cc.preview(&order.payment));
    println!("  Wallet preview:    {:?}", wallet.preview(&order.payment));

    // Prism::review — construct a variant
    let new_payment = wallet.review(("PayPal".into(), 5000));
    println!("  New wallet payment: {:?}", new_payment);

    // Prism::over — modify only if matched
    let updated_payment = cc.over(order.payment.clone(), |(last4, _exp)| {
        (last4, "01/28".into())
    });
    println!("  Updated CC expiry: {:?}", updated_payment);

    // Prism on non-matching variant: passes through unchanged
    let unchanged = wallet.over(order.payment.clone(), |(prov, bal)| (prov, bal + 1000));
    println!("  Wallet over on CC (unchanged): {:?}", unchanged);

    // 5. Prism::transform — reusable pattern-matching function
    println!("\n--- Prism::transform — reusable variant modifier ---");
    let add_balance: Box<dyn Fn((String, i64)) -> (String, i64)> =
        Box::new(|(prov, bal)| (prov, bal + 2500));
    let add_wallet_balance = wallet.transform::<FnP>(add_balance);

    let wallet_payment = Payment::Wallet {
        provider: "PayPal".into(),
        balance_cents: 10000,
    };
    let topped_up = add_wallet_balance(wallet_payment);
    println!("  Topped up: {:?}", topped_up);

    // Apply same transform to non-wallet — passes through
    let still_cc = add_wallet_balance(order.payment.clone());
    println!("  CC unchanged: {:?}", still_cc);

    // 6. Summary: combine multiple optics
    println!("\n--- Combining lenses and prisms ---");
    let orders = vec![
        sample_order(),
        Order {
            id: 1002,
            customer: Customer {
                name: "Bob Jones".into(),
                address: Address {
                    street: "789 Elm St".into(),
                    city: "Capital City".into(),
                    zip: "12345".into(),
                },
            },
            items: vec![Item {
                name: "Mouse".into(),
                price_cents: 2999,
                quantity: 1,
            }],
            payment: Payment::Wallet {
                provider: "Stripe".into(),
                balance_cents: 50000,
            },
        },
        Order {
            id: 1003,
            customer: Customer {
                name: "Carol White".into(),
                address: Address {
                    street: "321 Pine Rd".into(),
                    city: "Springfield".into(),
                    zip: "62702".into(),
                },
            },
            items: vec![],
            payment: Payment::BankTransfer {
                iban: "DE89370400440532013000".into(),
            },
        },
    ];

    let order_city_lens = customer_lens().then(address_lens()).then(city_lens());
    println!("  All cities:");
    for o in &orders {
        let payment_type = match &o.payment {
            Payment::CreditCard { .. } => "CC",
            Payment::BankTransfer { .. } => "Bank",
            Payment::Wallet { .. } => "Wallet",
        };
        println!(
            "    Order #{}: {} ({}, pays via {})",
            o.id,
            order_city_lens.get(o),
            name_lens().get(&o.customer),
            payment_type
        );
    }

    // Find all bank IBANs using Prism
    println!("\n  Bank IBANs:");
    for o in &orders {
        if let Some(iban) = bank.preview(&o.payment) {
            println!("    Order #{}: {}", o.id, iban);
        }
    }
}

impl<S, T, A, B> Lens<S, T, A, B>

pub fn to_getter(&self) -> Getter<S, A>

Convert to a Getter (read-only, discards setter).

pub fn to_setter(&self) -> Setter<S, T, A, B>

where S: 'static, T: 'static, A: 'static, B: 'static,

Convert to a Setter (modify-only).

pub fn to_traversal(&self) -> Traversal<S, T, A, B>

where S: 'static, T: 'static, A: 'static, B: 'static,

Convert to a Traversal (single-element focus).

pub fn to_fold(&self) -> Fold<S, A>

where S: 'static, A: 'static,

Convert to a Fold (single-element, read-only).

impl<S, T, A, B> Lens<S, T, A, B>

where S: Clone,

pub fn over(&self, s: S, f: impl FnOnce(A) -> B) -> T

Examples found in repository

examples/data_transformation.rs (line 92)

fn apply_discount(transactions: Vec<Transaction>, pct: f64) -> Vec<Transaction> {
    let lens = amount_lens();
    VecF::fmap(transactions, |t| {
        lens.over(t, |a| (a as f64 * (1.0 - pct / 100.0)) as i64)
    })
}

/// Normalize names to uppercase.
fn normalize_names(transactions: Vec<Transaction>) -> Vec<Transaction> {
    let lens = name_lens();
    VecF::fmap(transactions, |t| lens.over(t, |n| n.to_uppercase()))
}

pub fn transform<P>(&self, pab: <P as HKT2>::P<A, B>) -> <P as HKT2>::P<S, T>

where P: Strong, S: 'static, T: 'static, A: 'static, B: 'static,

Profunctor encoding: transform a P<A, B> into a P<S, T> via this lens.

This is the key operation that connects concrete lenses to the profunctor hierarchy. Given any Strong profunctor P and a value pab: P<A, B>, transform produces P<S, T> by:

1. first(pab) lifts to P<(A, S), (B, S)>
2. dimap pre-composes with s -> (get(s), s) and post-composes with (b, s) -> set(s, b)

Examples found in repository

examples/domain_model_optics.rs (line 193)

fn main() {
    println!("=== Domain Model with Optics Example ===\n");

    let order = sample_order();

    // 1. Lens: get/set/over
    println!("--- Lens: basic get/set/over ---");
    let customer = customer_lens();
    let address = address_lens();
    let city = city_lens();

    println!("  Customer name: {}", name_lens().get(&order.customer));
    println!("  City: {}", city.get(&address.get(&customer.get(&order))));

    // 2. Composed Lens: deep access with .then()
    println!("\n--- ComposedLens: deep access with .then() ---");
    let order_city = customer_lens().then(address_lens()).then(city_lens());
    let order_zip = customer_lens().then(address_lens()).then(zip_lens());

    println!("  Order city: {}", order_city.get(&order));
    println!("  Order zip:  {}", order_zip.get(&order));

    // Deep set
    let updated = order_city.set(order.clone(), "Shelbyville".into());
    println!("  After city update: {}", order_city.get(&updated));
    println!("  Original unchanged: {}", order_city.get(&order));

    // Deep over (modify)
    let uppercased = order_city.over(order.clone(), |c| c.to_uppercase());
    println!("  Uppercased city: {}", order_city.get(&uppercased));

    // 3. Lens::transform — reusable update function
    println!("\n--- Lens::transform — reusable update function ---");
    let normalize_city: Box<dyn Fn(String) -> String> = Box::new(|c| c.trim().to_uppercase());
    let normalize_order_city = city_lens().transform::<FnP>(normalize_city);
    let addr = Address {
        street: "456 Oak Ave".into(),
        city: "  new york  ".into(),
        zip: "10001".into(),
    };
    let normalized = normalize_order_city(addr);
    println!("  Normalized city: {:?}", normalized.city);

    // 4. Prism: sum type focus
    println!("\n--- Prism: sum type focus ---");
    let cc = credit_card_prism();
    let wallet = wallet_prism();
    let bank = bank_transfer_prism();

    println!("  Credit card last4: {:?}", cc.preview(&order.payment));
    println!("  Wallet preview:    {:?}", wallet.preview(&order.payment));

    // Prism::review — construct a variant
    let new_payment = wallet.review(("PayPal".into(), 5000));
    println!("  New wallet payment: {:?}", new_payment);

    // Prism::over — modify only if matched
    let updated_payment = cc.over(order.payment.clone(), |(last4, _exp)| {
        (last4, "01/28".into())
    });
    println!("  Updated CC expiry: {:?}", updated_payment);

    // Prism on non-matching variant: passes through unchanged
    let unchanged = wallet.over(order.payment.clone(), |(prov, bal)| (prov, bal + 1000));
    println!("  Wallet over on CC (unchanged): {:?}", unchanged);

    // 5. Prism::transform — reusable pattern-matching function
    println!("\n--- Prism::transform — reusable variant modifier ---");
    let add_balance: Box<dyn Fn((String, i64)) -> (String, i64)> =
        Box::new(|(prov, bal)| (prov, bal + 2500));
    let add_wallet_balance = wallet.transform::<FnP>(add_balance);

    let wallet_payment = Payment::Wallet {
        provider: "PayPal".into(),
        balance_cents: 10000,
    };
    let topped_up = add_wallet_balance(wallet_payment);
    println!("  Topped up: {:?}", topped_up);

    // Apply same transform to non-wallet — passes through
    let still_cc = add_wallet_balance(order.payment.clone());
    println!("  CC unchanged: {:?}", still_cc);

    // 6. Summary: combine multiple optics
    println!("\n--- Combining lenses and prisms ---");
    let orders = vec![
        sample_order(),
        Order {
            id: 1002,
            customer: Customer {
                name: "Bob Jones".into(),
                address: Address {
                    street: "789 Elm St".into(),
                    city: "Capital City".into(),
                    zip: "12345".into(),
                },
            },
            items: vec![Item {
                name: "Mouse".into(),
                price_cents: 2999,
                quantity: 1,
            }],
            payment: Payment::Wallet {
                provider: "Stripe".into(),
                balance_cents: 50000,
            },
        },
        Order {
            id: 1003,
            customer: Customer {
                name: "Carol White".into(),
                address: Address {
                    street: "321 Pine Rd".into(),
                    city: "Springfield".into(),
                    zip: "62702".into(),
                },
            },
            items: vec![],
            payment: Payment::BankTransfer {
                iban: "DE89370400440532013000".into(),
            },
        },
    ];

    let order_city_lens = customer_lens().then(address_lens()).then(city_lens());
    println!("  All cities:");
    for o in &orders {
        let payment_type = match &o.payment {
            Payment::CreditCard { .. } => "CC",
            Payment::BankTransfer { .. } => "Bank",
            Payment::Wallet { .. } => "Wallet",
        };
        println!(
            "    Order #{}: {} ({}, pays via {})",
            o.id,
            order_city_lens.get(o),
            name_lens().get(&o.customer),
            payment_type
        );
    }

    // Find all bank IBANs using Prism
    println!("\n  Bank IBANs:");
    for o in &orders {
        if let Some(iban) = bank.preview(&o.payment) {
            println!("    Order #{}: {}", o.id, iban);
        }
    }
}

Trait Implementations

impl<S, T, A, B> Optic for Lens<S, T, A, B>