Carthag Tuek fucked around with this message at 13:51 on Jun 29, 2018

    // this is silly and it's easier to just call a.product(b) directly, but the entire point of this is to be able talk about these behaviors generically.  
    fn show_off_kind_tupler<K, A, B>(a: Kind<K, A>, b: Kind<K, B>) -> Kind<K, (A, B)>
    where
        K: Applicative<K>,
    {
        a.product(b)
    }

    #[test]
    fn test_kind_tupler() {
        // type annotations are not necessary here, except in the calls to `point` (because the kind must be specified), they're just for the reader:
        let a: Kind<OptionKind, i32> = 5.point::<OptionKind>();
        let b: Kind<OptionKind, &str> = "rats".point::<OptionKind>();
        let k: Option<(i32, &str)> = show_off_kind_tupler(a, b).reify();
        assert_eq!(k, Some((5, "rats")));

        use data::id::{Id, IdExt};
        use kinds::IdKind;
        let a: Kind<IdKind, i32> = 5.point::<IdKind>();
        let b: Kind<IdKind, &str> = "rats".point::<IdKind>();
        let k: (i32, &str) = show_off_kind_tupler(a, b).reify().take();
        assert_eq!(k, (5, "rats"))
    }

pub trait Applicative<K: HKT>: Functor<K> {
    fn ap<A, B, F>(fa: Kind<K, A>, ff: Kind<K, F>) -> Kind<K, B>
    where
        F: FnOnce(A) -> B;

    fn point<T>(value: T) -> Kind<K, T>;

    fn product<A, B>(fa: Kind<K, A>, fb: Kind<K, B>) -> Kind<K, (A, B)> {
        let f1 = |a| |b| (a, b);
        let t = Self::map(fa, f1);
        Self::ap(fb, t)
    }
}

DONT THREAD ON ME fucked around with this message at 22:50 on Jun 29, 2018