Safe Haskell	None
Language	Haskell2010

RIO

Contents

Custom Prelude
The RIO Monad
- SimpleApp
MonadIO and MonadUnliftIO
Logger
Display
Optics
Concurrency
Exceptions
Files and handles
Exit
Mutable Variables
Debugging

Synopsis

module RIO.Prelude
module RIO.Prelude.Types
newtype RIO env a = RIO {
- unRIO :: ReaderT env IO a
}
liftRIO :: (MonadIO m, MonadReader env m) => RIO env a -> m a
runRIO :: MonadIO m => env -> RIO env a -> m a
module RIO.Prelude.Simple
newtype UnliftIO (m :: Type -> Type) = UnliftIO {
- unliftIO :: forall a. m a -> IO a
}
class Monad m => MonadIO (m :: Type -> Type) where
- liftIO :: IO a -> m a
class MonadIO m => MonadUnliftIO (m :: Type -> Type) where
- withRunInIO :: ((forall a. m a -> IO a) -> IO b) -> m b
askRunInIO :: MonadUnliftIO m => m (m a -> IO a)
askUnliftIO :: MonadUnliftIO m => m (UnliftIO m)
liftIOOp :: MonadUnliftIO m => (IO a -> IO b) -> m a -> m b
toIO :: MonadUnliftIO m => m a -> m (IO a)
withUnliftIO :: MonadUnliftIO m => (UnliftIO m -> IO a) -> m a
wrappedWithRunInIO :: MonadUnliftIO n => (n b -> m b) -> (forall a. m a -> n a) -> ((forall a. m a -> IO a) -> IO b) -> m b
withLogFunc :: MonadUnliftIO m => LogOptions -> (LogFunc -> m a) -> m a
newLogFunc :: (MonadIO n, MonadIO m) => LogOptions -> n (LogFunc, m ())
data LogFunc
class HasLogFunc env where
- logFuncL :: Lens' env LogFunc
logOptionsHandle :: MonadIO m => Handle -> Bool -> m LogOptions
data LogOptions
setLogMinLevel :: LogLevel -> LogOptions -> LogOptions
setLogMinLevelIO :: IO LogLevel -> LogOptions -> LogOptions
setLogVerboseFormat :: Bool -> LogOptions -> LogOptions
setLogVerboseFormatIO :: IO Bool -> LogOptions -> LogOptions
setLogTerminal :: Bool -> LogOptions -> LogOptions
setLogUseTime :: Bool -> LogOptions -> LogOptions
setLogUseColor :: Bool -> LogOptions -> LogOptions
setLogUseLoc :: Bool -> LogOptions -> LogOptions
setLogFormat :: (Utf8Builder -> Utf8Builder) -> LogOptions -> LogOptions
setLogLevelColors :: (LogLevel -> Utf8Builder) -> LogOptions -> LogOptions
setLogSecondaryColor :: Utf8Builder -> LogOptions -> LogOptions
setLogAccentColors :: (Int -> Utf8Builder) -> LogOptions -> LogOptions
logDebug :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => Utf8Builder -> m ()
logInfo :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => Utf8Builder -> m ()
logWarn :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => Utf8Builder -> m ()
logError :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => Utf8Builder -> m ()
logOther :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => Text -> Utf8Builder -> m ()
logSticky :: (MonadIO m, HasCallStack, MonadReader env m, HasLogFunc env) => Utf8Builder -> m ()
logStickyDone :: (MonadIO m, HasCallStack, MonadReader env m, HasLogFunc env) => Utf8Builder -> m ()
logDebugS :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => LogSource -> Utf8Builder -> m ()
logInfoS :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => LogSource -> Utf8Builder -> m ()
logWarnS :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => LogSource -> Utf8Builder -> m ()
logErrorS :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => LogSource -> Utf8Builder -> m ()
logOtherS :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => Text -> LogSource -> Utf8Builder -> m ()
logGeneric :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => LogSource -> LogLevel -> Utf8Builder -> m ()
mkLogFunc :: (CallStack -> LogSource -> LogLevel -> Utf8Builder -> IO ()) -> LogFunc
logOptionsMemory :: MonadIO m => m (IORef Builder, LogOptions)
data LogLevel
- = LevelDebug
- | LevelInfo
- | LevelWarn
- | LevelError
- | LevelOther !Text
type LogSource = Text
data CallStack
displayCallStack :: CallStack -> Utf8Builder
noLogging :: (HasLogFunc env, MonadReader env m) => m a -> m a
logFuncUseColorL :: HasLogFunc env => SimpleGetter env Bool
logFuncLogLevelColorsL :: HasLogFunc env => SimpleGetter env (LogLevel -> Utf8Builder)
logFuncSecondaryColorL :: HasLogFunc env => SimpleGetter env Utf8Builder
logFuncAccentColorsL :: HasLogFunc env => SimpleGetter env (Int -> Utf8Builder)
glog :: (MonadIO m, HasCallStack, HasGLogFunc env, MonadReader env m) => GMsg env -> m ()
data GLogFunc msg
gLogFuncClassic :: (HasLogLevel msg, HasLogSource msg, Display msg) => LogFunc -> GLogFunc msg
mkGLogFunc :: (CallStack -> msg -> IO ()) -> GLogFunc msg
contramapMaybeGLogFunc :: (a -> Maybe b) -> GLogFunc b -> GLogFunc a
contramapGLogFunc :: (a -> b) -> GLogFunc b -> GLogFunc a
class HasGLogFunc env where
- type GMsg env
- gLogFuncL :: Lens' env (GLogFunc (GMsg env))
class HasLogLevel msg where
- getLogLevel :: msg -> LogLevel
class HasLogSource msg where
- getLogSource :: msg -> LogSource
type family GMsg env
class Display a where
- display :: a -> Utf8Builder
- textDisplay :: a -> Text
newtype Utf8Builder = Utf8Builder {
- getUtf8Builder :: Builder
}
displayShow :: Show a => a -> Utf8Builder
utf8BuilderToText :: Utf8Builder -> Text
utf8BuilderToLazyText :: Utf8Builder -> Text
displayBytesUtf8 :: ByteString -> Utf8Builder
writeFileUtf8Builder :: MonadIO m => FilePath -> Utf8Builder -> m ()
type Lens s t a b = forall (f :: Type -> Type). Functor f => (a -> f b) -> s -> f t
lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b
view :: MonadReader s m => Getting a s a -> m a
preview :: MonadReader s m => Getting (First a) s a -> m (Maybe a)
type ASetter s t a b = (a -> Identity b) -> s -> Identity t
type ASetter' s a = ASetter s s a a
type Getting r s a = (a -> Const r a) -> s -> Const r s
type Lens' s a = Lens s s a a
type SimpleGetter s a = forall r. Getting r s a
over :: ASetter s t a b -> (a -> b) -> s -> t
set :: ASetter s t a b -> b -> s -> t
sets :: ((a -> b) -> s -> t) -> ASetter s t a b
to :: (s -> a) -> SimpleGetter s a
(^.) :: s -> Getting a s a -> a
(^?) :: s -> Getting (First a) s a -> Maybe a
(^..) :: s -> Getting (Endo [a]) s a -> [a]
(%~) :: ASetter s t a b -> (a -> b) -> s -> t
(.~) :: ASetter s t a b -> b -> s -> t
data ThreadId
myThreadId :: MonadIO m => m ThreadId
isCurrentThreadBound :: MonadIO m => m Bool
threadWaitRead :: MonadIO m => Fd -> m ()
threadWaitWrite :: MonadIO m => Fd -> m ()
threadDelay :: MonadIO m => Int -> m ()
yieldThread :: MonadIO m => m ()
async :: MonadUnliftIO m => m a -> m (Async a)
data Async a
link :: MonadIO m => Async a -> m ()
link2 :: MonadIO m => Async a -> Async b -> m ()
data Conc (m :: Type -> Type) a
data ConcException = EmptyWithNoAlternative
newtype Concurrently (m :: Type -> Type) a = Concurrently {
- runConcurrently :: m a
}
asyncBound :: MonadUnliftIO m => m a -> m (Async a)
asyncOn :: MonadUnliftIO m => Int -> m a -> m (Async a)
asyncOnWithUnmask :: MonadUnliftIO m => Int -> ((forall b. m b -> m b) -> m a) -> m (Async a)
asyncWithUnmask :: MonadUnliftIO m => ((forall b. m b -> m b) -> m a) -> m (Async a)
cancel :: MonadIO m => Async a -> m ()
cancelWith :: (Exception e, MonadIO m) => Async a -> e -> m ()
conc :: m a -> Conc m a
concurrently :: MonadUnliftIO m => m a -> m b -> m (a, b)
concurrently_ :: MonadUnliftIO m => m a -> m b -> m ()
forConcurrently :: (MonadUnliftIO m, Traversable t) => t a -> (a -> m b) -> m (t b)
forConcurrently_ :: (MonadUnliftIO m, Foldable f) => f a -> (a -> m b) -> m ()
mapConcurrently :: (MonadUnliftIO m, Traversable t) => (a -> m b) -> t a -> m (t b)
mapConcurrently_ :: (MonadUnliftIO m, Foldable f) => (a -> m b) -> f a -> m ()
poll :: MonadIO m => Async a -> m (Maybe (Either SomeException a))
pooledForConcurrently :: (MonadUnliftIO m, Traversable t) => t a -> (a -> m b) -> m (t b)
pooledForConcurrentlyN :: (MonadUnliftIO m, Traversable t) => Int -> t a -> (a -> m b) -> m (t b)
pooledForConcurrentlyN_ :: (MonadUnliftIO m, Foldable t) => Int -> t a -> (a -> m b) -> m ()
pooledForConcurrently_ :: (MonadUnliftIO m, Foldable f) => f a -> (a -> m b) -> m ()
pooledMapConcurrently :: (MonadUnliftIO m, Traversable t) => (a -> m b) -> t a -> m (t b)
pooledMapConcurrentlyN :: (MonadUnliftIO m, Traversable t) => Int -> (a -> m b) -> t a -> m (t b)
pooledMapConcurrentlyN_ :: (MonadUnliftIO m, Foldable f) => Int -> (a -> m b) -> f a -> m ()
pooledMapConcurrently_ :: (MonadUnliftIO m, Foldable f) => (a -> m b) -> f a -> m ()
pooledReplicateConcurrently :: MonadUnliftIO m => Int -> m a -> m [a]
pooledReplicateConcurrentlyN :: MonadUnliftIO m => Int -> Int -> m a -> m [a]
pooledReplicateConcurrentlyN_ :: MonadUnliftIO m => Int -> Int -> m a -> m ()
pooledReplicateConcurrently_ :: MonadUnliftIO m => Int -> m a -> m ()
race :: MonadUnliftIO m => m a -> m b -> m (Either a b)
race_ :: MonadUnliftIO m => m a -> m b -> m ()
replicateConcurrently :: MonadUnliftIO f => Int -> f a -> f [a]
replicateConcurrently_ :: (Applicative m, MonadUnliftIO m) => Int -> m a -> m ()
runConc :: MonadUnliftIO m => Conc m a -> m a
uninterruptibleCancel :: MonadIO m => Async a -> m ()
wait :: MonadIO m => Async a -> m a
waitAny :: MonadIO m => [Async a] -> m (Async a, a)
waitAnyCancel :: MonadIO m => [Async a] -> m (Async a, a)
waitAnyCatch :: MonadIO m => [Async a] -> m (Async a, Either SomeException a)
waitAnyCatchCancel :: MonadIO m => [Async a] -> m (Async a, Either SomeException a)
waitBoth :: MonadIO m => Async a -> Async b -> m (a, b)
waitCatch :: MonadIO m => Async a -> m (Either SomeException a)
waitEither :: MonadIO m => Async a -> Async b -> m (Either a b)
waitEitherCancel :: MonadIO m => Async a -> Async b -> m (Either a b)
waitEitherCatch :: MonadIO m => Async a -> Async b -> m (Either (Either SomeException a) (Either SomeException b))
waitEitherCatchCancel :: MonadIO m => Async a -> Async b -> m (Either (Either SomeException a) (Either SomeException b))
waitEither_ :: MonadIO m => Async a -> Async b -> m ()
withAsync :: MonadUnliftIO m => m a -> (Async a -> m b) -> m b
withAsyncBound :: MonadUnliftIO m => m a -> (Async a -> m b) -> m b
withAsyncOn :: MonadUnliftIO m => Int -> m a -> (Async a -> m b) -> m b
withAsyncOnWithUnmask :: MonadUnliftIO m => Int -> ((forall c. m c -> m c) -> m a) -> (Async a -> m b) -> m b
withAsyncWithUnmask :: MonadUnliftIO m => ((forall c. m c -> m c) -> m a) -> (Async a -> m b) -> m b
pollSTM :: Async a -> STM (Maybe (Either SomeException a))
waitAnyCatchSTM :: [Async a] -> STM (Async a, Either SomeException a)
waitAnySTM :: [Async a] -> STM (Async a, a)
waitBothSTM :: Async a -> Async b -> STM (a, b)
waitCatchSTM :: Async a -> STM (Either SomeException a)
waitEitherCatchSTM :: Async a -> Async b -> STM (Either (Either SomeException a) (Either SomeException b))
waitEitherSTM :: Async a -> Async b -> STM (Either a b)
waitEitherSTM_ :: Async a -> Async b -> STM ()
waitSTM :: Async a -> STM a
data AsyncCancelled = AsyncCancelled
data STM a
atomically :: MonadIO m => STM a -> m a
orElse :: STM a -> STM a -> STM a
checkSTM :: Bool -> STM ()
mkWeakTMVar :: MonadUnliftIO m => TMVar a -> m () -> m (Weak (TMVar a))
mkWeakTVar :: MonadUnliftIO m => TVar a -> m () -> m (Weak (TVar a))
newBroadcastTChanIO :: MonadIO m => m (TChan a)
newEmptyTMVarIO :: MonadIO m => m (TMVar a)
newTBQueueIO :: MonadIO m => Natural -> m (TBQueue a)
newTChanIO :: MonadIO m => m (TChan a)
newTMVarIO :: MonadIO m => a -> m (TMVar a)
newTQueueIO :: MonadIO m => m (TQueue a)
newTVarIO :: MonadIO m => a -> m (TVar a)
readTVarIO :: MonadIO m => TVar a -> m a
registerDelay :: MonadIO m => Int -> m (TVar Bool)
retrySTM :: STM a
newTVar :: a -> STM (TVar a)
readTVar :: TVar a -> STM a
writeTVar :: TVar a -> a -> STM ()
flushTBQueue :: TBQueue a -> STM [a]
isEmptyTBQueue :: TBQueue a -> STM Bool
isFullTBQueue :: TBQueue a -> STM Bool
lengthTBQueue :: TBQueue a -> STM Natural
newTBQueue :: Natural -> STM (TBQueue a)
peekTBQueue :: TBQueue a -> STM a
readTBQueue :: TBQueue a -> STM a
tryPeekTBQueue :: TBQueue a -> STM (Maybe a)
tryReadTBQueue :: TBQueue a -> STM (Maybe a)
unGetTBQueue :: TBQueue a -> a -> STM ()
writeTBQueue :: TBQueue a -> a -> STM ()
cloneTChan :: TChan a -> STM (TChan a)
dupTChan :: TChan a -> STM (TChan a)
isEmptyTChan :: TChan a -> STM Bool
newBroadcastTChan :: STM (TChan a)
newTChan :: STM (TChan a)
peekTChan :: TChan a -> STM a
readTChan :: TChan a -> STM a
tryPeekTChan :: TChan a -> STM (Maybe a)
tryReadTChan :: TChan a -> STM (Maybe a)
unGetTChan :: TChan a -> a -> STM ()
writeTChan :: TChan a -> a -> STM ()
isEmptyTMVar :: TMVar a -> STM Bool
newEmptyTMVar :: STM (TMVar a)
newTMVar :: a -> STM (TMVar a)
putTMVar :: TMVar a -> a -> STM ()
readTMVar :: TMVar a -> STM a
swapTMVar :: TMVar a -> a -> STM a
takeTMVar :: TMVar a -> STM a
tryPutTMVar :: TMVar a -> a -> STM Bool
tryReadTMVar :: TMVar a -> STM (Maybe a)
tryTakeTMVar :: TMVar a -> STM (Maybe a)
writeTMVar :: TMVar a -> a -> STM ()
isEmptyTQueue :: TQueue a -> STM Bool
newTQueue :: STM (TQueue a)
peekTQueue :: TQueue a -> STM a
readTQueue :: TQueue a -> STM a
tryPeekTQueue :: TQueue a -> STM (Maybe a)
tryReadTQueue :: TQueue a -> STM (Maybe a)
unGetTQueue :: TQueue a -> a -> STM ()
writeTQueue :: TQueue a -> a -> STM ()
modifyTVar :: TVar a -> (a -> a) -> STM ()
modifyTVar' :: TVar a -> (a -> a) -> STM ()
stateTVar :: TVar s -> (s -> (a, s)) -> STM a
swapTVar :: TVar a -> a -> STM a
data TVar a
data TBQueue a
data TChan a
data TMVar a
data TQueue a
data Chan a
dupChan :: MonadIO m => Chan a -> m (Chan a)
getChanContents :: MonadIO m => Chan a -> m [a]
newChan :: MonadIO m => m (Chan a)
readChan :: MonadIO m => Chan a -> m a
writeChan :: MonadIO m => Chan a -> a -> m ()
writeList2Chan :: MonadIO m => Chan a -> [a] -> m ()
timeout :: MonadUnliftIO m => Int -> m a -> m (Maybe a)
class (Typeable e, Show e) => Exception e where
- toException :: e -> SomeException
- fromException :: SomeException -> Maybe e
- displayException :: e -> String
- backtraceDesired :: e -> Bool
assert :: Bool -> a -> a
class Typeable (a :: k)
data SomeException = (Exception e, HasExceptionContext) => SomeException e
data IOException
throwIO :: (MonadIO m, Exception e) => e -> m a
bracket :: MonadUnliftIO m => m a -> (a -> m b) -> (a -> m c) -> m c
catch :: (MonadUnliftIO m, Exception e) => m a -> (e -> m a) -> m a
catchAny :: MonadUnliftIO m => m a -> (SomeException -> m a) -> m a
evaluate :: MonadIO m => a -> m a
finally :: MonadUnliftIO m => m a -> m b -> m a
mask :: MonadUnliftIO m => ((forall a. m a -> m a) -> m b) -> m b
mask_ :: MonadUnliftIO m => m a -> m a
onException :: MonadUnliftIO m => m a -> m b -> m a
uninterruptibleMask :: MonadUnliftIO m => ((forall a. m a -> m a) -> m b) -> m b
uninterruptibleMask_ :: MonadUnliftIO m => m a -> m a
data StringException = StringException String CallStack
bracketOnError :: MonadUnliftIO m => m a -> (a -> m b) -> (a -> m c) -> m c
bracketOnError_ :: MonadUnliftIO m => m a -> m b -> m c -> m c
bracket_ :: MonadUnliftIO m => m a -> m b -> m c -> m c
catchAnyDeep :: (NFData a, MonadUnliftIO m) => m a -> (SomeException -> m a) -> m a
catchDeep :: (MonadUnliftIO m, Exception e, NFData a) => m a -> (e -> m a) -> m a
catchIO :: MonadUnliftIO m => m a -> (IOException -> m a) -> m a
catchJust :: (MonadUnliftIO m, Exception e) => (e -> Maybe b) -> m a -> (b -> m a) -> m a
catchSyncOrAsync :: (MonadUnliftIO m, Exception e) => m a -> (e -> m a) -> m a
catches :: MonadUnliftIO m => m a -> [Handler m a] -> m a
catchesDeep :: (MonadUnliftIO m, NFData a) => m a -> [Handler m a] -> m a
evaluateDeep :: (MonadIO m, NFData a) => a -> m a
fromEither :: (Exception e, MonadIO m) => Either e a -> m a
fromEitherIO :: (Exception e, MonadIO m) => IO (Either e a) -> m a
fromEitherM :: (Exception e, MonadIO m) => m (Either e a) -> m a
fromExceptionUnwrap :: Exception e => SomeException -> Maybe e
handle :: (MonadUnliftIO m, Exception e) => (e -> m a) -> m a -> m a
handleAny :: MonadUnliftIO m => (SomeException -> m a) -> m a -> m a
handleAnyDeep :: (MonadUnliftIO m, NFData a) => (SomeException -> m a) -> m a -> m a
handleDeep :: (MonadUnliftIO m, Exception e, NFData a) => (e -> m a) -> m a -> m a
handleIO :: MonadUnliftIO m => (IOException -> m a) -> m a -> m a
handleJust :: (MonadUnliftIO m, Exception e) => (e -> Maybe b) -> (b -> m a) -> m a -> m a
handleSyncOrAsync :: (MonadUnliftIO m, Exception e) => (e -> m a) -> m a -> m a
impureThrow :: Exception e => e -> a
isAsyncException :: Exception e => e -> Bool
isSyncException :: Exception e => e -> Bool
mapExceptionM :: (Exception e1, Exception e2, MonadUnliftIO m) => (e1 -> e2) -> m a -> m a
pureTry :: a -> Either SomeException a
pureTryDeep :: NFData a => a -> Either SomeException a
stringException :: HasCallStack => String -> StringException
throwString :: (MonadIO m, HasCallStack) => String -> m a
throwTo :: (Exception e, MonadIO m) => ThreadId -> e -> m ()
toAsyncException :: Exception e => e -> SomeException
toSyncException :: Exception e => e -> SomeException
try :: (MonadUnliftIO m, Exception e) => m a -> m (Either e a)
tryAny :: MonadUnliftIO m => m a -> m (Either SomeException a)
tryAnyDeep :: (MonadUnliftIO m, NFData a) => m a -> m (Either SomeException a)
tryDeep :: (MonadUnliftIO m, Exception e, NFData a) => m a -> m (Either e a)
tryIO :: MonadUnliftIO m => m a -> m (Either IOException a)
tryJust :: (MonadUnliftIO m, Exception e) => (e -> Maybe b) -> m a -> m (Either b a)
trySyncOrAsync :: (MonadUnliftIO m, Exception e) => m a -> m (Either e a)
withException :: (MonadUnliftIO m, Exception e) => m a -> (e -> m b) -> m a
asyncExceptionFromException :: Exception e => SomeException -> Maybe e
asyncExceptionToException :: Exception e => e -> SomeException
data Handler (m :: Type -> Type) a = Exception e => Handler (e -> m a)
data SomeAsyncException = Exception e => SomeAsyncException e
data AsyncExceptionWrapper = Exception e => AsyncExceptionWrapper e
data SyncExceptionWrapper = Exception e => SyncExceptionWrapper e
throwM :: (MonadThrow m, HasCallStack, Exception e) => e -> m a
withBinaryFile :: MonadUnliftIO m => FilePath -> IOMode -> (Handle -> m a) -> m a
data Handle
data IOMode
- = ReadMode
- | WriteMode
- | AppendMode
- | ReadWriteMode
stdin :: Handle
stdout :: Handle
stderr :: Handle
getMonotonicTime :: MonadIO m => m Double
hClose :: MonadIO m => Handle -> m ()
hFileSize :: MonadIO m => Handle -> m Integer
hFlush :: MonadIO m => Handle -> m ()
hGetBuffering :: MonadIO m => Handle -> m BufferMode
hGetEcho :: MonadIO m => Handle -> m Bool
hIsClosed :: MonadIO m => Handle -> m Bool
hIsEOF :: MonadIO m => Handle -> m Bool
hIsOpen :: MonadIO m => Handle -> m Bool
hIsReadable :: MonadIO m => Handle -> m Bool
hIsSeekable :: MonadIO m => Handle -> m Bool
hIsTerminalDevice :: MonadIO m => Handle -> m Bool
hIsWritable :: MonadIO m => Handle -> m Bool
hReady :: MonadIO m => Handle -> m Bool
hSeek :: MonadIO m => Handle -> SeekMode -> Integer -> m ()
hSetBuffering :: MonadIO m => Handle -> BufferMode -> m ()
hSetEcho :: MonadIO m => Handle -> Bool -> m ()
hSetFileSize :: MonadIO m => Handle -> Integer -> m ()
hTell :: MonadIO m => Handle -> m Integer
hWaitForInput :: MonadIO m => Handle -> Int -> m Bool
openFile :: MonadIO m => FilePath -> IOMode -> m Handle
withFile :: MonadUnliftIO m => FilePath -> IOMode -> (Handle -> m a) -> m a
data SeekMode
- = AbsoluteSeek
- | RelativeSeek
- | SeekFromEnd
data BufferMode
- = NoBuffering
- | LineBuffering
- | BlockBuffering (Maybe Int)
withSystemTempDirectory :: MonadUnliftIO m => String -> (FilePath -> m a) -> m a
withSystemTempFile :: MonadUnliftIO m => String -> (FilePath -> Handle -> m a) -> m a
withTempDirectory :: MonadUnliftIO m => FilePath -> String -> (FilePath -> m a) -> m a
withTempFile :: MonadUnliftIO m => FilePath -> String -> (FilePath -> Handle -> m a) -> m a
withLazyFile :: MonadUnliftIO m => FilePath -> (ByteString -> m a) -> m a
withLazyFileUtf8 :: MonadUnliftIO m => FilePath -> (Text -> m a) -> m a
readFileBinary :: MonadIO m => FilePath -> m ByteString
writeFileBinary :: MonadIO m => FilePath -> ByteString -> m ()
readFileUtf8 :: MonadIO m => FilePath -> m Text
writeFileUtf8 :: MonadIO m => FilePath -> Text -> m ()
hPutBuilder :: MonadIO m => Handle -> Builder -> m ()
exitWith :: MonadIO m => ExitCode -> m a
exitFailure :: MonadIO m => m a
exitSuccess :: MonadIO m => m a
data ExitCode
- = ExitSuccess
- | ExitFailure Int
data SomeRef a
mapRIO :: (outer -> inner) -> RIO inner a -> RIO outer a
class HasStateRef s env | env -> s where
- stateRefL :: Lens' env (SomeRef s)
class HasWriteRef w env | env -> w where
- writeRefL :: Lens' env (SomeRef w)
newSomeRef :: MonadIO m => a -> m (SomeRef a)
newUnboxedSomeRef :: (MonadIO m, Unbox a) => a -> m (SomeRef a)
readSomeRef :: MonadIO m => SomeRef a -> m a
writeSomeRef :: MonadIO m => SomeRef a -> a -> m ()
modifySomeRef :: MonadIO m => SomeRef a -> (a -> a) -> m ()
data URef s a
type IOURef = URef (PrimState IO)
newURef :: (PrimMonad m, Unbox a) => a -> m (URef (PrimState m) a)
readURef :: (PrimMonad m, Unbox a) => URef (PrimState m) a -> m a
writeURef :: (PrimMonad m, Unbox a) => URef (PrimState m) a -> a -> m ()
modifyURef :: (PrimMonad m, Unbox a) => URef (PrimState m) a -> (a -> a) -> m ()
data IORef a
atomicModifyIORef :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
atomicModifyIORef' :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
atomicWriteIORef :: MonadIO m => IORef a -> a -> m ()
mkWeakIORef :: MonadUnliftIO m => IORef a -> m () -> m (Weak (IORef a))
modifyIORef :: MonadIO m => IORef a -> (a -> a) -> m ()
modifyIORef' :: MonadIO m => IORef a -> (a -> a) -> m ()
newIORef :: MonadIO m => a -> m (IORef a)
readIORef :: MonadIO m => IORef a -> m a
writeIORef :: MonadIO m => IORef a -> a -> m ()
data MVar a
isEmptyMVar :: MonadIO m => MVar a -> m Bool
mkWeakMVar :: MonadUnliftIO m => MVar a -> m () -> m (Weak (MVar a))
modifyMVar :: MonadUnliftIO m => MVar a -> (a -> m (a, b)) -> m b
modifyMVarMasked :: MonadUnliftIO m => MVar a -> (a -> m (a, b)) -> m b
modifyMVarMasked_ :: MonadUnliftIO m => MVar a -> (a -> m a) -> m ()
modifyMVar_ :: MonadUnliftIO m => MVar a -> (a -> m a) -> m ()
newEmptyMVar :: MonadIO m => m (MVar a)
newMVar :: MonadIO m => a -> m (MVar a)
putMVar :: MonadIO m => MVar a -> a -> m ()
readMVar :: MonadIO m => MVar a -> m a
swapMVar :: MonadIO m => MVar a -> a -> m a
takeMVar :: MonadIO m => MVar a -> m a
tryPutMVar :: MonadIO m => MVar a -> a -> m Bool
tryReadMVar :: MonadIO m => MVar a -> m (Maybe a)
tryTakeMVar :: MonadIO m => MVar a -> m (Maybe a)
withMVar :: MonadUnliftIO m => MVar a -> (a -> m b) -> m b
withMVarMasked :: MonadUnliftIO m => MVar a -> (a -> m b) -> m b
data QSem
newQSem :: MonadIO m => Int -> m QSem
signalQSem :: MonadIO m => QSem -> m ()
waitQSem :: MonadIO m => QSem -> m ()
withQSem :: MonadUnliftIO m => QSem -> m a -> m a
data QSemN
newQSemN :: MonadIO m => Int -> m QSemN
signalQSemN :: MonadIO m => QSemN -> Int -> m ()
waitQSemN :: MonadIO m => QSemN -> Int -> m ()
withQSemN :: MonadUnliftIO m => QSemN -> Int -> m a -> m a
data Memoized a
memoizeMVar :: MonadUnliftIO m => m a -> m (Memoized a)
memoizeRef :: MonadUnliftIO m => m a -> m (Memoized a)
runMemoized :: MonadIO m => Memoized a -> m a
module RIO.Deque
trace :: Text -> a -> a
traceId :: Text -> Text
traceIO :: MonadIO m => Text -> m ()
traceM :: Applicative f => Text -> f ()
traceEvent :: Text -> a -> a
traceEventIO :: MonadIO m => Text -> m ()
traceMarker :: Text -> a -> a
traceMarkerIO :: MonadIO m => Text -> m ()
traceStack :: Text -> a -> a
traceShow :: Show a => a -> b -> b
traceShowId :: Show a => a -> a
traceShowIO :: (Show a, MonadIO m) => a -> m ()
traceShowM :: (Show a, Applicative f) => a -> f ()
traceShowEvent :: Show a => a -> b -> b
traceShowEventIO :: (Show a, MonadIO m) => a -> m ()
traceShowMarker :: Show a => a -> b -> b
traceShowMarkerIO :: (Show a, MonadIO m) => a -> m ()
traceShowStack :: Show a => a -> b -> b
traceDisplay :: Display a => a -> b -> b
traceDisplayId :: Display a => a -> a
traceDisplayIO :: (Display a, MonadIO m) => a -> m ()
traceDisplayM :: (Display a, Applicative f) => a -> f ()
traceDisplayEvent :: Display a => a -> b -> b
traceDisplayEventIO :: (Display a, MonadIO m) => a -> m ()
traceDisplayMarker :: Display a => a -> b -> b
traceDisplayMarkerIO :: (Display a, MonadIO m) => a -> m ()
traceDisplayStack :: Display a => a -> b -> b

Custom `Prelude`

One of the core features of rio is that it can be used as a Prelude replacement. Therefore it is best to disable the default Prelude with: NoImplicitPrelude pragma:

{-# LANGUAGE NoImplicitPrelude #-}
import RIO

Some functions not exported here can be found in RIO.Partial: fromJust, read, toEnum, pred, succ.

module RIO.Prelude

module RIO.Prelude.Types

The `RIO` Monad

newtype RIO env a Source #

The Reader+IO monad. This is different from a ReaderT because:

It's not a transformer, it hardcodes IO for simpler usage and error messages.
Instances of typeclasses like MonadLogger are implemented using classes defined on the environment, instead of using an underlying monad.

Constructors

RIO
Fields unRIO :: ReaderT env IO a

Instances

Instances details

MonadReader env (RIO env) Source #

Instance details

Defined in RIO.Prelude.RIO

Methods

ask :: RIO env env #

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

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

HasStateRef s env => MonadState s (RIO env) Source #

Instance details

Defined in RIO.Prelude.RIO

Methods

get :: RIO env s #

put :: s -> RIO env () #

state :: (s -> (a, s)) -> RIO env a #

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

Instance details

Defined in RIO.Prelude.RIO

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 #

MonadIO (RIO env) Source #

Instance details

Defined in RIO.Prelude.RIO

Methods

liftIO :: IO a -> RIO env a #

MonadThrow (RIO env) Source #

Instance details

Defined in RIO.Prelude.RIO

Methods

throwM :: (HasCallStack, Exception e) => e -> RIO env a #

Applicative (RIO env) Source #

Instance details

Defined in RIO.Prelude.RIO

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 #

Functor (RIO env) Source #

Instance details

Defined in RIO.Prelude.RIO

Methods

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

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

Monad (RIO env) Source #

Instance details

Defined in RIO.Prelude.RIO

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 #

PrimMonad (RIO env) Source #

Instance details

Defined in RIO.Prelude.RIO

Associated Types

type PrimState (RIO env)
Instance details Defined in RIO.Prelude.RIO type PrimState (RIO env) = PrimState IO

Methods

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

MonadUnliftIO (RIO env) Source #

Instance details

Defined in RIO.Prelude.RIO

Methods

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

Monoid a => Monoid (RIO env a) Source #

Instance details

Defined in RIO.Prelude.RIO

Methods

mempty :: RIO env a #

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

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

Semigroup a => Semigroup (RIO env a) Source #

Instance details

Defined in RIO.Prelude.RIO

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

type PrimState (RIO env) Source #

Instance details

Defined in RIO.Prelude.RIO

type PrimState (RIO env) = PrimState IO

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

Abstract RIO to an arbitrary MonadReader instance, which can handle IO.

Since: 0.0.1.0

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

Using the environment run in IO the action that requires that environment.

Since: 0.0.1.0

`SimpleApp`

If all you need is just some default environment that does basic logging and allows spawning processes, then you can use SimpleApp:

{-# LANGUAGE OverloadedStrings #-}
module Main where

main :: IO ()
main =
  runSimpleApp $ do
    logInfo "Hello World!"

Note the OverloadedStrings extension, which is enabled to simplify logging.

module RIO.Prelude.Simple

`MonadIO` and `MonadUnliftIO`

newtype UnliftIO (m :: Type -> Type) #

Constructors

UnliftIO
Fields unliftIO :: forall a. m a -> IO a

class Monad m => MonadIO (m :: Type -> Type) where #

Methods

liftIO :: IO a -> m a #

Instances

Instances details

MonadIO IO
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a #
MonadIO Q
Instance details Defined in Language.Haskell.TH.Syntax Methods liftIO :: IO a -> Q a #
MonadIO m => MonadIO (CatchT m)
Instance details Defined in Control.Monad.Catch.Pure Methods liftIO :: IO a -> CatchT m a #
MonadIO (RIO env) Source #
Instance details Defined in RIO.Prelude.RIO Methods liftIO :: IO a -> RIO env a #
MonadIO m => MonadIO (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftIO :: IO a -> MaybeT m a #
(Monoid w, Functor m, MonadIO m) => MonadIO (AccumT w m)
Instance details Defined in Control.Monad.Trans.Accum Methods liftIO :: IO a -> AccumT w m a #
MonadIO m => MonadIO (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftIO :: IO a -> ExceptT e m a #
MonadIO m => MonadIO (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods liftIO :: IO a -> IdentityT m a #
MonadIO m => MonadIO (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods liftIO :: IO a -> ReaderT r m a #
MonadIO m => MonadIO (SelectT r m)
Instance details Defined in Control.Monad.Trans.Select Methods liftIO :: IO a -> SelectT r m a #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods liftIO :: IO a -> StateT s m a #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods liftIO :: IO a -> StateT s m a #
MonadIO m => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.CPS Methods liftIO :: IO a -> WriterT w m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods liftIO :: IO a -> WriterT w m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods liftIO :: IO a -> WriterT w m a #
MonadIO m => MonadIO (ContT r m)
Instance details Defined in Control.Monad.Trans.Cont Methods liftIO :: IO a -> ContT r m a #
MonadIO m => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.CPS Methods liftIO :: IO a -> RWST r w s m a #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods liftIO :: IO a -> RWST r w s m a #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods liftIO :: IO a -> RWST r w s m a #

class MonadIO m => MonadUnliftIO (m :: Type -> Type) where #

Methods

withRunInIO :: ((forall a. m a -> IO a) -> IO b) -> m b #

Instances

Instances details

MonadUnliftIO IO
Instance details Defined in Control.Monad.IO.Unlift Methods withRunInIO :: ((forall a. IO a -> IO a) -> IO b) -> IO b #
MonadUnliftIO (RIO env) Source #
Instance details Defined in RIO.Prelude.RIO Methods withRunInIO :: ((forall a. RIO env a -> IO a) -> IO b) -> RIO env b #
MonadUnliftIO m => MonadUnliftIO (IdentityT m)
Instance details Defined in Control.Monad.IO.Unlift Methods withRunInIO :: ((forall a. IdentityT m a -> IO a) -> IO b) -> IdentityT m b #
MonadUnliftIO m => MonadUnliftIO (ReaderT r m)
Instance details Defined in Control.Monad.IO.Unlift Methods withRunInIO :: ((forall a. ReaderT r m a -> IO a) -> IO b) -> ReaderT r m b #

askRunInIO :: MonadUnliftIO m => m (m a -> IO a) #

askUnliftIO :: MonadUnliftIO m => m (UnliftIO m) #

liftIOOp :: MonadUnliftIO m => (IO a -> IO b) -> m a -> m b #

toIO :: MonadUnliftIO m => m a -> m (IO a) #

withUnliftIO :: MonadUnliftIO m => (UnliftIO m -> IO a) -> m a #

wrappedWithRunInIO :: MonadUnliftIO n => (n b -> m b) -> (forall a. m a -> n a) -> ((forall a. m a -> IO a) -> IO b) -> m b #

Logger

The logging system in RIO is built upon "log functions", which are accessed in RIO's environment via a class like "has log function". There are two provided:

In the common case: for logging plain text (via Utf8Builder) efficiently, there is LogFunc, which can be created via withLogFunc, and is accessed via HasLogFunc. This provides all the classical logging facilities: timestamped text output with log levels and colors (if terminal-supported) to the terminal. We log output via logInfo, logDebug, etc.
In the advanced case: where logging takes on a more semantic meaning and the logs need to be digested, acted upon, translated or serialized upstream (to e.g. a JSON logging server), we have GLogFunc (as in "generic log function"), and is accessed via HasGLogFunc. In this case, we log output via glog. See the Type-generic logger section for more information.

withLogFunc :: MonadUnliftIO m => LogOptions -> (LogFunc -> m a) -> m a Source #

Given a LogOptions value, run the given function with the specified LogFunc. A common way to use this function is:

let isVerbose = False -- get from the command line instead
logOptions' <- logOptionsHandle stderr isVerbose
let logOptions = setLogUseTime True logOptions'
withLogFunc logOptions $ \lf -> do
  let app = App -- application specific environment
        { appLogFunc = lf
        , appOtherStuff = ...
        }
  runRIO app $ do
    logInfo "Starting app"
    myApp

Since: 0.0.0.0

newLogFunc :: (MonadIO n, MonadIO m) => LogOptions -> n (LogFunc, m ()) Source #

Given a LogOptions value, returns both a new LogFunc and a sub-routine that disposes it.

Intended for use if you want to deal with the teardown of LogFunc yourself, otherwise prefer the withLogFunc function instead.

Since: 0.1.3.0

data LogFunc Source #

A logging function, wrapped in a newtype for better error messages.

An implementation may choose any behavior of this value it wishes, including printing to standard output or no action at all.

Since: 0.0.0.0

Instances

Instances details

Monoid LogFunc Source #	`mempty` peforms no logging. Since: 0.0.0.0
Instance details Defined in RIO.Prelude.Logger Methods mempty :: LogFunc # mappend :: LogFunc -> LogFunc -> LogFunc # mconcat :: [LogFunc] -> LogFunc #
Semigroup LogFunc Source #	Perform both sets of actions per log entry. Since: 0.0.0.0
Instance details Defined in RIO.Prelude.Logger Methods (<>) :: LogFunc -> LogFunc -> LogFunc # sconcat :: NonEmpty LogFunc -> LogFunc stimes :: Integral b => b -> LogFunc -> LogFunc
HasLogFunc LogFunc Source #
Instance details Defined in RIO.Prelude.Logger Methods logFuncL :: Lens' LogFunc LogFunc Source #

class HasLogFunc env where Source #

Environment values with a logging function.

Since: 0.0.0.0

Methods

logFuncL :: Lens' env LogFunc Source #

Instances

Instances details

HasLogFunc LogFunc Source #
Instance details Defined in RIO.Prelude.Logger Methods logFuncL :: Lens' LogFunc LogFunc Source #
HasLogFunc SimpleApp Source #
Instance details Defined in RIO.Prelude.Simple Methods logFuncL :: Lens' SimpleApp LogFunc Source #
HasLogFunc LoggedProcessContext Source #
Instance details Defined in RIO.Process Methods logFuncL :: Lens' LoggedProcessContext LogFunc Source #

logOptionsHandle Source #

Arguments

:: MonadIO m
=> Handle
-> Bool	Verbose Flag
-> m LogOptions

Create a LogOptions value from the given Handle and whether to perform verbose logging or not. Individiual settings can be overridden using appropriate set functions. Logging output is guaranteed to be non-interleaved only for a UTF-8 Handle in a multi-thread environment.

When Verbose Flag is True, the following happens:

setLogVerboseFormat is called with True
setLogUseColor is called with True (except on Windows)
setLogUseLoc is called with True
setLogUseTime is called with True
setLogMinLevel is called with Debug log level

Since: 0.0.0.0

data LogOptions Source #

Configuration for how to create a LogFunc. Intended to be used with the withLogFunc function.

Since: 0.0.0.0

setLogMinLevel :: LogLevel -> LogOptions -> LogOptions Source #

Set the minimum log level. Messages below this level will not be printed.

Default: in verbose mode, LevelDebug. Otherwise, LevelInfo.

Since: 0.0.0.0

setLogMinLevelIO :: IO LogLevel -> LogOptions -> LogOptions Source #

Refer to setLogMinLevel. This modifier allows to alter the verbose format value dynamically at runtime.

Default: in verbose mode, LevelDebug. Otherwise, LevelInfo.

Since: 0.1.3.0

setLogVerboseFormat :: Bool -> LogOptions -> LogOptions Source #

Use the verbose format for printing log messages.

Default: follows the value of the verbose flag.

Since: 0.0.0.0

setLogVerboseFormatIO :: IO Bool -> LogOptions -> LogOptions Source #

Refer to setLogVerboseFormat. This modifier allows to alter the verbose format value dynamically at runtime.

Default: follows the value of the verbose flag.

Since: 0.1.3.0

setLogTerminal :: Bool -> LogOptions -> LogOptions Source #

Do we treat output as a terminal. If True, we will enable sticky logging functionality.

Default: checks if the Handle provided to logOptionsHandle is a terminal with hIsTerminalDevice.

Since: 0.0.0.0

setLogUseTime :: Bool -> LogOptions -> LogOptions Source #

Include the time when printing log messages.

Default: True in debug mode, False otherwise.

Since: 0.0.0.0

setLogUseColor :: Bool -> LogOptions -> LogOptions Source #

Use ANSI color codes in the log output.

Default: True if in verbose mode and the Handle is a terminal device.

Since: 0.0.0.0

setLogUseLoc :: Bool -> LogOptions -> LogOptions Source #

Use code location in the log output.

Default: True if in verbose mode, False otherwise.

Since: 0.1.2.0

setLogFormat :: (Utf8Builder -> Utf8Builder) -> LogOptions -> LogOptions Source #

Set format method for messages

Default: id

Since: 0.1.13.0

setLogLevelColors :: (LogLevel -> Utf8Builder) -> LogOptions -> LogOptions Source #

ANSI color codes for LogLevel in the log output.

Default: LevelDebug = "\ESC[32m" -- Green LevelInfo = "\ESC[34m" -- Blue LevelWarn = "\ESC[33m" -- Yellow LevelError = "\ESC[31m" -- Red LevelOther _ = "\ESC[35m" -- Magenta

Since: 0.1.18.0

setLogSecondaryColor :: Utf8Builder -> LogOptions -> LogOptions Source #

ANSI color codes for secondary content in the log output.

Default: "\ESC[90m" -- Bright black (gray)

Since: 0.1.18.0

setLogAccentColors Source #

Arguments

:: (Int -> Utf8Builder)	This should be a total function.
-> LogOptions
-> LogOptions

ANSI color codes for accents in the log output. Accent colors are indexed by Int.

Default: const "\ESC[92m" -- Bright green, for all indicies

Since: 0.1.18.0

logDebug :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => Utf8Builder -> m () Source #

Log a debug level message with no source.

Since: 0.0.0.0

logInfo :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => Utf8Builder -> m () Source #

Log an info level message with no source.

Since: 0.0.0.0

logWarn :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => Utf8Builder -> m () Source #

Log a warn level message with no source.

Since: 0.0.0.0

logError :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => Utf8Builder -> m () Source #

Log an error level message with no source.

Since: 0.0.0.0

logOther Source #

Arguments

:: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack)
=> Text	level
-> Utf8Builder
-> m ()

Log a message with the specified textual level and no source.

Since: 0.0.0.0

logSticky :: (MonadIO m, HasCallStack, MonadReader env m, HasLogFunc env) => Utf8Builder -> m () Source #

Write a "sticky" line to the terminal. Any subsequent lines will overwrite this one, and that same line will be repeated below again. In other words, the line sticks at the bottom of the output forever. Running this function again will replace the sticky line with a new sticky line. When you want to get rid of the sticky line, run logStickyDone.

Note that not all LogFunc implementations will support sticky messages as described. However, the withLogFunc implementation provided by this module does.

Since: 0.0.0.0

logStickyDone :: (MonadIO m, HasCallStack, MonadReader env m, HasLogFunc env) => Utf8Builder -> m () Source #

This will print out the given message with a newline and disable any further stickiness of the line until a new call to logSticky happens.

Since: 0.0.0.0

logDebugS :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => LogSource -> Utf8Builder -> m () Source #

Log a debug level message with the given source.

Since: 0.0.0.0

logInfoS :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => LogSource -> Utf8Builder -> m () Source #

Log an info level message with the given source.

Since: 0.0.0.0

logWarnS :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => LogSource -> Utf8Builder -> m () Source #

Log a warn level message with the given source.

Since: 0.0.0.0

logErrorS :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => LogSource -> Utf8Builder -> m () Source #

Log an error level message with the given source.

Since: 0.0.0.0

logOtherS Source #

Arguments

:: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack)
=> Text	level
-> LogSource
-> Utf8Builder
-> m ()

Log a message with the specified textual level and the given source.

Since: 0.0.0.0

logGeneric :: (MonadIO m, MonadReader env m, HasLogFunc env, HasCallStack) => LogSource -> LogLevel -> Utf8Builder -> m () Source #

Generic, basic function for creating other logging functions.

Since: 0.0.0.0

mkLogFunc :: (CallStack -> LogSource -> LogLevel -> Utf8Builder -> IO ()) -> LogFunc Source #

Create a LogFunc from the given function.

Since: 0.0.0.0

logOptionsMemory :: MonadIO m => m (IORef Builder, LogOptions) Source #

Create a LogOptions value which will store its data in memory. This is primarily intended for testing purposes. This will return both a LogOptions value and an IORef containing the resulting Builder value.

This will default to non-verbose settings and assume there is a terminal attached. These assumptions can be overridden using the appropriate set functions.

Since: 0.0.0.0

data LogLevel Source #

The log level of a message.

Since: 0.0.0.0

Constructors

LevelDebug
LevelInfo
LevelWarn
LevelError
LevelOther !Text

Instances

Instances details

Read LogLevel Source #
Instance details Defined in RIO.Prelude.Logger Methods readsPrec :: Int -> ReadS LogLevel readList :: ReadS [LogLevel] readPrec :: ReadPrec LogLevel readListPrec :: ReadPrec [LogLevel]
Show LogLevel Source #
Instance details Defined in RIO.Prelude.Logger Methods showsPrec :: Int -> LogLevel -> ShowS show :: LogLevel -> String # showList :: [LogLevel] -> ShowS
Eq LogLevel Source #
Instance details Defined in RIO.Prelude.Logger Methods (==) :: LogLevel -> LogLevel -> Bool # (/=) :: LogLevel -> LogLevel -> Bool #
Ord LogLevel Source #
Instance details Defined in RIO.Prelude.Logger Methods compare :: LogLevel -> LogLevel -> Ordering # (<) :: LogLevel -> LogLevel -> Bool # (<=) :: LogLevel -> LogLevel -> Bool # (>) :: LogLevel -> LogLevel -> Bool # (>=) :: LogLevel -> LogLevel -> Bool # max :: LogLevel -> LogLevel -> LogLevel # min :: LogLevel -> LogLevel -> LogLevel #

type LogSource = Text Source #

Where in the application a log message came from. Used for display purposes only.

Since: 0.0.0.0

data CallStack #

Instances

Instances details

NFData CallStack

Instance details

Defined in Control.DeepSeq

Methods

rnf :: CallStack -> () #

IsList CallStack

Instance details

Defined in GHC.Internal.IsList

Associated Types

type Item CallStack
Instance details Defined in GHC.Internal.IsList type Item CallStack = (String, SrcLoc)

Methods

fromList :: [Item CallStack] -> CallStack

fromListN :: Int -> [Item CallStack] -> CallStack

toList :: CallStack -> [Item CallStack]

Show CallStack

Instance details

Defined in GHC.Internal.Show

Methods

showsPrec :: Int -> CallStack -> ShowS

show :: CallStack -> String #

showList :: [CallStack] -> ShowS

type Item CallStack

Instance details

Defined in GHC.Internal.IsList

type Item CallStack = (String, SrcLoc)

displayCallStack :: CallStack -> Utf8Builder Source #

Convert a CallStack value into a Utf8Builder indicating the first source location.

TODO Consider showing the entire call stack instead.

Since: 0.0.0.0

noLogging :: (HasLogFunc env, MonadReader env m) => m a -> m a Source #

Disable logging capabilities in a given sub-routine

Intended to skip logging in general purpose implementations, where secrets might be logged accidently.

Since: 0.1.5.0

logFuncUseColorL :: HasLogFunc env => SimpleGetter env Bool Source #

Is the log func configured to use color output?

Intended for use by code which wants to optionally add additional color to its log messages.

Since: 0.1.0.0

logFuncLogLevelColorsL :: HasLogFunc env => SimpleGetter env (LogLevel -> Utf8Builder) Source #

What color is the log func configured to use for each LogLevel?

Intended for use by code which wants to optionally add additional color to its log messages.

Since: 0.1.18.0

logFuncSecondaryColorL :: HasLogFunc env => SimpleGetter env Utf8Builder Source #

What color is the log func configured to use for secondary content?

Intended for use by code which wants to optionally add additional color to its log messages.

Since: 0.1.18.0

logFuncAccentColorsL :: HasLogFunc env => SimpleGetter env (Int -> Utf8Builder) Source #

What accent colors, indexed by Int, is the log func configured to use?

Intended for use by code which wants to optionally add additional color to its log messages.

Since: 0.1.18.0

glog :: (MonadIO m, HasCallStack, HasGLogFunc env, MonadReader env m) => GMsg env -> m () Source #

Log a value generically.

Since: 0.1.13.0

data GLogFunc msg Source #

A generic logger of some type msg.

Your GLocFunc can re-use the existing classical logging framework of RIO, and/or implement additional transforms, filters. Alternatively, you may log to a JSON source in a database, or anywhere else as needed. You can decide how to log levels or severities based on the constructors in your type. You will normally determine this in your main app entry point.

Since: 0.1.13.0

Instances

Instances details

Contravariant GLogFunc Source #

Use this instance to wrap sub-loggers via mapRIO.

The Contravariant class is available in base 4.12.0.

Since: 0.1.13.0

Instance details

Defined in RIO.Prelude.Logger

Methods

contramap :: (a' -> a) -> GLogFunc a -> GLogFunc a'

(>$) :: b -> GLogFunc b -> GLogFunc a

Monoid (GLogFunc msg) Source #

mempty peforms no logging.

Since: 0.1.13.0

Instance details

Defined in RIO.Prelude.Logger

Methods

mempty :: GLogFunc msg #

mappend :: GLogFunc msg -> GLogFunc msg -> GLogFunc msg #

mconcat :: [GLogFunc msg] -> GLogFunc msg #

Semigroup (GLogFunc msg) Source #

Perform both sets of actions per log entry.

Since: 0.1.13.0

Instance details

Defined in RIO.Prelude.Logger

Methods

(<>) :: GLogFunc msg -> GLogFunc msg -> GLogFunc msg #

sconcat :: NonEmpty (GLogFunc msg) -> GLogFunc msg

stimes :: Integral b => b -> GLogFunc msg -> GLogFunc msg

HasGLogFunc (GLogFunc msg) Source #

Quick way to run a RIO that only has a logger in its environment.

Since: 0.1.13.0

Instance details

Defined in RIO.Prelude.Logger

Associated Types

type GMsg (GLogFunc msg)
Instance details Defined in RIO.Prelude.Logger type GMsg (GLogFunc msg) = msg

Methods

gLogFuncL :: Lens' (GLogFunc msg) (GLogFunc (GMsg (GLogFunc msg))) Source #

type GMsg (GLogFunc msg) Source #

Instance details

Defined in RIO.Prelude.Logger

type GMsg (GLogFunc msg) = msg

gLogFuncClassic :: (HasLogLevel msg, HasLogSource msg, Display msg) => LogFunc -> GLogFunc msg Source #

Make a GLogFunc via classic LogFunc. Use this if you'd like to log your generic data type via the classic RIO terminal logger.

Since: 0.1.13.0

mkGLogFunc :: (CallStack -> msg -> IO ()) -> GLogFunc msg Source #

Make a custom generic logger. With this you could, for example, write to a database or a log digestion service. For example:

mkGLogFunc (\stack msg -> send (Data.Aeson.encode (JsonLog stack msg)))

Since: 0.1.13.0

contramapMaybeGLogFunc :: (a -> Maybe b) -> GLogFunc b -> GLogFunc a Source #

A vesion of contramapMaybeGLogFunc which supports filering.

Since: 0.1.13.0

contramapGLogFunc :: (a -> b) -> GLogFunc b -> GLogFunc a Source #

A contramap. Use this to wrap sub-loggers via mapRIO.

If you are on base > 4.12.0, you can just use contramap.

Since: 0.1.13.0

class HasGLogFunc env where Source #

An app is capable of generic logging if it implements this.

Since: 0.1.13.0

Associated Types

type GMsg env Source #

Methods

gLogFuncL :: Lens' env (GLogFunc (GMsg env)) Source #

Instances

Instances details

HasGLogFunc (GLogFunc msg) Source #

Quick way to run a RIO that only has a logger in its environment.

Since: 0.1.13.0

Instance details

Defined in RIO.Prelude.Logger

Associated Types

type GMsg (GLogFunc msg)
Instance details Defined in RIO.Prelude.Logger type GMsg (GLogFunc msg) = msg

Methods

gLogFuncL :: Lens' (GLogFunc msg) (GLogFunc (GMsg (GLogFunc msg))) Source #

class HasLogLevel msg where Source #

Level, if any, of your logs. If unknown, use LogOther. Use for your generic log data types that want to sit inside the classic log framework.

Since: 0.1.13.0

Methods

getLogLevel :: msg -> LogLevel Source #

class HasLogSource msg where Source #

Source of a log. This can be whatever you want. Use for your generic log data types that want to sit inside the classic log framework.

Since: 0.1.13.0

Methods

getLogSource :: msg -> LogSource Source #

type family GMsg env Source #

Instances

Instances details

type GMsg (GLogFunc msg) Source #
Instance details Defined in RIO.Prelude.Logger type GMsg (GLogFunc msg) = msg

Display

class Display a where Source #

A typeclass for values which can be converted to a Utf8Builder. The intention of this typeclass is to provide a human-friendly display of the data.

Since: 0.1.0.0

Minimal complete definition

display | textDisplay

Methods

display :: a -> Utf8Builder Source #

textDisplay :: a -> Text Source #

Display data as Text, which will also be used for display if it is not overriden.

Since: 0.1.7.0

Instances

Instances details

Display SomeException Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: SomeException -> Utf8Builder Source # textDisplay :: SomeException -> Text Source #
Display IOException Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: IOException -> Utf8Builder Source # textDisplay :: IOException -> Text Source #
Display Int16 Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Int16 -> Utf8Builder Source # textDisplay :: Int16 -> Text Source #
Display Int32 Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Int32 -> Utf8Builder Source # textDisplay :: Int32 -> Text Source #
Display Int64 Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Int64 -> Utf8Builder Source # textDisplay :: Int64 -> Text Source #
Display Int8 Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Int8 -> Utf8Builder Source # textDisplay :: Int8 -> Text Source #
Display Word16 Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Word16 -> Utf8Builder Source # textDisplay :: Word16 -> Text Source #
Display Word32 Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Word32 -> Utf8Builder Source # textDisplay :: Word32 -> Text Source #
Display Word64 Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Word64 -> Utf8Builder Source # textDisplay :: Word64 -> Text Source #
Display Word8 Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Word8 -> Utf8Builder Source # textDisplay :: Word8 -> Text Source #
Display Utf8Builder Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Utf8Builder -> Utf8Builder Source # textDisplay :: Utf8Builder -> Text Source #
Display Text Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Text -> Utf8Builder Source # textDisplay :: Text -> Text Source #
Display Text Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Text -> Utf8Builder Source # textDisplay :: Text -> Text Source #
Display Integer Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Integer -> Utf8Builder Source # textDisplay :: Integer -> Text Source #
Display Char Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Char -> Utf8Builder Source # textDisplay :: Char -> Text Source #
Display Double Source #
Instance details Defined in RIO.Prelude.Display Methods display :: Double -> Utf8Builder Source # textDisplay :: Double -> Text Source #
Display Float Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Float -> Utf8Builder Source # textDisplay :: Float -> Text Source #
Display Int Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Int -> Utf8Builder Source # textDisplay :: Int -> Text Source #
Display Word Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Word -> Utf8Builder Source # textDisplay :: Word -> Text Source #
Display (ProcessConfig a b c) Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: ProcessConfig a b c -> Utf8Builder Source # textDisplay :: ProcessConfig a b c -> Text Source #

newtype Utf8Builder Source #

A builder of binary data, with the invariant that the underlying data is supposed to be UTF-8 encoded.

Since: 0.1.0.0

Constructors

Utf8Builder
Fields getUtf8Builder :: Builder

Instances

Instances details

Monoid Utf8Builder Source #
Instance details Defined in RIO.Prelude.Display Methods mempty :: Utf8Builder # mappend :: Utf8Builder -> Utf8Builder -> Utf8Builder # mconcat :: [Utf8Builder] -> Utf8Builder #
Semigroup Utf8Builder Source #
Instance details Defined in RIO.Prelude.Display Methods (<>) :: Utf8Builder -> Utf8Builder -> Utf8Builder # sconcat :: NonEmpty Utf8Builder -> Utf8Builder stimes :: Integral b => b -> Utf8Builder -> Utf8Builder
IsString Utf8Builder Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods fromString :: String -> Utf8Builder #
Display Utf8Builder Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: Utf8Builder -> Utf8Builder Source # textDisplay :: Utf8Builder -> Text Source #

displayShow :: Show a => a -> Utf8Builder Source #

Use the Show instance for a value to convert it to a Utf8Builder.

Since: 0.1.0.0

utf8BuilderToText :: Utf8Builder -> Text Source #

Convert a Utf8Builder value into a strict Text.

Since: 0.1.0.0

utf8BuilderToLazyText :: Utf8Builder -> Text Source #

Convert a Utf8Builder value into a lazy Text.

Since: 0.1.0.0

displayBytesUtf8 :: ByteString -> Utf8Builder Source #

Convert a ByteString into a Utf8Builder.

NOTE This function performs no checks to ensure that the data is, in fact, UTF8 encoded. If you provide non-UTF8 data, later functions may fail.

Since: 0.1.0.0

writeFileUtf8Builder :: MonadIO m => FilePath -> Utf8Builder -> m () Source #

Write the given Utf8Builder value to a file.

Since: 0.1.0.0

Optics

microlens-based Lenses, Traversals, etc.

type Lens s t a b = forall (f :: Type -> Type). Functor f => (a -> f b) -> s -> f t #

lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b #

view :: MonadReader s m => Getting a s a -> m a #

preview :: MonadReader s m => Getting (First a) s a -> m (Maybe a) #

type ASetter s t a b = (a -> Identity b) -> s -> Identity t #

type ASetter' s a = ASetter s s a a #

type Getting r s a = (a -> Const r a) -> s -> Const r s #

type Lens' s a = Lens s s a a #

type SimpleGetter s a = forall r. Getting r s a #

over :: ASetter s t a b -> (a -> b) -> s -> t #

set :: ASetter s t a b -> b -> s -> t #

sets :: ((a -> b) -> s -> t) -> ASetter s t a b #

to :: (s -> a) -> SimpleGetter s a #

(^.) :: s -> Getting a s a -> a #

(^?) :: s -> Getting (First a) s a -> Maybe a #

(^..) :: s -> Getting (Endo [a]) s a -> [a] #

(%~) :: ASetter s t a b -> (a -> b) -> s -> t #

(.~) :: ASetter s t a b -> b -> s -> t #

Concurrency

data ThreadId #

Instances

Instances details

NFData ThreadId
Instance details Defined in Control.DeepSeq Methods rnf :: ThreadId -> () #
Show ThreadId
Instance details Defined in GHC.Internal.Conc.Sync Methods showsPrec :: Int -> ThreadId -> ShowS show :: ThreadId -> String # showList :: [ThreadId] -> ShowS
Eq ThreadId
Instance details Defined in GHC.Internal.Conc.Sync Methods (==) :: ThreadId -> ThreadId -> Bool # (/=) :: ThreadId -> ThreadId -> Bool #
Ord ThreadId
Instance details Defined in GHC.Internal.Conc.Sync Methods compare :: ThreadId -> ThreadId -> Ordering # (<) :: ThreadId -> ThreadId -> Bool # (<=) :: ThreadId -> ThreadId -> Bool # (>) :: ThreadId -> ThreadId -> Bool # (>=) :: ThreadId -> ThreadId -> Bool # max :: ThreadId -> ThreadId -> ThreadId # min :: ThreadId -> ThreadId -> ThreadId #
Hashable ThreadId
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ThreadId -> Int hash :: ThreadId -> Int

myThreadId :: MonadIO m => m ThreadId #

isCurrentThreadBound :: MonadIO m => m Bool #

threadWaitRead :: MonadIO m => Fd -> m () #

threadWaitWrite :: MonadIO m => Fd -> m () #

threadDelay :: MonadIO m => Int -> m () #

yieldThread :: MonadIO m => m () Source #

Async

async :: MonadUnliftIO m => m a -> m (Async a) #

data Async a #

Instances

Instances details

Functor Async
Instance details Defined in Control.Concurrent.Async.Internal Methods fmap :: (a -> b) -> Async a -> Async b # (<$) :: a -> Async b -> Async a #
Eq (Async a)
Instance details Defined in Control.Concurrent.Async.Internal Methods (==) :: Async a -> Async a -> Bool # (/=) :: Async a -> Async a -> Bool #
Ord (Async a)
Instance details Defined in Control.Concurrent.Async.Internal Methods compare :: Async a -> Async a -> Ordering # (<) :: Async a -> Async a -> Bool # (<=) :: Async a -> Async a -> Bool # (>) :: Async a -> Async a -> Bool # (>=) :: Async a -> Async a -> Bool # max :: Async a -> Async a -> Async a # min :: Async a -> Async a -> Async a #
Hashable (Async a)
Instance details Defined in Control.Concurrent.Async.Internal Methods hashWithSalt :: Int -> Async a -> Int hash :: Async a -> Int

link :: MonadIO m => Async a -> m () #

link2 :: MonadIO m => Async a -> Async b -> m () #

data Conc (m :: Type -> Type) a #

Instances

Instances details

MonadUnliftIO m => Alternative (Conc m)
Instance details Defined in UnliftIO.Internals.Async Methods empty :: Conc m a (<\|>) :: Conc m a -> Conc m a -> Conc m a # some :: Conc m a -> Conc m [a] # many :: Conc m a -> Conc m [a] #
MonadUnliftIO m => Applicative (Conc m)
Instance details Defined in UnliftIO.Internals.Async Methods pure :: a -> Conc m a # (<>) :: Conc m (a -> b) -> Conc m a -> Conc m b # liftA2 :: (a -> b -> c) -> Conc m a -> Conc m b -> Conc m c # (>) :: Conc m a -> Conc m b -> Conc m b # (<*) :: Conc m a -> Conc m b -> Conc m a #
Functor m => Functor (Conc m)
Instance details Defined in UnliftIO.Internals.Async Methods fmap :: (a -> b) -> Conc m a -> Conc m b # (<$) :: a -> Conc m b -> Conc m a #
(Monoid a, MonadUnliftIO m) => Monoid (Conc m a)
Instance details Defined in UnliftIO.Internals.Async Methods mempty :: Conc m a # mappend :: Conc m a -> Conc m a -> Conc m a # mconcat :: [Conc m a] -> Conc m a #
(MonadUnliftIO m, Semigroup a) => Semigroup (Conc m a)
Instance details Defined in UnliftIO.Internals.Async Methods (<>) :: Conc m a -> Conc m a -> Conc m a # sconcat :: NonEmpty (Conc m a) -> Conc m a stimes :: Integral b => b -> Conc m a -> Conc m a

data ConcException #

Constructors

EmptyWithNoAlternative

Instances

Instances details

Exception ConcException

Instance details

Defined in UnliftIO.Internals.Async

Methods

toException :: ConcException -> SomeException #

fromException :: SomeException -> Maybe ConcException #

displayException :: ConcException -> String #

backtraceDesired :: ConcException -> Bool #

Generic ConcException

Instance details

Defined in UnliftIO.Internals.Async

Associated Types

type Rep ConcException
Instance details Defined in UnliftIO.Internals.Async type Rep ConcException = D1 ('MetaData "ConcException" "UnliftIO.Internals.Async" "unliftio-0.2.25.1-CrJy6qeOPxYiFqvgF7Ii0" 'False) (C1 ('MetaCons "EmptyWithNoAlternative" 'PrefixI 'False) (U1 :: Type -> Type))

Methods

from :: ConcException -> Rep ConcException x

to :: Rep ConcException x -> ConcException

Show ConcException

Instance details

Defined in UnliftIO.Internals.Async

Methods

showsPrec :: Int -> ConcException -> ShowS

show :: ConcException -> String #

showList :: [ConcException] -> ShowS

Eq ConcException

Instance details

Defined in UnliftIO.Internals.Async

Methods

(==) :: ConcException -> ConcException -> Bool #

(/=) :: ConcException -> ConcException -> Bool #

Ord ConcException

Instance details

Defined in UnliftIO.Internals.Async

Methods

compare :: ConcException -> ConcException -> Ordering #

(<) :: ConcException -> ConcException -> Bool #

(<=) :: ConcException -> ConcException -> Bool #

(>) :: ConcException -> ConcException -> Bool #

(>=) :: ConcException -> ConcException -> Bool #

max :: ConcException -> ConcException -> ConcException #

min :: ConcException -> ConcException -> ConcException #

type Rep ConcException

Instance details

Defined in UnliftIO.Internals.Async

type Rep ConcException = D1 ('MetaData "ConcException" "UnliftIO.Internals.Async" "unliftio-0.2.25.1-CrJy6qeOPxYiFqvgF7Ii0" 'False) (C1 ('MetaCons "EmptyWithNoAlternative" 'PrefixI 'False) (U1 :: Type -> Type))

newtype Concurrently (m :: Type -> Type) a #

Constructors

Concurrently
Fields runConcurrently :: m a

Instances

Instances details

MonadUnliftIO m => Alternative (Concurrently m)
Instance details Defined in UnliftIO.Internals.Async Methods empty :: Concurrently m a (<\|>) :: Concurrently m a -> Concurrently m a -> Concurrently m a # some :: Concurrently m a -> Concurrently m [a] # many :: Concurrently m a -> Concurrently m [a] #
MonadUnliftIO m => Applicative (Concurrently m)
Instance details Defined in UnliftIO.Internals.Async Methods pure :: a -> Concurrently m a # (<>) :: Concurrently m (a -> b) -> Concurrently m a -> Concurrently m b # liftA2 :: (a -> b -> c) -> Concurrently m a -> Concurrently m b -> Concurrently m c # (>) :: Concurrently m a -> Concurrently m b -> Concurrently m b # (<*) :: Concurrently m a -> Concurrently m b -> Concurrently m a #
Monad m => Functor (Concurrently m)
Instance details Defined in UnliftIO.Internals.Async Methods fmap :: (a -> b) -> Concurrently m a -> Concurrently m b # (<$) :: a -> Concurrently m b -> Concurrently m a #
(Semigroup a, Monoid a, MonadUnliftIO m) => Monoid (Concurrently m a)
Instance details Defined in UnliftIO.Internals.Async Methods mempty :: Concurrently m a # mappend :: Concurrently m a -> Concurrently m a -> Concurrently m a # mconcat :: [Concurrently m a] -> Concurrently m a #
(MonadUnliftIO m, Semigroup a) => Semigroup (Concurrently m a)
Instance details Defined in UnliftIO.Internals.Async Methods (<>) :: Concurrently m a -> Concurrently m a -> Concurrently m a # sconcat :: NonEmpty (Concurrently m a) -> Concurrently m a stimes :: Integral b => b -> Concurrently m a -> Concurrently m a

asyncBound :: MonadUnliftIO m => m a -> m (Async a) #

asyncOn :: MonadUnliftIO m => Int -> m a -> m (Async a) #

asyncOnWithUnmask :: MonadUnliftIO m => Int -> ((forall b. m b -> m b) -> m a) -> m (Async a) #

asyncWithUnmask :: MonadUnliftIO m => ((forall b. m b -> m b) -> m a) -> m (Async a) #

cancel :: MonadIO m => Async a -> m () #

cancelWith :: (Exception e, MonadIO m) => Async a -> e -> m () #

conc :: m a -> Conc m a #

concurrently :: MonadUnliftIO m => m a -> m b -> m (a, b) #

concurrently_ :: MonadUnliftIO m => m a -> m b -> m () #

forConcurrently :: (MonadUnliftIO m, Traversable t) => t a -> (a -> m b) -> m (t b) #

forConcurrently_ :: (MonadUnliftIO m, Foldable f) => f a -> (a -> m b) -> m () #

mapConcurrently :: (MonadUnliftIO m, Traversable t) => (a -> m b) -> t a -> m (t b) #

mapConcurrently_ :: (MonadUnliftIO m, Foldable f) => (a -> m b) -> f a -> m () #

poll :: MonadIO m => Async a -> m (Maybe (Either SomeException a)) #

pooledForConcurrently :: (MonadUnliftIO m, Traversable t) => t a -> (a -> m b) -> m (t b) #

pooledForConcurrentlyN :: (MonadUnliftIO m, Traversable t) => Int -> t a -> (a -> m b) -> m (t b) #

pooledForConcurrentlyN_ :: (MonadUnliftIO m, Foldable t) => Int -> t a -> (a -> m b) -> m () #

pooledForConcurrently_ :: (MonadUnliftIO m, Foldable f) => f a -> (a -> m b) -> m () #

pooledMapConcurrently :: (MonadUnliftIO m, Traversable t) => (a -> m b) -> t a -> m (t b) #

pooledMapConcurrentlyN :: (MonadUnliftIO m, Traversable t) => Int -> (a -> m b) -> t a -> m (t b) #

pooledMapConcurrentlyN_ :: (MonadUnliftIO m, Foldable f) => Int -> (a -> m b) -> f a -> m () #

pooledMapConcurrently_ :: (MonadUnliftIO m, Foldable f) => (a -> m b) -> f a -> m () #

pooledReplicateConcurrently :: MonadUnliftIO m => Int -> m a -> m [a] #

pooledReplicateConcurrentlyN :: MonadUnliftIO m => Int -> Int -> m a -> m [a] #

pooledReplicateConcurrentlyN_ :: MonadUnliftIO m => Int -> Int -> m a -> m () #

pooledReplicateConcurrently_ :: MonadUnliftIO m => Int -> m a -> m () #

race :: MonadUnliftIO m => m a -> m b -> m (Either a b) #

race_ :: MonadUnliftIO m => m a -> m b -> m () #

replicateConcurrently :: MonadUnliftIO f => Int -> f a -> f [a] #

replicateConcurrently_ :: (Applicative m, MonadUnliftIO m) => Int -> m a -> m () #

runConc :: MonadUnliftIO m => Conc m a -> m a #

uninterruptibleCancel :: MonadIO m => Async a -> m () #

wait :: MonadIO m => Async a -> m a #

waitAny :: MonadIO m => [Async a] -> m (Async a, a) #

waitAnyCancel :: MonadIO m => [Async a] -> m (Async a, a) #

waitAnyCatch :: MonadIO m => [Async a] -> m (Async a, Either SomeException a) #

waitAnyCatchCancel :: MonadIO m => [Async a] -> m (Async a, Either SomeException a) #

waitBoth :: MonadIO m => Async a -> Async b -> m (a, b) #

waitCatch :: MonadIO m => Async a -> m (Either SomeException a) #

waitEither :: MonadIO m => Async a -> Async b -> m (Either a b) #

waitEitherCancel :: MonadIO m => Async a -> Async b -> m (Either a b) #

waitEitherCatch :: MonadIO m => Async a -> Async b -> m (Either (Either SomeException a) (Either SomeException b)) #

waitEitherCatchCancel :: MonadIO m => Async a -> Async b -> m (Either (Either SomeException a) (Either SomeException b)) #

waitEither_ :: MonadIO m => Async a -> Async b -> m () #

withAsync :: MonadUnliftIO m => m a -> (Async a -> m b) -> m b #

withAsyncBound :: MonadUnliftIO m => m a -> (Async a -> m b) -> m b #

withAsyncOn :: MonadUnliftIO m => Int -> m a -> (Async a -> m b) -> m b #

withAsyncOnWithUnmask :: MonadUnliftIO m => Int -> ((forall c. m c -> m c) -> m a) -> (Async a -> m b) -> m b #

withAsyncWithUnmask :: MonadUnliftIO m => ((forall c. m c -> m c) -> m a) -> (Async a -> m b) -> m b #

pollSTM :: Async a -> STM (Maybe (Either SomeException a)) #

waitAnyCatchSTM :: [Async a] -> STM (Async a, Either SomeException a) #

waitAnySTM :: [Async a] -> STM (Async a, a) #

waitBothSTM :: Async a -> Async b -> STM (a, b) #

waitCatchSTM :: Async a -> STM (Either SomeException a) #

waitEitherCatchSTM :: Async a -> Async b -> STM (Either (Either SomeException a) (Either SomeException b)) #

waitEitherSTM :: Async a -> Async b -> STM (Either a b) #

waitEitherSTM_ :: Async a -> Async b -> STM () #

waitSTM :: Async a -> STM a #

data AsyncCancelled #

Constructors

AsyncCancelled

Instances

Instances details

Exception AsyncCancelled
Instance details Defined in Control.Concurrent.Async.Internal Methods toException :: AsyncCancelled -> SomeException # fromException :: SomeException -> Maybe AsyncCancelled # displayException :: AsyncCancelled -> String # backtraceDesired :: AsyncCancelled -> Bool #
Show AsyncCancelled
Instance details Defined in Control.Concurrent.Async.Internal Methods showsPrec :: Int -> AsyncCancelled -> ShowS show :: AsyncCancelled -> String # showList :: [AsyncCancelled] -> ShowS
Eq AsyncCancelled
Instance details Defined in Control.Concurrent.Async.Internal Methods (==) :: AsyncCancelled -> AsyncCancelled -> Bool # (/=) :: AsyncCancelled -> AsyncCancelled -> Bool #

STM

data STM a #

Instances

Instances details

MonadCatch STM
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => STM a -> (e -> STM a) -> STM a
MonadThrow STM
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> STM a #
Alternative STM
Instance details Defined in GHC.Internal.Conc.Sync Methods empty :: STM a (<\|>) :: STM a -> STM a -> STM a # some :: STM a -> STM [a] # many :: STM a -> STM [a] #
Applicative STM
Instance details Defined in GHC.Internal.Conc.Sync Methods pure :: a -> STM a # (<>) :: STM (a -> b) -> STM a -> STM b # liftA2 :: (a -> b -> c) -> STM a -> STM b -> STM c # (>) :: STM a -> STM b -> STM b # (<*) :: STM a -> STM b -> STM a #
Functor STM
Instance details Defined in GHC.Internal.Conc.Sync Methods fmap :: (a -> b) -> STM a -> STM b # (<$) :: a -> STM b -> STM a #
Monad STM
Instance details Defined in GHC.Internal.Conc.Sync Methods (>>=) :: STM a -> (a -> STM b) -> STM b # (>>) :: STM a -> STM b -> STM b # return :: a -> STM a #
MonadPlus STM
Instance details Defined in GHC.Internal.Conc.Sync Methods mzero :: STM a # mplus :: STM a -> STM a -> STM a #
MonadFix STM
Instance details Defined in Control.Monad.STM Methods mfix :: (a -> STM a) -> STM a
Monoid a => Monoid (STM a)
Instance details Defined in GHC.Internal.Conc.Sync Methods mempty :: STM a # mappend :: STM a -> STM a -> STM a # mconcat :: [STM a] -> STM a #
Semigroup a => Semigroup (STM a)
Instance details Defined in GHC.Internal.Conc.Sync Methods (<>) :: STM a -> STM a -> STM a # sconcat :: NonEmpty (STM a) -> STM a stimes :: Integral b => b -> STM a -> STM a

atomically :: MonadIO m => STM a -> m a #

orElse :: STM a -> STM a -> STM a #

checkSTM :: Bool -> STM () #

mkWeakTMVar :: MonadUnliftIO m => TMVar a -> m () -> m (Weak (TMVar a)) #

mkWeakTVar :: MonadUnliftIO m => TVar a -> m () -> m (Weak (TVar a)) #

newBroadcastTChanIO :: MonadIO m => m (TChan a) #

newEmptyTMVarIO :: MonadIO m => m (TMVar a) #

newTBQueueIO :: MonadIO m => Natural -> m (TBQueue a) #

newTChanIO :: MonadIO m => m (TChan a) #

newTMVarIO :: MonadIO m => a -> m (TMVar a) #

newTQueueIO :: MonadIO m => m (TQueue a) #

newTVarIO :: MonadIO m => a -> m (TVar a) #

readTVarIO :: MonadIO m => TVar a -> m a #

registerDelay :: MonadIO m => Int -> m (TVar Bool) #

retrySTM :: STM a #

newTVar :: a -> STM (TVar a) #

readTVar :: TVar a -> STM a #

writeTVar :: TVar a -> a -> STM () #

flushTBQueue :: TBQueue a -> STM [a] #

isEmptyTBQueue :: TBQueue a -> STM Bool #

isFullTBQueue :: TBQueue a -> STM Bool #

lengthTBQueue :: TBQueue a -> STM Natural #

newTBQueue :: Natural -> STM (TBQueue a) #

peekTBQueue :: TBQueue a -> STM a #

readTBQueue :: TBQueue a -> STM a #

tryPeekTBQueue :: TBQueue a -> STM (Maybe a) #

tryReadTBQueue :: TBQueue a -> STM (Maybe a) #

unGetTBQueue :: TBQueue a -> a -> STM () #

writeTBQueue :: TBQueue a -> a -> STM () #

cloneTChan :: TChan a -> STM (TChan a) #

dupTChan :: TChan a -> STM (TChan a) #

isEmptyTChan :: TChan a -> STM Bool #

newBroadcastTChan :: STM (TChan a) #

newTChan :: STM (TChan a) #

peekTChan :: TChan a -> STM a #

readTChan :: TChan a -> STM a #

tryPeekTChan :: TChan a -> STM (Maybe a) #

tryReadTChan :: TChan a -> STM (Maybe a) #

unGetTChan :: TChan a -> a -> STM () #

writeTChan :: TChan a -> a -> STM () #

isEmptyTMVar :: TMVar a -> STM Bool #

newEmptyTMVar :: STM (TMVar a) #

newTMVar :: a -> STM (TMVar a) #

putTMVar :: TMVar a -> a -> STM () #

readTMVar :: TMVar a -> STM a #

swapTMVar :: TMVar a -> a -> STM a #

takeTMVar :: TMVar a -> STM a #

tryPutTMVar :: TMVar a -> a -> STM Bool #

tryReadTMVar :: TMVar a -> STM (Maybe a) #

tryTakeTMVar :: TMVar a -> STM (Maybe a) #

writeTMVar :: TMVar a -> a -> STM () #

isEmptyTQueue :: TQueue a -> STM Bool #

newTQueue :: STM (TQueue a) #

peekTQueue :: TQueue a -> STM a #

readTQueue :: TQueue a -> STM a #

tryPeekTQueue :: TQueue a -> STM (Maybe a) #

tryReadTQueue :: TQueue a -> STM (Maybe a) #

unGetTQueue :: TQueue a -> a -> STM () #

writeTQueue :: TQueue a -> a -> STM () #

modifyTVar :: TVar a -> (a -> a) -> STM () #

modifyTVar' :: TVar a -> (a -> a) -> STM () #

stateTVar :: TVar s -> (s -> (a, s)) -> STM a #

swapTVar :: TVar a -> a -> STM a #

data TVar a #

Instances

Instances details

Eq (TVar a)
Instance details Defined in GHC.Internal.Conc.Sync Methods (==) :: TVar a -> TVar a -> Bool # (/=) :: TVar a -> TVar a -> Bool #

data TBQueue a #

Instances

Instances details

Eq (TBQueue a)
Instance details Defined in Control.Concurrent.STM.TBQueue Methods (==) :: TBQueue a -> TBQueue a -> Bool # (/=) :: TBQueue a -> TBQueue a -> Bool #

data TChan a #

Instances

Instances details

Eq (TChan a)
Instance details Defined in Control.Concurrent.STM.TChan Methods (==) :: TChan a -> TChan a -> Bool # (/=) :: TChan a -> TChan a -> Bool #

data TMVar a #

Instances

Instances details

Eq (TMVar a)
Instance details Defined in Control.Concurrent.STM.TMVar Methods (==) :: TMVar a -> TMVar a -> Bool # (/=) :: TMVar a -> TMVar a -> Bool #

data TQueue a #

Instances

Instances details

Eq (TQueue a)
Instance details Defined in Control.Concurrent.STM.TQueue Methods (==) :: TQueue a -> TQueue a -> Bool # (/=) :: TQueue a -> TQueue a -> Bool #

Chan

data Chan a #

Instances

Instances details

Eq (Chan a)
Instance details Defined in Control.Concurrent.Chan Methods (==) :: Chan a -> Chan a -> Bool # (/=) :: Chan a -> Chan a -> Bool #

dupChan :: MonadIO m => Chan a -> m (Chan a) #

getChanContents :: MonadIO m => Chan a -> m [a] #

newChan :: MonadIO m => m (Chan a) #

readChan :: MonadIO m => Chan a -> m a #

writeChan :: MonadIO m => Chan a -> a -> m () #

writeList2Chan :: MonadIO m => Chan a -> [a] -> m () #

Timeout

timeout :: MonadUnliftIO m => Int -> m a -> m (Maybe a) #

Exceptions

class (Typeable e, Show e) => Exception e where #

Minimal complete definition

Nothing

Methods

toException :: e -> SomeException #

fromException :: SomeException -> Maybe e #

displayException :: e -> String #

backtraceDesired :: e -> Bool #

Instances

Instances details

Exception AsyncCancelled
Instance details Defined in Control.Concurrent.Async.Internal Methods toException :: AsyncCancelled -> SomeException # fromException :: SomeException -> Maybe AsyncCancelled # displayException :: AsyncCancelled -> String # backtraceDesired :: AsyncCancelled -> Bool #
Exception ExceptionInLinkedThread
Instance details Defined in Control.Concurrent.Async.Internal Methods toException :: ExceptionInLinkedThread -> SomeException # fromException :: SomeException -> Maybe ExceptionInLinkedThread # displayException :: ExceptionInLinkedThread -> String # backtraceDesired :: ExceptionInLinkedThread -> Bool #
Exception Timeout
Instance details Defined in System.Timeout Methods toException :: Timeout -> SomeException # fromException :: SomeException -> Maybe Timeout # displayException :: Timeout -> String # backtraceDesired :: Timeout -> Bool #
Exception SizeOverflowException
Instance details Defined in Data.ByteString.Internal.Type Methods toException :: SizeOverflowException -> SomeException # fromException :: SomeException -> Maybe SizeOverflowException # displayException :: SizeOverflowException -> String # backtraceDesired :: SizeOverflowException -> Bool #
Exception Void
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: Void -> SomeException # fromException :: SomeException -> Maybe Void # displayException :: Void -> String # backtraceDesired :: Void -> Bool #
Exception ArithException
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: ArithException -> SomeException # fromException :: SomeException -> Maybe ArithException # displayException :: ArithException -> String # backtraceDesired :: ArithException -> Bool #
Exception SomeException
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String # backtraceDesired :: SomeException -> Bool #
Exception AllocationLimitExceeded
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: AllocationLimitExceeded -> SomeException # fromException :: SomeException -> Maybe AllocationLimitExceeded # displayException :: AllocationLimitExceeded -> String # backtraceDesired :: AllocationLimitExceeded -> Bool #
Exception ArrayException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: ArrayException -> SomeException # fromException :: SomeException -> Maybe ArrayException # displayException :: ArrayException -> String # backtraceDesired :: ArrayException -> Bool #
Exception AssertionFailed
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: AssertionFailed -> SomeException # fromException :: SomeException -> Maybe AssertionFailed # displayException :: AssertionFailed -> String # backtraceDesired :: AssertionFailed -> Bool #
Exception AsyncException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: AsyncException -> SomeException # fromException :: SomeException -> Maybe AsyncException # displayException :: AsyncException -> String # backtraceDesired :: AsyncException -> Bool #
Exception BlockedIndefinitelyOnMVar
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: BlockedIndefinitelyOnMVar -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar # displayException :: BlockedIndefinitelyOnMVar -> String # backtraceDesired :: BlockedIndefinitelyOnMVar -> Bool #
Exception BlockedIndefinitelyOnSTM
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: BlockedIndefinitelyOnSTM -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM # displayException :: BlockedIndefinitelyOnSTM -> String # backtraceDesired :: BlockedIndefinitelyOnSTM -> Bool #
Exception CompactionFailed
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: CompactionFailed -> SomeException # fromException :: SomeException -> Maybe CompactionFailed # displayException :: CompactionFailed -> String # backtraceDesired :: CompactionFailed -> Bool #
Exception Deadlock
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: Deadlock -> SomeException # fromException :: SomeException -> Maybe Deadlock # displayException :: Deadlock -> String # backtraceDesired :: Deadlock -> Bool #
Exception ExitCode
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: ExitCode -> SomeException # fromException :: SomeException -> Maybe ExitCode # displayException :: ExitCode -> String # backtraceDesired :: ExitCode -> Bool #
Exception FixIOException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: FixIOException -> SomeException # fromException :: SomeException -> Maybe FixIOException # displayException :: FixIOException -> String # backtraceDesired :: FixIOException -> Bool #
Exception IOException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: IOException -> SomeException # fromException :: SomeException -> Maybe IOException # displayException :: IOException -> String # backtraceDesired :: IOException -> Bool #
Exception SomeAsyncException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: SomeAsyncException -> SomeException # fromException :: SomeException -> Maybe SomeAsyncException # displayException :: SomeAsyncException -> String # backtraceDesired :: SomeAsyncException -> Bool #
Exception ProcessException Source #
Instance details Defined in RIO.Process Methods toException :: ProcessException -> SomeException # fromException :: SomeException -> Maybe ProcessException # displayException :: ProcessException -> String # backtraceDesired :: ProcessException -> Bool #
Exception AsyncExceptionWrapper
Instance details Defined in Control.Exception.Safe Methods toException :: AsyncExceptionWrapper -> SomeException # fromException :: SomeException -> Maybe AsyncExceptionWrapper # displayException :: AsyncExceptionWrapper -> String # backtraceDesired :: AsyncExceptionWrapper -> Bool #
Exception StringException
Instance details Defined in Control.Exception.Safe Methods toException :: StringException -> SomeException # fromException :: SomeException -> Maybe StringException # displayException :: StringException -> String # backtraceDesired :: StringException -> Bool #
Exception SyncExceptionWrapper
Instance details Defined in Control.Exception.Safe Methods toException :: SyncExceptionWrapper -> SomeException # fromException :: SomeException -> Maybe SyncExceptionWrapper # displayException :: SyncExceptionWrapper -> String # backtraceDesired :: SyncExceptionWrapper -> Bool #
Exception UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods toException :: UnicodeException -> SomeException # fromException :: SomeException -> Maybe UnicodeException # displayException :: UnicodeException -> String # backtraceDesired :: UnicodeException -> Bool #
Exception ByteStringOutputException
Instance details Defined in System.Process.Typed.Internal Methods toException :: ByteStringOutputException -> SomeException # fromException :: SomeException -> Maybe ByteStringOutputException # displayException :: ByteStringOutputException -> String # backtraceDesired :: ByteStringOutputException -> Bool #
Exception ExitCodeException
Instance details Defined in System.Process.Typed.Internal Methods toException :: ExitCodeException -> SomeException # fromException :: SomeException -> Maybe ExitCodeException # displayException :: ExitCodeException -> String # backtraceDesired :: ExitCodeException -> Bool #
Exception StringException
Instance details Defined in UnliftIO.Exception Methods toException :: StringException -> SomeException # fromException :: SomeException -> Maybe StringException # displayException :: StringException -> String # backtraceDesired :: StringException -> Bool #
Exception ConcException
Instance details Defined in UnliftIO.Internals.Async Methods toException :: ConcException -> SomeException # fromException :: SomeException -> Maybe ConcException # displayException :: ConcException -> String # backtraceDesired :: ConcException -> Bool #
Exception a => Exception (ExceptionWithContext a)
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: ExceptionWithContext a -> SomeException # fromException :: SomeException -> Maybe (ExceptionWithContext a) # displayException :: ExceptionWithContext a -> String # backtraceDesired :: ExceptionWithContext a -> Bool #
Exception e => Exception (NoBacktrace e)
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: NoBacktrace e -> SomeException # fromException :: SomeException -> Maybe (NoBacktrace e) # displayException :: NoBacktrace e -> String # backtraceDesired :: NoBacktrace e -> Bool #

assert :: Bool -> a -> a #

class Typeable (a :: k) #

Minimal complete definition

typeRep#

data SomeException #

Constructors

(Exception e, HasExceptionContext) => SomeException e

Instances

Instances details

Exception SomeException
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String # backtraceDesired :: SomeException -> Bool #
Show SomeException
Instance details Defined in GHC.Internal.Exception.Type Methods showsPrec :: Int -> SomeException -> ShowS show :: SomeException -> String # showList :: [SomeException] -> ShowS
Display SomeException Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: SomeException -> Utf8Builder Source # textDisplay :: SomeException -> Text Source #

data IOException #

Instances

Instances details

Exception IOException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: IOException -> SomeException # fromException :: SomeException -> Maybe IOException # displayException :: IOException -> String # backtraceDesired :: IOException -> Bool #
Show IOException
Instance details Defined in GHC.Internal.IO.Exception Methods showsPrec :: Int -> IOException -> ShowS show :: IOException -> String # showList :: [IOException] -> ShowS
Eq IOException
Instance details Defined in GHC.Internal.IO.Exception Methods (==) :: IOException -> IOException -> Bool # (/=) :: IOException -> IOException -> Bool #
Display IOException Source #	Since: 0.1.0.0
Instance details Defined in RIO.Prelude.Display Methods display :: IOException -> Utf8Builder Source # textDisplay :: IOException -> Text Source #
MonadError IOException IO
Instance details Defined in Control.Monad.Error.Class Methods throwError :: IOException -> IO a catchError :: IO a -> (IOException -> IO a) -> IO a

throwIO :: (MonadIO m, Exception e) => e -> m a #

bracket :: MonadUnliftIO m => m a -> (a -> m b) -> (a -> m c) -> m c #

catch :: (MonadUnliftIO m, Exception e) => m a -> (e -> m a) -> m a #

catchAny :: MonadUnliftIO m => m a -> (SomeException -> m a) -> m a #

evaluate :: MonadIO m => a -> m a #

finally :: MonadUnliftIO m => m a -> m b -> m a #

mask :: MonadUnliftIO m => ((forall a. m a -> m a) -> m b) -> m b #

mask_ :: MonadUnliftIO m => m a -> m a #

onException :: MonadUnliftIO m => m a -> m b -> m a #

uninterruptibleMask :: MonadUnliftIO m => ((forall a. m a -> m a) -> m b) -> m b #

uninterruptibleMask_ :: MonadUnliftIO m => m a -> m a #

data StringException #

Constructors

StringException String CallStack

Instances

Instances details

Exception StringException
Instance details Defined in UnliftIO.Exception Methods toException :: StringException -> SomeException # fromException :: SomeException -> Maybe StringException # displayException :: StringException -> String # backtraceDesired :: StringException -> Bool #
Show StringException
Instance details Defined in UnliftIO.Exception Methods showsPrec :: Int -> StringException -> ShowS show :: StringException -> String # showList :: [StringException] -> ShowS
Eq StringException
Instance details Defined in UnliftIO.Exception Methods (==) :: StringException -> StringException -> Bool # (/=) :: StringException -> StringException -> Bool #

bracketOnError :: MonadUnliftIO m => m a -> (a -> m b) -> (a -> m c) -> m c #

bracketOnError_ :: MonadUnliftIO m => m a -> m b -> m c -> m c #

bracket_ :: MonadUnliftIO m => m a -> m b -> m c -> m c #

catchAnyDeep :: (NFData a, MonadUnliftIO m) => m a -> (SomeException -> m a) -> m a #

catchDeep :: (MonadUnliftIO m, Exception e, NFData a) => m a -> (e -> m a) -> m a #

catchIO :: MonadUnliftIO m => m a -> (IOException -> m a) -> m a #

catchJust :: (MonadUnliftIO m, Exception e) => (e -> Maybe b) -> m a -> (b -> m a) -> m a #

catchSyncOrAsync :: (MonadUnliftIO m, Exception e) => m a -> (e -> m a) -> m a #

catches :: MonadUnliftIO m => m a -> [Handler m a] -> m a #

catchesDeep :: (MonadUnliftIO m, NFData a) => m a -> [Handler m a] -> m a #

evaluateDeep :: (MonadIO m, NFData a) => a -> m a #

fromEither :: (Exception e, MonadIO m) => Either e a -> m a #

fromEitherIO :: (Exception e, MonadIO m) => IO (Either e a) -> m a #

fromEitherM :: (Exception e, MonadIO m) => m (Either e a) -> m a #

fromExceptionUnwrap :: Exception e => SomeException -> Maybe e #

handle :: (MonadUnliftIO m, Exception e) => (e -> m a) -> m a -> m a #

handleAny :: MonadUnliftIO m => (SomeException -> m a) -> m a -> m a #

handleAnyDeep :: (MonadUnliftIO m, NFData a) => (SomeException -> m a) -> m a -> m a #

handleDeep :: (MonadUnliftIO m, Exception e, NFData a) => (e -> m a) -> m a -> m a #

handleIO :: MonadUnliftIO m => (IOException -> m a) -> m a -> m a #

handleJust :: (MonadUnliftIO m, Exception e) => (e -> Maybe b) -> (b -> m a) -> m a -> m a #

handleSyncOrAsync :: (MonadUnliftIO m, Exception e) => (e -> m a) -> m a -> m a #

impureThrow :: Exception e => e -> a #

isAsyncException :: Exception e => e -> Bool #

isSyncException :: Exception e => e -> Bool #

mapExceptionM :: (Exception e1, Exception e2, MonadUnliftIO m) => (e1 -> e2) -> m a -> m a #

pureTry :: a -> Either SomeException a #

pureTryDeep :: NFData a => a -> Either SomeException a #

stringException :: HasCallStack => String -> StringException #

throwString :: (MonadIO m, HasCallStack) => String -> m a #

throwTo :: (Exception e, MonadIO m) => ThreadId -> e -> m () #

toAsyncException :: Exception e => e -> SomeException #

toSyncException :: Exception e => e -> SomeException #

try :: (MonadUnliftIO m, Exception e) => m a -> m (Either e a) #

tryAny :: MonadUnliftIO m => m a -> m (Either SomeException a) #

tryAnyDeep :: (MonadUnliftIO m, NFData a) => m a -> m (Either SomeException a) #

tryDeep :: (MonadUnliftIO m, Exception e, NFData a) => m a -> m (Either e a) #

tryIO :: MonadUnliftIO m => m a -> m (Either IOException a) #

tryJust :: (MonadUnliftIO m, Exception e) => (e -> Maybe b) -> m a -> m (Either b a) #

trySyncOrAsync :: (MonadUnliftIO m, Exception e) => m a -> m (Either e a) #

withException :: (MonadUnliftIO m, Exception e) => m a -> (e -> m b) -> m a #

asyncExceptionFromException :: Exception e => SomeException -> Maybe e #

asyncExceptionToException :: Exception e => e -> SomeException #

data Handler (m :: Type -> Type) a #

Constructors

Exception e => Handler (e -> m a)

Instances

Instances details

Monad m => Functor (Handler m)
Instance details Defined in Control.Monad.Catch Methods fmap :: (a -> b) -> Handler m a -> Handler m b # (<$) :: a -> Handler m b -> Handler m a #

data SomeAsyncException #

Constructors

Exception e => SomeAsyncException e

Instances

Instances details

Exception SomeAsyncException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: SomeAsyncException -> SomeException # fromException :: SomeException -> Maybe SomeAsyncException # displayException :: SomeAsyncException -> String # backtraceDesired :: SomeAsyncException -> Bool #
Show SomeAsyncException
Instance details Defined in GHC.Internal.IO.Exception Methods showsPrec :: Int -> SomeAsyncException -> ShowS show :: SomeAsyncException -> String # showList :: [SomeAsyncException] -> ShowS

data AsyncExceptionWrapper #

Constructors

Exception e => AsyncExceptionWrapper e

Instances

Instances details

Exception AsyncExceptionWrapper
Instance details Defined in Control.Exception.Safe Methods toException :: AsyncExceptionWrapper -> SomeException # fromException :: SomeException -> Maybe AsyncExceptionWrapper # displayException :: AsyncExceptionWrapper -> String # backtraceDesired :: AsyncExceptionWrapper -> Bool #
Show AsyncExceptionWrapper
Instance details Defined in Control.Exception.Safe Methods showsPrec :: Int -> AsyncExceptionWrapper -> ShowS show :: AsyncExceptionWrapper -> String # showList :: [AsyncExceptionWrapper] -> ShowS

data SyncExceptionWrapper #

Constructors

Exception e => SyncExceptionWrapper e

Instances

Instances details

Exception SyncExceptionWrapper
Instance details Defined in Control.Exception.Safe Methods toException :: SyncExceptionWrapper -> SomeException # fromException :: SomeException -> Maybe SyncExceptionWrapper # displayException :: SyncExceptionWrapper -> String # backtraceDesired :: SyncExceptionWrapper -> Bool #
Show SyncExceptionWrapper
Instance details Defined in Control.Exception.Safe Methods showsPrec :: Int -> SyncExceptionWrapper -> ShowS show :: SyncExceptionWrapper -> String # showList :: [SyncExceptionWrapper] -> ShowS

Re-exported from Control.Monad.Catch:

throwM :: (MonadThrow m, HasCallStack, Exception e) => e -> m a #

Files and handles

withBinaryFile :: MonadUnliftIO m => FilePath -> IOMode -> (Handle -> m a) -> m a #

data Handle #

Instances

Instances details

Show Handle
Instance details Defined in GHC.Internal.IO.Handle.Types Methods showsPrec :: Int -> Handle -> ShowS show :: Handle -> String # showList :: [Handle] -> ShowS
Eq Handle
Instance details Defined in GHC.Internal.IO.Handle.Types Methods (==) :: Handle -> Handle -> Bool # (/=) :: Handle -> Handle -> Bool #

data IOMode #

Constructors

ReadMode
WriteMode
AppendMode
ReadWriteMode

Instances

Instances details

Enum IOMode
Instance details Defined in GHC.Internal.IO.IOMode Methods succ :: IOMode -> IOMode # pred :: IOMode -> IOMode # toEnum :: Int -> IOMode # fromEnum :: IOMode -> Int # enumFrom :: IOMode -> [IOMode] enumFromThen :: IOMode -> IOMode -> [IOMode] enumFromTo :: IOMode -> IOMode -> [IOMode] enumFromThenTo :: IOMode -> IOMode -> IOMode -> [IOMode]
Ix IOMode
Instance details Defined in GHC.Internal.IO.IOMode Methods range :: (IOMode, IOMode) -> [IOMode] index :: (IOMode, IOMode) -> IOMode -> Int unsafeIndex :: (IOMode, IOMode) -> IOMode -> Int inRange :: (IOMode, IOMode) -> IOMode -> Bool rangeSize :: (IOMode, IOMode) -> Int unsafeRangeSize :: (IOMode, IOMode) -> Int
Read IOMode
Instance details Defined in GHC.Internal.IO.IOMode Methods readsPrec :: Int -> ReadS IOMode readList :: ReadS [IOMode] readPrec :: ReadPrec IOMode readListPrec :: ReadPrec [IOMode]
Show IOMode
Instance details Defined in GHC.Internal.IO.IOMode Methods showsPrec :: Int -> IOMode -> ShowS show :: IOMode -> String # showList :: [IOMode] -> ShowS
Eq IOMode
Instance details Defined in GHC.Internal.IO.IOMode Methods (==) :: IOMode -> IOMode -> Bool # (/=) :: IOMode -> IOMode -> Bool #
Ord IOMode
Instance details Defined in GHC.Internal.IO.IOMode Methods compare :: IOMode -> IOMode -> Ordering # (<) :: IOMode -> IOMode -> Bool # (<=) :: IOMode -> IOMode -> Bool # (>) :: IOMode -> IOMode -> Bool # (>=) :: IOMode -> IOMode -> Bool # max :: IOMode -> IOMode -> IOMode # min :: IOMode -> IOMode -> IOMode #

stdin :: Handle #

stdout :: Handle #

stderr :: Handle #

getMonotonicTime :: MonadIO m => m Double #

hClose :: MonadIO m => Handle -> m () #

hFileSize :: MonadIO m => Handle -> m Integer #

hFlush :: MonadIO m => Handle -> m () #

hGetBuffering :: MonadIO m => Handle -> m BufferMode #

hGetEcho :: MonadIO m => Handle -> m Bool #

hIsClosed :: MonadIO m => Handle -> m Bool #

hIsEOF :: MonadIO m => Handle -> m Bool #

hIsOpen :: MonadIO m => Handle -> m Bool #

hIsReadable :: MonadIO m => Handle -> m Bool #

hIsSeekable :: MonadIO m => Handle -> m Bool #

hIsTerminalDevice :: MonadIO m => Handle -> m Bool #

hIsWritable :: MonadIO m => Handle -> m Bool #

hReady :: MonadIO m => Handle -> m Bool #

hSeek :: MonadIO m => Handle -> SeekMode -> Integer -> m () #

hSetBuffering :: MonadIO m => Handle -> BufferMode -> m () #

hSetEcho :: MonadIO m => Handle -> Bool -> m () #

hSetFileSize :: MonadIO m => Handle -> Integer -> m () #

hTell :: MonadIO m => Handle -> m Integer #

hWaitForInput :: MonadIO m => Handle -> Int -> m Bool #

openFile :: MonadIO m => FilePath -> IOMode -> m Handle #

withFile :: MonadUnliftIO m => FilePath -> IOMode -> (Handle -> m a) -> m a #

data SeekMode #

Constructors

AbsoluteSeek
RelativeSeek
SeekFromEnd

Instances

Instances details

Enum SeekMode
Instance details Defined in GHC.Internal.IO.Device Methods succ :: SeekMode -> SeekMode # pred :: SeekMode -> SeekMode # toEnum :: Int -> SeekMode # fromEnum :: SeekMode -> Int # enumFrom :: SeekMode -> [SeekMode] enumFromThen :: SeekMode -> SeekMode -> [SeekMode] enumFromTo :: SeekMode -> SeekMode -> [SeekMode] enumFromThenTo :: SeekMode -> SeekMode -> SeekMode -> [SeekMode]
Ix SeekMode
Instance details Defined in GHC.Internal.IO.Device Methods range :: (SeekMode, SeekMode) -> [SeekMode] index :: (SeekMode, SeekMode) -> SeekMode -> Int unsafeIndex :: (SeekMode, SeekMode) -> SeekMode -> Int inRange :: (SeekMode, SeekMode) -> SeekMode -> Bool rangeSize :: (SeekMode, SeekMode) -> Int unsafeRangeSize :: (SeekMode, SeekMode) -> Int
Read SeekMode
Instance details Defined in GHC.Internal.IO.Device Methods readsPrec :: Int -> ReadS SeekMode readList :: ReadS [SeekMode] readPrec :: ReadPrec SeekMode readListPrec :: ReadPrec [SeekMode]
Show SeekMode
Instance details Defined in GHC.Internal.IO.Device Methods showsPrec :: Int -> SeekMode -> ShowS show :: SeekMode -> String # showList :: [SeekMode] -> ShowS
Eq SeekMode
Instance details Defined in GHC.Internal.IO.Device Methods (==) :: SeekMode -> SeekMode -> Bool # (/=) :: SeekMode -> SeekMode -> Bool #
Ord SeekMode
Instance details Defined in GHC.Internal.IO.Device Methods compare :: SeekMode -> SeekMode -> Ordering # (<) :: SeekMode -> SeekMode -> Bool # (<=) :: SeekMode -> SeekMode -> Bool # (>) :: SeekMode -> SeekMode -> Bool # (>=) :: SeekMode -> SeekMode -> Bool # max :: SeekMode -> SeekMode -> SeekMode # min :: SeekMode -> SeekMode -> SeekMode #

data BufferMode #

Constructors

NoBuffering
LineBuffering
BlockBuffering (Maybe Int)

Instances

Instances details

Read BufferMode
Instance details Defined in GHC.Internal.IO.Handle.Types Methods readsPrec :: Int -> ReadS BufferMode readList :: ReadS [BufferMode] readPrec :: ReadPrec BufferMode readListPrec :: ReadPrec [BufferMode]
Show BufferMode
Instance details Defined in GHC.Internal.IO.Handle.Types Methods showsPrec :: Int -> BufferMode -> ShowS show :: BufferMode -> String # showList :: [BufferMode] -> ShowS
Eq BufferMode
Instance details Defined in GHC.Internal.IO.Handle.Types Methods (==) :: BufferMode -> BufferMode -> Bool # (/=) :: BufferMode -> BufferMode -> Bool #
Ord BufferMode
Instance details Defined in GHC.Internal.IO.Handle.Types Methods compare :: BufferMode -> BufferMode -> Ordering # (<) :: BufferMode -> BufferMode -> Bool # (<=) :: BufferMode -> BufferMode -> Bool # (>) :: BufferMode -> BufferMode -> Bool # (>=) :: BufferMode -> BufferMode -> Bool # max :: BufferMode -> BufferMode -> BufferMode # min :: BufferMode -> BufferMode -> BufferMode #

withSystemTempDirectory :: MonadUnliftIO m => String -> (FilePath -> m a) -> m a #

withSystemTempFile :: MonadUnliftIO m => String -> (FilePath -> Handle -> m a) -> m a #

withTempDirectory :: MonadUnliftIO m => FilePath -> String -> (FilePath -> m a) -> m a #

withTempFile :: MonadUnliftIO m => FilePath -> String -> (FilePath -> Handle -> m a) -> m a #

withLazyFile :: MonadUnliftIO m => FilePath -> (ByteString -> m a) -> m a Source #

Lazily get the contents of a file. Unlike readFile, this ensures that if an exception is thrown, the file handle is closed immediately.

withLazyFileUtf8 :: MonadUnliftIO m => FilePath -> (Text -> m a) -> m a Source #

Lazily read a file in UTF8 encoding.

Since: 0.1.13

readFileBinary :: MonadIO m => FilePath -> m ByteString Source #

Same as readFile, but generalized to MonadIO

writeFileBinary :: MonadIO m => FilePath -> ByteString -> m () Source #

Same as writeFile, but generalized to MonadIO

readFileUtf8 :: MonadIO m => FilePath -> m Text Source #

Read a file in UTF8 encoding, throwing an exception on invalid character encoding.

This function will use OS-specific line ending handling.

writeFileUtf8 :: MonadIO m => FilePath -> Text -> m () Source #

Write a file in UTF8 encoding

This function will use OS-specific line ending handling.

hPutBuilder :: MonadIO m => Handle -> Builder -> m () Source #

Exit

exitWith :: MonadIO m => ExitCode -> m a Source #

Lifted version of "System.Exit.exitWith".

@since 0.1.9.0.

exitFailure :: MonadIO m => m a Source #

Lifted version of "System.Exit.exitFailure".

@since 0.1.9.0.

exitSuccess :: MonadIO m => m a Source #

Lifted version of "System.Exit.exitSuccess".

@since 0.1.9.0.

data ExitCode #

Constructors

ExitSuccess
ExitFailure Int

Instances

Instances details

NFData ExitCode

Instance details

Defined in Control.DeepSeq

Methods

rnf :: ExitCode -> () #

Exception ExitCode

Instance details

Defined in GHC.Internal.IO.Exception

Methods

toException :: ExitCode -> SomeException #

fromException :: SomeException -> Maybe ExitCode #

displayException :: ExitCode -> String #

backtraceDesired :: ExitCode -> Bool #

Generic ExitCode

Instance details

Defined in GHC.Internal.IO.Exception

Associated Types

type Rep ExitCode
Instance details Defined in GHC.Internal.IO.Exception type Rep ExitCode = D1 ('MetaData "ExitCode" "GHC.Internal.IO.Exception" "ghc-internal" 'False) (C1 ('MetaCons "ExitSuccess" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ExitFailure" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)))

Methods

from :: ExitCode -> Rep ExitCode x

to :: Rep ExitCode x -> ExitCode

Read ExitCode

Instance details

Defined in GHC.Internal.IO.Exception

Methods

readsPrec :: Int -> ReadS ExitCode

readList :: ReadS [ExitCode]

readPrec :: ReadPrec ExitCode

readListPrec :: ReadPrec [ExitCode]

Show ExitCode

Instance details

Defined in GHC.Internal.IO.Exception

Methods

showsPrec :: Int -> ExitCode -> ShowS

show :: ExitCode -> String #

showList :: [ExitCode] -> ShowS

Eq ExitCode

Instance details

Defined in GHC.Internal.IO.Exception

Methods

(==) :: ExitCode -> ExitCode -> Bool #

(/=) :: ExitCode -> ExitCode -> Bool #

Ord ExitCode

Instance details

Defined in GHC.Internal.IO.Exception

Methods

compare :: ExitCode -> ExitCode -> Ordering #

(<) :: ExitCode -> ExitCode -> Bool #

(<=) :: ExitCode -> ExitCode -> Bool #

(>) :: ExitCode -> ExitCode -> Bool #

(>=) :: ExitCode -> ExitCode -> Bool #

max :: ExitCode -> ExitCode -> ExitCode #

min :: ExitCode -> ExitCode -> ExitCode #

type Rep ExitCode

Instance details

Defined in GHC.Internal.IO.Exception

type Rep ExitCode = D1 ('MetaData "ExitCode" "GHC.Internal.IO.Exception" "ghc-internal" 'False) (C1 ('MetaCons "ExitSuccess" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ExitFailure" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)))

Mutable Variables

SomeRef

data SomeRef a Source #

Abstraction over how to read from and write to a mutable reference

Since: 0.1.4.0

Instances

Instances details

HasStateRef a (SomeRef a) Source #	Identity state reference where the SomeRef is the env Since: 0.1.4.0
Instance details Defined in RIO.Prelude.RIO Methods stateRefL :: Lens' (SomeRef a) (SomeRef a) Source #
HasWriteRef a (SomeRef a) Source #	Identity write reference where the SomeRef is the env Since: 0.1.4.0
Instance details Defined in RIO.Prelude.RIO Methods writeRefL :: Lens' (SomeRef a) (SomeRef a) Source #

mapRIO :: (outer -> inner) -> RIO inner a -> RIO outer a Source #

Lift one RIO env to another.

Since: 0.1.13.0

class HasStateRef s env | env -> s where Source #

Environment values with stateful capabilities to SomeRef

Since: 0.1.4.0

Methods

stateRefL :: Lens' env (SomeRef s) Source #

Instances

Instances details

HasStateRef a (SomeRef a) Source #

Identity state reference where the SomeRef is the env

Since: 0.1.4.0

Instance details

Defined in RIO.Prelude.RIO

Methods

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

class HasWriteRef w env | env -> w where Source #

Environment values with writing capabilities to SomeRef

Since: 0.1.4.0

Methods

writeRefL :: Lens' env (SomeRef w) Source #

Instances

Instances details

HasWriteRef a (SomeRef a) Source #

Identity write reference where the SomeRef is the env

Since: 0.1.4.0

Instance details

Defined in RIO.Prelude.RIO

Methods

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

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

create a new boxed SomeRef

Since: 0.1.4.0

newUnboxedSomeRef :: (MonadIO m, Unbox a) => a -> m (SomeRef a) Source #

create a new unboxed SomeRef

Since: 0.1.4.0

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

Read from a SomeRef

Since: 0.1.4.0

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

Write to a SomeRef

Since: 0.1.4.0

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

Modify a SomeRef This function is subject to change due to the lack of atomic operations

Since: 0.1.4.0

URef

data URef s a Source #

An unboxed reference. This works like an IORef, but the data is stored in a bytearray instead of a heap object, avoiding significant allocation overhead in some cases. For a concrete example, see this Stack Overflow question: https://stackoverflow.com/questions/27261813/why-is-my-little-stref-int-require-allocating-gigabytes.

The first parameter is the state token type, the same as would be used for the ST monad. If you're using an IO-based monad, you can use the convenience IOURef type synonym instead.

Since: 0.0.2.0

type IOURef = URef (PrimState IO) Source #

Helpful type synonym for using a URef from an IO-based stack.

Since: 0.0.2.0

newURef :: (PrimMonad m, Unbox a) => a -> m (URef (PrimState m) a) Source #

Create a new URef

Since: 0.0.2.0

readURef :: (PrimMonad m, Unbox a) => URef (PrimState m) a -> m a Source #

Read the value in a URef

Since: 0.0.2.0

writeURef :: (PrimMonad m, Unbox a) => URef (PrimState m) a -> a -> m () Source #

Write a value into a URef. Note that this action is strict, and will force evalution of the value.

Since: 0.0.2.0

modifyURef :: (PrimMonad m, Unbox a) => URef (PrimState m) a -> (a -> a) -> m () Source #

Modify a value in a URef. Note that this action is strict, and will force evaluation of the result value.

Since: 0.0.2.0

IORef

data IORef a #

Instances

Instances details

NFData1 IORef
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> IORef a -> ()
NFData (IORef a)
Instance details Defined in Control.DeepSeq Methods rnf :: IORef a -> () #
Eq (IORef a)
Instance details Defined in GHC.Internal.IORef Methods (==) :: IORef a -> IORef a -> Bool # (/=) :: IORef a -> IORef a -> Bool #

atomicModifyIORef :: MonadIO m => IORef a -> (a -> (a, b)) -> m b #

atomicModifyIORef' :: MonadIO m => IORef a -> (a -> (a, b)) -> m b #

atomicWriteIORef :: MonadIO m => IORef a -> a -> m () #

mkWeakIORef :: MonadUnliftIO m => IORef a -> m () -> m (Weak (IORef a)) #

modifyIORef :: MonadIO m => IORef a -> (a -> a) -> m () #

modifyIORef' :: MonadIO m => IORef a -> (a -> a) -> m () #

newIORef :: MonadIO m => a -> m (IORef a) #

readIORef :: MonadIO m => IORef a -> m a #

writeIORef :: MonadIO m => IORef a -> a -> m () #

MVar

data MVar a #

Instances

Instances details

NFData1 MVar
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> MVar a -> ()
NFData (MVar a)
Instance details Defined in Control.DeepSeq Methods rnf :: MVar a -> () #
Eq (MVar a)
Instance details Defined in GHC.Internal.MVar Methods (==) :: MVar a -> MVar a -> Bool # (/=) :: MVar a -> MVar a -> Bool #

isEmptyMVar :: MonadIO m => MVar a -> m Bool #

mkWeakMVar :: MonadUnliftIO m => MVar a -> m () -> m (Weak (MVar a)) #

modifyMVar :: MonadUnliftIO m => MVar a -> (a -> m (a, b)) -> m b #

modifyMVarMasked :: MonadUnliftIO m => MVar a -> (a -> m (a, b)) -> m b #

modifyMVarMasked_ :: MonadUnliftIO m => MVar a -> (a -> m a) -> m () #

modifyMVar_ :: MonadUnliftIO m => MVar a -> (a -> m a) -> m () #

newEmptyMVar :: MonadIO m => m (MVar a) #

newMVar :: MonadIO m => a -> m (MVar a) #

putMVar :: MonadIO m => MVar a -> a -> m () #

readMVar :: MonadIO m => MVar a -> m a #

swapMVar :: MonadIO m => MVar a -> a -> m a #

takeMVar :: MonadIO m => MVar a -> m a #

tryPutMVar :: MonadIO m => MVar a -> a -> m Bool #

tryReadMVar :: MonadIO m => MVar a -> m (Maybe a) #

tryTakeMVar :: MonadIO m => MVar a -> m (Maybe a) #

withMVar :: MonadUnliftIO m => MVar a -> (a -> m b) -> m b #

withMVarMasked :: MonadUnliftIO m => MVar a -> (a -> m b) -> m b #

QSem

data QSem #

newQSem :: MonadIO m => Int -> m QSem #

signalQSem :: MonadIO m => QSem -> m () #

waitQSem :: MonadIO m => QSem -> m () #

withQSem :: MonadUnliftIO m => QSem -> m a -> m a #

QSemN

data QSemN #

newQSemN :: MonadIO m => Int -> m QSemN #

signalQSemN :: MonadIO m => QSemN -> Int -> m () #

waitQSemN :: MonadIO m => QSemN -> Int -> m () #

withQSemN :: MonadUnliftIO m => QSemN -> Int -> m a -> m a #

Memoize

data Memoized a #

Instances

Instances details

Applicative Memoized
Instance details Defined in UnliftIO.Memoize Methods pure :: a -> Memoized a # (<>) :: Memoized (a -> b) -> Memoized a -> Memoized b # liftA2 :: (a -> b -> c) -> Memoized a -> Memoized b -> Memoized c # (>) :: Memoized a -> Memoized b -> Memoized b # (<*) :: Memoized a -> Memoized b -> Memoized a #
Functor Memoized
Instance details Defined in UnliftIO.Memoize Methods fmap :: (a -> b) -> Memoized a -> Memoized b # (<$) :: a -> Memoized b -> Memoized a #
Monad Memoized
Instance details Defined in UnliftIO.Memoize Methods (>>=) :: Memoized a -> (a -> Memoized b) -> Memoized b # (>>) :: Memoized a -> Memoized b -> Memoized b # return :: a -> Memoized a #
Show (Memoized a)
Instance details Defined in UnliftIO.Memoize Methods showsPrec :: Int -> Memoized a -> ShowS show :: Memoized a -> String # showList :: [Memoized a] -> ShowS