Stack.Prelude

Documentation

mapLeft :: (a1 -> a2) -> Either a1 b -> Either a2 b

data ResourceT (m :: * -> *) a :: (* -> *) -> * -> *

The Resource transformer. This transformer keeps track of all registered actions, and calls them upon exit (via runResourceT). Actions may be registered via register, or resources may be allocated atomically via allocate. allocate corresponds closely to bracket.

Releasing may be performed before exit via the release function. This is a highly recommended optimization, as it will ensure that scarce resources are freed early. Note that calling release will deregister the action, so that a release action will only ever be called once.

Since 0.3.0

Instances

MonadTrans ResourceT

Methods

lift :: Monad m => m a -> ResourceT m a

MMonad ResourceT

Since 0.4.7

Methods

embed :: Monad n => (forall a. m a -> ResourceT n a) -> ResourceT m b -> ResourceT n b

MonadTransControl ResourceT

Associated Types

type StT (ResourceT :: (* -> *) -> * -> *) a :: *

Methods

liftWith :: Monad m => (Run ResourceT -> m a) -> ResourceT m a

restoreT :: Monad m => m (StT ResourceT a) -> ResourceT m a

MonadRWS r w s m => MonadRWS r w s (ResourceT m)

MonadBaseControl b m => MonadBaseControl b (ResourceT m)

Associated Types

type StM (ResourceT m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (ResourceT m) b -> b a) -> ResourceT m a

restoreM :: StM (ResourceT m) a -> ResourceT m a

MonadReader r m => MonadReader r (ResourceT m)

Methods

ask :: ResourceT m r

local :: (r -> r) -> ResourceT m a -> ResourceT m a

reader :: (r -> a) -> ResourceT m a

MonadState s m => MonadState s (ResourceT m)

Methods

get :: ResourceT m s

put :: s -> ResourceT m ()

state :: (s -> (a, s)) -> ResourceT m a

MonadBase b m => MonadBase b (ResourceT m)

Methods

liftBase :: b α -> ResourceT m α

MonadWriter w m => MonadWriter w (ResourceT m)

Methods

writer :: (a, w) -> ResourceT m a

tell :: w -> ResourceT m ()

listen :: ResourceT m a -> ResourceT m (a, w)

pass :: ResourceT m (a, w -> w) -> ResourceT m a

MonadError e m => MonadError e (ResourceT m)

Methods

throwError :: e -> ResourceT m a

catchError :: ResourceT m a -> (e -> ResourceT m a) -> ResourceT m a

Monad m => Monad (ResourceT m)

Methods

(>>=) :: ResourceT m a -> (a -> ResourceT m b) -> ResourceT m b

(>>) :: ResourceT m a -> ResourceT m b -> ResourceT m b

return :: a -> ResourceT m a

fail :: String -> ResourceT m a

Functor m => Functor (ResourceT m)

Methods

fmap :: (a -> b) -> ResourceT m a -> ResourceT m b

(<$) :: a -> ResourceT m b -> ResourceT m a

MonadFix m => MonadFix (ResourceT m)

Since: 1.1.8

Methods

mfix :: (a -> ResourceT m a) -> ResourceT m a

Applicative m => Applicative (ResourceT m)

Methods

pure :: a -> ResourceT m a

(<*>) :: ResourceT m (a -> b) -> ResourceT m a -> ResourceT m b

liftA2 :: (a -> b -> c) -> ResourceT m a -> ResourceT m b -> ResourceT m c

(*>) :: ResourceT m a -> ResourceT m b -> ResourceT m b

(<*) :: ResourceT m a -> ResourceT m b -> ResourceT m a

MonadPlus m => MonadPlus (ResourceT m)

Since 1.1.5

Methods

mzero :: ResourceT m a

mplus :: ResourceT m a -> ResourceT m a -> ResourceT m a

Alternative m => Alternative (ResourceT m)

Since 1.1.5

Methods

empty :: ResourceT m a

(<|>) :: ResourceT m a -> ResourceT m a -> ResourceT m a

some :: ResourceT m a -> ResourceT m [a]

many :: ResourceT m a -> ResourceT m [a]

MonadThrow m => MonadThrow (ResourceT m)

Methods

throwM :: Exception e => e -> ResourceT m a

MonadIO m => MonadIO (ResourceT m)

Methods

liftIO :: IO a -> ResourceT m a

MonadUnliftIO m => MonadUnliftIO (ResourceT m)

Since: 1.1.10

Methods

askUnliftIO :: ResourceT m (UnliftIO (ResourceT m))

(MonadIO m, MonadActive m) => MonadActive (ResourceT m)

Methods

monadActive :: ResourceT m Bool

MonadCatch m => MonadCatch (ResourceT m)

Methods

catch :: Exception e => ResourceT m a -> (e -> ResourceT m a) -> ResourceT m a

MonadMask m => MonadMask (ResourceT m)

Methods

mask :: ((forall a. ResourceT m a -> ResourceT m a) -> ResourceT m b) -> ResourceT m b

uninterruptibleMask :: ((forall a. ResourceT m a -> ResourceT m a) -> ResourceT m b) -> ResourceT m b

(MonadThrow m, MonadBase IO m, MonadIO m, Applicative m) => MonadResource (ResourceT m)

Methods

liftResourceT :: ResourceT IO a -> ResourceT m a

MonadLogger m => MonadLogger (ResourceT m)

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> ResourceT m ()

MonadLoggerIO m => MonadLoggerIO (ResourceT m)

Methods

askLoggerIO :: ResourceT m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

MonadCont m => MonadCont (ResourceT m)

Methods

callCC :: ((a -> ResourceT m b) -> ResourceT m a) -> ResourceT m a

MFunctor * ResourceT

Since 0.4.7

Methods

hoist :: Monad m => (forall a. m a -> n a) -> t m b -> t n b

type StT ResourceT a

type StT ResourceT a = a

type StM (ResourceT m) a

type StM (ResourceT m) a = StM m a

runConduitRes :: MonadUnliftIO m => ConduitM () Void (ResourceT m) r -> m r

runResourceT :: MonadUnliftIO m => ResourceT m a -> m a

liftResourceT :: MonadIO m => ResourceT IO a -> ResourceT m a

newtype NoLogging a

Avoid orphan messes

Constructors

NoLogging

Fields

• runNoLogging :: IO a

Instances

Monad NoLogging

Methods

(>>=) :: NoLogging a -> (a -> NoLogging b) -> NoLogging b

(>>) :: NoLogging a -> NoLogging b -> NoLogging b

return :: a -> NoLogging a

fail :: String -> NoLogging a

Functor NoLogging

Methods

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

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

Applicative NoLogging

Methods

pure :: a -> NoLogging a

(<*>) :: NoLogging (a -> b) -> NoLogging a -> NoLogging b

liftA2 :: (a -> b -> c) -> NoLogging a -> NoLogging b -> NoLogging c

(*>) :: NoLogging a -> NoLogging b -> NoLogging b

(<*) :: NoLogging a -> NoLogging b -> NoLogging a

MonadIO NoLogging

Methods

liftIO :: IO a -> NoLogging a

MonadUnliftIO NoLogging

Methods

askUnliftIO :: NoLogging (UnliftIO NoLogging)

MonadLogger NoLogging

Methods

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

withSystemTempDir :: MonadUnliftIO m => String -> (Path Abs Dir -> m a) -> m a

Path version

fromFirst :: a -> First a -> a

mapMaybeA :: Applicative f => (a -> f (Maybe b)) -> [a] -> f [b]

Applicative mapMaybe.

mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b]

Monadic mapMaybe.

forMaybeA :: Applicative f => [a] -> (a -> f (Maybe b)) -> f [b]

forMaybeA == flip mapMaybeA

forMaybeM :: Monad m => [a] -> (a -> m (Maybe b)) -> m [b]

forMaybeM == flip mapMaybeM

stripCR :: Text -> Text

Strip trailing carriage return from Text

logSticky :: MonadLogger m => Text -> m ()

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.

logStickyDone :: MonadLogger m => Text -> m ()

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.

It might be better at some point to have a runSticky function that encompasses the logSticky->logStickyDone pairing.

newtype RIO env a

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

MonadReader env (RIO env)

Methods

ask :: RIO env env

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

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

Monad (RIO env)

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

fail :: String -> RIO env a

Functor (RIO env)

Methods

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

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

Applicative (RIO env)

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

MonadThrow (RIO env)

Methods

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

MonadIO (RIO env)

Methods

liftIO :: IO a -> RIO env a

MonadUnliftIO (RIO env)

Methods

askUnliftIO :: RIO env (UnliftIO (RIO env))

HasLogFunc env => MonadLogger (RIO env)

Methods

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

HasLogFunc env => MonadLoggerIO (RIO env)

Methods

askLoggerIO :: RIO env (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

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

class HasLogFunc env where

Minimal complete definition

logFuncL

Methods

logFuncL :: Getting r env (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

Instances

HasLogFunc Runner

Methods

logFuncL :: Getting r Runner (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

HasLogFunc LoadConfig

Methods

logFuncL :: Getting r LoadConfig (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

HasLogFunc EnvConfig

Methods

logFuncL :: Getting r EnvConfig (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

HasLogFunc BuildConfig

Methods

logFuncL :: Getting r BuildConfig (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

HasLogFunc Config

Methods

logFuncL :: Getting r Config (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

HasLogFunc MiniConfig

Methods

logFuncL :: Getting r MiniConfig (Loc -> LogSource -> LogLevel -> LogStr -> IO ())