tagged-exception-core 2.1.0.0 → 2.2.0.0

raw patch · 10 files changed

+338/−193 lines, 10 filesdep +ghc-primPVP ok

version bump matches the API change (PVP)

Dependencies added: ghc-prim

API changes (from Hackage documentation)

Files

• ChangeLog.md +32/−6
• LICENSE +1/−1
• README.md +48/−0
• src/Control/Monad/TaggedException.hs +6/−3
• src/Control/Monad/TaggedException/Core.hs +178/−4
• src/Control/Monad/TaggedException/Hidden.hs +24/−3
• src/Control/Monad/TaggedException/Internal/Throws.hs +10/−2
• src/Control/Monad/TaggedException/Unsafe.hs +1/−1
• src/Control/Monad/TaggedException/Utilities.hs +18/−164
• tagged-exception-core.cabal +20/−9

@@ -1,17 +1,39 @@ # ChangeLog / ReleaseNotes  +## Version 2.2.0.0++* Deprecating module `Control.Monad.TaggedException.Utilities`, definitions+  from it were moved in to `Control.Monad.TaggedException.Core`. (**change**)+* Type `Throws` has now instance for `Generic1`, but only on GHC >=7.10, due to+  `PolyKinds`. (**new**)+* `HiddenException` instances for `AllocationLimitExceeded` and `Void`, both+  defined in base >=4.8. (**new**)+* `HiddenException` instance for `TypeError`, defined in base >=4.9. (**new**)+* Bumped upper bound of [transformers][] package to include 0.5.\* branch.+  (**change**)+++## Version 2.1.0.1++* Relaxing upper bound on [exceptions][] package to include versions up to+  0.8.\*. (**new**)+* Not uploaded on to [Hackage][], instead opted to modify package metadata of+  [2.1.0.0](http://hackage.haskell.org/package/tagged-exception-core-2.1.0.0)+  release.++ ## Version 2.1.0.0 -* Builds on GHC from 7.4 to 7.10, later with base 4.8. (change)-* Bumping transformers bounds to include 0.4.\* versions. (change)+* Builds on GHC from 7.4 to 7.10, later with base 4.8. (**change**)+* Bumping [transformers][] bounds to include 0.4.\* versions. (**change**) * Dropped last threads of support for base <= 4.5; it hadn't worked anyway   since [exceptions][] ==0.6 depend on base >=4.5 && <5. (breaking change) * Instances for [mtl][] >=2.1 package. Package [exceptions][] already depends-  on [mtl][], so it doesn't make sense to shy away from them. (new)-* Introduced unsafe functions (new):+  on [mtl][], so it doesn't make sense to shy away from them. (**new**)+* Introduced unsafe functions (**new**): -    ````Haskell+    ```Haskell     liftCCLike         :: (((a -> m b) -> m' c) -> m'' d)         -> ((a -> Throws e m b) -> Throws e m' c) -> Throws e m'' d@@ -25,13 +47,14 @@         -> Throws e m b -> Throws e' n b     ``` -* Documentation updates. (new)+* Documentation updates. (**new**) * Uploaded to [Hackage][]:   <http://hackage.haskell.org/package/tagged-exception-core-2.1.0.0>   ## Version 2.0.0.0 +* First public release. * Rewritten to use classes from [exceptions][] package. * Uploaded to [Hackage][]:   <http://hackage.haskell.org/package/tagged-exception-core-2.0.0.0>@@ -47,3 +70,6 @@ [mtl]:   http://hackage.haskell.org/package/mtl   "mtl package on Hackage"+[transformers]:+  http://hackage.haskell.org/package/transformers+  "transformers package on Hackage"

@@ -1,4 +1,4 @@-Copyright (c) 2009-2015, Peter Trško+Copyright (c) 2009-2016, Peter Trško  All rights reserved. 

@@ -1,6 +1,7 @@ # Tagged Exception Core  [![Hackage](http://img.shields.io/hackage/v/tagged-exception-core.svg)][Hackage: tagged-exception-core]+[![Hackage Dependencies](https://img.shields.io/hackage-deps/v/tagged-exception-core.svg)](http://packdeps.haskellers.com/reverse/tagged-exception-core) [![Haskell Programming Language](https://img.shields.io/badge/language-Haskell-blue.svg)][Haskell.org] [![BSD3 License](http://img.shields.io/badge/license-BSD3-brightgreen.svg)][tl;dr Legal: BSD3] @@ -13,13 +14,60 @@ others may build on top of it.  +## Usage Example +Example of reflecting reised exception in type:++```Haskell+{-# LANGUAGE DeriveDataTypeable #-}++import Control.Exception (Exception)++import Control.Monad.TaggedException (Throws)+import qualified Control.Monad.TaggedException as E (liftT, throw)+import Data.Typeable (Typeable)+++data NotReady = NotReady String+    deriving (Show, Typeable)+        -- Both required by Exception class++instance Exception NotReady++myFunction :: Input -> Throws NotReady IO Output+myFunction input = do++    -- ... some stuff ...++    -- isReady :: Input -> IO Bool+    ready <- E.liftT $ isReady input+    unless ready+        . E.throw $ NotReady "Resource of myFunction is not ready."++    -- ... some other stuff ...+```++## License++The BSD 3-Clause License, see [LICENSE][] file for details.+++## Contributions++Contributions, pull requests and bug reports are welcome! Please don't be+afraid to contact author using GitHub or by e-mail.+++ [Hackage: tagged-exception-core]:   http://hackage.haskell.org/package/tagged-exception-core   "tagged-exception-core package on Hackage" [Haskell.org]:   http://www.haskell.org   "The Haskell Programming Language"+[LICENSE]:+  https://github.com/trskop/tagged-exception-core/blob/master/LICENSE+  "License of endo package." [tl;dr Legal: BSD3]:   https://tldrlegal.com/license/bsd-3-clause-license-%28revised%29   "BSD 3-Clause License (Revised)"

@@ -2,7 +2,7 @@ {-# OPTIONS_GHC -fno-warn-missing-import-lists #-} -- | -- Module:       $HEADER$--- Copyright:    (c) 2009-2015 Peter Trško+-- Copyright:    (c) 2009-2015, Peter Trško -- License:      BSD3 -- -- Stability:    provisional@@ -232,7 +232,11 @@     , module Control.Monad.TaggedException.Hidden      -- ** Asynchronous exceptions and bracket family of functions-    , module Control.Monad.TaggedException.Utilities+    --+    -- | These functions are exported as part of+    -- "Control.Monad.TaggedException.Core" module, there is also module+    -- "Control.Monad.TaggedException.Utilities", which reexports only+    -- functions that make use of 'Control.Monad.Catch.MonadMask' type class.      -- * Some related work     --@@ -271,7 +275,6 @@  import Control.Monad.TaggedException.Core import Control.Monad.TaggedException.Hidden-import Control.Monad.TaggedException.Utilities  -- $usage --

@@ -1,8 +1,9 @@ {-# LANGUAGE NoImplicitPrelude #-}+{-# LANGUAGE RankNTypes #-} -- | -- Module:       $HEADER$ -- Description:  Core functionality.--- Copyright:    (c) 2009-2015 Peter Trško+-- Copyright:    (c) 2009-2016, Peter Trško -- License:      BSD3 -- -- Stability:    provisional@@ -24,6 +25,15 @@     , onException     , onException' +    -- * Utilities+    , bracket+    , bracket'+    , bracket_+    , bracketOnError+    , bracketOnError'+    , finally+    , finally'+     -- * Exception tag     , Throws @@ -47,11 +57,12 @@     where  import Control.Exception (Exception)+import Control.Monad (Monad(return)) import Data.Either (Either)-import Data.Function ((.), flip)+import Data.Function ((.), ($), const, flip) import Data.Functor (Functor) -import Control.Monad.Catch (MonadCatch, MonadThrow)+import Control.Monad.Catch (MonadCatch, MonadMask, MonadThrow) import qualified Control.Monad.Catch as Exceptions  import Control.Monad.TaggedException.Internal.Throws (Throws(Throws))@@ -65,6 +76,7 @@     , insideTf2     , joinT     , joinT3+    , liftMask     , liftT1     , liftT2     , liftT3@@ -441,7 +453,7 @@  -- | ----- Since @1.2.0.0@+-- /Since 1.2.0.0/ embedT :: (Exception e, MonadThrow m, MonadThrow m')     => (m a -> Throws e m' b)     -> Throws e m a -> Throws e m' b@@ -449,3 +461,165 @@ {-# INLINE embedT #-}  -- }}} Exception tag -- Combinators -------------------------------------------++-- {{{ Utilities --------------------------------------------------------------++mask' :: MonadMask m => ((forall a. m a -> m a) -> m b) -> m b+mask' = Exceptions.mask++mask+    :: (Exception e, MonadMask m)+    => ((forall a. Throws e m a -> Throws e m a) -> Throws e m b)+    -> Throws e m b+mask = Unsafe.liftMask Exceptions.mask++-- | Run computation afeter another even if exception was thrown. See also+-- 'finally'', 'onException' and 'onException''.+--+-- Implemented as:+--+-- @+-- m ``finally`` n = 'mask' $ \\restore -> do+--     r <- restore m ``onException`` n+--     _ <- 'liftT' n+--     return r+-- @+finally+    :: (Exception e, MonadMask m)+    => Throws e m a+    -- ^ Computation to run first+    -> m b+    -- ^ Computation to run afterward (even if exception @e@ was raised)+    -> Throws e m a+    -- ^ Returns the result of the first computation+m `finally` n = mask $ \restore -> do+    r <- restore m `onException` n+    _ <- liftT n+    return r++-- | Run computation afeter another even if exception was thrown. See also+-- 'finally', 'onException' and 'onException''.+finally'+    :: MonadMask m+    => m a+    -- ^ Computation to run first+    -> m b+    -- ^ Computation to run afterward (even if some exception was raised)+    -> m a+    -- ^ Returns the result of the first computation+finally' = Exceptions.finally++-- | Run computation surrounded by acquire and release computations. The+-- release computation is executed even if \"in-between\" computation+-- raises exception. See also 'bracket'', 'bracket_', 'bracketOnError',+-- and 'bracketOnError''.+bracket+    :: (Exception e, MonadMask m)+    => m a+    -- ^ Computation to run before+    -> (a -> m b)+    -- ^ Computation to run after+    -> (a -> Throws e m c)+    -- ^ Computation to run in-between+    -> Throws e m c+    -- ^ Result of the in-between computation+bracket acq rel go = mask $ \ restore -> do+    x <- liftT acq+    r <- restore (go x) `onException` rel x+    _ <- liftT $ rel x+    return r++-- | Run computation surrounded by acquire and release computations. The+-- release computation is executed even if \"in-between\" computation+-- raises exception. See also 'bracket', 'bracket_', 'bracketOnError', and+-- 'bracketOnError''.+--+-- Implementated as:+--+-- @+-- 'bracket'' acq rel go = 'mask'' $ \\restore -> do+--     x <- acq+--     r <- restore (go x) ``onException'`` rel x+--     _ <- rel x+--     return r+-- @+bracket'+    :: MonadMask m+    => m a+    -- ^ Computation to run before+    -> (a -> m b)+    -- ^ Computation to run after+    -> (a -> m c)+    -- ^ Computation to run in-between+    -> m c+    -- ^ Result of the in-between computation+bracket' = Exceptions.bracket++-- | Version of 'bracket' where \"after\" computation is executed only if+-- \"in-between\" computation raises exception.+--+-- Implemented as:+--+-- @+-- 'bracketOnError' acq rel go = 'mask' $ \\restore -> do+--     x <- 'liftT' acq+--     restore (go x) ``onException`` rel x+-- @+bracketOnError+    :: (Exception e, MonadMask m)+    => m a+    -- ^ Computation to run before+    -> (a -> m b)+    -- ^ Computation to run after if an exception was raised+    -> (a -> Throws e m c)+    -- ^ Computation to run in-between+    -> Throws e m c+    -- ^ Result of the in-between computation+bracketOnError acq rel go = mask $ \ restore -> do+    x <- liftT acq+    restore (go x) `onException` rel x++-- | Version of 'bracket' where \"after\" computation is executed only if+-- \"in-between\" computation raises exception.+--+-- Implemented as:+--+-- @+-- 'bracketOnError'' acq rel go = 'mask'' $ \\restore -> do+--     x <- 'liftT' acq+--     restore (go x) ``onException'`` rel x+-- @+bracketOnError'+    :: MonadMask m+    => m a+    -- ^ Computation to run before+    -> (a -> m b)+    -- ^ Computation to run after if an exception was raised+    -> (a -> m c)+    -- ^ Computation to run in-between+    -> m c+    -- ^ Result of the in-between computation+bracketOnError' acq rel go = mask' $ \ restore -> do+    x <- acq+    restore (go x) `onException'` rel x++-- | Variant of 'bracket'.+--+-- Implemented as:+--+-- @+-- 'bracket_' acq rel go = 'bracket' acq ('const' rel) ('const' go)+-- @+bracket_+    :: (Exception e, MonadMask m)+    => m a+    -- ^ Computation to run before+    -> m b+    -- ^ Computation to run after+    -> Throws e m c+    -- ^ Computation to run in-between+    -> Throws e m c+    -- ^ Result of the in-between computation+bracket_ acq rel go = bracket acq (const rel) (const go)++-- }}} Utilities --------------------------------------------------------------

@@ -3,7 +3,7 @@ -- | -- Module:       $HEADER$ -- Description:  Support for hidden exceptions.--- Copyright:    (c) 2009 - 2014 Peter Trsko+-- Copyright:    (c) 2009-2016, Peter Trško -- License:      BSD3 -- -- Stability:    provisional@@ -65,7 +65,12 @@  import Control.Exception (Exception) import qualified Control.Exception as E+#if MIN_VERSION_base(4,8,0)+    ( AllocationLimitExceeded+    , ArithException+#else     ( ArithException+#endif     , ArrayException     , AssertionFailed     , AsyncException@@ -90,9 +95,15 @@     , SomeAsyncException #endif     , SomeException+#if MIN_VERSION_base(4,9,0)+    , TypeError+#endif     ) import Data.Dynamic (Dynamic) import Data.Function ((.))+#if MIN_VERSION_base(4,8,0)+import Data.Void (Void)+#endif import System.Exit (ExitCode)  import Control.Monad.Catch (MonadCatch, MonadThrow)@@ -136,11 +147,21 @@ instance HiddenException E.RecConError instance HiddenException E.RecSelError instance HiddenException E.RecUpdError+instance HiddenException E.SomeException+instance HiddenException ExitCode+ #if MIN_VERSION_base(4,7,0) instance HiddenException E.SomeAsyncException #endif-instance HiddenException E.SomeException-instance HiddenException ExitCode++#if MIN_VERSION_base(4,8,0)+instance HiddenException E.AllocationLimitExceeded+instance HiddenException Void+#endif++#if MIN_VERSION_base(4,9,0)+instance HiddenException E.TypeError+#endif  -- }}} HiddenException -- Instances ------------------------------------------- 

@@ -19,7 +19,7 @@ -- | -- Module:       $HEADER$ -- Description:  Data type for associating monadic value with phantom type.--- Copyright:    (c) 2009 - 2015 Peter Trsko+-- Copyright:    (c) 2009-2016, Peter Trško -- License:      BSD3 -- -- Maintainer:   peter.trsko@gmail.com@@ -56,8 +56,13 @@ import Data.Typeable (Typeable) #endif #ifdef GHC_GENERICS-import GHC.Generics (Generic)+import GHC.Generics+    ( Generic+#if __GLASGOW_HASKELL__ >= 710+    , Generic1 #endif+    )+#endif  import Control.Monad.Cont.Class (MonadCont(callCC)) import Control.Monad.Error.Class (MonadError(catchError, throwError))@@ -85,6 +90,9 @@     -- GHC Generics were introduced earlier then polykinded Typeable.   deriving     ( Generic+#if __GLASGOW_HASKELL__ >= 710+    , Generic1+#endif #ifdef KIND_POLYMORPHIC_TYPEABLE     , Typeable #endif

@@ -3,7 +3,7 @@ -- Module:       $HEADER$ -- Description:  Unsafe exception tag cobinators and specific lifting --               functions.--- Copyright:    (c) 2009-2015 Peter Trsko+-- Copyright:    (c) 2009-2015, Peter Trško -- License:      BSD3 -- -- Stability:    provisional

@@ -3,16 +3,23 @@ -- | -- Module:       $HEADER$ -- Description:  Utility functions built on top of core API.--- Copyright:    (c) 2009-2014 Peter Trsko.+-- Copyright:    (c) 2009-2015, Peter Trško -- License:      BSD3 -- -- Stability:    provisional -- Portability:  NoImplicitPrelude, RankNTypes -- -- Utility functions built on top of core API.+--+-- Functions from this module were moved in to+-- "Control.Monad.TaggedException.Core", and this module became deprecated.+--+-- For compatibility reasons this module re-exports all functions that were+-- previously defined here, but this module will be removed in the future.+-- Please update your code to use "Control.Monad.TaggedException.Core" instead. module Control.Monad.TaggedException.Utilities-    (-      bracket+    {-# DEPRECATED "Use module Control.Monad.TaggedException.Core instead." #-}+    ( bracket     , bracket'     , bracket_     , bracketOnError@@ -20,167 +27,14 @@     , finally     , finally'     )-    where--import Control.Monad (Monad(return))-import Control.Exception (Exception)-import Data.Function (($), const)--import Control.Monad.Catch (MonadMask)-import qualified Control.Monad.Catch as Exceptions+  where  import Control.Monad.TaggedException.Core-    ( liftT-    , onException-    , onException'+    ( bracket+    , bracket'+    , bracket_+    , bracketOnError+    , bracketOnError'+    , finally+    , finally'     )-import Control.Monad.TaggedException.Internal.Throws (Throws)-import qualified Control.Monad.TaggedException.Internal.Throws-    as Unsafe (liftMask)---mask' :: MonadMask m => ((forall a. m a -> m a) -> m b) -> m b-mask' = Exceptions.mask--mask-    :: (Exception e, MonadMask m)-    => ((forall a. Throws e m a -> Throws e m a) -> Throws e m b)-    -> Throws e m b-mask = Unsafe.liftMask Exceptions.mask---- | Run computation afeter another even if exception was thrown. See also--- 'finally'', 'onException' and 'onException''.------ Default implementation:------ > m `finally` n = mask $ \ restore -> do--- >     r <- restore m `onException` n--- >     _ <- liftT n--- >     return r-finally-    :: (Exception e, MonadMask m)-    => Throws e m a-    -- ^ Computation to run first-    -> m b-    -- ^ Computation to run afterward (even if exception @e@ was raised)-    -> Throws e m a-    -- ^ Returns the result of the first computation-m `finally` n = mask $ \restore -> do-    r <- restore m `onException` n-    _ <- liftT n-    return r---- | Run computation afeter another even if exception was thrown. See also--- 'finally', 'onException' and 'onException''.-finally'-    :: MonadMask m-    => m a-    -- ^ Computation to run first-    -> m b-    -- ^ Computation to run afterward (even if some exception was raised)-    -> m a-    -- ^ Returns the result of the first computation-finally' = Exceptions.finally---- | Run computation surrounded by acquire and release computations. The--- release computation is executed even if \"in-between\" computation--- raises exception. See also 'bracket'', 'bracket_', 'bracketOnError',--- and 'bracketOnError''.-bracket-    :: (Exception e, MonadMask m)-    => m a-    -- ^ Computation to run before-    -> (a -> m b)-    -- ^ Computation to run after-    -> (a -> Throws e m c)-    -- ^ Computation to run in-between-    -> Throws e m c-    -- ^ Result of the in-between computation-bracket acq rel go = mask $ \ restore -> do-    x <- liftT acq-    r <- restore (go x) `onException` rel x-    _ <- liftT $ rel x-    return r---- | Run computation surrounded by acquire and release computations. The--- release computation is executed even if \"in-between\" computation--- raises exception. See also 'bracket', 'bracket_', 'bracketOnError', and--- 'bracketOnError''.------ Default implementation:------ > bracket' acq rel go = mask' $ \ restore -> do--- >     x <- acq--- >     r <- restore (go x) `onException'` rel x--- >     _ <- rel x--- >     return r-bracket'-    :: MonadMask m-    => m a-    -- ^ Computation to run before-    -> (a -> m b)-    -- ^ Computation to run after-    -> (a -> m c)-    -- ^ Computation to run in-between-    -> m c-    -- ^ Result of the in-between computation-bracket' = Exceptions.bracket---- | Version of 'bracket' where \"after\" computation is executed only if--- \"in-between\" computation raises exception.------ Default implementation:------ > bracketOnError acq rel go = mask $ \ restore -> do--- >     x <- liftT acq--- >     restore (go x) `onException` rel x-bracketOnError-    :: (Exception e, MonadMask m)-    => m a-    -- ^ Computation to run before-    -> (a -> m b)-    -- ^ Computation to run after if an exception was raised-    -> (a -> Throws e m c)-    -- ^ Computation to run in-between-    -> Throws e m c-    -- ^ Result of the in-between computation-bracketOnError acq rel go = mask $ \ restore -> do-    x <- liftT acq-    restore (go x) `onException` rel x---- | Version of 'bracket' where \"after\" computation is executed only if--- \"in-between\" computation raises exception.------ Default implementation:------ > bracketOnError' acq rel go = mask' $ \ restore -> do--- >     x <- liftT acq--- >     restore (go x) `onException'` rel x-bracketOnError'-    :: MonadMask m-    => m a-    -- ^ Computation to run before-    -> (a -> m b)-    -- ^ Computation to run after if an exception was raised-    -> (a -> m c)-    -- ^ Computation to run in-between-    -> m c-    -- ^ Result of the in-between computation-bracketOnError' acq rel go = mask' $ \ restore -> do-    x <- acq-    restore (go x) `onException'` rel x---- | Variant of 'bracket'.------ > bracket_ acq rel go = bracket acq (const rel) (const go)-bracket_-    :: (Exception e, MonadMask m)-    => m a-    -- ^ Computation to run before-    -> m b-    -- ^ Computation to run after-    -> Throws e m c-    -- ^ Computation to run in-between-    -> Throws e m c-    -- ^ Result of the in-between computation-bracket_ acq rel go = bracket acq (const rel) (const go)

@@ -1,5 +1,5 @@ Name:               tagged-exception-core-Version:            2.1.0.0+Version:            2.2.0.0  Synopsis:           Reflect exceptions using phantom types. Description:@@ -7,9 +7,10 @@   introduces @Throws@ monad transformer that uses phantom type to tag code that   may raise exception.  Intention is to make exceptions explicit and to enforce   exception handling.-Homepage:           https://github.com/trskop/tagged-exception-Bug-reports:        https://github.com/trskop/tagged-exception/issues-Copyright:          Copyright (c) 2009-2015, Peter Trško++Homepage:           https://github.com/trskop/tagged-exception-core+Bug-reports:        https://github.com/trskop/tagged-exception-core/issues+Copyright:          Copyright (c) 2009-2016, Peter Trško License:            BSD3 License-file:       LICENSE Author:             Peter Trško@@ -60,18 +61,26 @@    Build-depends:     -- {{{ Distributed with GHC or Haskell Platform ---------------------------+       base >= 4.5 && < 5     -- ^ Same restrictions as exceptions 0.6 have.-    , transformers >= 0.3 && < 0.5++    , transformers >= 0.3 && < 0.6     -- ^ Based on dependencies of mtl==2.1 and mtl==2.2.1+     -- }}} Distributed with GHC or Haskell Platform --------------------------- -    , exceptions > 0.6 && < 0.7+    , exceptions > 0.6 && < 0.9     -- ^ Interface of this package changed a lot between minor versions,     -- therefore trying conservative approach. Dependency introduced in     -- tagged-exception-core-2.0.0.0.+    --+    -- From the used API view, there has been little changes between 0.6.1 and+    -- 0.8.2.1 (newest at the time of writing).+     , mmorph >= 1.0.0 && < 1.1     -- ^ Dependency introduced in tagged-exception-core-1.2.0.0.+     , mtl >=2.1 && <2.3     -- ^ Dependency introduced in tagged-exception-core-2.0.1.0.     -- Package exceptions already depends on it so it doesn't make sense to@@ -80,8 +89,10 @@   if impl(ghc >= 7.8.1)     CPP-options:    -DKIND_POLYMORPHIC_TYPEABLE -  if impl(ghc >= 7.6.1)-    CPP-options:    -DGHC_GENERICS+  CPP-options:      -DGHC_GENERICS+  if impl(ghc < 7.6)+    -- GHC.Generics moved from ghc-prim to base with GHC 7.6 release.+    Build-depends:  ghc-prim    GHC-options:      -Wall   if flag(pedantic)@@ -98,4 +109,4 @@ source-repository this   type:             git   location:         git://github.com/trskop/tagged-exception-core.git-  tag:              2.1.0.0+  tag:              2.2.0.0