aivika-transformers 4.5.1 → 4.6

raw patch · 21 files changed

+295/−201 lines, 21 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• CHANGELOG.md +12/−0
• Simulation/Aivika/IO/Comp.hs +4/−6
• Simulation/Aivika/IO/DES.hs +4/−6
• Simulation/Aivika/IO/Dynamics/Memo.hs +4/−4
• Simulation/Aivika/IO/Dynamics/Memo/Unboxed.hs +5/−5
• Simulation/Aivika/IO/Event.hs +26/−16
• Simulation/Aivika/IO/Generator.hs +7/−7
• Simulation/Aivika/IO/QueueStrategy.hs +60/−45
• Simulation/Aivika/IO/Ref/Base.hs +10/−9
• Simulation/Aivika/IO/Resource/Preemption.hs +32/−22
• Simulation/Aivika/IO/Resource/Preemption/Base.hs +17/−13
• Simulation/Aivika/IO/SD.hs +4/−6
• Simulation/Aivika/IO/Signal.hs +9/−7
• Simulation/Aivika/IO/Var.hs +7/−7
• Simulation/Aivika/IO/Var/Unboxed.hs +6/−6
• Simulation/Aivika/Trans.hs +0/−2
• Simulation/Aivika/Trans/DoubleLinkedList.hs +80/−1
• Simulation/Aivika/Trans/Net.hs +2/−4
• Simulation/Aivika/Trans/Processor.hs +4/−4
• Simulation/Aivika/Trans/Template.hs +0/−29
• aivika-transformers.cabal +2/−2

@@ -0,0 +1,12 @@++Version 4.6+-----++* Removed the MonadTemplate type class as it often caused overlapping family data+  instances.++* Updated module DoubleLinkedList.++* Breaking change: arrows Net and Processor are trying to perform computations+  in parallel as possible, when using the proc notation. Earlier they executed+  sequentially.

@@ -1,6 +1,4 @@ -{-# LANGUAGE FlexibleInstances, UndecidableInstances #-}- -- | -- Module     : Simulation.Aivika.IO.Comp -- Copyright  : Copyright (c) 2009-2016, David Sorokin <david.sorokin@gmail.com>@@ -9,7 +7,7 @@ -- Stability  : experimental -- Tested with: GHC 8.0.1 ----- It allows making the 'MonadIO'-based monad an instance of type class 'MonadComp'+-- It makes the 'IO' monad an instance of type class 'MonadComp' -- on top of which the simulation monads can be built. -- module Simulation.Aivika.IO.Comp () where@@ -22,9 +20,9 @@  import Simulation.Aivika.Trans.Comp import Simulation.Aivika.Trans.Exception-import Simulation.Aivika.Trans.Template --- | A template-based instantiation of the 'MonadComp' type class. -instance (Functor m, Monad m, MonadIO m, MonadException m, MonadTemplate m) => MonadComp m where+-- | An instantiation of the 'MonadComp' type class. +instance MonadComp IO where+-- instance (Functor m, Monad m, MonadIO m, MonadException m, MonadTemplate m) => MonadComp m where    {-# SPECIALISE instance MonadComp IO #-}

@@ -1,6 +1,4 @@ -{-# LANGUAGE FlexibleInstances, UndecidableInstances #-}- -- | -- Module     : Simulation.Aivika.IO.DES -- Copyright  : Copyright (c) 2009-2016, David Sorokin <david.sorokin@gmail.com>@@ -9,7 +7,7 @@ -- Stability  : experimental -- Tested with: GHC 8.0.1 ----- It allows making the 'MonadIO'-based monad an instance of type class 'MonadDES'+-- It makes the 'IO' monad an instance of type class 'MonadDES' -- used for Discrete Event Simulation (DES). -- module Simulation.Aivika.IO.DES () where@@ -22,11 +20,11 @@  import Simulation.Aivika.Trans.Comp import Simulation.Aivika.Trans.DES-import Simulation.Aivika.Trans.Template  import Simulation.Aivika.IO.QueueStrategy --- | A template-based instantiation of the 'MonadDES' type class.-instance (Monad m, MonadComp m, MonadIO m, MonadTemplate m, MonadEventQueueTemplate m) => MonadDES m where+-- | An instantiation of the 'MonadDES' type class.+instance MonadDES IO where+-- instance (Monad m, MonadComp m, MonadIO m, MonadTemplate m, MonadEventQueueTemplate m) => MonadDES m where    {-# SPECIALISE instance MonadDES IO #-}

@@ -9,7 +9,7 @@ -- Stability  : experimental -- Tested with: GHC 8.0.1 ----- The 'MonadIO'-based monad can be an instance of the 'MonadMemo' type class.+-- The 'IO' monad is an instance of the 'MonadMemo' type class. --  module Simulation.Aivika.IO.Dynamics.Memo () where@@ -27,11 +27,11 @@ import Simulation.Aivika.Trans.Internal.Dynamics import Simulation.Aivika.Trans.Dynamics.Memo import Simulation.Aivika.Trans.Dynamics.Extra-import Simulation.Aivika.Trans.Template import Simulation.Aivika.Trans.Array --- | The 'MonadIO' based monad is an instance of the 'MonadMemo' type class.-instance (Monad m, MonadIO m, MonadTemplate m) => MonadMemo m where+-- | The 'IO' monad is an instance of the 'MonadMemo' type class.+instance MonadMemo IO where+-- instance (Monad m, MonadIO m, MonadTemplate m) => MonadMemo m where    {-# SPECIALISE instance MonadMemo IO #-} 

@@ -1,5 +1,5 @@ -{-# LANGUAGE MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, UndecidableInstances #-}+{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, FlexibleContexts, UndecidableInstances #-}  -- | -- Module     : Simulation.Aivika.IO.Dynamics.Memo.Unboxed@@ -9,7 +9,7 @@ -- Stability  : experimental -- Tested with: GHC 8.0.1 ----- The 'MonadIO'-based monad can be an instance of the 'MonadMemo' type class.+-- The 'IO' monad can be an instance of the 'MonadMemo' type class. --  module Simulation.Aivika.IO.Dynamics.Memo.Unboxed () where@@ -27,11 +27,11 @@ import Simulation.Aivika.Trans.Internal.Dynamics import Simulation.Aivika.Trans.Dynamics.Memo.Unboxed import Simulation.Aivika.Trans.Dynamics.Extra-import Simulation.Aivika.Trans.Template import Simulation.Aivika.Trans.Array --- | The 'MonadIO' based monad is an instance of the 'MonadMemo' type class.-instance (Monad m, MonadIO m, MonadTemplate m, MArray IOUArray e IO) => MonadMemo m e where+-- | The 'IO' based monad can be an instance of the 'MonadMemo' type class.+instance MArray IOUArray e IO => MonadMemo IO e where+-- instance (Monad m, MonadIO m, MonadTemplate m, MArray IOUArray e IO) => MonadMemo m e where    {-# SPECIALISE instance MonadMemo IO Double #-}   {-# SPECIALISE instance MonadMemo IO Float #-}

@@ -9,8 +9,8 @@ -- Stability  : experimental -- Tested with: GHC 8.0.1 ----- The module defines a template-based event queue, where--- the 'MonadIO'-based monad can be an instance of 'EventQueueing' and 'EventIOQueueing'.+-- The module defines an event queue, where the 'IO' monad is an instance of+-- 'EventQueueing' and 'EventIOQueueing'. -- module Simulation.Aivika.IO.Event () where @@ -24,17 +24,17 @@ import Simulation.Aivika.Trans.Ref.Base import Simulation.Aivika.Trans.DES import Simulation.Aivika.Trans.Comp-import Simulation.Aivika.Trans.Template import Simulation.Aivika.Trans.Internal.Types import Simulation.Aivika.Trans.Event --- | A template-based implementation of the 'EventQueueing' type class.-instance (Monad m, MonadIO m, MonadEventQueueTemplate m) => EventQueueing m where+-- | An implementation of the 'EventQueueing' type class.+instance EventQueueing IO where+-- instance (Monad m, MonadIO m, MonadEventQueueTemplate m) => EventQueueing m where    {-# SPECIALISE instance EventQueueing IO #-} -  data EventQueue m =-    EventQueue { queuePQ :: PQ.PriorityQueue (Point m -> m ()),+  data EventQueue IO =+    EventQueue { queuePQ :: PQ.PriorityQueue (Point IO -> IO ()),                  -- ^ the underlying priority queue                  queueBusy :: IORef Bool,                  -- ^ whether the queue is currently processing events@@ -70,7 +70,8 @@     liftIO . PQ.queueCount . queuePQ . runEventQueue . pointRun  -- | Process the pending events.-processPendingEventsCore :: (MonadIO m, MonadEventQueueTemplate m) => Bool -> Dynamics m ()+processPendingEventsCore :: Bool -> Dynamics IO ()+-- processPendingEventsCore :: (MonadIO m, MonadEventQueueTemplate m) => Bool -> Dynamics m () {-# INLINE processPendingEventsCore #-} processPendingEventsCore includingCurrentEvents = Dynamics r where   r p =@@ -105,7 +106,8 @@                  call q p  -- | Process the pending events synchronously, i.e. without past.-processPendingEvents :: (MonadIO m, MonadEventQueueTemplate m) => Bool -> Dynamics m ()+processPendingEvents :: Bool -> Dynamics IO ()+-- processPendingEvents :: (MonadIO m, MonadEventQueueTemplate m) => Bool -> Dynamics m () {-# INLINE processPendingEvents #-} processPendingEvents includingCurrentEvents = Dynamics r where   r p =@@ -120,34 +122,42 @@   m = processPendingEventsCore includingCurrentEvents  -- | A memoized value.-processEventsIncludingCurrent :: (MonadIO m, MonadEventQueueTemplate m) => Dynamics m ()+processEventsIncludingCurrent :: Dynamics IO ()+-- processEventsIncludingCurrent :: (MonadIO m, MonadEventQueueTemplate m) => Dynamics m () {-# INLINE processEventsIncludingCurrent #-} processEventsIncludingCurrent = processPendingEvents True  -- | A memoized value.-processEventsIncludingEarlier :: (MonadIO m, MonadEventQueueTemplate m) => Dynamics m ()+processEventsIncludingEarlier :: Dynamics IO ()+-- processEventsIncludingEarlier :: (MonadIO m, MonadEventQueueTemplate m) => Dynamics m () {-# INLINE processEventsIncludingEarlier #-} processEventsIncludingEarlier = processPendingEvents False  -- | A memoized value.-processEventsIncludingCurrentCore :: (MonadIO m, MonadEventQueueTemplate m) => Dynamics m ()+processEventsIncludingCurrentCore :: Dynamics IO ()+-- processEventsIncludingCurrentCore :: (MonadIO m, MonadEventQueueTemplate m) => Dynamics m () {-# INLINE processEventsIncludingCurrentCore #-} processEventsIncludingCurrentCore = processPendingEventsCore True  -- | A memoized value.-processEventsIncludingEarlierCore :: (MonadIO m, MonadEventQueueTemplate m) => Dynamics m ()+processEventsIncludingEarlierCore :: Dynamics IO ()+-- processEventsIncludingEarlierCore :: (MonadIO m, MonadEventQueueTemplate m) => Dynamics m () {-# INLINE processEventsIncludingEarlierCore #-} processEventsIncludingEarlierCore = processPendingEventsCore True  -- | Process the events.-processEvents :: (MonadIO m, MonadEventQueueTemplate m) => EventProcessing -> Dynamics m ()+processEvents :: EventProcessing -> Dynamics IO ()+-- processEvents :: (MonadIO m, MonadEventQueueTemplate m) => EventProcessing -> Dynamics m () {-# INLINABLE processEvents #-} processEvents CurrentEvents = processEventsIncludingCurrent processEvents EarlierEvents = processEventsIncludingEarlier processEvents CurrentEventsOrFromPast = processEventsIncludingCurrentCore processEvents EarlierEventsOrFromPast = processEventsIncludingEarlierCore --- | A template-based implementation of the 'EventIOQueueing' type class.-instance (Monad m, MonadIO m, MonadEventQueueTemplate m, MonadDES m) => EventIOQueueing m where+-- | An implementation of the 'EventIOQueueing' type class.+instance EventIOQueueing IO where+-- instance (Monad m, MonadIO m, MonadEventQueueTemplate m, MonadDES m) => EventIOQueueing m where++  {-# SPECIALISE instance EventIOQueueing IO #-}    enqueueEventIO = enqueueEvent

@@ -1,5 +1,5 @@ -{-# LANGUAGE TypeFamilies, FlexibleInstances, UndecidableInstances #-}+{-# LANGUAGE TypeFamilies #-}  -- | -- Module     : Simulation.Aivika.IO.Generator@@ -10,7 +10,7 @@ -- Tested with: GHC 8.0.1 -- -- Here is defined a random number generator, where--- the 'MonadIO'-based monad can be an instance of 'MonadGenerator'.+-- the 'IO' monad is an instance of 'MonadGenerator'. -- module Simulation.Aivika.IO.Generator () where @@ -23,16 +23,16 @@  import Simulation.Aivika.Trans.Generator import Simulation.Aivika.Trans.Generator.Primitive-import Simulation.Aivika.Trans.Template -instance (Functor m, Monad m, MonadIO m, MonadTemplate m) => MonadGenerator m where+instance MonadGenerator IO where+-- instance (Functor m, Monad m, MonadIO m, MonadTemplate m) => MonadGenerator m where    {-# SPECIALISE instance MonadGenerator IO #-} -  data Generator m =-    Generator { generator01 :: m Double,+  data Generator IO =+    Generator { generator01 :: IO Double,                 -- ^ the generator of uniform numbers from 0 to 1-                generatorNormal01 :: m Double+                generatorNormal01 :: IO Double                 -- ^ the generator of normal numbers with mean 0 and variance 1               } 

@@ -1,5 +1,5 @@ -{-# LANGUAGE TypeFamilies, MultiParamTypeClasses, FlexibleInstances, FlexibleContexts, FunctionalDependencies, UndecidableInstances #-}+{-# LANGUAGE TypeFamilies, MultiParamTypeClasses #-}  -- | -- Module     : Simulation.Aivika.IO.QueueStrategy@@ -10,7 +10,7 @@ -- Tested with: GHC 8.0.1 -- -- This module defines some queue strategy instances--- for the 'MonadIO'-based computations.+-- for the 'IO' computation. -- module Simulation.Aivika.IO.QueueStrategy () where @@ -22,7 +22,6 @@ import Simulation.Aivika.Trans.Simulation import Simulation.Aivika.Trans.Event import Simulation.Aivika.Trans.QueueStrategy-import Simulation.Aivika.Trans.Template  import Simulation.Aivika.IO.Comp @@ -31,13 +30,14 @@ import qualified Simulation.Aivika.Vector as V  -- | An implementation of the 'FCFS' queue strategy.-instance (Monad m, MonadComp m, MonadIO m, MonadTemplate m)-         => QueueStrategy m FCFS where+instance QueueStrategy IO FCFS where+-- instance (Monad m, MonadComp m, MonadIO m, MonadTemplate m)+--          => QueueStrategy m FCFS where    {-# SPECIALISE instance QueueStrategy IO FCFS #-}    -- | A queue used by the 'FCFS' strategy.-  newtype StrategyQueue m FCFS a = FCFSQueue (LL.DoubleLinkedList a)+  newtype StrategyQueue IO FCFS a = FCFSQueue (LL.DoubleLinkedList a)    {-# INLINABLE newStrategyQueue #-}   newStrategyQueue s =@@ -49,8 +49,9 @@     liftIO $ LL.listNull q  -- | An implementation of the 'FCFS' queue strategy.-instance (QueueStrategy m FCFS, MonadComp m, MonadIO m, MonadTemplate m)-         => DequeueStrategy m FCFS where+instance DequeueStrategy IO FCFS where+-- instance (QueueStrategy m FCFS, MonadComp m, MonadIO m, MonadTemplate m)+--          => DequeueStrategy m FCFS where    {-# SPECIALISE instance DequeueStrategy IO FCFS #-} @@ -62,8 +63,9 @@        return i  -- | An implementation of the 'FCFS' queue strategy.-instance (DequeueStrategy m FCFS, MonadComp m, MonadIO m, MonadTemplate m)-         => EnqueueStrategy m FCFS where+instance EnqueueStrategy IO FCFS where+-- instance (DequeueStrategy m FCFS, MonadComp m, MonadIO m, MonadTemplate m)+--          => EnqueueStrategy m FCFS where    {-# SPECIALISE instance EnqueueStrategy IO FCFS #-} @@ -72,8 +74,9 @@     liftIO $ LL.listAddLast q i  -- | An implementation of the 'FCFS' queue strategy.-instance (DequeueStrategy m FCFS, MonadComp m, MonadIO m, MonadTemplate m)-         => DeletingQueueStrategy m FCFS where+instance DeletingQueueStrategy IO FCFS where+-- instance (DequeueStrategy m FCFS, MonadComp m, MonadIO m, MonadTemplate m)+--          => DeletingQueueStrategy m FCFS where    {-# SPECIALISE instance DeletingQueueStrategy IO FCFS #-} @@ -86,13 +89,14 @@     liftIO $ LL.listContainsBy q p  -- | An implementation of the 'LCFS' queue strategy.-instance (MonadComp m, MonadIO m, MonadTemplate m)-         => QueueStrategy m LCFS where+instance QueueStrategy IO LCFS where+-- instance (MonadComp m, MonadIO m, MonadTemplate m)+--          => QueueStrategy m LCFS where    {-# SPECIALISE instance QueueStrategy IO LCFS #-}    -- | A queue used by the 'LCFS' strategy.-  newtype StrategyQueue m LCFS a = LCFSQueue (LL.DoubleLinkedList a)+  newtype StrategyQueue IO LCFS a = LCFSQueue (LL.DoubleLinkedList a)    {-# INLINABLE newStrategyQueue #-}   newStrategyQueue s =@@ -104,8 +108,9 @@     liftIO $ LL.listNull q  -- | An implementation of the 'LCFS' queue strategy.-instance (QueueStrategy m LCFS, MonadComp m, MonadIO m, MonadTemplate m)-         => DequeueStrategy m LCFS where+instance DequeueStrategy IO LCFS where+-- instance (QueueStrategy m LCFS, MonadComp m, MonadIO m, MonadTemplate m)+--          => DequeueStrategy m LCFS where    {-# SPECIALISE instance DequeueStrategy IO LCFS #-} @@ -117,8 +122,9 @@        return i  -- | An implementation of the 'LCFS' queue strategy.-instance (DequeueStrategy m LCFS, MonadComp m, MonadIO m, MonadTemplate m)-         => EnqueueStrategy m LCFS where+instance EnqueueStrategy IO LCFS where+-- instance (DequeueStrategy m LCFS, MonadComp m, MonadIO m, MonadTemplate m)+--          => EnqueueStrategy m LCFS where    {-# SPECIALISE instance EnqueueStrategy IO LCFS #-} @@ -127,8 +133,9 @@     liftIO $ LL.listInsertFirst q i  -- | An implementation of the 'LCFS' queue strategy.-instance (DequeueStrategy m LCFS, MonadComp m, MonadIO m, MonadTemplate m)-         => DeletingQueueStrategy m LCFS where+instance DeletingQueueStrategy IO LCFS where+-- instance (DequeueStrategy m LCFS, MonadComp m, MonadIO m, MonadTemplate m)+--          => DeletingQueueStrategy m LCFS where    {-# SPECIALISE instance DeletingQueueStrategy IO LCFS #-} @@ -140,14 +147,15 @@   strategyQueueContainsBy (LCFSQueue q) p =     liftIO $ LL.listContainsBy q p --- | A template-based implementation of the 'StaticPriorities' queue strategy.-instance (MonadComp m, MonadIO m, MonadTemplate m)-         => QueueStrategy m StaticPriorities where+-- | An implementation of the 'StaticPriorities' queue strategy.+instance QueueStrategy IO StaticPriorities where+-- instance (MonadComp m, MonadIO m, MonadTemplate m)+--          => QueueStrategy m StaticPriorities where    {-# SPECIALISE instance QueueStrategy IO StaticPriorities #-}    -- | A queue used by the 'StaticPriorities' strategy.-  newtype StrategyQueue m StaticPriorities a = StaticPriorityQueue (PQ.PriorityQueue a)+  newtype StrategyQueue IO StaticPriorities a = StaticPriorityQueue (PQ.PriorityQueue a)    {-# INLINABLE newStrategyQueue #-}   newStrategyQueue s =@@ -158,9 +166,10 @@   strategyQueueNull (StaticPriorityQueue q) =     liftIO $ PQ.queueNull q --- | A template-based implementation of the 'StaticPriorities' queue strategy.-instance (QueueStrategy m StaticPriorities, MonadComp m, MonadIO m, MonadTemplate m)-         => DequeueStrategy m StaticPriorities where+-- | An implementation of the 'StaticPriorities' queue strategy.+instance DequeueStrategy IO StaticPriorities where+-- instance (QueueStrategy m StaticPriorities, MonadComp m, MonadIO m, MonadTemplate m)+--          => DequeueStrategy m StaticPriorities where    {-# SPECIALISE instance DequeueStrategy IO StaticPriorities #-} @@ -171,9 +180,10 @@        PQ.dequeue q        return i --- | A template-based implementation of the 'StaticPriorities' queue strategy.-instance (DequeueStrategy m StaticPriorities, MonadComp m, MonadIO m, MonadTemplate m)-         => PriorityQueueStrategy m StaticPriorities Double where+-- | An implementation of the 'StaticPriorities' queue strategy.+instance PriorityQueueStrategy IO StaticPriorities Double where+-- instance (DequeueStrategy m StaticPriorities, MonadComp m, MonadIO m, MonadTemplate m)+--          => PriorityQueueStrategy m StaticPriorities Double where    {-# SPECIALISE instance PriorityQueueStrategy IO StaticPriorities Double #-} @@ -182,8 +192,9 @@     liftIO $ PQ.enqueue q p i  -- | An implementation of the 'StaticPriorities' queue strategy.-instance (DequeueStrategy m StaticPriorities, MonadComp m, MonadIO m, MonadTemplate m)-         => DeletingQueueStrategy m StaticPriorities where+instance DeletingQueueStrategy IO StaticPriorities where+-- instance (DequeueStrategy m StaticPriorities, MonadComp m, MonadIO m, MonadTemplate m)+--          => DeletingQueueStrategy m StaticPriorities where    {-# SPECIALISE instance DeletingQueueStrategy IO StaticPriorities #-} @@ -195,14 +206,15 @@   strategyQueueContainsBy (StaticPriorityQueue q) p =     liftIO $ PQ.queueContainsBy q p --- | A template-based implementation of the 'SIRO' queue strategy.-instance (MonadComp m, MonadIO m, MonadTemplate m)-         => QueueStrategy m SIRO where+-- | An implementation of the 'SIRO' queue strategy.+instance QueueStrategy IO SIRO where+-- instance (MonadComp m, MonadIO m, MonadTemplate m)+--          => QueueStrategy m SIRO where    {-# SPECIALISE instance QueueStrategy IO SIRO #-}    -- | A queue used by the 'SIRO' strategy.-  newtype StrategyQueue m SIRO a = SIROQueue (V.Vector a)+  newtype StrategyQueue IO SIRO a = SIROQueue (V.Vector a)      {-# INLINABLE newStrategyQueue #-}   newStrategyQueue s =@@ -215,9 +227,10 @@     do n <- V.vectorCount q        return (n == 0) --- | A template-based implementation of the 'SIRO' queue strategy.-instance (QueueStrategy m SIRO, MonadComp m, MonadIO m, MonadTemplate m)-         => DequeueStrategy m SIRO where+-- | An implementation of the 'SIRO' queue strategy.+instance DequeueStrategy IO SIRO where+-- instance (QueueStrategy m SIRO, MonadComp m, MonadIO m, MonadTemplate m)+--          => DequeueStrategy m SIRO where    {-# SPECIALISE instance DequeueStrategy IO SIRO #-} @@ -229,9 +242,10 @@        liftIO $ V.vectorDeleteAt q i        return x --- | A template-based implementation of the 'SIRO' queue strategy.-instance (DequeueStrategy m SIRO, MonadComp m, MonadIO m, MonadTemplate m)-         => EnqueueStrategy m SIRO where+-- | An implementation of the 'SIRO' queue strategy.+instance EnqueueStrategy IO SIRO where+-- instance (DequeueStrategy m SIRO, MonadComp m, MonadIO m, MonadTemplate m)+--          => EnqueueStrategy m SIRO where    {-# SPECIALISE instance EnqueueStrategy IO SIRO #-} @@ -240,8 +254,9 @@     liftIO $ V.appendVector q i  -- | An implementation of the 'SIRO' queue strategy.-instance (DequeueStrategy m SIRO, MonadComp m, MonadIO m, MonadTemplate m)-         => DeletingQueueStrategy m SIRO where+instance DeletingQueueStrategy IO SIRO where+-- instance (DequeueStrategy m SIRO, MonadComp m, MonadIO m, MonadTemplate m)+--          => DeletingQueueStrategy m SIRO where    {-# SPECIALISE instance DeletingQueueStrategy IO SIRO #-} 

@@ -1,5 +1,5 @@ -{-# LANGUAGE TypeFamilies, FlexibleInstances, UndecidableInstances #-}+{-# LANGUAGE TypeFamilies #-}  -- | -- Module     : Simulation.Aivika.IO.Ref.Base@@ -9,7 +9,7 @@ -- Stability  : experimental -- Tested with: GHC 8.0.1 ----- The 'MonadIO'-based monad can be an instance of 'MonadRef'.+-- The 'IO' monad in an instance of 'MonadRef'. -- module Simulation.Aivika.IO.Ref.Base () where @@ -20,15 +20,15 @@  import Simulation.Aivika.Trans.Internal.Types import Simulation.Aivika.Trans.Ref.Base-import Simulation.Aivika.Trans.Template --- | The 'MonadIO' based monad is an instance of 'MonadRef'.-instance (Monad m, MonadIO m, MonadTemplate m) => MonadRef m where+-- | 'IO' is an instance of 'MonadRef'.+instance MonadRef IO where+-- instance (Monad m, MonadIO m, MonadTemplate m) => MonadRef m where    {-# SPECIALISE instance MonadRef IO #-}    -- | A type safe wrapper for the 'IORef' reference.-  newtype Ref m a = Ref { refValue :: IORef a }+  newtype Ref IO a = Ref { refValue :: IORef a }    {-# INLINE newRef #-}   newRef a =@@ -53,11 +53,12 @@   {-# INLINE equalRef #-}   equalRef (Ref r1) (Ref r2) = (r1 == r2) --- | The 'MonadIO' based monad is an instance of 'MonadRef0'.-instance (MonadIO m, MonadTemplate m) => MonadRef0 m where+-- | 'IO' is an instance of 'MonadRef0'.+instance MonadRef0 IO where+-- instance (MonadIO m, MonadTemplate m) => MonadRef0 m where    {-# SPECIALISE instance MonadRef0 IO #-}-+     {-# INLINE newRef0 #-}   newRef0 a =     do x <- liftIO $ newIORef a

@@ -1,5 +1,5 @@ -{-# LANGUAGE TypeFamilies, FlexibleInstances, UndecidableInstances #-}+{-# LANGUAGE TypeFamilies, FlexibleInstances #-}  -- | -- Module     : Simulation.Aivika.IO.Resource.Preemption@@ -10,7 +10,7 @@ -- Tested with: GHC 8.0.1 -- -- This module defines the preemptible resource, where--- the 'MonadIO'-based monad can be an instance of 'MonadResource'.+-- the 'IO' monad is an instance of 'MonadResource'. -- module Simulation.Aivika.IO.Resource.Preemption () where @@ -24,7 +24,6 @@ import Simulation.Aivika.Trans.Exception import Simulation.Aivika.Trans.Ref.Base import Simulation.Aivika.Trans.DES-import Simulation.Aivika.Trans.Template import Simulation.Aivika.Trans.Internal.Specs import Simulation.Aivika.Trans.Internal.Simulation import Simulation.Aivika.Trans.Internal.Event@@ -38,30 +37,31 @@  import qualified Simulation.Aivika.PriorityQueue as PQ --- | The 'MonadIO' based monad is an instance of 'MonadResource'.-instance (Monad m, MonadDES m, MonadIO m, MonadTemplate m) => MonadResource m where+-- | The 'IO' monad is an instance of 'MonadResource'.+instance MonadResource IO where+-- instance (Monad m, MonadDES m, MonadIO m, MonadTemplate m) => MonadResource m where    {-# SPECIALISE instance MonadResource IO #-}    -- | A template-based implementation of the preemptible resource.-  data Resource m = +  data Resource IO =      Resource { resourceMaxCount0 :: Maybe Int,                -- ^ Return the maximum count of the resource, where 'Nothing'                -- means that the resource has no upper bound.                resourceCountRef :: IORef Int,                resourceCountStatsRef :: IORef (TimingStats Int),-               resourceCountSource :: SignalSource m Int,+               resourceCountSource :: SignalSource IO Int,                resourceUtilisationCountRef :: IORef Int,                resourceUtilisationCountStatsRef :: IORef (TimingStats Int),-               resourceUtilisationCountSource :: SignalSource m Int,+               resourceUtilisationCountSource :: SignalSource IO Int,                resourceQueueCountRef :: IORef Int,                resourceQueueCountStatsRef :: IORef (TimingStats Int),-               resourceQueueCountSource :: SignalSource m Int,+               resourceQueueCountSource :: SignalSource IO Int,                resourceTotalWaitTimeRef :: IORef Double,                resourceWaitTimeRef :: IORef (SamplingStats Double),-               resourceWaitTimeSource :: SignalSource m (),-               resourceActingQueue :: PQ.PriorityQueue (ResourceActingItem m),-               resourceWaitQueue :: PQ.PriorityQueue (ResourceAwaitingItem m) }+               resourceWaitTimeSource :: SignalSource IO (),+               resourceActingQueue :: PQ.PriorityQueue (ResourceActingItem IO),+               resourceWaitQueue :: PQ.PriorityQueue (ResourceAwaitingItem IO) }    {-# INLINABLE newResource #-}   newResource count =@@ -290,22 +290,27 @@                           preemptedItemTime :: Double,                           preemptedItemId :: ProcessId m } -instance (MonadDES m, MonadIO m, MonadTemplate m) => Eq (Resource m) where+instance Eq (Resource IO) where+-- instance (MonadDES m, MonadIO m, MonadTemplate m) => Eq (Resource m) where    {-# INLINABLE (==) #-}   x == y = resourceCountRef x == resourceCountRef y  -- unique references -instance (MonadDES m, MonadIO m, MonadTemplate m) => Eq (ResourceActingItem m) where+instance Eq (ResourceActingItem IO) where+-- instance (MonadDES m, MonadIO m, MonadTemplate m) => Eq (ResourceActingItem m) where    {-# INLINABLE (==) #-}   x == y = actingItemId x == actingItemId y  -- | Release the resource increasing its count and resuming one of the -- previously suspended or preempted processes as possible.-releaseResource' :: (MonadDES m, MonadIO m, MonadTemplate m)-                    => Resource m+releaseResource' :: Resource IO                     -- ^ the resource to release-                    -> Event m ()+                    -> Event IO ()+-- releaseResource' :: (MonadDES m, MonadIO m, MonadTemplate m)+--                     => Resource m+--                     -- ^ the resource to release+--                     -> Event m () {-# INLINABLE releaseResource' #-} releaseResource' r =   Event $ \p ->@@ -349,7 +354,8 @@  -- | Preempt a process with the lowest priority that acquires yet the resource -- and decrease the count of available resource by 1. -decResourceCount' :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Event m ()+decResourceCount' :: Resource IO -> Event IO ()+-- decResourceCount' :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Event m () {-# INLINABLE decResourceCount' #-} decResourceCount' r =   Event $ \p ->@@ -372,7 +378,8 @@      invokeEvent p $ updateResourceCount r (-1)  -- | Update the resource count and its statistics.-updateResourceCount :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Int -> Event m ()+updateResourceCount :: Resource IO -> Int -> Event IO ()+-- updateResourceCount :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Int -> Event m () {-# INLINABLE updateResourceCount #-} updateResourceCount r delta =   Event $ \p ->@@ -386,7 +393,8 @@        triggerSignal (resourceCountSource r) a'  -- | Update the resource queue length and its statistics.-updateResourceQueueCount :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Int -> Event m ()+updateResourceQueueCount :: Resource IO -> Int -> Event IO ()+-- updateResourceQueueCount :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Int -> Event m () {-# INLINABLE updateResourceQueueCount #-} updateResourceQueueCount r delta =   Event $ \p ->@@ -400,7 +408,8 @@        triggerSignal (resourceQueueCountSource r) a'  -- | Update the resource utilisation count and its statistics.-updateResourceUtilisationCount :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Int -> Event m ()+updateResourceUtilisationCount :: Resource IO -> Int -> Event IO ()+-- updateResourceUtilisationCount :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Int -> Event m () {-# INLINABLE updateResourceUtilisationCount #-} updateResourceUtilisationCount r delta =   Event $ \p ->@@ -414,7 +423,8 @@        triggerSignal (resourceUtilisationCountSource r) a'  -- | Update the resource wait time and its statistics.-updateResourceWaitTime :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Double -> Event m ()+updateResourceWaitTime :: Resource IO -> Double -> Event IO ()+-- updateResourceWaitTime :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Double -> Event m () {-# INLINABLE updateResourceWaitTime #-} updateResourceWaitTime r delta =   Event $ \p ->

@@ -1,5 +1,5 @@ -{-# LANGUAGE TypeFamilies, FlexibleInstances, UndecidableInstances #-}+{-# LANGUAGE TypeFamilies, FlexibleInstances #-}  -- | -- Module     : Simulation.Aivika.IO.Resource.Preemption.Base@@ -9,8 +9,8 @@ -- Stability  : experimental -- Tested with: GHC 8.0.1 ----- This module defines the optimised preemptible resource, where--- the 'MonadIO'-based monad can be an instance of 'MonadResource'.+-- This module defines an optimised preemptible resource, where+-- the 'IO' monad is an instance of 'MonadResource'. -- module Simulation.Aivika.IO.Resource.Preemption.Base () where @@ -23,7 +23,6 @@ import Simulation.Aivika.Trans.Exception import Simulation.Aivika.Trans.Ref.Base import Simulation.Aivika.Trans.DES-import Simulation.Aivika.Trans.Template import Simulation.Aivika.Trans.Internal.Specs import Simulation.Aivika.Trans.Internal.Simulation import Simulation.Aivika.Trans.Internal.Event@@ -35,17 +34,18 @@  import qualified Simulation.Aivika.PriorityQueue as PQ --- | The 'MonadIO' based monad is an instance of 'MonadResource'.-instance (Monad m, MonadDES m, MonadIO m, MonadTemplate m) => MonadResource m where+-- | The 'IO' monad is an instance of 'MonadResource'.+instance MonadResource IO where+-- instance (Monad m, MonadDES m, MonadIO m, MonadTemplate m) => MonadResource m where    {-# SPECIALISE instance MonadResource IO #-}    -- | A template-based implementation of the preemptible resource.-  data Resource m = +  data Resource IO =      Resource { resourceMaxCount0 :: Maybe Int,                resourceCountRef :: IORef Int,-               resourceActingQueue :: PQ.PriorityQueue (ResourceActingItem m),-               resourceWaitQueue :: PQ.PriorityQueue (ResourceAwaitingItem m) }+               resourceActingQueue :: PQ.PriorityQueue (ResourceActingItem IO),+               resourceWaitQueue :: PQ.PriorityQueue (ResourceAwaitingItem IO) }    {-# INLINABLE newResource #-}   newResource count =@@ -189,17 +189,20 @@ type ResourceAwaitingItem m =   Either (ResourceRequestingItem m) (ResourcePreemptedItem m) -instance (MonadDES m, MonadIO m, MonadTemplate m) => Eq (Resource m) where+instance Eq (Resource IO) where+-- instance (MonadDES m, MonadIO m, MonadTemplate m) => Eq (Resource m) where    {-# INLINABLE (==) #-}   x == y = resourceCountRef x == resourceCountRef y  -- unique references -instance (MonadDES m, MonadIO m, MonadTemplate m) => Eq (ResourceActingItem m) where+instance Eq (ResourceActingItem IO) where+-- instance (MonadDES m, MonadIO m, MonadTemplate m) => Eq (ResourceActingItem m) where    {-# INLINABLE (==) #-}   x == y = actingItemId x == actingItemId y -releaseResource' :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Event m ()+releaseResource' :: Resource IO -> Event IO ()+-- releaseResource' :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Event m () {-# INLINABLE releaseResource' #-} releaseResource' r =   Event $ \p ->@@ -236,7 +239,8 @@                           do liftIO $ PQ.enqueue (resourceActingQueue r) (- priority) $ ResourceActingItem priority pid                              invokeEvent p $ processPreemptionEnd pid -decResourceCount' :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Event m ()+decResourceCount' :: Resource IO -> Event IO ()+-- decResourceCount' :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Event m () {-# INLINABLE decResourceCount' #-} decResourceCount' r =   Event $ \p ->

@@ -1,6 +1,4 @@ -{-# LANGUAGE FlexibleInstances, UndecidableInstances #-}- -- | -- Module     : Simulation.Aivika.IO.SD -- Copyright  : Copyright (c) 2009-2016, David Sorokin <david.sorokin@gmail.com>@@ -9,7 +7,7 @@ -- Stability  : experimental -- Tested with: GHC 8.0.1 ----- It allows making the 'MonadIO'-based monad an instance of type class 'MonadSD'+-- It makes the 'IO' monad an instance of type class 'MonadSD' -- used for System Dynamics (SD). -- module Simulation.Aivika.IO.SD () where@@ -22,9 +20,9 @@  import Simulation.Aivika.Trans.Comp import Simulation.Aivika.Trans.SD-import Simulation.Aivika.Trans.Template --- | A template-based instantiation of the 'MonadSD' type class.-instance (Monad m, MonadComp m, MonadIO m, MonadTemplate m) => MonadSD m where+-- | An instantiation of the 'MonadSD' type class.+instance MonadSD IO where+-- instance (Monad m, MonadComp m, MonadIO m, MonadTemplate m) => MonadSD m where      {-# SPECIALISE instance MonadSD IO #-}

@@ -29,7 +29,6 @@ import Simulation.Aivika.Trans.DES import Simulation.Aivika.Trans.Internal.Specs import Simulation.Aivika.Trans.Internal.Event-import Simulation.Aivika.Trans.Template import Simulation.Aivika.Trans.Signal  import Simulation.Aivika.IO.DES@@ -45,16 +44,18 @@                   signalHistoryValues :: V.Vector a }  -- | Create a history of the signal values.-newSignalHistory :: (MonadDES m, MonadIO m, MonadTemplate m)-                    => Signal m a -> Event m (SignalHistory m a)+newSignalHistory :: Signal IO a -> Event IO (SignalHistory IO a)+-- newSignalHistory :: (MonadDES m, MonadIO m, MonadTemplate m)+--                     => Signal m a -> Event m (SignalHistory m a) {-# INLINABLE newSignalHistory #-} newSignalHistory =   newSignalHistoryStartingWith Nothing  -- | Create a history of the signal values starting with -- the optional initial value.-newSignalHistoryStartingWith :: (MonadDES m, MonadIO m, MonadTemplate m)-                                => Maybe a -> Signal m a -> Event m (SignalHistory m a)+newSignalHistoryStartingWith :: Maybe a -> Signal IO a -> Event IO (SignalHistory IO a)+-- newSignalHistoryStartingWith :: (MonadDES m, MonadIO m, MonadTemplate m)+--                                 => Maybe a -> Signal m a -> Event m (SignalHistory m a) {-# INLINABLE newSignalHistoryStartingWith #-} newSignalHistoryStartingWith init signal =   Event $ \p ->@@ -77,8 +78,9 @@                             signalHistoryValues = xs }         -- | Read the history of signal values.-readSignalHistory :: (MonadDES m, MonadIO m, MonadTemplate m)-                     => SignalHistory m a -> Event m (Array Int Double, Array Int a)+readSignalHistory :: SignalHistory IO a -> Event IO (Array Int Double, Array Int a)+-- readSignalHistory :: (MonadDES m, MonadIO m, MonadTemplate m)+--                      => SignalHistory m a -> Event m (Array Int Double, Array Int a) {-# INLINABLE readSignalHistory #-} readSignalHistory history =   Event $ \p ->

@@ -1,5 +1,5 @@ -{-# LANGUAGE TypeFamilies, FlexibleInstances, UndecidableInstances #-}+{-# LANGUAGE TypeFamilies #-}  -- | -- Module     : Simulation.Aivika.IO.Var@@ -9,7 +9,7 @@ -- Stability  : experimental -- Tested with: GHC 8.0.1 ----- The 'MonadIO'-based monad can be an instance 'MonadVar'.+-- The 'IO' monad is an instance of 'MonadVar'. -- module Simulation.Aivika.IO.Var () where @@ -24,7 +24,6 @@ import Simulation.Aivika.Trans.Internal.Event import Simulation.Aivika.Trans.Ref import Simulation.Aivika.Trans.Signal-import Simulation.Aivika.Trans.Template import Simulation.Aivika.Trans.Var  import Simulation.Aivika.IO.DES@@ -32,17 +31,18 @@ import qualified Simulation.Aivika.Vector as V import qualified Simulation.Aivika.Vector.Unboxed as UV --- | The 'MonadIO' based monad is an instance of 'MonadVar'.-instance (Monad m, MonadDES m, MonadIO m, MonadTemplate m) => MonadVar m where+-- | The 'IO' monad is an instance of 'MonadVar'.+instance MonadVar IO where+-- instance (Monad m, MonadDES m, MonadIO m, MonadTemplate m) => MonadVar m where    {-# SPECIALISE instance MonadVar IO #-}    -- | A template-based implementation of the variable.-  data Var m a = +  data Var IO a =      Var { varXS    :: UV.Vector Double,           varMS    :: V.Vector a,           varYS    :: V.Vector a,-          varChangedSource :: SignalSource m a }+          varChangedSource :: SignalSource IO a }    {-# INLINABLE newVar #-}   newVar a =

@@ -9,7 +9,7 @@ -- Stability  : experimental -- Tested with: GHC 8.0.1 ----- The 'MonadIO'-based monad can be an instance 'MonadVar'.+-- The 'IO' monad can be an instance of 'MonadVar'. -- module Simulation.Aivika.IO.Var.Unboxed () where @@ -24,7 +24,6 @@ import Simulation.Aivika.Trans.Internal.Event import Simulation.Aivika.Trans.Ref import Simulation.Aivika.Trans.Signal-import Simulation.Aivika.Trans.Template import Simulation.Aivika.Trans.Var.Unboxed  import Simulation.Aivika.IO.DES@@ -32,19 +31,20 @@ import Simulation.Aivika.Unboxed import qualified Simulation.Aivika.Vector.Unboxed as UV --- | The 'MonadIO' based monad is an instance of 'MonadVar'.-instance (Monad m, MonadDES m, MonadIO m, MonadTemplate m, Unboxed a) => MonadVar m a where+-- | The 'IO' monad can be an instance of 'MonadVar'.+instance Unboxed a => MonadVar IO a where+-- instance (Monad m, MonadDES m, MonadIO m, MonadTemplate m, Unboxed a) => MonadVar m a where    {-# SPECIALISE instance MonadVar IO Double #-}   {-# SPECIALISE instance MonadVar IO Float #-}   {-# SPECIALISE instance MonadVar IO Int #-}    -- | A template-based implementation of the variable.-  data Var m a = +  data Var IO a =      Var { varXS    :: UV.Vector Double,           varMS    :: UV.Vector a,           varYS    :: UV.Vector a,-          varChangedSource :: SignalSource m a }+          varChangedSource :: SignalSource IO a }         {-# INLINABLE newVar #-}   newVar a =

@@ -57,7 +57,6 @@         module Simulation.Aivika.Trans.Stream,         module Simulation.Aivika.Trans.Stream.Random,         module Simulation.Aivika.Trans.Task,-        module Simulation.Aivika.Trans.Template,         module Simulation.Aivika.Trans.Transform,         module Simulation.Aivika.Trans.Transform.Extra,         module Simulation.Aivika.Trans.Transform.Memo.Unboxed,@@ -108,7 +107,6 @@ import Simulation.Aivika.Trans.Stream import Simulation.Aivika.Trans.Stream.Random import Simulation.Aivika.Trans.Task-import Simulation.Aivika.Trans.Template import Simulation.Aivika.Trans.Transform import Simulation.Aivika.Trans.Transform.Extra import Simulation.Aivika.Trans.Transform.Memo.Unboxed

@@ -18,9 +18,17 @@         listAddLast,         listRemoveFirst,         listRemoveLast,+        listRemove,+        listRemoveBy,+        listContains,+        listContainsBy,         listFirst,-        listLast) where +        listLast,+        clearList,+        freezeList) where  +import Data.Maybe+ import Control.Monad  import Simulation.Aivika.Trans.Ref.Base@@ -175,3 +183,74 @@          error "Empty list: listLast"        Just t ->          return $ itemVal t++-- | Remove the specified element from the list and return a flag+-- indicating whether the element was found and removed.+listRemove :: (Eq a, MonadRef m) => DoubleLinkedList m a -> a -> Event m Bool+{-# INLINABLE listRemove #-}+listRemove x v = fmap isJust $ listRemoveBy x (== v)++-- | Remove an element satisfying the specified predicate and return+-- the element if found.+listRemoveBy :: MonadRef m => DoubleLinkedList m a -> (a -> Bool) -> Event m (Maybe a)+{-# INLINABLE listRemoveBy #-}+listRemoveBy x p = readRef (listHead x) >>= loop+  where loop item =+          case item of+            Nothing   -> return Nothing+            Just item ->+              do let f = p (itemVal item)+                 if not f+                   then readRef (itemNext item) >>= loop+                   else do size <- readRef (listSize x)+                           prev <- readRef (itemPrev item)+                           next <- readRef (itemNext item)+                           writeRef (listSize x) (size - 1)+                           case (prev, next) of+                             (Nothing, Nothing) ->+                               do writeRef (listHead x) Nothing+                                  writeRef (listTail x) Nothing+                             (Nothing, head' @ (Just item')) ->+                               do writeRef (itemPrev item') Nothing+                                  writeRef (listHead x) head'+                             (tail' @ (Just item'), Nothing) ->+                               do writeRef (itemNext item') Nothing+                                  writeRef (listTail x) tail'+                             (Just prev', Just next') ->+                               do writeRef (itemNext prev') (Just next')+                                  writeRef (itemPrev next') (Just prev')+                           return (Just $ itemVal item)++-- | Detect whether the specified element is contained in the list.+listContains :: (Eq a, MonadRef m) => DoubleLinkedList m a -> a -> Event m Bool+{-# INLINABLE listContains #-}+listContains x v = fmap isJust $ listContainsBy x (== v)++-- | Detect whether an element satisfying the specified predicate is contained in the list.+listContainsBy :: MonadRef m => DoubleLinkedList m a -> (a -> Bool) -> Event m (Maybe a)+{-# INLINABLE listContainsBy #-}+listContainsBy x p = readRef (listHead x) >>= loop+  where loop item =+          case item of+            Nothing   -> return Nothing+            Just item ->+              do let f = p (itemVal item)+                 if not f+                   then readRef (itemNext item) >>= loop+                   else return $ Just (itemVal item)++-- | Clear the contents of the list.+clearList :: MonadRef m => DoubleLinkedList m a -> Event m ()+{-# INLINABLE clearList #-}+clearList q =+  do writeRef (listHead q) Nothing+     writeRef (listTail q) Nothing+     writeRef (listSize q) 0++-- | Freeze the list and return its contents.+freezeList :: MonadRef m => DoubleLinkedList m a -> Event m [a]+{-# INLINABLE freezeList #-}+freezeList x = readRef (listTail x) >>= loop []+  where loop acc Nothing     = return acc+        loop acc (Just item) = readRef (itemPrev item) >>= loop (itemVal item : acc)+  

@@ -106,15 +106,13 @@   {-# INLINABLE (***) #-}   (Net f) *** (Net g) =     Net $ \(b, b') ->-    do (c, p1) <- f b-       (c', p2) <- g b'+    do ((c, p1), (c', p2)) <- zipProcessParallel (f b) (g b')        return ((c, c'), p1 *** p2)           {-# INLINABLE (&&&) #-}   (Net f) &&& (Net g) =     Net $ \b ->-    do (c, p1) <- f b-       (c', p2) <- g b+    do ((c, p1), (c', p2)) <- zipProcessParallel (f b) (g b)        return ((c, c'), p1 &&& p2)  instance MonadDES m => ArrowChoice (Net m) where

@@ -97,25 +97,25 @@     Processor $ \xys ->     Cons $     do (xs, ys) <- liftSimulation $ unzipStream xys-       runStream $ zipStreamSeq (f xs) ys+       runStream $ zipStreamParallel (f xs) ys    {-# INLINABLE second #-}   second (Processor f) =     Processor $ \xys ->     Cons $     do (xs, ys) <- liftSimulation $ unzipStream xys-       runStream $ zipStreamSeq xs (f ys)+       runStream $ zipStreamParallel xs (f ys)    {-# INLINABLE (***) #-}   Processor f *** Processor g =     Processor $ \xys ->     Cons $     do (xs, ys) <- liftSimulation $ unzipStream xys-       runStream $ zipStreamSeq (f xs) (g ys)+       runStream $ zipStreamParallel (f xs) (g ys)    {-# INLINABLE (&&&) #-}   Processor f &&& Processor g =-    Processor $ \xs -> zipStreamSeq (f xs) (g xs)+    Processor $ \xs -> zipStreamParallel (f xs) (g xs)  instance MonadDES m => ArrowChoice (Processor m) where 

@@ -1,29 +0,0 @@---- |--- Module     : Simulation.Aivika.Trans.Template--- Copyright  : Copyright (c) 2009-2016, David Sorokin <david.sorokin@gmail.com>--- License    : BSD3--- Maintainer : David Sorokin <david.sorokin@gmail.com>--- Stability  : experimental--- Tested with: GHC 8.0.1------ It defines explicit type sub-classes of 'IO'-based monads on top of which--- the simulation monads can be automatically generated.----module Simulation.Aivika.Trans.Template-       (MonadTemplate,-        MonadEventQueueTemplate) where--import Control.Monad.Trans---- | It defines a type class based on which the simulation computations can be automatically generated.-class Monad m => MonadTemplate m---- | It defines a type class based on which the event queue can be automatically generated.-class Monad m => MonadEventQueueTemplate m---- | An instance of the type class.-instance MonadTemplate IO---- | An instance of the type class.-instance MonadEventQueueTemplate IO

@@ -1,5 +1,5 @@ name:            aivika-transformers-version:         4.5.1+version:         4.6 synopsis:        Transformers for the Aivika simulation library description:     This package is a generalization of the aivika [1] simulation library@@ -43,6 +43,7 @@                      examples/TimeOutWait.hs                      examples/TruckHaulingSituation.hs                      examples/WorkStationsInSeries.hs+                     CHANGELOG.md  library @@ -107,7 +108,6 @@                      Simulation.Aivika.Trans.SystemDynamics                      Simulation.Aivika.Trans.Table                      Simulation.Aivika.Trans.Task-                     Simulation.Aivika.Trans.Template                      Simulation.Aivika.Trans.Transform                      Simulation.Aivika.Trans.Transform.Extra                      Simulation.Aivika.Trans.Transform.Memo