Control.Monad.STLike.IO

IOS monad

type IOS s t = STLike IO s t

Monad for scoped IO computations The underlying monad must be strict here.

io :: IO t -> IOS s t

Lift IO computations into IOS. liftIO also works.

runIOS :: (forall s. IOS s t) -> IO t

Run an IOS computation in the IO monad.

Regioned monad

data Regioned s t

Regioned variables. A regioned variable is safe i.e. no references to it may escape the current IOS.

Instances

Monad (Regioned s)

Functor (Regioned s)

runRegion :: (NotShared ty, RegionMonad m region s) => Regioned s ty -> STLike m region ty

Run a computation on regioned data and return the result in a strict fashion.

region :: t -> Regioned s t

Regions a value. Synonym for return.

unfoldRegion :: Foldable t => Regioned s (t a) -> [Regioned s a]

Utilities

class STLikeImpl m => RegionMonad m region s

Instances

(STLikeImpl m, TypeCast reg (:< any rest), RegionMonad m rest s) => RegionMonad m reg s

STLikeImpl m => RegionMonad m s s

data a :< b

withRIOR

Arguments

:: IOS o resource

Open the resource

-> (resource -> IOS o ())

Close it.

-> (forall s. Regioned (s :< o) resource -> IOS (s :< o) result)

Compute with it.

-> IOS o result

Use a resource with IOS. Like bracket.

try :: IOS s t -> IOS s (Either SomeException t)

rbsFromPtr :: Ptr a -> Int -> IOS s (Regioned s ByteString)

Create a ByteString representing the pointer and length. No copying done, O(1).

rbsToBS :: RegionMonad m s reg => Regioned s ByteString -> STLike m reg ByteString

Create a copy of a regioned ByteString as a normal ByteString. O(n).

withRbsPtr :: Regioned s ByteString -> (Ptr any -> Int -> IOS s t) -> IOS s t

Use a regioned ByteString as a pointer. O(1). The pointer points to the region contents, so be cafeful with it.

rbsMapLookup :: (RegionMonad m s reg, Ord key) => Regioned s key -> Map key value -> STLike m reg (Maybe value)

Lookup inside a Map with a regioned ByteString.