module Control.Monad.Trans.Order.Lazy (
Order,
evalOrder,
evalOrderWith,
OrderT,
evalOrderT,
evalOrderTWith,
force,
newMinimum,
newMaximum,
newAfter,
newBefore
) where
import Control.Monad.Trans.State.Lazy
import Control.Monad.Trans.Order.Lazy.Type
import Data.Functor.Identity
import Data.Order.Algorithm
import Data.Order.Algorithm.Type
import Data.Order.Internals
hiding (newMinimum, newMaximum, newAfter, newBefore)
import qualified Data.Order.Internals as Internals
import Data.Order.Raw (RawAlgorithm)
import System.IO.Unsafe
type Order o = OrderT o Identity
evalOrder :: (forall o . Order o a) -> a
evalOrder order = runIdentity (evalOrderT order)
evalOrderWith :: Algorithm -> (forall o . Order o a) -> a
evalOrderWith alg order = runIdentity (evalOrderTWith alg order)
evalOrderT :: Monad m => (forall o . OrderT o m a) -> m a
evalOrderT = evalOrderTWith defaultAlgorithm
evalOrderTWith :: Monad m => Algorithm -> (forall o . OrderT o m a) -> m a
evalOrderTWith (Algorithm rawAlg) (OrderT stateT) = monad where
monad = evalStateT stateT (localOrderRep rawAlg)
force :: Monad m => OrderT o m ()
force = OrderT $ get >>= \ order -> order `seq` return ()
newMinimum :: Monad m => OrderT o m (Element o)
newMinimum = fromRepNew Internals.newMinimum
newMaximum :: Monad m => OrderT o m (Element o)
newMaximum = fromRepNew Internals.newMaximum
newAfter :: Monad m => Element o -> OrderT o m (Element o)
newAfter elem = fromRepNew (Internals.newAfter elem)
newBefore :: Monad m => Element o -> OrderT o m (Element o)
newBefore elem = fromRepNew (Internals.newBefore elem)
fromRepNew :: Monad m
=> (OrderRep o -> IO (Element o))
-> OrderT o m (Element o)
fromRepNew repNew = OrderT $ state statefulNew where
statefulNew orderRep = (elem, elem `seq` orderRep) where
elem = unsafePerformIO $ repNew orderRep