Merge remote-tracking branch 'yoneda/master' into topic/yoneda

Author: ethul

.gitignore

@@ -1,4 +1,5 @@
 .psci
+.psci_modules/
 node_modules
 bower_components
 dist

README.md

@@ -1,3 +1 @@
-# Deprecation Notice
-
-Please note that this library has been merged into [purescript-transformers](https://github.com/purescript-contrib/purescript-transformers).
+# purescript-free

bower.json

@@ -13,7 +13,9 @@
     "dist"
   ],
   "dependencies": {
-    "purescript-transformers": "0.1.2",
-    "purescript-either": "0.1.3"
+    "purescript-control": "0.2.1",
+    "purescript-either": "0.1.3",
+    "purescript-exists": "*",
+    "purescript-transformers": "0.1.2"
   }
 }

gulpfile.js

@@ -33,7 +33,7 @@ gulp.task('clean', function(){
   );
 });
 
-gulp.task('examples', ['clean'], function(){
+gulp.task('examples', function(){
   return (
     gulp.src([config.purescript.examples].concat(config.purescript.src)).
     pipe(plumber()).

src/Data/Coyoneda.purs

@@ -0,0 +1,59 @@
+module Data.Coyoneda
+  ( Coyoneda(..)
+  , Natural(..)
+  , coyoneda
+  , liftCoyoneda
+  , lowerCoyoneda
+  , liftCoyonedaT
+  , liftCoyonedaTF
+  ) where
+
+import Data.Exists
+
+import Control.Comonad
+import Control.Extend
+import Control.Monad.Trans
+
+newtype CoyonedaF f a i = CoyonedaF { k :: i -> a, fi :: f i }
+
+newtype Coyoneda f a = Coyoneda (Exists (CoyonedaF f a))
+
+type Natural f g = forall a. f a -> g a
+
+instance functorCoyoneda :: Functor (Coyoneda f) where
+  (<$>) f (Coyoneda e) = runExists (\(CoyonedaF v) -> coyoneda (f <<< v.k) v.fi) e
+
+instance applyCoyoneda :: (Apply f) => Apply (Coyoneda f) where
+  (<*>) f g = liftCoyoneda $ lowerCoyoneda f <*> lowerCoyoneda g
+
+instance applicativeCoyoneda :: (Applicative f) => Applicative (Coyoneda f) where
+  pure = liftCoyoneda <<< pure
+
+instance bindCoyoneda :: (Bind f) => Bind (Coyoneda f) where
+  (>>=) (Coyoneda e) k = liftCoyoneda $ runExists (\(CoyonedaF v) -> v.fi >>= lowerCoyoneda <<< k <<< v.k) e
+
+instance monadCoyoneda :: (Monad f) => Monad (Coyoneda f)
+
+instance monadTransCoyoneda :: MonadTrans Coyoneda where
+  lift = liftCoyoneda
+
+instance extendCoyoneda :: (Extend w) => Extend (Coyoneda w) where
+  (<<=) f (Coyoneda e) = runExists (\(CoyonedaF w) -> liftCoyoneda $ f <<< coyoneda w.k <<= w.fi) e
+
+instance comonadCoyoneda :: (Comonad w) => Comonad (Coyoneda w) where
+  extract (Coyoneda e) = runExists (\(CoyonedaF w) -> w.k $ extract w.fi) e
+
+coyoneda :: forall f a b. (a -> b) -> f a -> Coyoneda f b
+coyoneda k fi = Coyoneda $ mkExists $ CoyonedaF { k: k, fi: fi }
+
+liftCoyoneda :: forall f a. f a -> Coyoneda f a
+liftCoyoneda fa = Coyoneda $ mkExists $ CoyonedaF { k: id, fi: fa }
+
+lowerCoyoneda :: forall f a. (Functor f) => Coyoneda f a -> f a
+lowerCoyoneda (Coyoneda e) = runExists (\(CoyonedaF v) -> v.k <$> v.fi) e
+
+liftCoyonedaT :: forall f g. Natural f g -> Natural (Coyoneda f) (Coyoneda g)
+liftCoyonedaT nat (Coyoneda e) = runExists (\(CoyonedaF v) -> coyoneda v.k (nat v.fi)) e
+
+liftCoyonedaTF :: forall f g. (Functor g) => Natural f g -> Natural (Coyoneda f) g
+liftCoyonedaTF nat = lowerCoyoneda <<< liftCoyonedaT nat

src/Data/Yoneda.purs

@@ -0,0 +1,44 @@
+module Data.Yoneda
+  ( Yoneda(..)
+  , runYoneda
+  , liftYoneda
+  , lowerYoneda
+  ) where
+
+import Control.Comonad
+import Control.Extend
+import Control.Monad.Trans
+
+newtype Yoneda f a = Yoneda (forall b. (a -> b) -> f b)
+
+instance functorYoneda :: Functor (Yoneda f) where
+  (<$>) f m = Yoneda (\k -> runYoneda m (k <<< f))
+
+instance applyYoneda :: (Apply f) => Apply (Yoneda f) where
+  (<*>) (Yoneda f) (Yoneda g) = Yoneda (\k -> (f $ (<<<) k) <*> g id)
+
+instance applicativeYoneda :: (Applicative f) => Applicative (Yoneda f) where
+  pure = liftYoneda <<< pure
+
+instance bindCoyoneda :: (Bind f) => Bind (Yoneda f) where
+  (>>=) (Yoneda f) g = Yoneda (\k -> f id >>= \a -> runYoneda (g a) k)
+
+instance monadYoneda :: (Monad f) => Monad (Yoneda f)
+
+instance monadTransYoneda :: MonadTrans Yoneda where
+  lift = liftYoneda
+
+instance extendYoneda :: (Extend w) => Extend (Yoneda w) where
+  (<<=) f (Yoneda w) = Yoneda (\k -> k <<< f <<< liftYoneda <<= w id)
+
+instance comonadYoneda :: (Comonad w) => Comonad (Yoneda w) where
+  extract = extract <<< lowerYoneda
+
+runYoneda :: forall f a b. Yoneda f a -> (a -> b) -> f b
+runYoneda (Yoneda f) k = f k
+
+liftYoneda :: forall f a. (Functor f) => f a -> Yoneda f a
+liftYoneda m = Yoneda (\k -> k <$> m)
+
+lowerYoneda :: forall f a. Yoneda f a -> f a
+lowerYoneda (Yoneda k) = k id