Struct EnumKeyPath 

pub struct EnumKeyPath<Enum = (), Variant = (), ExtractFn = fn(&()) -> Option<&()>, EmbedFn = fn(())>
where
    ExtractFn: for<'r> Fn(&'r Enum) -> Option<&'r Variant> + 'static,
    EmbedFn: Fn(Variant) -> Enum + 'static,
{ /* private fields */ }

EnumKeyPath - A keypath for enum variants that supports both extraction and embedding Uses generic type parameters instead of dynamic dispatch for zero-cost abstraction

This struct serves dual purpose:

1. As a concrete keypath instance: EnumKeyPath<Enum, Variant, ExtractFn, EmbedFn>
2. As a namespace for static factory methods: EnumKeyPath::readable_enum(...)

Implementations

impl<Enum, Variant, ExtractFn, EmbedFn> EnumKeyPath<Enum, Variant, ExtractFn, EmbedFn>

where ExtractFn: for<'r> Fn(&'r Enum) -> Option<&'r Variant> + 'static, EmbedFn: Fn(Variant) -> Enum + 'static,

pub fn new( extractor: ExtractFn, embedder: EmbedFn, ) -> EnumKeyPath<Enum, Variant, ExtractFn, EmbedFn>

Create a new EnumKeyPath with extractor and embedder functions

pub fn get<'r>(&self, enum_value: &'r Enum) -> Option<&'r Variant>

Extract the value from an enum variant

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

Embed a value into the enum variant

pub fn as_optional(&self) -> &OptionalKeyPath<Enum, Variant, ExtractFn>

Get the underlying OptionalKeyPath for composition

pub fn to_optional(self) -> OptionalKeyPath<Enum, Variant, ExtractFn>

Convert to OptionalKeyPath (loses embedding capability but gains composition)

impl EnumKeyPath

pub fn readable_enum<Enum, Variant, ExtractFn, EmbedFn>( embedder: EmbedFn, extractor: ExtractFn, ) -> EnumKeyPath<Enum, Variant, ExtractFn, EmbedFn>

where ExtractFn: for<'r> Fn(&'r Enum) -> Option<&'r Variant> + 'static, EmbedFn: Fn(Variant) -> Enum + 'static,

Create a readable enum keypath with both extraction and embedding Returns an EnumKeyPath that supports both get() and embed() operations

pub fn for_variant<Enum, Variant, ExtractFn>( extractor: ExtractFn, ) -> OptionalKeyPath<Enum, Variant, impl for<'r> Fn(&'r Enum)>

where ExtractFn: Fn(&Enum) -> Option<&Variant>,

Extract from a specific enum variant

pub fn for_match<Enum, Output, MatchFn>( matcher: MatchFn, ) -> KeyPath<Enum, Output, impl for<'r> Fn(&'r Enum)>

where MatchFn: Fn(&Enum) -> &Output,

Match against multiple variants (returns a tagged union)

pub fn for_ok<T, E>() -> OptionalKeyPath<Result<T, E>, T, impl for<'r> Fn(&'r Result<T, E>)>

Extract from Result<T, E> - Ok variant

pub fn for_err<T, E>() -> OptionalKeyPath<Result<T, E>, E, impl for<'r> Fn(&'r Result<T, E>)>

Extract from Result<T, E> - Err variant

pub fn for_some<T>() -> OptionalKeyPath<Option<T>, T, impl for<'r> Fn(&'r Option<T>)>

Extract from Option - Some variant

pub fn for_option<T>() -> OptionalKeyPath<Option<T>, T, impl for<'r> Fn(&'r Option<T>)>

Extract from Option - Some variant (alias for for_some for consistency)

pub fn for_box<T>() -> KeyPath<Box<T>, T, impl for<'r> Fn(&'r Box<T>)>

Unwrap Box -> T

pub fn for_arc<T>() -> KeyPath<Arc<T>, T, impl for<'r> Fn(&'r Arc<T>)>

Unwrap Arc -> T

pub fn for_rc<T>() -> KeyPath<Rc<T>, T, impl for<'r> Fn(&'r Rc<T>)>

Unwrap Rc -> T

pub fn for_box_mut<T>() -> WritableKeyPath<Box<T>, T, impl for<'r> Fn(&'r mut Box<T>)>

Unwrap Box -> T (mutable)