Merge pull request #19 from joneshf/comonad-trans

Comonad trans

Author: paf31

.travis.yml

@@ -1,12 +1,15 @@
 language: node_js
 node_js:
   - "0.10"
+env:
+  - PATH=$HOME/bin:$PATH purescript_datadir=$HOME/.local/share/purescript
+before_install:
+  - mkdir -p $HOME/bin
+  - mkdir -p $HOME/.local/share/purescript/prelude
 install:
-  - "sudo apt-get install cabal-install"
-  - "cabal update"
-  - "cabal install Cabal cabal-install"
-  - "export PATH=~/.cabal/bin:$PATH"
-  - "cabal install purescript --force-reinstalls"
+  - wget -O $HOME/bin/psc https://github.com/purescript/purescript/releases/download/0.5.6.2/psc
+  - chmod a+x $HOME/bin/psc
+  - wget -O $purescript_datadir/prelude/prelude.purs https://github.com/purescript/purescript/releases/download/0.5.6.2/prelude.purs
   - "npm install bower grunt-cli -g"
   - "npm install"
   - "bower install"

docs/Module.md

@@ -1,5 +1,205 @@
 # Module Documentation
 
+## Module Control.Comonad.Env
+
+### Types
+
+    type Env e = EnvT e Identity
+
+
+### Values
+
+    env :: forall e a. e -> a -> Env e a
+
+    mapEnv :: forall e a b. (a -> b) -> Env e a -> Env e b
+
+    runEnv :: forall e a. Env e a -> Tuple e a
+
+    withEnv :: forall e1 e2 a. (e1 -> e2) -> Env e1 a -> Env e2 a
+
+
+## Module Control.Comonad.Env.Class
+
+### Type Classes
+
+    class (Comonad w) <= ComonadEnv e w where
+      ask :: forall a. w a -> e
+      local :: forall a. (e -> e) -> w a -> w a
+
+
+### Type Class Instances
+
+    instance comonadEnvEnvT :: (Comonad w) => ComonadEnv e (EnvT e w)
+
+    instance comonadEnvTuple :: ComonadEnv e (Tuple e)
+
+
+### Values
+
+    asks :: forall e1 e2 w a. (ComonadEnv e1 w) => (e1 -> e2) -> w e1 -> e2
+
+
+## Module Control.Comonad.Env.Trans
+
+### Types
+
+    newtype EnvT e w a where
+      EnvT :: Tuple e (w a) -> EnvT e w a
+
+
+### Type Class Instances
+
+    instance comonadEnvT :: (Comonad w) => Comonad (EnvT e w)
+
+    instance comonadTransEnvT :: ComonadTrans (EnvT e)
+
+    instance extendEnvT :: (Extend w) => Extend (EnvT e w)
+
+    instance functorEnvT :: (Functor w) => Functor (EnvT e w)
+
+
+### Values
+
+    mapEnvT :: forall e w1 w2 a b. (w1 a -> w2 b) -> EnvT e w1 a -> EnvT e w2 b
+
+    runEnvT :: forall e w a. EnvT e w a -> Tuple e (w a)
+
+    withEnvT :: forall e1 e2 w a. (e1 -> e2) -> EnvT e1 w a -> EnvT e2 w a
+
+
+## Module Control.Comonad.Store
+
+### Types
+
+    type Store s a = StoreT s Identity a
+
+
+### Values
+
+    runStore :: forall s a. Store s a -> Tuple (s -> a) s
+
+    store :: forall s a. (s -> a) -> s -> Store s a
+
+
+## Module Control.Comonad.Store.Class
+
+### Type Classes
+
+    class (Comonad w) <= ComonadStore s w where
+      pos :: forall a. w a -> s
+      peek :: forall a. s -> w a -> a
+
+
+### Type Class Instances
+
+    instance comonadStoreStoreT :: (Comonad w) => ComonadStore s (StoreT s w)
+
+
+### Values
+
+    experiment :: forall f a w s. (ComonadStore s w, Functor f) => (s -> f s) -> w a -> f a
+
+    peeks :: forall s a w. (ComonadStore s w) => (s -> s) -> w a -> a
+
+    seek :: forall s a w. (ComonadStore s w, Extend w) => s -> w a -> w a
+
+    seeks :: forall s a w. (ComonadStore s w, Extend w) => (s -> s) -> w a -> w a
+
+
+## Module Control.Comonad.Store.Trans
+
+### Types
+
+    newtype StoreT s w a where
+      StoreT :: Tuple (w (s -> a)) s -> StoreT s w a
+
+
+### Type Class Instances
+
+    instance comonadStoreT :: (Comonad w) => Comonad (StoreT s w)
+
+    instance comonadTransStoreT :: ComonadTrans (StoreT s)
+
+    instance extendStoreT :: (Extend w) => Extend (StoreT s w)
+
+    instance functorStoreT :: (Functor w) => Functor (StoreT s w)
+
+
+### Values
+
+    runStoreT :: forall s w a. StoreT s w a -> Tuple (w (s -> a)) s
+
+
+## Module Control.Comonad.Traced
+
+### Types
+
+    type Traced m = TracedT m Identity
+
+
+### Values
+
+    runTraced :: forall m a. Traced m a -> m -> a
+
+    traced :: forall m a. (m -> a) -> Traced m a
+
+
+## Module Control.Comonad.Traced.Class
+
+### Type Classes
+
+    class (Comonad w) <= ComonadTraced t w where
+      track :: forall a. t -> w a -> a
+
+
+### Type Class Instances
+
+    instance comonadTracedTracedT :: (Comonad w, Monoid t) => ComonadTraced t (TracedT t w)
+
+
+### Values
+
+    censor :: forall w a t b. (Functor w) => (t -> t) -> TracedT t w a -> TracedT t w a
+
+    listen :: forall w a t. (Functor w) => TracedT t w a -> TracedT t w (Tuple a t)
+
+    listens :: forall w a t b. (Functor w) => (t -> b) -> TracedT t w a -> TracedT t w (Tuple a b)
+
+    tracks :: forall w a t. (Comonad w, ComonadTraced t w) => (a -> t) -> w a -> a
+
+
+## Module Control.Comonad.Traced.Trans
+
+### Types
+
+    newtype TracedT t w a where
+      TracedT :: w (t -> a) -> TracedT t w a
+
+
+### Type Class Instances
+
+    instance comonadTracedT :: (Comonad w, Monoid t) => Comonad (TracedT t w)
+
+    instance comonadTransTracedT :: (Monoid t) => ComonadTrans (TracedT t)
+
+    instance extendTracedT :: (Extend w, Semigroup t) => Extend (TracedT t w)
+
+    instance functorTracedT :: (Functor w) => Functor (TracedT t w)
+
+
+### Values
+
+    runTracedT :: forall w a t. TracedT t w a -> w (t -> a)
+
+
+## Module Control.Comonad.Trans
+
+### Type Classes
+
+    class ComonadTrans f where
+      lower :: forall w a. (Comonad w) => f w a -> w a
+
+
 ## Module Control.Monad.Cont.Class
 
 ### Type Classes
@@ -35,7 +235,7 @@
 
     instance applicativeContT :: (Functor m, Monad m) => Applicative (ContT r m)
 
-    instance appluContT :: (Functor m, Monad m) => Apply (ContT r m)
+    instance applyContT :: (Functor m, Monad m) => Apply (ContT r m)
 
     instance bindContT :: (Monad m) => Bind (ContT r m)
 
@@ -109,9 +309,9 @@
 
     instance alternativeErrorT :: (Monad m, Error e) => Alternative (ErrorT e m)
 
-    instance applicativeErrorT :: (Functor m, Monad m) => Applicative (ErrorT e m)
+    instance applicativeErrorT :: (Applicative m) => Applicative (ErrorT e m)
 
-    instance applyErrorT :: (Functor m, Monad m) => Apply (ErrorT e m)
+    instance applyErrorT :: (Apply m) => Apply (ErrorT e m)
 
     instance bindErrorT :: (Monad m, Error e) => Bind (ErrorT e m)
 

src/Control/Comonad/Env.purs

@@ -0,0 +1,20 @@
+module Control.Comonad.Env where
+
+import Control.Comonad.Env.Trans
+import Control.Monad.Identity
+
+import Data.Tuple
+
+type Env e = EnvT e Identity
+
+runEnv :: forall e a. Env e a -> Tuple e a
+runEnv x = runIdentity <$> runEnvT x
+
+withEnv :: forall e1 e2 a. (e1 -> e2) -> Env e1 a -> Env e2 a
+withEnv = withEnvT
+
+mapEnv :: forall e a b. (a -> b) -> Env e a -> Env e b
+mapEnv = (<$>)
+
+env :: forall e a. e -> a -> Env e a
+env e a = EnvT $ Tuple e $ Identity a

src/Control/Comonad/Env/Class.purs

@@ -0,0 +1,23 @@
+module Control.Comonad.Env.Class where
+
+import Control.Comonad
+import Control.Comonad.Env
+import Control.Comonad.Env.Trans
+
+import Data.Tuple
+
+class (Comonad w) <= ComonadEnv e w where
+  ask :: forall a. w a -> e
+  local :: forall a. (e -> e) -> w a -> w a
+
+instance comonadEnvTuple :: ComonadEnv e (Tuple e) where
+  ask = fst
+  local f (Tuple x y) = Tuple (f x) y
+
+instance comonadEnvEnvT :: (Comonad w) => ComonadEnv e (EnvT e w) where
+  ask x = fst $ runEnvT x
+  local f x = EnvT $ case runEnvT x of
+    Tuple x y -> Tuple (f x) y
+
+asks :: forall e1 e2 w a. (ComonadEnv e1 w) => (e1 -> e2) -> w e1 -> e2
+asks f x = f $ ask x

src/Control/Comonad/Env/Trans.purs

@@ -0,0 +1,29 @@
+module Control.Comonad.Env.Trans where
+
+import Control.Comonad
+import Control.Comonad.Trans
+import Control.Extend
+import Data.Tuple
+
+newtype EnvT e w a = EnvT (Tuple e (w a))
+
+runEnvT :: forall e w a. EnvT e w a -> Tuple e (w a)
+runEnvT (EnvT x) = x
+
+withEnvT :: forall e1 e2 w a. (e1 -> e2) -> EnvT e1 w a -> EnvT e2 w a
+withEnvT f (EnvT (Tuple e x)) = EnvT $ Tuple (f e) x
+
+mapEnvT :: forall e w1 w2 a b. (w1 a -> w2 b) -> EnvT e w1 a -> EnvT e w2 b
+mapEnvT f (EnvT (Tuple e x)) = EnvT $ Tuple e (f x)
+
+instance functorEnvT :: (Functor w) => Functor (EnvT e w) where
+  (<$>) f (EnvT (Tuple e x)) = EnvT $ Tuple e (f <$> x)
+
+instance extendEnvT :: (Extend w) => Extend (EnvT e w) where
+  (<<=) f (EnvT (Tuple e x)) = EnvT $ Tuple e (f <$> ((Tuple e >>> EnvT) <<= x))
+
+instance comonadEnvT :: (Comonad w) => Comonad (EnvT e w) where
+  extract (EnvT (Tuple e x)) = extract x
+
+instance comonadTransEnvT :: ComonadTrans (EnvT e) where
+  lower (EnvT (Tuple e x)) = x

src/Control/Comonad/Store.purs

@@ -0,0 +1,14 @@
+module Control.Comonad.Store where
+
+import Control.Comonad.Store.Trans
+import Control.Monad.Identity
+
+import Data.Tuple
+
+type Store s a = StoreT s Identity a
+
+runStore :: forall s a. Store s a -> Tuple (s -> a) s
+runStore s = swap (runIdentity <$> (swap $ runStoreT s))
+
+store :: forall s a. (s -> a) -> s -> Store s a
+store f x = StoreT $ Tuple (Identity f) x

src/Control/Comonad/Store/Class.purs

@@ -0,0 +1,27 @@
+module Control.Comonad.Store.Class where
+
+import Control.Comonad
+import Control.Comonad.Store.Trans
+import Control.Extend
+
+import Data.Tuple
+
+class (Comonad w) <= ComonadStore s w where
+  pos :: forall a. w a -> s
+  peek :: forall a. s -> w a -> a
+
+instance comonadStoreStoreT :: (Comonad w) => ComonadStore s (StoreT s w) where
+  pos (StoreT (Tuple f s)) = s
+  peek s (StoreT (Tuple f _)) = extract f s
+
+experiment :: forall f a w s. (ComonadStore s w, Functor f) => (s -> f s) ->  w a -> f a
+experiment f x = flip peek x <$> f (pos x)
+
+peeks :: forall s a w. (ComonadStore s w) => (s -> s) -> w a -> a
+peeks f x = peek (f $ pos x) x
+
+seek :: forall s a w. (ComonadStore s w, Extend w) => s -> w a -> w a
+seek s x = peek s $ duplicate x
+
+seeks :: forall s a w. (ComonadStore s w, Extend w) => (s -> s) -> w a -> w a
+seeks f x = peeks f $ duplicate x

src/Control/Comonad/Store/Trans.purs

@@ -0,0 +1,24 @@
+module Control.Comonad.Store.Trans where
+
+import Control.Extend
+import Control.Comonad
+import Control.Comonad.Trans
+
+import Data.Tuple
+
+newtype StoreT s w a = StoreT (Tuple (w (s -> a)) s)
+
+runStoreT :: forall s w a. StoreT s w a -> Tuple (w (s -> a)) s
+runStoreT (StoreT s) = s
+
+instance functorStoreT :: (Functor w) => Functor (StoreT s w) where
+  (<$>) f (StoreT (Tuple w s)) = StoreT $ Tuple ((\h -> h >>> f) <$> w) s
+
+instance extendStoreT :: (Extend w) => Extend (StoreT s w) where
+  (<<=) f (StoreT (Tuple w s)) = StoreT $ Tuple ((\w' s' -> f $ StoreT $ Tuple w' s') <<= w) s
+
+instance comonadStoreT :: (Comonad w) => Comonad (StoreT s w) where
+  extract (StoreT (Tuple w s)) = extract w s
+
+instance comonadTransStoreT :: ComonadTrans (StoreT s) where
+  lower (StoreT (Tuple w s)) = (\f -> f s) <$> w