Struct EnumKp 

pub struct EnumKp<Enum, Variant, Root, Value, MutRoot, MutValue, G, S, E>
where
    Root: Borrow<Enum>,
    Value: Borrow<Variant>,
    MutRoot: BorrowMut<Enum>,
    MutValue: BorrowMut<Variant>,
    G: Fn(Root) -> Option<Value>,
    S: Fn(MutRoot) -> Option<MutValue>,
    E: Fn(Variant) -> Enum,
{ /* private fields */ }

EnumKp - A keypath for enum variants that supports both extraction and embedding Leverages the existing Kp architecture where optionals are built-in via Option

This struct serves dual purposes:

1. As a concrete keypath instance for extracting and embedding enum variants
2. As a namespace for static factory methods: EnumKp::for_ok(), EnumKp::for_some(), etc.

Implementations

impl<Enum, Variant, Root, Value, MutRoot, MutValue, G, S, E> EnumKp<Enum, Variant, Root, Value, MutRoot, MutValue, G, S, E>

where Root: Borrow<Enum>, Value: Borrow<Variant>, MutRoot: BorrowMut<Enum>, MutValue: BorrowMut<Variant>, G: Fn(Root) -> Option<Value>, S: Fn(MutRoot) -> Option<MutValue>, E: Fn(Variant) -> Enum,

pub fn new( extractor: Kp<Enum, Variant, Root, Value, MutRoot, MutValue, G, S>, embedder: E, ) -> Self

Create a new EnumKp with extractor and embedder functions

pub fn get(&self, enum_value: Root) -> Option<Value>

Extract the variant from an enum (returns None if wrong variant)

pub fn get_mut(&self, enum_value: MutRoot) -> Option<MutValue>

Extract the variant mutably from an enum (returns None if wrong variant)

pub fn embed(&self, value: Variant) -> Enum

Embed a value into the enum variant

pub fn as_kp(&self) -> &Kp<Enum, Variant, Root, Value, MutRoot, MutValue, G, S>

Get the underlying Kp for composition with other keypaths

pub fn into_kp(self) -> Kp<Enum, Variant, Root, Value, MutRoot, MutValue, G, S>

Convert to Kp (loses embedding capability but gains composition)

pub fn map<MappedValue, F>( &self, mapper: F, ) -> EnumKp<Enum, MappedValue, Root, MappedValue, MutRoot, MappedValue, impl Fn(Root) -> Option<MappedValue>, impl Fn(MutRoot) -> Option<MappedValue>, impl Fn(MappedValue) -> Enum>

where F: Fn(&Variant) -> MappedValue + Copy + 'static, Variant: 'static, MappedValue: 'static, E: Fn(Variant) -> Enum + Copy + 'static,

Map the variant value through a transformation function

Example

use rust_key_paths::enum_ok;
let result: Result<String, i32> = Ok("hello".to_string());
let ok_kp = enum_ok();
let len_kp = ok_kp.map(|s: &String| s.len());
assert_eq!(len_kp.get(&result), Some(5));

pub fn filter<F>( &self, predicate: F, ) -> EnumKp<Enum, Variant, Root, Value, MutRoot, MutValue, impl Fn(Root) -> Option<Value>, impl Fn(MutRoot) -> Option<MutValue>, E>

where F: Fn(&Variant) -> bool + Copy + 'static, Variant: 'static, E: Copy,

Filter the variant value based on a predicate Returns None if the predicate fails or if wrong variant

Example

use rust_key_paths::enum_ok;
let result: Result<i32, String> = Ok(42);
let ok_kp = enum_ok();
let positive_kp = ok_kp.filter(|x: &i32| *x > 0);
assert_eq!(positive_kp.get(&result), Some(&42));