Add Functor and Applicative

src/applicative.rs

@@ -0,0 +1,37 @@
+use kind::Kind;
+use functor::Functor;
+
+pub trait Applicative<B, F>: Functor<B> + Kind<F> + Sized
+    where F: Fn(Self::Item) -> B {
+    fn pure_(Self::Item) -> Self;
+    fn apply(f: <Self as Kind<F>>::Make, Self) -> <Self as Kind<B>>::Make;
+}
+
+impl<A, B, F> Applicative<B, F> for Option<A>
+    where F: Fn(A) -> B {
+    fn pure_(a: A) -> Option<A> {
+        Some(a)
+    }
+
+    fn apply(f: Option<F>, to: Option<A>) -> Option<B> {
+        match f {
+            Some(f) => to.map(f),
+            None => None,
+        }
+    }
+}
+
+impl<A: Clone, B, F> Applicative<B, F> for Vec<A>
+    where F: Fn(A) -> B {
+    fn pure_(a: A) -> Vec<A> {
+        vec![a]
+    }
+
+    fn apply(f: Vec<F>, to: Vec<A>) -> Vec<B> {
+        f.into_iter().flat_map(|f| {
+            to.clone().into_iter().map(|to| {
+                f(to)
+            }).collect::<Vec<B>>()
+        }).collect()
+    }
+}

src/functor.rs

@@ -0,0 +1,27 @@
+use kind::Kind;
+
+pub trait Functor<B>: Kind<B> {
+    type Item;
+    fn fmap<F>(self, f: F) -> <Self as Kind<B>>::Make where F: Fn(Self::Item) -> B;
+}
+
+impl<A, B> Functor<B> for Option<A> {
+    type Item = A;
+    fn fmap<F>(self, f: F) -> Option<B> where F: Fn(A) -> B {
+        self.map(f)
+    }
+}
+
+impl<A, B, E> Functor<B> for Result<A, E> {
+    type Item = A;
+    fn fmap<F>(self, f: F) -> Result<B, E> where F: Fn(A) -> B {
+        self.map(f)
+    }
+}
+
+impl<A, B> Functor<B> for Vec<A> {
+    type Item = A;
+    fn fmap<F>(self, f: F) -> Vec<B> where F: Fn(A) -> B{
+        self.into_iter().map(f).collect()
+    }
+}

src/kind.rs

@@ -0,0 +1,15 @@
+pub trait Kind<T> {
+    type Make;
+}
+
+impl<A, B> Kind<B> for Option<A> {
+    type Make = Option<B>;
+}
+
+impl<A, B, E> Kind<B> for Result<A, E> {
+    type Make = Result<B, E>;
+}
+
+impl<A, B> Kind<B> for Vec<A> {
+    type Make = Vec<B>;
+}

src/lib.rs

@@ -109,6 +109,9 @@ extern crate frunk_derives;
 pub mod semigroup;
 pub mod monoid;
 pub mod validated;
+pub mod kind;
+pub mod functor;
+pub mod applicative;
 
 pub use frunk_core::*;
 pub use frunk_derives::*;