Trait Pure

pub trait Pure<'a, B>
where
    Self: Functor<'a, B>,
    B: 'a,
{
    // Required method
    fn pure(b: B) -> Self::Mapped;
}

A Functor that provides a pure operation to wrap a single inner value

Use this trait to implement a monad’s “return” function.

Examples

use fmap::Pure;
assert_eq!(Vec::<i32>::pure(6), vec![6]);

Required Methods

fn pure(b: B) -> Self::Mapped

Wrap single value

This is also called “return” in the context of monads.

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.

Implementations on Foreign Types

impl<'a, A, B> Pure<'a, B> for Option<A>

where A: 'a, B: 'a,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B> Pure<'a, B> for Box<dyn Iterator<Item = A> + 'a>

where A: 'a, B: 'a,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B> Pure<'a, B> for Box<dyn Iterator<Item = A> + Send + 'a>

where A: 'a, B: 'a + Send,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B> Pure<'a, B> for Box<dyn Send + FnMut() -> A + 'a>

where A: 'a, B: 'a + Clone + Send,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B> Pure<'a, B> for Box<dyn Send + FnOnce() -> A + 'a>

where A: 'a, B: 'a + Send,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B> Pure<'a, B> for Box<dyn FnMut() -> A + 'a>

where A: 'a, B: 'a + Clone,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B> Pure<'a, B> for Box<dyn FnOnce() -> A + 'a>

where A: 'a, B: 'a,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B> Pure<'a, B> for BinaryHeap<A>

where A: 'a + Ord, B: 'a + Ord,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B> Pure<'a, B> for BTreeSet<A>

where A: 'a + Ord, B: 'a + Ord,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B> Pure<'a, B> for LinkedList<A>

where A: 'a, B: 'a,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B> Pure<'a, B> for VecDeque<A>

where A: 'a, B: 'a,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B> Pure<'a, B> for Vec<A>

where A: 'a, B: 'a,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B> Pure<'a, B> for Pin<Box<dyn Future<Output = A> + 'a>>

where A: 'a, B: 'a,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B> Pure<'a, B> for Pin<Box<dyn Future<Output = A> + Send + 'a>>

where A: 'a, B: 'a + Send,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B> Pure<'a, B> for HashSet<A>

where A: 'a + Eq + Hash, B: 'a + Eq + Hash,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B, E> Pure<'a, B> for Result<A, E>

where A: 'a, B: 'a,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B, X> Pure<'a, B> for Box<dyn Send + FnMut(X) -> A + 'a>

where A: 'a, B: 'a + Clone + Send, X: 'a,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B, X> Pure<'a, B> for Box<dyn Send + FnOnce(X) -> A + 'a>

where A: 'a, B: 'a + Send, X: 'a,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B, X> Pure<'a, B> for Box<dyn FnMut(X) -> A + 'a>

where A: 'a, B: 'a + Clone, X: 'a,

fn pure(b: B) -> Self::Mapped

impl<'a, A, B, X> Pure<'a, B> for Box<dyn FnOnce(X) -> A + 'a>

where A: 'a, B: 'a, X: 'a,

fn pure(b: B) -> Self::Mapped

Implementors