Trait rust2fun::apply::Apply

source ·
pub trait Apply<A, B>: Functor<B> {
    // Required method
    fn ap(self, fa: Self::Target<A>) -> Self::Target<B>
       where Self::Param: FnMut(A) -> B;
}
Expand description

Weaker version of Applicative has apply but not pure.

Required Methods§

source

fn ap(self, fa: Self::Target<A>) -> Self::Target<B>where Self::Param: FnMut(A) -> B,

Apply a function in a context to a value in a context.

Examples
use rust2fun::prelude::*;

let ff = Some(|x: i32| x.to_string());
assert_eq!(Some("1".to_string()), ff.ap(Some(1)));
assert_eq!(Some("2".to_string()), ff.ap(Some(2)));

let ff = vec![|x| x + 1, |x| x + 2];
let fa = vec![3, 4];
let actual = ff.ap(fa);
assert_eq!(actual, [4, 5, 5, 6]);

Implementations on Foreign Types§

source§

impl<F: Ord, A: Clone, B: Ord> Apply<A, B> for BTreeSet<F>

source§

fn ap(self, fa: Self::Target<A>) -> Self::Target<B>where Self::Param: FnMut(A) -> B,

source§

impl<F: Ord, A: Clone, B: Ord> Apply<A, B> for BinaryHeap<F>

source§

fn ap(self, fa: Self::Target<A>) -> Self::Target<B>where Self::Param: FnMut(A) -> B,

source§

impl<F, A: Clone, B> Apply<A, B> for LinkedList<F>

source§

fn ap(self, fa: Self::Target<A>) -> Self::Target<B>where Self::Param: FnMut(A) -> B,

source§

impl<F, A, B, E> Apply<A, B> for Result<F, E>

source§

fn ap(self, fa: Result<A, E>) -> Result<B, E>where F: FnOnce(A) -> B,

source§

impl<F, A: Clone, B> Apply<A, B> for VecDeque<F>

source§

fn ap(self, fa: Self::Target<A>) -> Self::Target<B>where Self::Param: FnMut(A) -> B,

source§

impl<F, A, B> Apply<A, B> for Option<F>

source§

fn ap(self, fa: Option<A>) -> Option<B>where F: FnOnce(A) -> B,

source§

impl<F, A, B> Apply<A, B> for Box<F>

source§

fn ap(self, fa: Box<A>) -> Box<B>where F: FnOnce(A) -> B,

source§

impl<F, A, B, K: Eq + Hash> Apply<A, B> for HashMap<K, F>

source§

fn ap(self, fa: HashMap<K, A>) -> HashMap<K, B>where F: FnOnce(A) -> B,

source§

impl<F, A, B> Apply<A, B> for PhantomData<F>

source§

fn ap(self, _fa: PhantomData<A>) -> PhantomData<B>where F: FnOnce(A) -> B,

source§

impl<F: Eq + Hash, A: Clone, B: Eq + Hash> Apply<A, B> for HashSet<F>

source§

fn ap(self, fa: Self::Target<A>) -> Self::Target<B>where Self::Param: FnMut(A) -> B,

source§

impl<F, A: Clone, B> Apply<A, B> for Vec<F>

source§

fn ap(self, fa: Self::Target<A>) -> Self::Target<B>where Self::Param: FnMut(A) -> B,

Implementors§

source§

impl<F, A, B, E: Semigroup> Apply<A, B> for Validated<F, E>

source§

impl<F, A: Clone, B> Apply<A, B> for NEVec<F>