DONT THREAD ON ME fucked around with this message at 22:26 on Jul 23, 2018

DONT THREAD ON ME fucked around with this message at 14:05 on Jul 26, 2018

    #[test]
    fn test_compose_and_map() {
        let parse = kleisli::apply(|s: &str| s.parse::<i32>().map_err(|_| "parse error").lift());

        let reciprocal = kleisli::apply(|i: i32| {
            if i != 0 {
                Ok(1.0 / i as f32)
            } else {
                Err("divide by 0")
            }.lift()
        });

        let parse_and_recriprocal = reciprocal.compose(parse);

        assert_eq!(parse_and_recriprocal.run("123").unlift(), Ok(0.008130081));

        assert_eq!(
            parse_and_recriprocal.run("yospos").unlift(),
            Err("parse error")
        );

        let doubled = parse_and_recriprocal.map(|f| f * 2 as f32);
        assert_eq!(doubled.run("123").unlift(), Ok(0.016260162));
        assert_eq!(doubled.run("0").unlift(), Err("divide by 0"));
    }

pub struct Compose<A, K1, K2> {
    k1: K1,
    k2: K2,
    marker: PhantomData<*const A>,
}

impl<'a, F, A, B, C, K1, K2, Z, G> KleisliT<'a, F, C, B, Z, G> for Compose<A, K1, K2>
where
    A: 'a,
    B: 'a,
    F: Monad<'a, F, Z, G> + 'static,
    K1: KleisliT<'a, F, A, B, Z, G>,
    K2: KleisliT<'a, F, C, A, Z, G>,
{
    fn run(&self, a: C) -> Lifted<'a, F, B, Z, G> {
        F::flat_map(self.k2.run(a), |a| self.k1.run(a))
    }
}

pub struct Foo<'a,A,B,C> where A+B+C: 'a

DONT THREAD ON ME fucked around with this message at 00:23 on Jul 27, 2018

DONT THREAD ON ME fucked around with this message at 17:13 on Jul 27, 2018

DONT THREAD ON ME fucked around with this message at 18:57 on Jul 27, 2018

    #[test]
    fn test_kleisli_future_map() {
        let k = kleisli::lift(|i: i32| {
            future::lazy(move |_| i)
        });
        let k = k.map(|i| i * 2);
        
        assert_eq!(block_on(k.runlift(15)), 30);
    }

    #[test]
    fn test_applicative() {
        let fut = future::lazy(|_| "yospos").lift();
        let fut2 = future::lazy(|_| "bictch").lift();

        assert_eq!(
            block_on(FutureKind::product(fut, fut2).unlift()),
            ("yospos", "bictch")
        )
    }

DONT THREAD ON ME fucked around with this message at 21:02 on Jul 27, 2018

    #[test]
    fn test_kleisli_map_and_compose() {
        let parse = kleisli::run(|s: &str| {
            // I think it's possible to get around the type annotations here but I need to redesign
            // a few things.
            let l: Lifted<FutureKind, i32, Nothing, Nothing> =
                future::lazy(move |_| s.parse::<i32>().unwrap()).lift();
            l
        });

        let reciprocal = kleisli::lift(|i: i32| future::lazy(move |_| 1.0 / i as f32));

        let parse_and_recriprocal = reciprocal.compose(parse);

        assert_eq!(
            block_on(parse_and_recriprocal.runlift("123")),
            0.008130081f32
        );
        let doubled = parse_and_recriprocal.map(|f| f * 2f32);
        assert_eq!(block_on(doubled.runlift("123")), 0.016260162f32);
    }

DONT THREAD ON ME fucked around with this message at 16:47 on Jul 29, 2018

DONT THREAD ON ME fucked around with this message at 17:00 on Jul 29, 2018