-- |
-- Module     : Simulation.Aivika.Trans.GPSS.Block.Loop
-- Copyright  : Copyright (c) 2017, David Sorokin <david.sorokin@gmail.com>
-- License    : BSD3
-- Maintainer : David Sorokin <david.sorokin@gmail.com>
-- Stability  : experimental
-- Tested with: GHC 8.0.2
--
-- This module defines the GPSS block LOOP.
--
module Simulation.Aivika.Trans.GPSS.Block.Loop
       (loopBlock,
        loopBlockM) where

import Simulation.Aivika.Trans
import Simulation.Aivika.Trans.GPSS.Block

-- | This is the GPSS construct
--
-- @LOOP A,B@
loopBlock :: MonadDES m
             => (a -> (b, Bool))
             -- ^ by the specified transact return the next version
             -- of the same transact and a condition whether we should
             -- exit the loop
             -> Block m b ()
             -- ^ the block to transfer in when the condition fails
             -> Block m a b
{-# INLINABLE loopBlock #-}
loopBlock :: (a -> (b, Bool)) -> Block m b () -> Block m a b
loopBlock a -> (b, Bool)
f Block m b ()
block =
  Block :: forall (m :: * -> *) a b. (a -> Process m b) -> Block m a b
Block { blockProcess :: a -> Process m b
blockProcess = \a
a ->
           do let (b
b, Bool
c) = a -> (b, Bool)
f a
a
              if Bool
c
                then b -> Process m b
forall (m :: * -> *) a. Monad m => a -> m a
return b
b
                else Process m () -> Process m b
forall (m :: * -> *) a. MonadDES m => Process m () -> Process m a
transferProcess (Block m b () -> b -> Process m ()
forall (m :: * -> *) a b. Block m a b -> a -> Process m b
blockProcess Block m b ()
block b
b)
        }

-- | This is the GPSS construct
--
-- @LOOP A,B@
loopBlockM :: MonadDES m
              => (a -> Process m (b, Bool))
              -- ^ by the specified transact return the next version
              -- of the same transact and a condition whether we should
              -- exit the loop
              -> Block m b ()
              -- ^ the block to transfer in when the condition fails
              -> Block m a b
{-# INLINABLE loopBlockM #-}
loopBlockM :: (a -> Process m (b, Bool)) -> Block m b () -> Block m a b
loopBlockM a -> Process m (b, Bool)
f Block m b ()
block =
  Block :: forall (m :: * -> *) a b. (a -> Process m b) -> Block m a b
Block { blockProcess :: a -> Process m b
blockProcess = \a
a ->
           do (b
b, Bool
c) <- a -> Process m (b, Bool)
f a
a
              if Bool
c
                then b -> Process m b
forall (m :: * -> *) a. Monad m => a -> m a
return b
b
                else Process m () -> Process m b
forall (m :: * -> *) a. MonadDES m => Process m () -> Process m a
transferProcess (Block m b () -> b -> Process m ()
forall (m :: * -> *) a b. Block m a b -> a -> Process m b
blockProcess Block m b ()
block b
b)
        }