Use newtypes where possible

Author: garyb

docs/Module.md

@@ -27,7 +27,7 @@
 
 ### Types
 
-    data ContT r m a where
+    newtype ContT r m a where
       ContT :: (a -> m r) -> m r -> ContT r m a
 
 
@@ -101,7 +101,7 @@
 
 ### Types
 
-    data ErrorT e m a where
+    newtype ErrorT e m a where
       ErrorT :: m (Either e a) -> ErrorT e m a
 
 
@@ -187,7 +187,7 @@
 
 ### Types
 
-    data Identity a where
+    newtype Identity a where
       Identity :: a -> Identity a
 
 
@@ -213,7 +213,7 @@
 
 ### Types
 
-    data MaybeT m a where
+    newtype MaybeT m a where
       MaybeT :: m (Maybe a) -> MaybeT m a
 
 
@@ -317,7 +317,7 @@
 
 ### Types
 
-    data RWST r w s m a where
+    newtype RWST r w s m a where
       RWST :: r -> s -> m (See s a w) -> RWST r w s m a
 
     type See s a w = { log :: w, result :: a, state :: s }
@@ -404,7 +404,7 @@
 
 ### Types
 
-    data ReaderT r m a where
+    newtype ReaderT r m a where
       ReaderT :: r -> m a -> ReaderT r m a
 
 
@@ -500,7 +500,7 @@
 
 ### Types
 
-    data StateT s m a where
+    newtype StateT s m a where
       StateT :: s -> m (Tuple a s) -> StateT s m a
 
 
@@ -548,7 +548,7 @@
 
 ### Types
 
-    data Delay a where
+    newtype Delay a where
       Delay :: Unit -> a -> Delay a
 
     type Trampoline a = Free Delay a
@@ -636,7 +636,7 @@
 
 ### Types
 
-    data WriterT w m a where
+    newtype WriterT w m a where
       WriterT :: m (Tuple a w) -> WriterT w m a
 
 

src/Control/Monad/Cont/Trans.purs

@@ -3,7 +3,7 @@ module Control.Monad.Cont.Trans where
 import Prelude
 import Control.Monad.Trans
 
-data ContT r m a = ContT ((a -> m r) -> m r)
+newtype ContT r m a = ContT ((a -> m r) -> m r)
 
 runContT :: forall r m a. ContT r m a -> (a -> m r) -> m r
 runContT (ContT f) k = f k

src/Control/Monad/Error/Trans.purs

@@ -7,7 +7,7 @@ import Data.Either
 import Data.Monoid
 import Data.Tuple
 
-data ErrorT e m a = ErrorT (m (Either e a))
+newtype ErrorT e m a = ErrorT (m (Either e a))
 
 runErrorT :: forall e m a. ErrorT e m a -> m (Either e a)
 runErrorT (ErrorT x) = x
@@ -17,7 +17,7 @@ mapErrorT f m = ErrorT $ f (runErrorT m)
 
 instance functorErrorT :: (Functor m) => Functor (ErrorT e m) where
   (<$>) f = ErrorT <<< (<$>) ((<$>) f) <<< runErrorT
-  
+
 instance applyErrorT :: (Functor m, Monad m) => Apply (ErrorT e m) where
   (<*>) f v = ErrorT $ do
     mf <- runErrorT f
@@ -28,10 +28,10 @@ instance applyErrorT :: (Functor m, Monad m) => Apply (ErrorT e m) where
         return case mv of
           Left e -> Left e
           Right x -> Right (k x)
-  
+
 instance applicativeErrorT :: (Functor m, Monad m) => Applicative (ErrorT e m) where
   pure a = ErrorT $ pure $ Right a
-  
+
 instance alternativeErrorT :: (Monad m, Error e) => Alternative (ErrorT e m) where
   empty = ErrorT (return (Left $ strMsg "No alternative"))
   (<|>) x y = ErrorT $ runErrorT x >>= \e -> case e of
@@ -44,9 +44,9 @@ instance bindErrorT :: (Monad m, Error e) => Bind (ErrorT e m) where
     case a of
       Left e -> return $ Left e
       Right x -> runErrorT (f x)
-    
+
 instance monadErrorT :: (Monad m, Error e) => Monad (ErrorT e m)
-    
+
 instance monadTransErrorT :: (Error e) => MonadTrans (ErrorT e) where
   lift m = ErrorT $ do
     a <- m

src/Control/Monad/Identity.purs

@@ -2,21 +2,21 @@ module Control.Monad.Identity where
 
 import Prelude
 
-data Identity a = Identity a
+newtype Identity a = Identity a
 
 runIdentity :: forall a. Identity a -> a
 runIdentity (Identity x) = x
 
 instance functorIdentity :: Functor Identity where
   (<$>) f m = Identity $ f $ runIdentity m
-  
+
 instance applyIdentity :: Apply Identity where
   (<*>) (Identity f) (Identity x) = Identity $ f x
-  
+
 instance applicativeIdentity :: Applicative Identity where
   pure = Identity
 
 instance bindIdentity :: Bind Identity where
   (>>=) m f = f $ runIdentity m
-  
+
 instance monadIdentity :: Monad Identity

src/Control/Monad/Maybe/Trans.purs

@@ -7,7 +7,7 @@ import Data.Either
 import Data.Maybe
 import Data.Tuple
 
-data MaybeT m a = MaybeT (m (Maybe a))
+newtype MaybeT m a = MaybeT (m (Maybe a))
 
 instance functorMaybeT :: (Monad m) => Functor (MaybeT m) where
   (<$>) = liftA1

src/Control/Monad/RWS/Trans.purs

@@ -9,11 +9,11 @@ type See s a w =
   , result :: a
   , log    :: w
   }
-  
+
 mkSee :: forall s a w. (Monoid w) => s -> a -> w -> See s a w
 mkSee s a w = { state: s, result: a, log: w }
 
-data 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 (See s a w))
 
 runRWST :: forall r w s m a. RWST r w s m a -> r -> s -> m (See s a w)
 runRWST (RWST x) = x

src/Control/Monad/Reader/Trans.purs

@@ -3,7 +3,7 @@ module Control.Monad.Reader.Trans where
 import Prelude
 import Control.Monad.Trans
 
-data ReaderT r m a = ReaderT (r -> m a)
+newtype ReaderT r m a = ReaderT (r -> m a)
 
 runReaderT :: forall r m a. ReaderT r m a -> (r -> m a)
 runReaderT (ReaderT x) = x
@@ -19,13 +19,13 @@ liftReaderT m = ReaderT (const m)
 
 instance functorReaderT :: (Functor m) => Functor (ReaderT r m) where
   (<$>) f = mapReaderT $ (<$>) f
-  
+
 instance applyReaderT :: (Applicative m) => Apply (ReaderT r m) where
   (<*>) f v = ReaderT \r -> runReaderT f r <*> runReaderT v r
-    
+
 instance applicativeReaderT :: (Applicative m) => Applicative (ReaderT r m) where
   pure = liftReaderT <<< pure
-  
+
 instance alternativeReaderT :: (Alternative m) => Alternative (ReaderT r m) where
   empty = liftReaderT empty
   (<|>) m n = ReaderT \r -> runReaderT m r <|> runReaderT n r

src/Control/Monad/State/Trans.purs

@@ -4,7 +4,7 @@ import Prelude
 import Control.Monad.Trans
 import Data.Tuple
 
-data StateT s m a = StateT (s -> m (Tuple a s))
+newtype StateT s m a = StateT (s -> m (Tuple a s))
 
 runStateT :: forall s m a. StateT s m a -> s -> m (Tuple a s)
 runStateT (StateT s) = s
@@ -23,13 +23,13 @@ withStateT f s = StateT $ runStateT s <<< f
 
 instance functorStateT :: (Monad m) => Functor (StateT s m) where
   (<$>) = liftM1
-  
+
 instance applyStateT :: (Monad m) => Apply (StateT s m) where
   (<*>) = ap
 
 instance applicativeStateT :: (Monad m) => Applicative (StateT s m) where
   pure a = StateT $ \s -> return $ Tuple a s
-  
+
 instance alternativeStateT :: (Alternative m) => Alternative (StateT s m) where
   empty = StateT $ \_ -> empty
   (<|>) x y = StateT $ \s -> runStateT x s <|> runStateT y s
@@ -38,7 +38,7 @@ instance bindStateT :: (Monad m) => Bind (StateT s m) where
   (>>=) (StateT x) f = StateT \s -> do
     Tuple v s' <- x s
     runStateT (f v) s'
-    
+
 instance monadStateT :: (Monad m) => Monad (StateT s m)
 
 instance monadTransStateT :: MonadTrans (StateT s) where

src/Control/Monad/Trampoline.purs

@@ -2,7 +2,7 @@ module Control.Monad.Trampoline where
 
 import Control.Monad.Free
 
-data Delay a = Delay (Unit -> a)
+newtype Delay a = Delay (Unit -> a)
 
 instance delayFunctor :: Functor Delay where
   (<$>) f (Delay g) = Delay (const (f (g unit)))

src/Control/Monad/Writer/Trans.purs

@@ -5,7 +5,7 @@ import Control.Monad.Trans
 import Data.Monoid
 import Data.Tuple
 
-data WriterT w m a = WriterT (m (Tuple a w))
+newtype WriterT w m a = WriterT (m (Tuple a w))
 
 runWriterT :: forall w m a. WriterT w m a -> m (Tuple a w)
 runWriterT (WriterT x) = x
@@ -15,12 +15,12 @@ mapWriterT f m = WriterT $ f (runWriterT m)
 
 instance functorWriterT :: (Functor m) => Functor (WriterT w m) where
   (<$>) f = mapWriterT $ (<$>) \(Tuple a w) -> Tuple (f a) w
-  
+
 instance applyWriterT :: (Monoid w, Functor m, Applicative m) => Apply (WriterT w m) where
   (<*>) f v = WriterT $
     let k (Tuple a w) (Tuple b w') = Tuple (a b) (w <> w')
     in k <$> (runWriterT f) <*> (runWriterT v)
-  
+
 instance applicativeWriterT :: (Monoid w, Functor m, Applicative m) => Applicative (WriterT w m) where
   pure a = WriterT $ pure $ Tuple a mempty