transformers 0.4.1.0 → 0.4.2.0

raw patch · 27 files changed

+235/−90 lines, 27 filesdep −special-functorsdep ~basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies removed: special-functors

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• Control/Applicative/Backwards.hs +6/−0
• Control/Applicative/Lift.hs +33/−0
• Control/Monad/IO/Class.hs +4/−0
• Control/Monad/Trans/Class.hs +4/−0
• Control/Monad/Trans/Cont.hs +4/−0
• Control/Monad/Trans/Error.hs +3/−0
• Control/Monad/Trans/Except.hs +9/−5
• Control/Monad/Trans/Identity.hs +4/−0
• Control/Monad/Trans/List.hs +4/−0
• Control/Monad/Trans/Maybe.hs +6/−2
• Control/Monad/Trans/RWS/Lazy.hs +4/−0
• Control/Monad/Trans/RWS/Strict.hs +4/−0
• Control/Monad/Trans/Reader.hs +3/−0
• Control/Monad/Trans/State/Lazy.hs +4/−0
• Control/Monad/Trans/State/Strict.hs +4/−0
• Control/Monad/Trans/Writer/Lazy.hs +4/−0
• Control/Monad/Trans/Writer/Strict.hs +4/−0
• Data/Functor/Classes.hs +15/−0
• Data/Functor/Compose.hs +6/−0
• Data/Functor/Constant.hs +6/−0
• Data/Functor/Identity.hs +0/−73
• Data/Functor/Product.hs +6/−0
• Data/Functor/Reverse.hs +6/−0
• Data/Functor/Sum.hs +6/−0
• changelog +7/−0
• oldsrc/Data/Functor/Identity.hs +70/−0
• transformers.cabal +9/−10

@@ -1,3 +1,8 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif+----------------------------------------------------------------------------- -- | -- Module      :  Control.Applicative.Backwards -- Copyright   :  (c) Russell O'Connor 2009@@ -9,6 +14,7 @@ -- -- Making functors with an 'Applicative' instance that performs actions -- in the reverse order.+-----------------------------------------------------------------------------  module Control.Applicative.Backwards (     Backwards(..),

@@ -1,3 +1,8 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif+----------------------------------------------------------------------------- -- | -- Module      :  Control.Applicative.Lift -- Copyright   :  (c) Ross Paterson 2010@@ -8,12 +13,16 @@ -- Portability :  portable -- -- Adding a new kind of pure computation to an applicative functor.+-----------------------------------------------------------------------------  module Control.Applicative.Lift (+    -- * Lifting an applicative     Lift(..),     unLift,+    mapLift,     -- * Collecting errors     Errors,+    runErrors,     failure   ) where @@ -85,11 +94,35 @@ unLift (Pure x) = pure x unLift (Other e) = e +-- | Apply a transformation to the other computation.+mapLift :: (f a -> g a) -> Lift f a -> Lift g a+mapLift f (Pure x) = Pure x+mapLift f (Other e) = Other (f e)+ -- | An applicative functor that collects a monoid (e.g. lists) of errors. -- A sequence of computations fails if any of its components do, but -- unlike monads made with 'ExceptT' from "Control.Monad.Trans.Except", -- these computations continue after an error, collecting all the errors.+--+-- * @'pure' f '<*>' 'pure' x = 'pure' (f x)@+--+-- * @'pure' f '<*>' 'failure' e = 'failure' e@+--+-- * @'failure' e '<*>' 'pure' x = 'failure' e@+--+-- * @'failure' e1 '<*>' 'failure' e2 = 'failure' (e1 '<>' e2)@+-- type Errors e = Lift (Constant e)++-- | Extractor for computations with accumulating errors.+--+-- * @'runErrors' ('pure' x) = 'Right' x@+--+-- * @'runErrors' ('failure' e) = 'Left' e@+--+runErrors :: Errors e a -> Either e a+runErrors (Other (Constant e)) = Left e+runErrors (Pure x) = Right x  -- | Report an error. failure :: (Monoid e) => e -> Errors e a

@@ -1,3 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.IO.Class

@@ -1,3 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.Trans.Class

@@ -1,3 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.Trans.Cont

@@ -1,4 +1,7 @@ {-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif {-# OPTIONS_GHC -fno-warn-orphans #-} ----------------------------------------------------------------------------- -- |

@@ -1,3 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.Trans.Except@@ -57,8 +61,9 @@ -- -- Computations are either exceptions or normal values. ----- The 'return' function returns a normal value, while @>>=@ exits--- on the first exception.+-- The 'return' function returns a normal value, while @>>=@ exits on+-- the first exception.  For a variant that continies after an error+-- and collects all the errors, see 'Control.Applicative.Lift.Errors'. type Except e = ExceptT e Identity  -- | Constructor for computations in the exception monad.@@ -175,9 +180,8 @@             Right x -> return (Right x)  instance (MonadFix m) => MonadFix (ExceptT e m) where-    mfix f = ExceptT $ mfix $ \ a -> runExceptT $ f $ case a of-        Right x -> x-        Left _ -> error "mfix ExceptT: Left"+    mfix f = ExceptT (mfix (runExceptT . f . either (const bomb) id))+      where bomb = error "mfix (ExceptT): inner computation returned Left value"  instance MonadTrans (ExceptT e) where     lift = ExceptT . liftM Right

@@ -1,3 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.Trans.Identity

@@ -1,3 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.Trans.List

@@ -1,3 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.Trans.Maybe@@ -124,8 +128,8 @@             Just _  -> return v  instance (MonadFix m) => MonadFix (MaybeT m) where-    mfix f = MaybeT (mfix (runMaybeT . f . unJust))-      where unJust = fromMaybe (error "mfix MaybeT: Nothing")+    mfix f = MaybeT (mfix (runMaybeT . f . fromMaybe bomb))+      where bomb = error "mfix (MaybeT): inner computation returned Nothing"  instance MonadTrans MaybeT where     lift = MaybeT . liftM Just

@@ -1,3 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.Trans.RWS.Lazy

@@ -1,3 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.Trans.RWS.Strict

@@ -1,4 +1,7 @@ {-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.Trans.Reader

@@ -1,3 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.Trans.State.Lazy

@@ -1,3 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.Trans.State.Strict

@@ -1,3 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.Trans.Writer.Lazy

@@ -1,3 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.Trans.Writer.Strict

@@ -1,3 +1,8 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif+----------------------------------------------------------------------------- -- | -- Module      :  Data.Functor.Classes -- Copyright   :  (c) Ross Paterson 2013@@ -8,6 +13,7 @@ -- Portability :  portable -- -- Prelude classes, lifted to unary type constructors.+-----------------------------------------------------------------------------  module Data.Functor.Classes (     -- * Liftings of Prelude classes@@ -25,6 +31,8 @@     showsBinary1,   ) where +import Data.Functor.Identity+ -- | Lifting of the 'Eq' class to unary type constructors. class Eq1 f where     eq1 :: (Eq a) => f a -> f a -> Bool@@ -62,6 +70,13 @@ instance (Ord a) => Ord1 (Either a) where compare1 = compare instance (Read a) => Read1 (Either a) where readsPrec1 = readsPrec instance (Show a) => Show1 (Either a) where showsPrec1 = showsPrec++-- Instances for other functors++instance Eq1 Identity where eq1 = (==)+instance Ord1 Identity where compare1 = compare+instance Read1 Identity where readsPrec1 = readsPrec+instance Show1 Identity where showsPrec1 = showsPrec  -- Building blocks 

@@ -1,3 +1,8 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif+----------------------------------------------------------------------------- -- | -- Module      :  Data.Functor.Compose -- Copyright   :  (c) Ross Paterson 2010@@ -8,6 +13,7 @@ -- Portability :  portable -- -- Composition of functors.+-----------------------------------------------------------------------------  module Data.Functor.Compose (     Compose(..),

@@ -1,3 +1,8 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif+----------------------------------------------------------------------------- -- | -- Module      :  Data.Functor.Constant -- Copyright   :  (c) Ross Paterson 2010@@ -8,6 +13,7 @@ -- Portability :  portable -- -- The constant functor.+-----------------------------------------------------------------------------  module Data.Functor.Constant (     Constant(..),

@@ -1,73 +0,0 @@--- |--- Module      :  Data.Functor.Identity--- Copyright   :  (c) Andy Gill 2001,---                (c) Oregon Graduate Institute of Science and Technology 2001--- License     :  BSD-style (see the file LICENSE)------ Maintainer  :  ross@soi.city.ac.uk--- Stability   :  experimental--- Portability :  portable------ The identity functor and monad.------ This trivial type constructor serves two purposes:------ * It can be used with functions parameterized by functor or monad classes.------ * It can be used as a base monad to which a series of monad---   transformers may be applied to construct a composite monad.---   Most monad transformer modules include the special case of---   applying the transformer to 'Identity'.  For example, @State s@---   is an abbreviation for @StateT s 'Identity'@.--module Data.Functor.Identity (-    Identity(..),-  ) where--import Data.Functor.Classes--import Control.Applicative-import Control.Monad.Fix-import Data.Foldable (Foldable(foldMap))-import Data.Traversable (Traversable(traverse))---- | Identity functor and monad. (a non-strict monad)-newtype Identity a = Identity { runIdentity :: a }-    deriving (Eq, Ord)---- These instances would be equivalent to the derived instances of the--- newtype if the field were removed.--instance (Read a) => Read (Identity a) where-    readsPrec = readsData $ readsUnary "Identity" Identity--instance (Show a) => Show (Identity a) where-    showsPrec d (Identity x) = showsUnary "Identity" d x--instance Eq1 Identity where eq1 = (==)-instance Ord1 Identity where compare1 = compare-instance Read1 Identity where readsPrec1 = readsPrec-instance Show1 Identity where showsPrec1 = showsPrec---- ------------------------------------------------------------------------------ Identity instances for Functor and Monad--instance Functor Identity where-    fmap f m = Identity (f (runIdentity m))--instance Foldable Identity where-    foldMap f (Identity x) = f x--instance Traversable Identity where-    traverse f (Identity x) = Identity <$> f x--instance Applicative Identity where-    pure a = Identity a-    Identity f <*> Identity x = Identity (f x)--instance Monad Identity where-    return a = Identity a-    m >>= k  = k (runIdentity m)--instance MonadFix Identity where-    mfix f = Identity (fix (runIdentity . f))

@@ -1,3 +1,8 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif+----------------------------------------------------------------------------- -- | -- Module      :  Data.Functor.Product -- Copyright   :  (c) Ross Paterson 2010@@ -8,6 +13,7 @@ -- Portability :  portable -- -- Products, lifted to functors.+-----------------------------------------------------------------------------  module Data.Functor.Product (     Product(..),

@@ -1,3 +1,8 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif+----------------------------------------------------------------------------- -- | -- Module      :  Data.Functor.Reverse -- Copyright   :  (c) Russell O'Connor 2009@@ -9,6 +14,7 @@ -- -- Making functors whose elements are notionally in the reverse order -- from the original functor.+-----------------------------------------------------------------------------  module Data.Functor.Reverse (     Reverse(..),

@@ -1,3 +1,8 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 709+{-# LANGUAGE AutoDeriveTypeable #-}+#endif+----------------------------------------------------------------------------- -- | -- Module      :  Data.Functor.Sum -- Copyright   :  (c) Ross Paterson 2014@@ -8,6 +13,7 @@ -- Portability :  portable -- -- Sums, lifted to functors.+-----------------------------------------------------------------------------  module Data.Functor.Sum (     Sum(..),

@@ -1,5 +1,12 @@ -*-change-log-*- +0.4.2.0 Ross Paterson <ross@soi.city.ac.uk> Nov 2014+	* Dropped compatibility with base-1.x+	* Data.Functor.Identity in base for GHC >= 7.10+	* Added mapLift and runErrors to Control.Applicative.Lift+	* Added AutoDeriveTypeable for GHC >= 7.10+	* Expanded messages from mfix on ExceptT and MaybeT+ 0.4.1.0 Ross Paterson <ross@soi.city.ac.uk> May 2014 	* Reverted to record syntax for newtypes until next major release 

@@ -0,0 +1,70 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.Functor.Identity+-- Copyright   :  (c) Andy Gill 2001,+--                (c) Oregon Graduate Institute of Science and Technology 2001+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  ross@soi.city.ac.uk+-- Stability   :  experimental+-- Portability :  portable+--+-- The identity functor and monad.+--+-- This trivial type constructor serves two purposes:+--+-- * It can be used with functions parameterized by functor or monad classes.+--+-- * It can be used as a base monad to which a series of monad+--   transformers may be applied to construct a composite monad.+--   Most monad transformer modules include the special case of+--   applying the transformer to 'Identity'.  For example, @State s@+--   is an abbreviation for @StateT s 'Identity'@.+-----------------------------------------------------------------------------++module Data.Functor.Identity (+    Identity(..),+  ) where++import Control.Applicative+import Control.Monad.Fix+import Data.Foldable (Foldable(foldMap))+import Data.Traversable (Traversable(traverse))++-- | Identity functor and monad. (a non-strict monad)+newtype Identity a = Identity { runIdentity :: a }+    deriving (Eq, Ord)++-- These instances would be equivalent to the derived instances of the+-- newtype if the field were removed.++instance (Read a) => Read (Identity a) where+    readsPrec d = readParen (d > 10) $ \ r ->+        [(Identity x,t) | ("Identity",s) <- lex r, (x,t) <- readsPrec 11 s]++instance (Show a) => Show (Identity a) where+    showsPrec d (Identity x) = showParen (d > 10) $+        showString "Identity " . showsPrec 11 x++-- ---------------------------------------------------------------------------+-- Identity instances for Functor and Monad++instance Functor Identity where+    fmap f m = Identity (f (runIdentity m))++instance Foldable Identity where+    foldMap f (Identity x) = f x++instance Traversable Identity where+    traverse f (Identity x) = Identity <$> f x++instance Applicative Identity where+    pure a = Identity a+    Identity f <*> Identity x = Identity (f x)++instance Monad Identity where+    return a = Identity a+    m >>= k  = k (runIdentity m)++instance MonadFix Identity where+    mfix f = Identity (fix (runIdentity . f))

@@ -1,5 +1,5 @@ name:         transformers-version:      0.4.1.0+version:      0.4.2.0 license:      BSD3 license-file: LICENSE author:       Andy Gill, Ross Paterson@@ -37,15 +37,15 @@   type: darcs   location: http://code.haskell.org/~ross/transformers -flag ApplicativeInBase-  description: Use the current base package, including Applicative and-    other Functor classes.- library-  if flag(ApplicativeInBase)-    build-depends: base >= 2 && < 6-  else-    build-depends: base >= 1.0 && < 2, special-functors >= 1.0 && < 1.1+  build-depends: base >= 2 && < 6+  hs-source-dirs: .+  if !impl(ghc>=7.9)+    -- Data.Functor.Identity was moved into base-4.8.0.0 (GHC 7.10)+    -- see also https://ghc.haskell.org/trac/ghc/ticket/9664+    -- NB: using impl(ghc>=7.9) instead of fragile Cabal flags+    hs-source-dirs: oldsrc+    exposed-modules: Data.Functor.Identity   exposed-modules:     Control.Applicative.Backwards     Control.Applicative.Lift@@ -71,7 +71,6 @@     Data.Functor.Classes     Data.Functor.Compose     Data.Functor.Constant-    Data.Functor.Identity     Data.Functor.Product     Data.Functor.Reverse     Data.Functor.Sum