aivika 5.6 → 5.7

raw patch · 10 files changed

+138/−9 lines, 10 filesdep +exceptionsPVP ok

version bump matches the API change (PVP)

Dependencies added: exceptions

API changes (from Hackage documentation)

Files

• CHANGELOG.md +5/−0
• LICENSE +1/−1
• Simulation/Aivika/Generator.hs +1/−0
• Simulation/Aivika/Internal/Cont.hs +8/−1
• Simulation/Aivika/Internal/Dynamics.hs +28/−1
• Simulation/Aivika/Internal/Event.hs +28/−1
• Simulation/Aivika/Internal/Parameter.hs +28/−1
• Simulation/Aivika/Internal/Process.hs +7/−0
• Simulation/Aivika/Internal/Simulation.hs +28/−1
• aivika.cabal +4/−3

@@ -1,4 +1,9 @@ +Version 5.7+-----++* Implemented MonadMask and MonadCatch for basic simulation computations.+ Version 5.6 ----- 

@@ -1,4 +1,4 @@-Copyright (c) 2009-2017 David Sorokin <david.sorokin@gmail.com>+Copyright (c) 2009-2018 David Sorokin <david.sorokin@gmail.com>  All rights reserved. 

@@ -24,6 +24,7 @@ import Data.IORef import Data.Word import Data.Vector+import Data.Functor  -- | A discrete probability density function. type DiscretePDF a = [(a, Double)]

@@ -62,6 +62,7 @@ import Control.Exception import Control.Monad import Control.Monad.Trans+import qualified Control.Monad.Catch as MC import Control.Applicative  import Debug.Trace@@ -284,6 +285,12 @@ instance MonadIO Cont where   liftIO = liftIOC  +instance MC.MonadThrow Cont where+  throwM = throwCont++instance MC.MonadCatch Cont where+  catch = catchCont+ -- | Invoke the computation. invokeCont :: ContParams a -> Cont a -> Event () {-# INLINE invokeCont #-}@@ -381,7 +388,7 @@ -- if it will be wrapped in the 'IO' monad. Therefore, you should use specialised -- functions like the stated one that use the 'throw' function but within the 'IO' computation, -- which allows already handling the exception.-throwCont :: IOException -> Cont a+throwCont :: Exception e => e -> Cont a throwCont = liftIO . throw  -- | Run the 'Cont' computation with the specified cancelation source 

@@ -1,5 +1,5 @@ -{-# LANGUAGE RecursiveDo #-}+{-# LANGUAGE RecursiveDo, RankNTypes #-}  -- | -- Module     : Simulation.Aivika.Internal.Dynamics@@ -39,6 +39,7 @@ import Control.Monad import Control.Monad.Trans import Control.Monad.Fix+import qualified Control.Monad.Catch as MC import Control.Applicative  import Debug.Trace@@ -192,6 +193,22 @@ throwDynamics :: Exception e => e -> Dynamics a throwDynamics = throw +-- | Runs an action with asynchronous exceptions disabled.+maskDynamics :: ((forall a. Dynamics a -> Dynamics a) -> Dynamics b) -> Dynamics b+maskDynamics a =+  Dynamics $ \p ->+  MC.mask $ \u ->+  invokeDynamics p (a $ q u)+  where q u (Dynamics b) = Dynamics (u . b)++-- | Like 'maskDynamics', but the masked computation is not interruptible.+uninterruptibleMaskDynamics :: ((forall a. Dynamics a -> Dynamics a) -> Dynamics b) -> Dynamics b+uninterruptibleMaskDynamics a =+  Dynamics $ \p ->+  MC.uninterruptibleMask $ \u ->+  invokeDynamics p (a $ q u)+  where q u (Dynamics b) = Dynamics (u . b)+ -- | Invoke the 'Dynamics' computation. invokeDynamics :: Point -> Dynamics a -> IO a {-# INLINE invokeDynamics #-}@@ -201,6 +218,16 @@   mfix f =      Dynamics $ \p ->     do { rec { a <- invokeDynamics p (f a) }; return a }++instance MC.MonadThrow Dynamics where+  throwM = throwDynamics++instance MC.MonadCatch Dynamics where+  catch = catchDynamics++instance MC.MonadMask Dynamics where+  mask = maskDynamics+  uninterruptibleMask = uninterruptibleMaskDynamics  -- | Computation that returns the current simulation time. time :: Dynamics Double

@@ -1,5 +1,5 @@ -{-# LANGUAGE RecursiveDo #-}+{-# LANGUAGE RecursiveDo, RankNTypes #-}  -- | -- Module     : Simulation.Aivika.Internal.Event@@ -67,6 +67,7 @@ import Control.Monad import Control.Monad.Trans import Control.Monad.Fix+import qualified Control.Monad.Catch as MC import Control.Applicative  import Debug.Trace (trace)@@ -163,6 +164,22 @@ throwEvent :: Exception e => e -> Event a throwEvent = throw +-- | Runs an action with asynchronous exceptions disabled.+maskEvent :: ((forall a. Event a -> Event a) -> Event b) -> Event b+maskEvent a =+  Event $ \p ->+  MC.mask $ \u ->+  invokeEvent p (a $ q u)+  where q u (Event b) = Event (u . b)++-- | Like 'maskEvent', but the masked computation is not interruptible.+uninterruptibleMaskEvent :: ((forall a. Event a -> Event a) -> Event b) -> Event b+uninterruptibleMaskEvent a =+  Event $ \p ->+  MC.uninterruptibleMask $ \u ->+  invokeEvent p (a $ q u)+  where q u (Event b) = Event (u . b)+ -- | Invoke the 'Event' computation. invokeEvent :: Point -> Event a -> IO a {-# INLINE invokeEvent #-}@@ -172,6 +189,16 @@   mfix f =      Event $ \p ->     do { rec { a <- invokeEvent p (f a) }; return a }++instance MC.MonadThrow Event where+  throwM = throwEvent++instance MC.MonadCatch Event where+  catch = catchEvent++instance MC.MonadMask Event where+  mask = maskEvent+  uninterruptibleMask = uninterruptibleMaskEvent  -- | Defines how the events are processed. data EventProcessing = CurrentEvents

@@ -1,5 +1,5 @@ -{-# LANGUAGE RecursiveDo #-}+{-# LANGUAGE RecursiveDo, RankNTypes #-}  -- | -- Module     : Simulation.Aivika.Internal.Parameter@@ -47,6 +47,7 @@ import Control.Monad import Control.Monad.Trans import Control.Monad.Fix+import qualified Control.Monad.Catch as MC import Control.Applicative  import Data.IORef@@ -203,6 +204,22 @@ throwParameter :: Exception e => e -> Parameter a throwParameter = throw +-- | Runs an action with asynchronous exceptions disabled.+maskParameter :: ((forall a. Parameter a -> Parameter a) -> Parameter b) -> Parameter b+maskParameter a =+  Parameter $ \r ->+  MC.mask $ \u ->+  invokeParameter r (a $ q u)+  where q u (Parameter b) = Parameter (u . b)++-- | Like 'maskParameter', but the masked computation is not interruptible.+uninterruptibleMaskParameter :: ((forall a. Parameter a -> Parameter a) -> Parameter b) -> Parameter b+uninterruptibleMaskParameter a =+  Parameter $ \r ->+  MC.uninterruptibleMask $ \u ->+  invokeParameter r (a $ q u)+  where q u (Parameter b) = Parameter (u . b)+ -- | Invoke the 'Parameter' computation. invokeParameter :: Run -> Parameter a -> IO a {-# INLINE invokeParameter #-}@@ -213,6 +230,16 @@     Parameter $ \r ->     do { rec { a <- invokeParameter r (f a) }; return a }   +instance MC.MonadThrow Parameter where+  throwM = throwParameter++instance MC.MonadCatch Parameter where+  catch = catchParameter++instance MC.MonadMask Parameter where+  mask = maskParameter+  uninterruptibleMask = uninterruptibleMaskParameter+   -- | Memoize the 'Parameter' computation, always returning the same value -- within a simulation run. However, the value will be recalculated for other -- simulation runs. Also it is thread-safe when different simulation runs

@@ -104,6 +104,7 @@ import Control.Exception import Control.Monad import Control.Monad.Trans+import qualified Control.Monad.Catch as MC import Control.Applicative  import Simulation.Aivika.Internal.Specs@@ -470,6 +471,12 @@ instance MonadIO Process where   liftIO = liftIOP   +instance MC.MonadThrow Process where+  throwM = throwProcess++instance MC.MonadCatch Process where+  catch = catchProcess+ returnP :: a -> Process a {-# INLINE returnP #-} returnP a = Process $ \pid -> return a

@@ -1,5 +1,5 @@ -{-# LANGUAGE RecursiveDo, ExistentialQuantification, DeriveDataTypeable #-}+{-# LANGUAGE RecursiveDo, ExistentialQuantification, DeriveDataTypeable, RankNTypes #-}  -- | -- Module     : Simulation.Aivika.Internal.Simulation@@ -39,6 +39,7 @@ import Control.Monad import Control.Monad.Trans import Control.Monad.Fix+import qualified Control.Monad.Catch as MC import Control.Applicative  import Data.IORef@@ -163,6 +164,22 @@ throwSimulation :: Exception e => e -> Simulation a throwSimulation = throw +-- | Runs an action with asynchronous exceptions disabled.+maskSimulation :: ((forall a. Simulation a -> Simulation a) -> Simulation b) -> Simulation b+maskSimulation a =+  Simulation $ \r ->+  MC.mask $ \u ->+  invokeSimulation r (a $ q u)+  where q u (Simulation b) = Simulation (u . b)++-- | Like 'maskSimulation', but the masked computation is not interruptible.+uninterruptibleMaskSimulation :: ((forall a. Simulation a -> Simulation a) -> Simulation b) -> Simulation b+uninterruptibleMaskSimulation a =+  Simulation $ \r ->+  MC.uninterruptibleMask $ \u ->+  invokeSimulation r (a $ q u)+  where q u (Simulation b) = Simulation (u . b)+ -- | Invoke the 'Simulation' computation. invokeSimulation :: Run -> Simulation a -> IO a {-# INLINE invokeSimulation #-}@@ -172,6 +189,16 @@   mfix f =      Simulation $ \r ->     do { rec { a <- invokeSimulation r (f a) }; return a }  ++instance MC.MonadThrow Simulation where+  throwM = throwSimulation++instance MC.MonadCatch Simulation where+  catch = catchSimulation++instance MC.MonadMask Simulation where+  mask = maskSimulation+  uninterruptibleMask = uninterruptibleMaskSimulation  -- | Memoize the 'Simulation' computation, always returning the same value -- within a simulation run.

@@ -1,5 +1,5 @@ name:            aivika-version:         5.6+version:         5.7 synopsis:        A multi-method simulation library description:     Aivika is a discrete event simulation (DES) framework with support of activity-oriented,@@ -113,7 +113,7 @@ category:        Simulation license:         BSD3 license-file:    LICENSE-copyright:       (c) 2009-2017. David Sorokin <david.sorokin@gmail.com>+copyright:       (c) 2009-2018. David Sorokin <david.sorokin@gmail.com> author:          David Sorokin maintainer:      David Sorokin <david.sorokin@gmail.com> homepage:        http://www.aivikasoft.com@@ -239,7 +239,8 @@                      vector >= 0.10.0.1,                      deepseq >= 1.1.0.0,                      binary >= 0.6.4.0,-                     semigroups >= 0.10+                     semigroups >= 0.10,+                     exceptions >= 0.6      other-extensions:   FlexibleContexts,                         FlexibleInstances,