maybe.rs

trait Monad<A, MA> {
    fn _return(a: A) -> MA;
    fn _bind<F>(self, f: F) -> MA
    where
        F: Fn(A) -> MA;
}

#[derive(Debug, PartialEq)]
enum Maybe<T> {
    Just(T),
    Nothing,
}

impl<A> Monad<A, Maybe<A>> for Maybe<A> {
    fn _return(a: A) -> Maybe<A> {
        Maybe::Just(a)
    }

    fn _bind<F>(self, f: F) -> Maybe<A>
    where
        F: Fn(A) -> Maybe<A>,
    {
        match self {
            Maybe::Nothing => Maybe::Nothing,
            Maybe::Just(a) => f(a),
        }
    }
}

fn add1(a: i64) -> Maybe<i64> {
    Maybe::_return(a + 1)
}

fn main() {
    println!("{:?}, {:?}", Maybe::_return(1), Maybe::Nothing::<i64>);
}

#[test]
fn id1() {
    assert_eq!(Maybe::_return(1)._bind(add1), add1(1));
}

#[test]
fn id2() {
    assert_eq!(Maybe::_return(1), Maybe::_return(1)._bind(Maybe::_return));
}

#[test]
fn associativity() {
    let ma1 = Maybe::_return(1)._bind(add1);
    let ma2 = ma1._bind(add1);

    let ma3 = Maybe::_return(1)._bind(|a| add1(a)._bind(add1));
    assert_eq!(ma2, ma3);
}