tagged-transformer 0.6.5 → 0.7

raw patch · 3 files changed

+145/−26 lines, 3 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• CHANGELOG.markdown +7/−1
• src/Data/Functor/Trans/Tagged.hs +133/−24
• tagged-transformer.cabal +5/−1

@@ -1,6 +1,12 @@+0.7+---+* Enable `-XPolyKinds`+* Added the Tagged monad synonym+* Added useful functions currently in Data.Tagged for both Tagged and TaggedT+ 0.6.5 ----* Allowed mtl 2.2+* Relaxed `mtl` upper bound * Removed unused `transformers` dependency  0.6.4

@@ -4,6 +4,13 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE CPP #-}+{-# LANGUAGE CPP #-}+#ifdef LANGUAGE_DeriveDataTypeable+{-# LANGUAGE DeriveDataTypeable #-}+#endif+#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 706+{-# LANGUAGE PolyKinds #-}+#endif #if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif@@ -22,12 +29,19 @@ module Data.Functor.Trans.Tagged   (   -- * Tagged values-    TaggedT(..)-  , tag, untag+    TaggedT(..), Tagged+  , tag, tagT+  , untag   , retag   , mapTaggedT   , reflected, reflectedM   , asTaggedTypeOf+  , proxy, proxyT+  , unproxy, unproxyT+  , tagSelf, tagTSelf+  , untagSelf, untagTSelf+  , tagWith, tagTWith+  , witness, witnessT   ) where  #if defined(__GLASGOW_HASKELL__) && (__GLASGOW_HASKELL__ >= 706)@@ -39,6 +53,7 @@ import Control.Monad (liftM, MonadPlus(..)) import Control.Monad.Catch (MonadCatch(..), MonadThrow(..), MonadMask(..)) import Control.Monad.Fix (MonadFix(..))+import Control.Monad.Identity (Identity, runIdentity) import Control.Monad.Trans (MonadIO(..), MonadTrans(..)) import Control.Monad.Reader (MonadReader(..)) import Control.Monad.Writer (MonadWriter(..))@@ -48,15 +63,19 @@ import Control.Comonad.Hoist.Class (ComonadHoist(..)) import Control.Comonad (Comonad(..)) import Data.Traversable (Traversable(..))+import Data.Typeable import Data.Foldable (Foldable(..)) import Data.Distributive (Distributive(..)) import Data.Functor.Bind (Apply(..), Bind(..)) import Data.Functor.Extend (Extend(..)) import Data.Functor.Plus (Alt(..), Plus(..)) import Data.Functor.Contravariant (Contravariant(..))+#if !(defined(__GLASGOW_HASKELL__)) || __GLASGOW_HASKELL__ < 707 import Data.Proxy (Proxy(..))+#endif import Data.Reflection (Reifies(..)) +-- --------------------------------------------------------------------------- -- | A @'Tagged' s b@ value is a value @b@ with an attached phantom type @s@. -- This can be used in place of the more traditional but less safe idiom of -- passing in an undefined value with the type, because unlike an @(s -> b)@,@@ -65,8 +84,72 @@ -- Moreover, you don't have to rely on the compiler to inline away the extra -- argument, because the newtype is \"free\" +type Tagged s b = TaggedT s Identity b++-- | Tag a value in Identity monad+tag :: b -> Tagged s b+tag = TagT . return+{-# INLINE tag #-}++-- | Untag a value in Identity monad+untag :: Tagged s b -> b+untag = runIdentity . untagT+{-# INLINE untag #-}++-- | Convert from a 'Tagged' representation to a representation+-- based on a 'Proxy'.+proxy :: Tagged s b -> Proxy s -> b+proxy x _ = untag x+{-# INLINE proxy #-}++-- | Convert from a representation based on a 'Proxy' to a 'Tagged'+-- representation.+unproxy :: (Proxy s -> a) -> Tagged s a+unproxy f = TagT (return $ f Proxy)+{-# INLINE unproxy #-}++-- | Tag a value with its own type.+tagSelf :: a -> Tagged a a+tagSelf = TagT . return+{-# INLINE tagSelf #-}++-- | 'untagSelf' is a type-restricted version of 'untag'.+untagSelf :: Tagged a a -> a+untagSelf = untag+{-# INLINE untagSelf #-}++-- | Another way to convert a proxy to a tag.+tagWith :: proxy s -> a -> Tagged s a+tagWith _ = TagT . return+{-# INLINE tagWith #-}++witness :: Tagged a b -> a -> b+witness x _ = untag x+{-# INLINE witness #-}+++-- ---------------------------------------------------------------------------+-- | A Tagged monad parameterized by:+--+--   * @s@ - the phantom type+--+--   * @m@ - the inner monad+--+--   * @b@ - the tagged value+--+-- | A @'TaggedT' s m b@ value is a monadic value @m b@ with an attached phantom type @s@.+-- This can be used in place of the more traditional but less safe idiom of+-- passing in an undefined value with the type, because unlike an @(s -> m b)@,+-- a @'TaggedT' s m b@ can't try to use the argument @s@ as a real value.+--+-- Moreover, you don't have to rely on the compiler to inline away the extra+-- argument, because the newtype is \"free\" newtype TaggedT s m b = TagT { untagT :: m b }-  deriving ( Eq, Ord, Read, Show )+  deriving ( Eq, Ord, Read, Show+#if __GLASGOW_HASKELL__ >= 707+  , Typeable+#endif+  )  instance Functor m => Functor (TaggedT s m) where   fmap f (TagT x) = TagT (fmap f x)@@ -147,15 +230,15 @@ #endif   tell = lift . tell   {-# INLINE tell #-}-  listen = lift . listen . untag+  listen = lift . listen . untagT   {-# INLINE listen #-}-  pass = lift . pass . untag+  pass = lift . pass . untagT   {-# INLINE pass #-}  instance MonadReader r m => MonadReader r (TaggedT s m) where   ask = lift ask   {-# INLINE ask #-}-  local f = lift . local f . untag+  local f = lift . local f . untagT   {-# INLINE local #-} #if MIN_VERSION_mtl(2,1,0)   reader = lift . reader@@ -173,7 +256,7 @@ #endif  instance MonadCont m => MonadCont (TaggedT s m) where-  callCC f = lift . callCC $ \k -> untag (f (tag . k))+  callCC f = lift . callCC $ \k -> untagT (f (TagT . k))   {-# INLINE callCC #-}  instance Foldable f => Foldable (TaggedT s f) where@@ -225,26 +308,21 @@   {-# INLINE throwM #-}  instance MonadCatch m => MonadCatch (TaggedT s m) where-  catch m f = tag (catch (untag m) (untag . f))+  catch m f = TagT (catch (untagT m) (untagT . f))   {-# INLINE catch #-}  instance MonadMask m => MonadMask (TaggedT s m) where-  mask a = tag $ mask $ \u -> untag (a $ q u)-    where q u = tag . u . untag+  mask a = TagT $ mask $ \u -> untagT (a $ q u)+    where q u = TagT . u . untagT   {-# INLINE mask #-}-  uninterruptibleMask a = tag $ uninterruptibleMask $ \u -> untag (a $ q u)-    where q u = tag . u . untag+  uninterruptibleMask a = TagT $ uninterruptibleMask $ \u -> untagT (a $ q u)+    where q u = TagT . u . untagT   {-# INLINE uninterruptibleMask#-}  -- | Easier to type alias for 'TagT'-tag :: m b -> TaggedT s m b-tag = TagT-{-# INLINE tag #-}---- | Easier to type alias for 'untagT'-untag :: TaggedT s m b -> m b-untag = untagT-{-# INLINE untag #-}+tagT :: m b -> TaggedT s m b+tagT = TagT+{-# INLINE tagT #-}  -- | Some times you need to change the tag you have lying around. -- Idiomatic usage is to make a new combinator for the relationship between the@@ -254,25 +332,56 @@ -- > retagSucc :: Tagged n a -> Tagged (Succ n) a -- > retagSucc = retag retag :: TaggedT s m b -> TaggedT t m b-retag = tag . untag+retag = TagT . untagT {-# INLINE retag #-}  -- | Lift an operation on underlying monad mapTaggedT :: (m a -> n b) -> TaggedT s m a -> TaggedT s n b-mapTaggedT f = tag . f . untag+mapTaggedT f = TagT . f . untagT {-# INLINE mapTaggedT #-}  -- | Reflect reified value back in 'Applicative' context reflected :: forall s m a. (Applicative m, Reifies s a) => TaggedT s m a-reflected = tag . pure . reflect $ (Proxy :: Proxy s)+reflected = TagT . pure . reflect $ (Proxy :: Proxy s) {-# INLINE reflected #-}  -- | Reflect reified value back in 'Monad' context reflectedM :: forall s m a. (Monad m, Reifies s a) => TaggedT s m a-reflectedM = tag . return . reflect $ (Proxy :: Proxy s)+reflectedM = TagT . return . reflect $ (Proxy :: Proxy s) {-# INLINE reflectedM #-}  -- | 'asTaggedTypeOf' is a type-restricted version of 'const'. It is usually used as an infix operator, and its typing forces its first argument (which is usually overloaded) to have the same type as the tag of the second. asTaggedTypeOf :: s -> TaggedT s m b -> s asTaggedTypeOf = const {-# INLINE asTaggedTypeOf #-}++-- | Convert from a 'TaggedT' representation to a representation+-- based on a 'Proxy'.+proxyT :: TaggedT s m b -> Proxy s -> m b+proxyT x _ = untagT x+{-# INLINE proxyT #-}++-- | Convert from a representation based on a 'Proxy' to a 'TaggedT'+-- representation.+unproxyT :: (Proxy s -> m a) -> TaggedT s m a+unproxyT f = TagT (f Proxy)+{-# INLINE unproxyT #-}++-- | Tag a value with its own type.+tagTSelf :: m a -> TaggedT a m a+tagTSelf = TagT+{-# INLINE tagTSelf #-}++-- | 'untagSelf' is a type-restricted version of 'untag'.+untagTSelf :: TaggedT a m a -> m a+untagTSelf = untagT+{-# INLINE untagTSelf #-}++-- | Another way to convert a proxy to a tag.+tagTWith :: proxy s -> m a -> TaggedT s m a+tagTWith _ = TagT+{-# INLINE tagTWith #-}++witnessT :: TaggedT a m b -> a -> m b+witnessT x _ = untagT x+{-# INLINE witnessT #-}

@@ -1,5 +1,5 @@ name:           tagged-transformer-version:        0.6.5+version:        0.7 license:        BSD3 license-file:   LICENSE author:         Edward A. Kmett@@ -41,3 +41,7 @@    hs-source-dirs: src   ghc-options: -Wall++  if !impl(hugs)+    cpp-options: -DLANGUAGE_DeriveDataTypeable+    other-extensions: DeriveDataTypeable