Renaming See to RWSResult

Author: ethul

docs/Control/Monad/RWS.md

@@ -14,7 +14,7 @@ to the `Identity` monad.
 #### `rws`
 
 ``` purescript
-rws :: forall r w s a. (r -> s -> See s a w) -> RWS r w s a
+rws :: forall r w s a. (r -> s -> RWSResult s a w) -> RWS r w s a
 ```
 
 Create an action in the `RWS` monad from a function which uses the
@@ -23,7 +23,7 @@ global context and state explicitly.
 #### `runRWS`
 
 ``` purescript
-runRWS :: forall r w s a. RWS r w s a -> r -> s -> See s a w
+runRWS :: forall r w s a. RWS r w s a -> r -> s -> RWSResult s a w
 ```
 
 Run a computation in the `RWS` monad.
@@ -47,7 +47,7 @@ Run a computation in the `RWS` monad, discarding the result
 #### `mapRWS`
 
 ``` purescript
-mapRWS :: forall r w1 w2 s a1 a2. (See s a1 w1 -> See s a2 w2) -> RWS r w1 s a1 -> RWS r w2 s a2
+mapRWS :: forall r w1 w2 s a1 a2. (RWSResult s a1 w1 -> RWSResult s a2 w2) -> RWS r w1 s a1 -> RWS r w2 s a2
 ```
 
 Change the types of the result and accumulator in a `RWS` action

docs/Control/Monad/RWS/Trans.md

@@ -2,17 +2,18 @@
 
 This module defines the reader-writer-state monad transformer, `RWST`.
 
-#### `See`
+#### `RWSResult`
 
 ``` purescript
-data See state result writer
+data RWSResult state result writer
+  = RWSResult state result writer
 ```
 
 #### `RWST`
 
 ``` purescript
 newtype RWST r w s m a
-  = RWST (r -> s -> m (See s a w))
+  = RWST (r -> s -> m (RWSResult s a w))
 ```
 
 The reader-writer-state monad transformer, which combines the operations
@@ -38,7 +39,7 @@ instance monadRecRWST :: (Monoid w, MonadRec m) => MonadRec (RWST r w s m)
 #### `runRWST`
 
 ``` purescript
-runRWST :: forall r w s m a. RWST r w s m a -> r -> s -> m (See s a w)
+runRWST :: forall r w s m a. RWST r w s m a -> r -> s -> m (RWSResult s a w)
 ```
 
 Run a computation in the `RWST` monad.
@@ -62,7 +63,7 @@ Run a computation in the `RWST` monad, discarding the result.
 #### `mapRWST`
 
 ``` purescript
-mapRWST :: forall r w1 w2 s m1 m2 a1 a2. (m1 (See s a1 w1) -> m2 (See s a2 w2)) -> RWST r w1 s m1 a1 -> RWST r w2 s m2 a2
+mapRWST :: forall r w1 w2 s m1 m2 a1 a2. (m1 (RWSResult s a1 w1) -> m2 (RWSResult s a2 w2)) -> RWST r w1 s m1 a1 -> RWST r w2 s m2 a2
 ```
 
 Change the result and accumulator types in a `RWST` monad action.

src/Control/Monad/RWS.purs

@@ -26,11 +26,11 @@ type RWS r w s = RWST r w s Identity
 
 -- | Create an action in the `RWS` monad from a function which uses the
 -- | global context and state explicitly.
-rws :: forall r w s a. (r -> s -> See s a w) -> RWS r w s a
+rws :: forall r w s a. (r -> s -> RWSResult s a w) -> RWS r w s a
 rws f = RWST \r s -> return $ f r s
 
 -- | Run a computation in the `RWS` monad.
-runRWS :: forall r w s a. RWS r w s a -> r -> s -> See s a w
+runRWS :: forall r w s a. RWS r w s a -> r -> s -> RWSResult s a w
 runRWS m r s = runIdentity $ runRWST m r s
 
 -- | Run a computation in the `RWS` monad, discarding the final state
@@ -42,7 +42,7 @@ execRWS :: forall r w s a. RWS r w s a -> r -> s -> Tuple s w
 execRWS m r s = runIdentity $ execRWST m r s
 
 -- | Change the types of the result and accumulator in a `RWS` action
-mapRWS :: forall r w1 w2 s a1 a2. (See s a1 w1 -> See s a2 w2) -> RWS r w1 s a1 -> RWS r w2 s a2
+mapRWS :: forall r w1 w2 s a1 a2. (RWSResult s a1 w1 -> RWSResult s a2 w2) -> RWS r w1 s a1 -> RWS r w2 s a2
 mapRWS f = mapRWST (runIdentity >>> f >>> Identity)
 
 -- | Change the type of the context in a `RWS` action

src/Control/Monad/RWS/Trans.purs

@@ -1,7 +1,7 @@
 -- | This module defines the reader-writer-state monad transformer, `RWST`.
 
 module Control.Monad.RWS.Trans
-  ( See()
+  ( RWSResult(..)
   , RWST(..), runRWST, evalRWST, execRWST, mapRWST, withRWST
   , module Control.Monad.Trans
   , module Control.Monad.RWS.Class
@@ -22,69 +22,69 @@ import Control.Monad.State.Class
 import Control.Monad.Trans
 import Control.Monad.Writer.Class
 
-data See state result writer = See state result writer
+data RWSResult state result writer = RWSResult state result writer
 
 -- | The reader-writer-state monad transformer, which combines the operations
 -- | of `ReaderT`, `WriterT` and `StateT` into a single monad transformer.
-newtype RWST r w s m a = RWST (r -> s -> m (See s a w))
+newtype RWST r w s m a = RWST (r -> s -> m (RWSResult s a w))
 
 -- | Run a computation in the `RWST` monad.
-runRWST :: forall r w s m a. RWST r w s m a -> r -> s -> m (See s a w)
+runRWST :: forall r w s m a. RWST r w s m a -> r -> s -> m (RWSResult s a w)
 runRWST (RWST x) = x
 
 -- | Run a computation in the `RWST` monad, discarding the final state.
 evalRWST :: forall r w s m a. (Monad m) => RWST r w s m a -> r -> s -> m (Tuple a w)
-evalRWST m r s = runRWST m r s >>= \(See _ result writer) -> return (Tuple result writer)
+evalRWST m r s = runRWST m r s >>= \(RWSResult _ result writer) -> return (Tuple result writer)
 
 -- | Run a computation in the `RWST` monad, discarding the result.
 execRWST :: forall r w s m a. (Monad m) => RWST r w s m a -> r -> s -> m (Tuple s w)
-execRWST m r s = runRWST m r s >>= \(See state _ writer) -> return (Tuple state writer)
+execRWST m r s = runRWST m r s >>= \(RWSResult state _ writer) -> return (Tuple state writer)
 
 -- | Change the result and accumulator types in a `RWST` monad action.
-mapRWST :: forall r w1 w2 s m1 m2 a1 a2. (m1 (See s a1 w1) -> m2 (See s a2 w2)) -> RWST r w1 s m1 a1 -> RWST r w2 s m2 a2
+mapRWST :: forall r w1 w2 s m1 m2 a1 a2. (m1 (RWSResult s a1 w1) -> m2 (RWSResult s a2 w2)) -> RWST r w1 s m1 a1 -> RWST r w2 s m2 a2
 mapRWST f m = RWST \r s -> f $ runRWST m r s
 
 -- | Change the context type in a `RWST` monad action.
 withRWST :: forall r1 r2 w s m a. (r2 -> s -> Tuple r1 s) -> RWST r1 w s m a -> RWST r2 w s m a
 withRWST f m = RWST \r s -> uncurry (runRWST m) (f r s)
 
 instance functorRWST :: (Functor m, Monoid w) => Functor (RWST r w s m) where
-  map f m = RWST \r s -> (\(See state result writer) -> See state (f result) writer) <$> runRWST m r s
+  map f m = RWST \r s -> (\(RWSResult state result writer) -> RWSResult state (f result) writer) <$> runRWST m r s
 
 instance applyRWST :: (Bind m, Monoid w) => Apply (RWST r w s m) where
   apply f m = RWST \r s ->
-    runRWST f r s  >>= \(See s' f' w') ->
-    runRWST m r s' <#> \(See s'' a'' w'') ->
-    See s'' (f' a'') (w' ++ w'')
+    runRWST f r s  >>= \(RWSResult s' f' w') ->
+    runRWST m r s' <#> \(RWSResult s'' a'' w'') ->
+    RWSResult s'' (f' a'') (w' ++ w'')
 
 instance bindRWST :: (Bind m, Monoid w) => Bind (RWST r w s m) where
   bind m f = RWST \r s ->
-    runRWST m     r s  >>= \(See s' a w) ->
-    runRWST (f a) r s' <#> \(See state result writer) ->
-    See state result (w ++ writer)
+    runRWST m     r s  >>= \(RWSResult s' a w) ->
+    runRWST (f a) r s' <#> \(RWSResult state result writer) ->
+    RWSResult state result (w ++ writer)
 
 instance applicativeRWST :: (Monad m, Monoid w) => Applicative (RWST r w s m) where
-  pure a = RWST \_ s -> pure $ See s a mempty
+  pure a = RWST \_ s -> pure $ RWSResult s a mempty
 
 instance monadRWST :: (Monad m, Monoid w) => Monad (RWST r w s m)
 
 instance monadTransRWST :: (Monoid w) => MonadTrans (RWST r w s) where
-  lift m = RWST \_ s -> m >>= \a -> return $ See s a mempty
+  lift m = RWST \_ s -> m >>= \a -> return $ RWSResult s a mempty
 
 instance monadEffRWS :: (Monad m, Monoid w, MonadEff eff m) => MonadEff eff (RWST r w s m) where
   liftEff = lift <<< liftEff
 
 instance monadReaderRWST :: (Monad m, Monoid w) => MonadReader r (RWST r w s m) where
-  ask = RWST \r s -> pure $ See s r mempty
+  ask = RWST \r s -> pure $ RWSResult s r mempty
   local f m = RWST \r s -> runRWST m (f r) s
 
 instance monadStateRWST :: (Monad m, Monoid w) => MonadState s (RWST r w s m) where
-  state f = RWST \_ s -> case f s of Tuple a s' -> pure $ See s' a mempty
+  state f = RWST \_ s -> case f s of Tuple a s' -> pure $ RWSResult s' a mempty
 
 instance monadWriterRWST :: (Monad m, Monoid w) => MonadWriter w (RWST r w s m) where
-  writer (Tuple a w) = RWST \_ s -> pure $ See s a w
-  listen m = RWST \r s -> runRWST m r s >>= \(See s' a w) -> pure $ See s' (Tuple a w) w
-  pass m = RWST \r s -> runRWST m r s >>= \(See s' (Tuple a f) w) -> pure $ See s' a (f w)
+  writer (Tuple a w) = RWST \_ s -> pure $ RWSResult s a w
+  listen m = RWST \r s -> runRWST m r s >>= \(RWSResult s' a w) -> pure $ RWSResult s' (Tuple a w) w
+  pass m = RWST \r s -> runRWST m r s >>= \(RWSResult s' (Tuple a f) w) -> pure $ RWSResult s' a (f w)
 
 instance monadRWSRWST :: (Monad m, Monoid w) => MonadRWS r w s (RWST r w s m)
 
@@ -93,10 +93,10 @@ instance monadErrorRWST :: (MonadError e m, Monoid w) => MonadError e (RWST r w
   catchError m h = RWST $ \r s -> catchError (runRWST m r s) (\e -> runRWST (h e) r s)
 
 instance monadRecRWST :: (Monoid w, MonadRec m) => MonadRec (RWST r w s m) where
-  tailRecM k a = RWST \r s -> tailRecM (k' r) (See s a mempty)
+  tailRecM k a = RWST \r s -> tailRecM (k' r) (RWSResult s a mempty)
     where
-    k' r (See state result writer) = do
-      See state' result' writer' <- runRWST (k result) r state
+    k' r (RWSResult state result writer) = do
+      RWSResult state' result' writer' <- runRWST (k result) r state
       return case result' of
-                  Left a -> Left (See state' a (writer <> writer'))
-                  Right b -> Right (See state' b (writer <> writer'))
+                  Left a -> Left (RWSResult state' a (writer <> writer'))
+                  Right b -> Right (RWSResult state' b (writer <> writer'))