Skip to main content

RefFunctor

fp_library::classes::ref_functor

Trait RefFunctor 

Source 
pub trait RefFunctor: Kind_cdc7cd43dac7585f {
    // Required method
    fn map_ref<'a, B: 'a, A: 'a, F>(
        f: F,
        fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>,
    ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>
       where F: FnOnce(&A) -> B + 'a;
}
Expand description

A type class for types that can be mapped over, returning references.

This is a variant of Functor for types where map receives/returns references. This is required for types like Lazy where get() returns &A, not A.

Required Methods§

Source

fn map_ref<'a, B: 'a, A: 'a, F>( f: F, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>
where F: FnOnce(&A) -> B + 'a,

Maps a function over the values in the functor context, where the function takes a reference.

§Type Signature

forall f b a. RefFunctor f => (a -> b, f a) -> f b

§Type Parameters
  • B: The type of the result(s) of applying the function.
  • A: The type of the value(s) inside the functor.
  • F: The type of the function to apply.
§Parameters
  • f: The function to apply to the value(s) inside the functor.
  • fa: The functor instance containing the value(s).
§Returns

A new functor instance containing the result(s) of applying the function.

§Examples
use fp_library::{
    brands::*,
    classes::*,
    types::*,
    functions::map_ref,
};

let memo = Lazy::<_, RcLazyConfig>::new(|| 10);
let mapped = LazyBrand::<RcLazyConfig>::map_ref(
    |x: &i32| *x * 2,
    memo
);
assert_eq!(*mapped.get(), 20);

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§