hsdev- Haskell development library and tool with support of autocompletion, symbol info, go to declaration, find references etc.

Safe HaskellNone




stack :: [String] -> MaybeT IO String Source

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

yaml :: Maybe FilePath -> [String] Source

Make yaml opts

path :: Maybe FilePath -> MaybeT IO Paths Source

Stack path

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

Get path for

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

Build stack project

buildDeps :: Maybe FilePath -> MaybeT IO () Source

Build only dependencies

configure :: Maybe FilePath -> MaybeT IO () Source

Configure project

stackPackageDbStack :: Lens' StackEnv PackageDbStack Source

Get package-db stack for stack environment

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.




runMaybeT :: m (Maybe a)


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)