Struct optics::concrete::MapFallible

pub struct MapFallible<L, F, G>(/* private fields */);

Optics wrapper for mapping the Success and Error value.

Trait Implementations

impl<T, L: AffineFold<T>, S, F, E, G> AffineFold<T> for MapFallible<L, F, G>

where F: Fn(L::Success) -> S, G: Fn(L::Error) -> E, L::View: Sized,

fn preview(&self, s: T) -> Result<Self::View, E>

Retrieve the value targeted by an AffineFold.

impl<'a, T: ?Sized, L: AffineFoldMut<'a, T>, S, F, E, G> AffineFoldMut<'a, T> for MapFallible<L, F, G>

where F: Fn(L::Success) -> S, G: Fn(L::Error) -> E, L::View: 'a,

fn preview_mut(&self, s: &'a mut T) -> Result<&'a mut Self::View, E>

Retrieve a mutable reference the value targeted by an AffineFold.

impl<'a, T: ?Sized, L: AffineFoldRef<'a, T>, S, F, E, G> AffineFoldRef<'a, T> for MapFallible<L, F, G>

where F: Fn(L::Success) -> S, G: Fn(L::Error) -> E, L::View: 'a,

fn preview_ref(&self, s: &'a T) -> Result<&'a Self::View, E>

Retrieve a shared reference the value targeted by an AffineFold.

impl<T, L: AffineTraversal<T>, S, F, E, G> AffineTraversal<T> for MapFallible<L, F, G>

where F: Fn(L::Success) -> S, G: Fn(L::Error) -> E, L::View: Sized,

fn map(&self, s: &mut T, f: impl FnOnce(&mut Self::View))

Restricted version for Setter::over. Custom implementation recommended.

fn set(&self, s: &mut T, a: Self::View)

Apply a setter. No Clone is needed, because this optics is affine.

impl<T, L: Getter<T>, S, F, E, G> Getter<T> for MapFallible<L, F, G>

where F: Fn(L::Success) -> S, G: Fn(L::Error) -> E, L::View: Sized,

fn view(&self, s: T) -> Self::View

View the value pointed to by a getter.

impl<'a, T: ?Sized, L: GetterMut<'a, T>, S, F, E, G> GetterMut<'a, T> for MapFallible<L, F, G>

where F: Fn(L::Success) -> S, G: Fn(L::Error) -> E, L::View: 'a,

fn view_mut(&self, s: &'a mut T) -> &'a mut Self::View

Get a mutable reference to the value pointed to by a getter.

impl<'a, T: ?Sized, L: GetterRef<'a, T>, S, F, E, G> GetterRef<'a, T> for MapFallible<L, F, G>

where F: Fn(L::Success) -> S, G: Fn(L::Error) -> E, L::View: 'a,

fn view_ref(&self, s: &'a T) -> &'a Self::View

Get a shared reference to the value pointed to by a getter.

impl<T: ?Sized, L: Optics<T>, F, G> Optics<T> for MapFallible<L, F, G>

type View = <L as Optics<T>>::View

View type for this optics.

impl<L: OpticsFallible, S, F, E, G> OpticsFallible for MapFallible<L, F, G>

where F: Fn(L::Success) -> S, G: Fn(L::Error) -> E,

type Success = S

Success type for this optics.

type Error = E

Error type for this optics.

fn success_witness(&self) -> S

Get a lightweight witness for success.

fn map_fallible<S, F, E, G>(self, f: F, g: G) -> MapFallible<Self, F, G>

where Self: Sized, F: Fn(Self::Success) -> S, G: Fn(Self::Error) -> E,

Map the Success and Error type for this fallible optics.

fn map_success<S, F>(self, f: F) -> MapSuccess<Self, F>

where Self: Sized, F: Fn(Self::Success) -> S,

Map the Success type for this fallible optics.

fn map_error<E, G>(self, g: G) -> MapError<Self, G>

where Self: Sized, G: Fn(Self::Error) -> E,

Map the Error type for this fallible optics.

impl<T, L: Review<T>, F, G> Review<T> for MapFallible<L, F, G>

where L::View: Sized,

fn review(&self, a: Self::View) -> T

Retrieve the value targeted by a review.

impl<T, L: Setter<T>, F, G> Setter<T> for MapFallible<L, F, G>

where L::View: Sized,

fn over(&self, s: &mut T, f: &mut dyn FnMut(&mut Self::View))

Apply a setter as a modifier.

fn set_cloned(&self, a: &Self::View, s: &mut T)

where Self::View: Clone,

Apply a setter.

impl<T, L: Traversal<T>, F, G> Traversal<T> for MapFallible<L, F, G>

where L::View: Sized,

fn traverse(&self, s: T, f: &mut dyn FnMut(Self::View))

Evaluate the action from left to right on each element targeted by a Traversal.

fn fold<C>(&self, s: T, init: C, f: impl FnMut(&mut C, Self::View)) -> C

Fold every element targeted by this Traversal into a single result.

fn flatten(&self, s: T) -> Vec<Self::View>

Flatten the elements targeted by this Traversal into a Vec.

impl<T, L: Iso<T>, S, F, E, G> Iso<T> for MapFallible<L, F, G>

where F: Fn(L::Success) -> S, G: Fn(L::Error) -> E, L::View: Sized,

impl<T, L: Lens<T>, S, F, E, G> Lens<T> for MapFallible<L, F, G>

where F: Fn(L::Success) -> S, G: Fn(L::Error) -> E, L::View: Sized,

impl<T, L: Prism<T>, S, F, E, G> Prism<T> for MapFallible<L, F, G>

where F: Fn(L::Success) -> S, G: Fn(L::Error) -> E, L::View: Sized,