HsDev.Stack

Documentation

stack :: [String] -> MaybeT IO String

Invoke stack command, we are trying to get actual stack near current hsdev executable

yaml :: Maybe FilePath -> [String]

Make yaml opts

path :: Maybe FilePath -> MaybeT IO Paths

Stack path

pathOf :: String -> Lens' Paths (Maybe FilePath)

Get path for

build :: [String] -> Maybe FilePath -> MaybeT IO ()

Build stack project

buildDeps :: Maybe FilePath -> MaybeT IO ()

Build only dependencies

configure :: Maybe FilePath -> MaybeT IO ()

Configure project

data StackEnv

Constructors

StackEnv

Fields

_stackRoot :: FilePath

_stackProject :: FilePath

_stackConfig :: FilePath

_stackGhc :: FilePath

_stackSnapshot :: FilePath

_stackLocal :: FilePath

stackRoot :: Lens' StackEnv FilePath

stackProject :: Lens' StackEnv FilePath

stackConfig :: Lens' StackEnv FilePath

stackGhc :: Lens' StackEnv FilePath

stackSnapshot :: Lens' StackEnv FilePath

stackLocal :: Lens' StackEnv FilePath

getStackEnv :: Paths -> Maybe StackEnv

projectEnv :: FilePath -> MaybeT IO StackEnv

Projects paths

stackPackageDbStack :: Lens' StackEnv PackageDbStack

Get package-db stack for stack environment

stackCompiler :: MaybeT IO String

Get compiler version

stackArch :: String

Get arch for stack

newtype MaybeT m a :: (* -> *) -> * -> *

The parameterizable maybe monad, obtained by composing an arbitrary monad with the Maybe monad.

Computations are actions that may produce a value or exit.

The return function yields a computation that produces that value, while >>= sequences two subcomputations, exiting if either computation does.

Constructors

MaybeT

Fields

runMaybeT :: m (Maybe a)

Instances

MonadTrans MaybeT

MonadTransControl MaybeT

MonadState s m => MonadState s (MaybeT m)

MonadReader r m => MonadReader r (MaybeT m)

MonadError e m => MonadError e (MaybeT m)

MonadWriter w m => MonadWriter w (MaybeT m)

MonadBase b m => MonadBase b (MaybeT m)

MonadBaseControl b m => MonadBaseControl b (MaybeT m)

Monad m => Monad (MaybeT m)

Functor m => Functor (MaybeT m)

MonadFix m => MonadFix (MaybeT m)

(Functor m, Monad m) => Applicative (MaybeT m)

Foldable f => Foldable (MaybeT f)

Traversable f => Traversable (MaybeT f)

MonadCatchIO m => MonadCatchIO (MaybeT m)

Contravariant m => Contravariant (MaybeT m)

(Functor m, Monad m) => Alternative (MaybeT m)

Monad m => MonadPlus (MaybeT m)

MonadThrow m => MonadThrow (MaybeT m)

Throws exceptions into the base monad.

MonadCatch m => MonadCatch (MaybeT m)

Catches exceptions from the base monad.

MonadIO m => MonadIO (MaybeT m)

GmState m => GmState (MaybeT m)

GmOut m => GmOut (MaybeT m)

(Monad m, GmLog m) => GmLog (MaybeT m)

PrimMonad m => PrimMonad (MaybeT m)

Eq1 m => Eq1 (MaybeT m)

Ord1 m => Ord1 (MaybeT m)

Read1 m => Read1 (MaybeT m)

Show1 m => Show1 (MaybeT m)

(Eq1 m, Eq a) => Eq (MaybeT m a)

(Ord1 m, Ord a) => Ord (MaybeT m a)

(Read1 m, Read a) => Read (MaybeT m a)

(Show1 m, Show a) => Show (MaybeT m a)

Wrapped (MaybeT m a)

(~) * t (MaybeT n b) => Rewrapped (MaybeT m a) t

type StT MaybeT a = Maybe a

type Zoomed (MaybeT m) = FocusingMay (Zoomed m)

type PrimState (MaybeT m) = PrimState m

type StM (MaybeT m) a = ComposeSt MaybeT m a

type Unwrapped (MaybeT m a) = m (Maybe a)