LittleRIO

Most definitions follow the RIO lib: https://hackage.haskell.org/package/rio-0.1.18.0/docs/RIO.html The rest follow from orphans: https://hackage.haskell.org/package/rio-orphans-0.1.1.0/docs/src/RIO.Orphans.html See LICENSE info in the README.

Documentation

class HasResourceMap env where

Methods

resourceMapL :: Lens' env ResourceMap

Instances

HasResourceMap (IORef ReleaseMap)

Defined in LittleRIO

Methods

resourceMapL :: Lens' (IORef ReleaseMap) ResourceMap

HasResourceMap (SimpleResourceEnv env)

Defined in LittleRIO

Methods

resourceMapL :: Lens' (SimpleResourceEnv env) ResourceMap

class HasStateRef st env | env -> st where

Methods

stateRefL :: Lens' env (SomeRef st)

Instances

HasStateRef a (SomeRef a)

Defined in LittleRIO

Methods

stateRefL :: Lens' (SomeRef a) (SomeRef a)

HasStateRef st (SimpleStateEnv st env)

Defined in LittleRIO

Methods

stateRefL :: Lens' (SimpleStateEnv st env) (SomeRef st)

class HasWriteRef w env | env -> w where

Methods

writeRefL :: Lens' env (SomeRef w)

Instances

HasWriteRef a (SomeRef a)

Defined in LittleRIO

Methods

writeRefL :: Lens' (SomeRef a) (SomeRef a)

HasWriteRef w (SimpleWriteEnv w env)

Defined in LittleRIO

Methods

writeRefL :: Lens' (SimpleWriteEnv w env) (SomeRef w)

data SimpleResourceEnv env

Constructors

SimpleResourceEnv

Fields

• sreMap :: !ResourceMap
• sreEnv :: !env

Instances

Functor SimpleResourceEnv

Defined in LittleRIO

Methods

fmap :: (a -> b) -> SimpleResourceEnv a -> SimpleResourceEnv b

(<$) :: a -> SimpleResourceEnv b -> SimpleResourceEnv a

Foldable SimpleResourceEnv

Defined in LittleRIO

Methods

fold :: Monoid m => SimpleResourceEnv m -> m

foldMap :: Monoid m => (a -> m) -> SimpleResourceEnv a -> m

foldMap' :: Monoid m => (a -> m) -> SimpleResourceEnv a -> m

foldr :: (a -> b -> b) -> b -> SimpleResourceEnv a -> b

foldr' :: (a -> b -> b) -> b -> SimpleResourceEnv a -> b

foldl :: (b -> a -> b) -> b -> SimpleResourceEnv a -> b

foldl' :: (b -> a -> b) -> b -> SimpleResourceEnv a -> b

foldr1 :: (a -> a -> a) -> SimpleResourceEnv a -> a

foldl1 :: (a -> a -> a) -> SimpleResourceEnv a -> a

toList :: SimpleResourceEnv a -> [a]

null :: SimpleResourceEnv a -> Bool

length :: SimpleResourceEnv a -> Int

elem :: Eq a => a -> SimpleResourceEnv a -> Bool

maximum :: Ord a => SimpleResourceEnv a -> a

minimum :: Ord a => SimpleResourceEnv a -> a

sum :: Num a => SimpleResourceEnv a -> a

product :: Num a => SimpleResourceEnv a -> a

Traversable SimpleResourceEnv

Defined in LittleRIO

Methods

traverse :: Applicative f => (a -> f b) -> SimpleResourceEnv a -> f (SimpleResourceEnv b)

sequenceA :: Applicative f => SimpleResourceEnv (f a) -> f (SimpleResourceEnv a)

mapM :: Monad m => (a -> m b) -> SimpleResourceEnv a -> m (SimpleResourceEnv b)

sequence :: Monad m => SimpleResourceEnv (m a) -> m (SimpleResourceEnv a)

Generic (SimpleResourceEnv env)

Defined in LittleRIO

Associated Types

type Rep (SimpleResourceEnv env) :: Type -> Type

Methods

from :: SimpleResourceEnv env -> Rep (SimpleResourceEnv env) x

to :: Rep (SimpleResourceEnv env) x -> SimpleResourceEnv env

NFData env => NFData (SimpleResourceEnv env)

Defined in LittleRIO

Methods

rnf :: SimpleResourceEnv env -> ()

HasResourceMap (SimpleResourceEnv env)

Defined in LittleRIO

Methods

resourceMapL :: Lens' (SimpleResourceEnv env) ResourceMap

type Rep (SimpleResourceEnv env)

Defined in LittleRIO

type Rep (SimpleResourceEnv env) = D1 ('MetaData "SimpleResourceEnv" "LittleRIO" "little-rio-1.0.1-DzooWnCoDmw9p5TrHoqYTE" 'False) (C1 ('MetaCons "SimpleResourceEnv" 'PrefixI 'True) (S1 ('MetaSel ('Just "sreMap") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 ResourceMap) :*: S1 ('MetaSel ('Just "sreEnv") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 env)))

data SimpleStateEnv st env

Constructors

SimpleStateEnv

Fields

• sseRef :: !(SomeRef st)
• sseEnv :: !env

Instances

HasStateRef st (SimpleStateEnv st env)

Defined in LittleRIO

Methods

stateRefL :: Lens' (SimpleStateEnv st env) (SomeRef st)

Functor (SimpleStateEnv st)

Defined in LittleRIO

Methods

fmap :: (a -> b) -> SimpleStateEnv st a -> SimpleStateEnv st b

(<$) :: a -> SimpleStateEnv st b -> SimpleStateEnv st a

Foldable (SimpleStateEnv st)

Defined in LittleRIO

Methods

fold :: Monoid m => SimpleStateEnv st m -> m

foldMap :: Monoid m => (a -> m) -> SimpleStateEnv st a -> m

foldMap' :: Monoid m => (a -> m) -> SimpleStateEnv st a -> m

foldr :: (a -> b -> b) -> b -> SimpleStateEnv st a -> b

foldr' :: (a -> b -> b) -> b -> SimpleStateEnv st a -> b

foldl :: (b -> a -> b) -> b -> SimpleStateEnv st a -> b

foldl' :: (b -> a -> b) -> b -> SimpleStateEnv st a -> b

foldr1 :: (a -> a -> a) -> SimpleStateEnv st a -> a

foldl1 :: (a -> a -> a) -> SimpleStateEnv st a -> a

toList :: SimpleStateEnv st a -> [a]

null :: SimpleStateEnv st a -> Bool

length :: SimpleStateEnv st a -> Int

elem :: Eq a => a -> SimpleStateEnv st a -> Bool

maximum :: Ord a => SimpleStateEnv st a -> a

minimum :: Ord a => SimpleStateEnv st a -> a

sum :: Num a => SimpleStateEnv st a -> a

product :: Num a => SimpleStateEnv st a -> a

Traversable (SimpleStateEnv st)

Defined in LittleRIO

Methods

traverse :: Applicative f => (a -> f b) -> SimpleStateEnv st a -> f (SimpleStateEnv st b)

sequenceA :: Applicative f => SimpleStateEnv st (f a) -> f (SimpleStateEnv st a)

mapM :: Monad m => (a -> m b) -> SimpleStateEnv st a -> m (SimpleStateEnv st b)

sequence :: Monad m => SimpleStateEnv st (m a) -> m (SimpleStateEnv st a)

Generic (SimpleStateEnv st env)

Defined in LittleRIO

Associated Types

type Rep (SimpleStateEnv st env) :: Type -> Type

Methods

from :: SimpleStateEnv st env -> Rep (SimpleStateEnv st env) x

to :: Rep (SimpleStateEnv st env) x -> SimpleStateEnv st env

NFData env => NFData (SimpleStateEnv st env)

Defined in LittleRIO

Methods

rnf :: SimpleStateEnv st env -> ()

type Rep (SimpleStateEnv st env)

Defined in LittleRIO

type Rep (SimpleStateEnv st env) = D1 ('MetaData "SimpleStateEnv" "LittleRIO" "little-rio-1.0.1-DzooWnCoDmw9p5TrHoqYTE" 'False) (C1 ('MetaCons "SimpleStateEnv" 'PrefixI 'True) (S1 ('MetaSel ('Just "sseRef") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (SomeRef st)) :*: S1 ('MetaSel ('Just "sseEnv") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 env)))

data SimpleWriteEnv w env

Constructors

SimpleWriteEnv

Fields

• sweRef :: !(SomeRef w)
• sweEnv :: !env

Instances

HasWriteRef w (SimpleWriteEnv w env)

Defined in LittleRIO

Methods

writeRefL :: Lens' (SimpleWriteEnv w env) (SomeRef w)

Functor (SimpleWriteEnv w)

Defined in LittleRIO

Methods

fmap :: (a -> b) -> SimpleWriteEnv w a -> SimpleWriteEnv w b

(<$) :: a -> SimpleWriteEnv w b -> SimpleWriteEnv w a

Foldable (SimpleWriteEnv w)

Defined in LittleRIO

Methods

fold :: Monoid m => SimpleWriteEnv w m -> m

foldMap :: Monoid m => (a -> m) -> SimpleWriteEnv w a -> m

foldMap' :: Monoid m => (a -> m) -> SimpleWriteEnv w a -> m

foldr :: (a -> b -> b) -> b -> SimpleWriteEnv w a -> b

foldr' :: (a -> b -> b) -> b -> SimpleWriteEnv w a -> b

foldl :: (b -> a -> b) -> b -> SimpleWriteEnv w a -> b

foldl' :: (b -> a -> b) -> b -> SimpleWriteEnv w a -> b

foldr1 :: (a -> a -> a) -> SimpleWriteEnv w a -> a

foldl1 :: (a -> a -> a) -> SimpleWriteEnv w a -> a

toList :: SimpleWriteEnv w a -> [a]

null :: SimpleWriteEnv w a -> Bool

length :: SimpleWriteEnv w a -> Int

elem :: Eq a => a -> SimpleWriteEnv w a -> Bool

maximum :: Ord a => SimpleWriteEnv w a -> a

minimum :: Ord a => SimpleWriteEnv w a -> a

sum :: Num a => SimpleWriteEnv w a -> a

product :: Num a => SimpleWriteEnv w a -> a

Traversable (SimpleWriteEnv w)

Defined in LittleRIO

Methods

traverse :: Applicative f => (a -> f b) -> SimpleWriteEnv w a -> f (SimpleWriteEnv w b)

sequenceA :: Applicative f => SimpleWriteEnv w (f a) -> f (SimpleWriteEnv w a)

mapM :: Monad m => (a -> m b) -> SimpleWriteEnv w a -> m (SimpleWriteEnv w b)

sequence :: Monad m => SimpleWriteEnv w (m a) -> m (SimpleWriteEnv w a)

Generic (SimpleWriteEnv w env)

Defined in LittleRIO

Associated Types

type Rep (SimpleWriteEnv w env) :: Type -> Type

Methods

from :: SimpleWriteEnv w env -> Rep (SimpleWriteEnv w env) x

to :: Rep (SimpleWriteEnv w env) x -> SimpleWriteEnv w env

NFData env => NFData (SimpleWriteEnv w env)

Defined in LittleRIO

Methods

rnf :: SimpleWriteEnv w env -> ()

type Rep (SimpleWriteEnv w env)

Defined in LittleRIO

type Rep (SimpleWriteEnv w env) = D1 ('MetaData "SimpleWriteEnv" "LittleRIO" "little-rio-1.0.1-DzooWnCoDmw9p5TrHoqYTE" 'False) (C1 ('MetaCons "SimpleWriteEnv" 'PrefixI 'True) (S1 ('MetaSel ('Just "sweRef") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (SomeRef w)) :*: S1 ('MetaSel ('Just "sweEnv") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 env)))

data SomeRef a

Constructors

SomeRef !(IO a) !(a -> IO ())

Instances

HasWriteRef a (SomeRef a)

Defined in LittleRIO

Methods

writeRefL :: Lens' (SomeRef a) (SomeRef a)

HasStateRef a (SomeRef a)

Defined in LittleRIO

Methods

stateRefL :: Lens' (SomeRef a) (SomeRef a)

NFData (SomeRef a)

Defined in LittleRIO

Methods

rnf :: SomeRef a -> ()

type ResourceMap = IORef ReleaseMap

newtype RIO env a

Constructors

RIO

Fields

• unRIO :: ReaderT env IO a

Instances

MonadReader env (RIO env)

Defined in LittleRIO

Methods

ask :: RIO env env

local :: (env -> env) -> RIO env a -> RIO env a

reader :: (env -> a) -> RIO env a

HasStateRef st env => MonadState st (RIO env)

Defined in LittleRIO

Methods

get :: RIO env st

put :: st -> RIO env ()

state :: (st -> (a, st)) -> RIO env a

(Monoid w, HasWriteRef w env) => MonadWriter w (RIO env)

Defined in LittleRIO

Methods

writer :: (a, w) -> RIO env a

tell :: w -> RIO env ()

listen :: RIO env a -> RIO env (a, w)

pass :: RIO env (a, w -> w) -> RIO env a

Monad (RIO env)

Defined in LittleRIO

Methods

(>>=) :: RIO env a -> (a -> RIO env b) -> RIO env b

(>>) :: RIO env a -> RIO env b -> RIO env b

return :: a -> RIO env a

Functor (RIO env)

Defined in LittleRIO

Methods

fmap :: (a -> b) -> RIO env a -> RIO env b

(<$) :: a -> RIO env b -> RIO env a

MonadFail (RIO env)

Defined in LittleRIO

Methods

fail :: String -> RIO env a

Applicative (RIO env)

Defined in LittleRIO

Methods

pure :: a -> RIO env a

(<*>) :: RIO env (a -> b) -> RIO env a -> RIO env b

liftA2 :: (a -> b -> c) -> RIO env a -> RIO env b -> RIO env c

(*>) :: RIO env a -> RIO env b -> RIO env b

(<*) :: RIO env a -> RIO env b -> RIO env a

MonadIO (RIO env)

Defined in LittleRIO

Methods

liftIO :: IO a -> RIO env a

MonadUnliftIO (RIO env)

Defined in LittleRIO

Methods

withRunInIO :: ((forall a. RIO env a -> IO a) -> IO b) -> RIO env b

HasResourceMap env => MonadResource (RIO env)

Defined in LittleRIO

Methods

liftResourceT :: ResourceT IO a -> RIO env a

PrimMonad (RIO env)

Defined in LittleRIO

Associated Types

type PrimState (RIO env)

Methods

primitive :: (State# (PrimState (RIO env)) -> (# State# (PrimState (RIO env)), a #)) -> RIO env a

MonadThrow (RIO env)

Defined in LittleRIO

Methods

throwM :: Exception e => e -> RIO env a

MonadCatch (RIO env)

Defined in LittleRIO

Methods

catch :: Exception e => RIO env a -> (e -> RIO env a) -> RIO env a

MonadMask (RIO env)

Defined in LittleRIO

Methods

mask :: ((forall a. RIO env a -> RIO env a) -> RIO env b) -> RIO env b

uninterruptibleMask :: ((forall a. RIO env a -> RIO env a) -> RIO env b) -> RIO env b

generalBracket :: RIO env a -> (a -> ExitCase b -> RIO env c) -> (a -> RIO env b) -> RIO env (b, c)

HasLogAction env => MonadLogger (RIO env)

Defined in LittleRIO

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> RIO env ()

Semigroup a => Semigroup (RIO env a)

Defined in LittleRIO

Methods

(<>) :: RIO env a -> RIO env a -> RIO env a

sconcat :: NonEmpty (RIO env a) -> RIO env a

stimes :: Integral b => b -> RIO env a -> RIO env a

Monoid a => Monoid (RIO env a)

Defined in LittleRIO

Methods

mempty :: RIO env a

mappend :: RIO env a -> RIO env a -> RIO env a

mconcat :: [RIO env a] -> RIO env a

type PrimState (RIO env)

Defined in LittleRIO

type PrimState (RIO env) = PrimState IO

getStateRef :: (HasStateRef st env, MonadReader env m, MonadIO m) => m st

liftRIO :: (MonadIO m, MonadReader env m) => RIO env a -> m a

listenWriteRef :: (HasWriteRef w env, MonadReader env m, MonadIO m) => m a -> m (a, w)

newSomeRef :: MonadIO m => a -> m (SomeRef a)

mapRIO :: (env -> env') -> RIO env' a -> RIO env a

modifySomeRef :: MonadIO m => SomeRef a -> (a -> a) -> m ()

modifyStateRef :: (HasStateRef st env, MonadReader env m, MonadIO m) => (st -> st) -> m ()

passWriteRef :: (HasWriteRef w env, MonadReader env m, MonadIO m) => m (a, w -> w) -> m a

putStateRef :: (HasStateRef st env, MonadReader env m, MonadIO m) => st -> m ()

runSimpleResourceRIO :: MonadUnliftIO m => env -> RIO (SimpleResourceEnv env) a -> m a

runSimpleStateRIO :: MonadIO m => st -> env -> RIO (SimpleStateEnv st env) a -> m (a, st)

runSimpleWriteRIO :: (MonadIO m, Monoid w) => env -> RIO (SimpleWriteEnv w env) a -> m (a, w)

runRIO :: MonadIO m => env -> RIO env a -> m a

readSomeRef :: MonadIO m => SomeRef a -> m a

resourceRIO :: HasResourceMap env => ResourceT IO a -> RIO env a

tellWriteRef :: (HasWriteRef w env, MonadReader env m, MonadIO m, Semigroup w) => w -> m ()

unliftRIO :: MonadIO m => env -> m (UnliftIO (RIO env))

withResourceMap :: MonadUnliftIO m => (ResourceMap -> m a) -> m a

writeSomeRef :: MonadIO m => SomeRef a -> a -> m ()