Merge pull request #1 from paf31/exists

Use purescript-exists

Author: ethul

README.md

@@ -5,7 +5,7 @@
 ### Types
 
     newtype Coyoneda f a where
-      Coyoneda :: forall i. { fi :: f i, k :: i -> a } -> Coyoneda f a
+      Coyoneda :: Exists (CoyonedaF f a) -> Coyoneda f a
 
     type Natural f g = forall a. f a -> g a
 

bower.json

@@ -15,6 +15,7 @@
     "dist"
   ],
   "dependencies": {
+    "purescript-exists": "*",
     "purescript-control": "0.2.1",
     "purescript-transformers": "0.1.1"
   }

src/Data/Coyoneda.purs

@@ -8,16 +8,20 @@ module Data.Coyoneda
   , liftCoyonedaTF
   ) where
 
+import Data.Exists
+
 import Control.Comonad
 import Control.Extend
 import Control.Monad.Trans
 
-newtype Coyoneda f a = Coyoneda (forall i. { k :: i -> a , fi :: f i })
+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 v) = Coyoneda v { k = f <<< v.k }
+  (<$>) 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
@@ -26,32 +30,30 @@ instance applicativeCoyoneda :: (Applicative f) => Applicative (Coyoneda f) wher
   pure = liftCoyoneda <<< pure
 
 instance bindCoyoneda :: (Bind f) => Bind (Coyoneda f) where
-  (>>=) (Coyoneda v) k = liftCoyoneda $ v.fi >>= lowerCoyoneda <<< k <<< v.k
+  (>>=) (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 w) = liftCoyoneda $ f <<< coyoneda w.k <<= w.fi
+  (<<=) f (Coyoneda e) = runExists (\(CoyonedaF w) -> liftCoyoneda $ f <<< coyoneda w.k <<= w.fi) e
 
 instance comonadCoyoneda :: (Comonad w) => Comonad (Coyoneda w) where
-  extract (Coyoneda w) = w.k $ extract w.fi
+  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 = k <$> liftCoyoneda fi
+coyoneda k fi = Coyoneda $ mkExists $ CoyonedaF { k: k, fi: fi }
 
---liftCoyoneda :: forall f a. f a -> Coyoneda f a
---liftCoyoneda fa = Coyoneda { k: id , fi: fa }
-foreign import liftCoyoneda "function liftCoyoneda(fa){return {k: function(a){return a;}, fi: fa};}"
-  :: forall f a. f a -> Coyoneda f a
+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 v) = v.k <$> v.fi
+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 v) -> Coyoneda v { fi = nat v.fi }
+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