    {-# LANGUAGE ScopedTypeVariables, DeriveDataTypeable, OverloadedStrings,
                 FlexibleInstances, FlexibleContexts, IncoherentInstances,
                 TypeFamilies, ExistentialQuantification, RankNTypes,
                 ImpredicativeTypes #-}
    {-# OPTIONS_GHC -fno-warn-orphans #-}

    -- | A module for shell-like programming in Haskell.
    -- Shelly's focus is entirely on ease of use for those coming from shell scripting.
    -- However, it also tries to use modern libraries and techniques to keep things efficient.
    --
    -- The functionality provided by
    -- this module is (unlike standard Haskell filesystem functionality)
    -- thread-safe: each Sh maintains its own environment and its own working
    -- directory.
    --
    -- Recommended usage includes putting the following at the top of your program,
    -- otherwise you will likely need either type annotations or type conversions
    --
    -- > {-# LANGUAGE OverloadedStrings #-}
    -- > {-# LANGUAGE ExtendedDefaultRules #-}
    -- > {-# OPTIONS_GHC -fno-warn-type-defaults #-}
    -- > import Shelly
    -- > import qualified Data.Text as T
    -- > default (T.Text)
    module Shelly.Lifted
           (
             MonadSh(..),
             MonadShControl(..),

             -- This is copied from Shelly.hs, so that we are sure to export the
             -- exact same set of symbols.  Whenever that export list is updated,
             -- please make the same updates here and implements the corresponding
             -- lifted functions.

             -- * Entering Sh.
             Sh, ShIO, S.shelly, S.shellyNoDir, S.shellyFailDir, sub
             , silently, verbosely, escaping, print_stdout, print_stderr, print_commands
             , tracing, errExit
             , log_stdout_with, log_stderr_with

             -- * Running external commands.
             , run, run_, runFoldLines, S.cmd, S.FoldCallback
             , (-|-), lastStderr, setStdin, lastExitCode
             , command, command_, command1, command1_
             , sshPairs, sshPairs_
             , S.ShellCmd(..), S.CmdArg (..)

             -- * Running commands Using handles
             , runHandle, runHandles, transferLinesAndCombine, S.transferFoldHandleLines
             , S.StdHandle(..), S.StdStream(..)

             -- * Modifying and querying environment.
             , setenv, get_env, get_env_text, get_env_all, appendToPath, prependToPath

             -- * Environment directory
             , cd, chdir, chdir_p, pwd

             -- * Printing
             , echo, echo_n, echo_err, echo_n_err, inspect, inspect_err
             , tag, trace, S.show_command

             -- * Querying filesystem.
             , ls, lsT, test_e, test_f, test_d, test_s, test_px, which

             -- * Filename helpers
             , absPath, (S.</>), (S.<.>), canonic, canonicalize, relPath, relativeTo
             , S.hasExt

             -- * Manipulating filesystem.
             , mv, rm, rm_f, rm_rf, cp, cp_r, mkdir, mkdir_p, mkdirTree

             -- * reading/writing Files
             , readfile, readBinary, writefile, appendfile, touchfile, withTmpDir

             -- * exiting the program
             , exit, errorExit, quietExit, terror

             -- * Exceptions
             , bracket_sh, catchany, catch_sh, handle_sh, handleany_sh, finally_sh, catches_sh, catchany_sh

             -- * convert between Text and FilePath
             , S.toTextIgnore, toTextWarn, S.fromText

             -- * Utility Functions
             , S.whenM, S.unlessM, time, sleep

             -- * Re-exported for your convenience
             , liftIO, S.when, S.unless, FilePath, (S.<$>)

             -- * internal functions for writing extensions
             , Shelly.Lifted.get, Shelly.Lifted.put

             -- * find functions
             , S.find, S.findWhen, S.findFold, S.findDirFilter, S.findDirFilterWhen, S.findFoldDirFilter
             , followSymlink
             ) where

    import qualified Shelly as S
    import Shelly.Base (Sh(..), ShIO, Text, (>=>), FilePath)
    import qualified Shelly.Base as S
    import Control.Monad ( liftM )
    import Prelude hiding ( FilePath )
    import Data.ByteString ( ByteString )
    import Data.Monoid
    import System.IO ( Handle )
    import Data.Tree ( Tree )
    import qualified System.FilePath as FP

    import Control.Exception.Lifted
    import Control.Exception.Enclosed
    import Control.Monad.IO.Class
    import Control.Monad.Trans.Control
    import Control.Monad.Trans.Identity
    import Control.Monad.Trans.List
    import Control.Monad.Trans.Maybe
    import Control.Monad.Trans.Cont
    import Control.Monad.Trans.Error
    import Control.Monad.Trans.Reader
    import Control.Monad.Trans.State
    import qualified Control.Monad.Trans.State.Strict as Strict
    import Control.Monad.Trans.Writer
    import qualified Control.Monad.Trans.Writer.Strict as Strict
    import qualified Control.Monad.Trans.RWS as RWS
    import qualified Control.Monad.Trans.RWS.Strict as Strict

    class Monad m => MonadSh m where
        liftSh :: Sh a -> m a

    instance MonadSh Sh where
        liftSh :: Sh a -> Sh a
    liftSh = Sh a -> Sh a
    forall a. a -> a
    id

    instance MonadSh m => MonadSh (IdentityT m) where
        liftSh :: Sh a -> IdentityT m a
    liftSh = m a -> IdentityT m a
    forall k (f :: k -> *) (a :: k). f a -> IdentityT f a
    IdentityT (m a -> IdentityT m a) -> (Sh a -> m a) -> Sh a -> IdentityT m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh
    instance MonadSh m => MonadSh (ListT m) where
        liftSh :: Sh a -> ListT m a
    liftSh m :: Sh a
    m = m [a] -> ListT m a
    forall (m :: * -> *) a. m [a] -> ListT m a
    ListT (m [a] -> ListT m a) -> m [a] -> ListT m a
    forall a b. (a -> b) -> a -> b
    $ do
            a
    a <- Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh Sh a
    m
            [a] -> m [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return [a
    a]
    instance MonadSh m => MonadSh (MaybeT m) where
        liftSh :: Sh a -> MaybeT m a
    liftSh = m (Maybe a) -> MaybeT m a
    forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
    MaybeT (m (Maybe a) -> MaybeT m a)
    -> (Sh a -> m (Maybe a)) -> Sh a -> MaybeT m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> Maybe a) -> m a -> m (Maybe a)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM a -> Maybe a
    forall a. a -> Maybe a
    Just (m a -> m (Maybe a)) -> (Sh a -> m a) -> Sh a -> m (Maybe a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh
    instance MonadSh m => MonadSh (ContT r m) where
        liftSh :: Sh a -> ContT r m a
    liftSh m :: Sh a
    m = ((a -> m r) -> m r) -> ContT r m a
    forall k (r :: k) (m :: k -> *) a.
    ((a -> m r) -> m r) -> ContT r m a
    ContT (Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh Sh a
    m m a -> (a -> m r) -> m r
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>=)
    instance (Error e, MonadSh m) => MonadSh (ErrorT e m) where
        liftSh :: Sh a -> ErrorT e m a
    liftSh m :: Sh a
    m = m (Either e a) -> ErrorT e m a
    forall e (m :: * -> *) a. m (Either e a) -> ErrorT e m a
    ErrorT (m (Either e a) -> ErrorT e m a) -> m (Either e a) -> ErrorT e m a
    forall a b. (a -> b) -> a -> b
    $ do
            a
    a <- Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh Sh a
    m
            Either e a -> m (Either e a)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a -> Either e a
    forall a b. b -> Either a b
    Right a
    a)
    instance MonadSh m => MonadSh (ReaderT r m) where
        liftSh :: Sh a -> ReaderT r m a
    liftSh = (r -> m a) -> ReaderT r m a
    forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
    ReaderT ((r -> m a) -> ReaderT r m a)
    -> (Sh a -> r -> m a) -> Sh a -> ReaderT r m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . m a -> r -> m a
    forall a b. a -> b -> a
    const (m a -> r -> m a) -> (Sh a -> m a) -> Sh a -> r -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh
    instance MonadSh m => MonadSh (StateT s m) where
        liftSh :: Sh a -> StateT s m a
    liftSh m :: Sh a
    m = (s -> m (a, s)) -> StateT s m a
    forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
    StateT ((s -> m (a, s)) -> StateT s m a)
    -> (s -> m (a, s)) -> StateT s m a
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> do
            a
    a <- Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh Sh a
    m
            (a, s) -> m (a, s)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    a, s
    s)
    instance MonadSh m => MonadSh (Strict.StateT s m) where
        liftSh :: Sh a -> StateT s m a
    liftSh m :: Sh a
    m = (s -> m (a, s)) -> StateT s m a
    forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
    Strict.StateT ((s -> m (a, s)) -> StateT s m a)
    -> (s -> m (a, s)) -> StateT s m a
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> do
            a
    a <- Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh Sh a
    m
            (a, s) -> m (a, s)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    a, s
    s)
    instance (Monoid w, MonadSh m) => MonadSh (WriterT w m) where
        liftSh :: Sh a -> WriterT w m a
    liftSh m :: Sh a
    m = m (a, w) -> WriterT w m a
    forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
    WriterT (m (a, w) -> WriterT w m a) -> m (a, w) -> WriterT w m a
    forall a b. (a -> b) -> a -> b
    $ do
            a
    a <- Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh Sh a
    m
            (a, w) -> m (a, w)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    a, w
    forall a. Monoid a => a
    mempty :: w)
    instance (Monoid w, MonadSh m) => MonadSh (Strict.WriterT w m) where
        liftSh :: Sh a -> WriterT w m a
    liftSh m :: Sh a
    m = m (a, w) -> WriterT w m a
    forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
    Strict.WriterT (m (a, w) -> WriterT w m a) -> m (a, w) -> WriterT w m a
    forall a b. (a -> b) -> a -> b
    $ do
            a
    a <- Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh Sh a
    m
            (a, w) -> m (a, w)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    a, w
    forall a. Monoid a => a
    mempty :: w)
    instance (Monoid w, MonadSh m) => MonadSh (RWS.RWST r w s m) where
        liftSh :: Sh a -> RWST r w s m a
    liftSh m :: Sh a
    m = (r -> s -> m (a, s, w)) -> RWST r w s m a
    forall r w s (m :: * -> *) a.
    (r -> s -> m (a, s, w)) -> RWST r w s m a
    RWS.RWST ((r -> s -> m (a, s, w)) -> RWST r w s m a)
    -> (r -> s -> m (a, s, w)) -> RWST r w s m a
    forall a b. (a -> b) -> a -> b
    $ \_ s :: s
    s -> do
            a
    a <- Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh Sh a
    m
            (a, s, w) -> m (a, s, w)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    a, s
    s, w
    forall a. Monoid a => a
    mempty :: w)
    instance (Monoid w, MonadSh m) => MonadSh (Strict.RWST r w s m) where
        liftSh :: Sh a -> RWST r w s m a
    liftSh m :: Sh a
    m = (r -> s -> m (a, s, w)) -> RWST r w s m a
    forall r w s (m :: * -> *) a.
    (r -> s -> m (a, s, w)) -> RWST r w s m a
    Strict.RWST ((r -> s -> m (a, s, w)) -> RWST r w s m a)
    -> (r -> s -> m (a, s, w)) -> RWST r w s m a
    forall a b. (a -> b) -> a -> b
    $ \_ s :: s
    s -> do
            a
    a <- Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh Sh a
    m
            (a, s, w) -> m (a, s, w)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    a, s
    s, w
    forall a. Monoid a => a
    mempty :: w)

    instance MonadSh m => S.ShellCmd (m Text) where
        cmdAll :: FilePath -> [Text] -> m Text
    cmdAll = (Sh Text -> m Text
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh Text -> m Text) -> ([Text] -> Sh Text) -> [Text] -> m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .) (([Text] -> Sh Text) -> [Text] -> m Text)
    -> (FilePath -> [Text] -> Sh Text) -> FilePath -> [Text] -> m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> [Text] -> Sh Text
    S.run

    instance (MonadSh m, s ~ Text, Show s) => S.ShellCmd (m s) where
        cmdAll :: FilePath -> [Text] -> m s
    cmdAll = (Sh Text -> m Text
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh Text -> m Text) -> ([Text] -> Sh Text) -> [Text] -> m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .) (([Text] -> Sh Text) -> [Text] -> m Text)
    -> (FilePath -> [Text] -> Sh Text) -> FilePath -> [Text] -> m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> [Text] -> Sh Text
    S.run

    instance MonadSh m => S.ShellCmd (m ()) where
        cmdAll :: FilePath -> [Text] -> m ()
    cmdAll = (Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> ([Text] -> Sh ()) -> [Text] -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .) (([Text] -> Sh ()) -> [Text] -> m ())
    -> (FilePath -> [Text] -> Sh ()) -> FilePath -> [Text] -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> [Text] -> Sh ()
    S.run_

    class Monad m => MonadShControl m where
        data ShM m a :: *
        liftShWith :: ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
        restoreSh :: ShM m a -> m a

    instance MonadShControl Sh where
         newtype ShM Sh a = ShSh a
         liftShWith :: ((forall x. Sh x -> Sh (ShM Sh x)) -> Sh a) -> Sh a
    liftShWith f :: (forall x. Sh x -> Sh (ShM Sh x)) -> Sh a
    f = (forall x. Sh x -> Sh (ShM Sh x)) -> Sh a
    f ((forall x. Sh x -> Sh (ShM Sh x)) -> Sh a)
    -> (forall x. Sh x -> Sh (ShM Sh x)) -> Sh a
    forall a b. (a -> b) -> a -> b
    $ (x -> ShM Sh x) -> Sh x -> Sh (ShM Sh x)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM x -> ShM Sh x
    forall a. a -> ShM Sh a
    ShSh
         restoreSh :: ShM Sh a -> Sh a
    restoreSh (ShSh x) = a -> Sh a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    x
         {-# INLINE liftShWith #-}
         {-# INLINE restoreSh #-}

    instance MonadShControl m => MonadShControl (ListT m) where
        newtype ShM (ListT m) a = ListTShM (ShM m [a])
        liftShWith :: ((forall x. ListT m x -> Sh (ShM (ListT m) x)) -> Sh a)
    -> ListT m a
    liftShWith f :: (forall x. ListT m x -> Sh (ShM (ListT m) x)) -> Sh a
    f =
            m [a] -> ListT m a
    forall (m :: * -> *) a. m [a] -> ListT m a
    ListT (m [a] -> ListT m a) -> m [a] -> ListT m a
    forall a b. (a -> b) -> a -> b
    $ (a -> [a]) -> m a -> m [a]
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM a -> [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return (m a -> m [a]) -> m a -> m [a]
    forall a b. (a -> b) -> a -> b
    $ ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    liftShWith (((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> (forall x. ListT m x -> Sh (ShM (ListT m) x)) -> Sh a
    f ((forall x. ListT m x -> Sh (ShM (ListT m) x)) -> Sh a)
    -> (forall x. ListT m x -> Sh (ShM (ListT m) x)) -> Sh a
    forall a b. (a -> b) -> a -> b
    $ \k :: ListT m x
    k ->
                (ShM m [x] -> ShM (ListT m) x)
    -> Sh (ShM m [x]) -> Sh (ShM (ListT m) x)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM ShM m [x] -> ShM (ListT m) x
    forall (m :: * -> *) a. ShM m [a] -> ShM (ListT m) a
    ListTShM (Sh (ShM m [x]) -> Sh (ShM (ListT m) x))
    -> Sh (ShM m [x]) -> Sh (ShM (ListT m) x)
    forall a b. (a -> b) -> a -> b
    $ m [x] -> Sh (ShM m [x])
    forall x. m x -> Sh (ShM m x)
    runInSh (m [x] -> Sh (ShM m [x])) -> m [x] -> Sh (ShM m [x])
    forall a b. (a -> b) -> a -> b
    $ ListT m x -> m [x]
    forall (m :: * -> *) a. ListT m a -> m [a]
    runListT ListT m x
    k
        restoreSh :: ShM (ListT m) a -> ListT m a
    restoreSh (ListTShM m) = m [a] -> ListT m a
    forall (m :: * -> *) a. m [a] -> ListT m a
    ListT (m [a] -> ListT m a)
    -> (ShM m [a] -> m [a]) -> ShM m [a] -> ListT m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ShM m [a] -> m [a]
    forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
    restoreSh (ShM m [a] -> ListT m a) -> ShM m [a] -> ListT m a
    forall a b. (a -> b) -> a -> b
    $ ShM m [a]
    m
        {-# INLINE liftShWith #-}
        {-# INLINE restoreSh #-}

    instance MonadShControl m => MonadShControl (MaybeT m) where
        newtype ShM (MaybeT m) a = MaybeTShM (ShM m (Maybe a))
        liftShWith :: ((forall x. MaybeT m x -> Sh (ShM (MaybeT m) x)) -> Sh a)
    -> MaybeT m a
    liftShWith f :: (forall x. MaybeT m x -> Sh (ShM (MaybeT m) x)) -> Sh a
    f =
            m (Maybe a) -> MaybeT m a
    forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
    MaybeT (m (Maybe a) -> MaybeT m a) -> m (Maybe a) -> MaybeT m a
    forall a b. (a -> b) -> a -> b
    $ (a -> Maybe a) -> m a -> m (Maybe a)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM a -> Maybe a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (m a -> m (Maybe a)) -> m a -> m (Maybe a)
    forall a b. (a -> b) -> a -> b
    $ ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    liftShWith (((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> (forall x. MaybeT m x -> Sh (ShM (MaybeT m) x)) -> Sh a
    f ((forall x. MaybeT m x -> Sh (ShM (MaybeT m) x)) -> Sh a)
    -> (forall x. MaybeT m x -> Sh (ShM (MaybeT m) x)) -> Sh a
    forall a b. (a -> b) -> a -> b
    $ \k :: MaybeT m x
    k ->
                (ShM m (Maybe x) -> ShM (MaybeT m) x)
    -> Sh (ShM m (Maybe x)) -> Sh (ShM (MaybeT m) x)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM ShM m (Maybe x) -> ShM (MaybeT m) x
    forall (m :: * -> *) a. ShM m (Maybe a) -> ShM (MaybeT m) a
    MaybeTShM (Sh (ShM m (Maybe x)) -> Sh (ShM (MaybeT m) x))
    -> Sh (ShM m (Maybe x)) -> Sh (ShM (MaybeT m) x)
    forall a b. (a -> b) -> a -> b
    $ m (Maybe x) -> Sh (ShM m (Maybe x))
    forall x. m x -> Sh (ShM m x)
    runInSh (m (Maybe x) -> Sh (ShM m (Maybe x)))
    -> m (Maybe x) -> Sh (ShM m (Maybe x))
    forall a b. (a -> b) -> a -> b
    $ MaybeT m x -> m (Maybe x)
    forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
    runMaybeT MaybeT m x
    k
        restoreSh :: ShM (MaybeT m) a -> MaybeT m a
    restoreSh (MaybeTShM m) = m (Maybe a) -> MaybeT m a
    forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
    MaybeT (m (Maybe a) -> MaybeT m a)
    -> (ShM m (Maybe a) -> m (Maybe a))
    -> ShM m (Maybe a)
    -> MaybeT m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ShM m (Maybe a) -> m (Maybe a)
    forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
    restoreSh (ShM m (Maybe a) -> MaybeT m a) -> ShM m (Maybe a) -> MaybeT m a
    forall a b. (a -> b) -> a -> b
    $ ShM m (Maybe a)
    m
        {-# INLINE liftShWith #-}
        {-# INLINE restoreSh #-}

    instance MonadShControl m
             => MonadShControl (IdentityT m) where
        newtype ShM (IdentityT m) a = IdentityTShM (ShM m a)
        liftShWith :: ((forall x. IdentityT m x -> Sh (ShM (IdentityT m) x)) -> Sh a)
    -> IdentityT m a
    liftShWith f :: (forall x. IdentityT m x -> Sh (ShM (IdentityT m) x)) -> Sh a
    f =
            m a -> IdentityT m a
    forall k (f :: k -> *) (a :: k). f a -> IdentityT f a
    IdentityT (m a -> IdentityT m a) -> m a -> IdentityT m a
    forall a b. (a -> b) -> a -> b
    $ (a -> a) -> m a -> m a
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM a -> a
    forall a. a -> a
    id (m a -> m a) -> m a -> m a
    forall a b. (a -> b) -> a -> b
    $ ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    liftShWith (((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> (forall x. IdentityT m x -> Sh (ShM (IdentityT m) x)) -> Sh a
    f ((forall x. IdentityT m x -> Sh (ShM (IdentityT m) x)) -> Sh a)
    -> (forall x. IdentityT m x -> Sh (ShM (IdentityT m) x)) -> Sh a
    forall a b. (a -> b) -> a -> b
    $ \k :: IdentityT m x
    k ->
                (ShM m x -> ShM (IdentityT m) x)
    -> Sh (ShM m x) -> Sh (ShM (IdentityT m) x)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM ShM m x -> ShM (IdentityT m) x
    forall (m :: * -> *) a. ShM m a -> ShM (IdentityT m) a
    IdentityTShM (Sh (ShM m x) -> Sh (ShM (IdentityT m) x))
    -> Sh (ShM m x) -> Sh (ShM (IdentityT m) x)
    forall a b. (a -> b) -> a -> b
    $ m x -> Sh (ShM m x)
    forall x. m x -> Sh (ShM m x)
    runInSh (m x -> Sh (ShM m x)) -> m x -> Sh (ShM m x)
    forall a b. (a -> b) -> a -> b
    $ IdentityT m x -> m x
    forall k (f :: k -> *) (a :: k). IdentityT f a -> f a
    runIdentityT IdentityT m x
    k
        restoreSh :: ShM (IdentityT m) a -> IdentityT m a
    restoreSh (IdentityTShM m) = m a -> IdentityT m a
    forall k (f :: k -> *) (a :: k). f a -> IdentityT f a
    IdentityT (m a -> IdentityT m a)
    -> (ShM m a -> m a) -> ShM m a -> IdentityT m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ShM m a -> m a
    forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
    restoreSh (ShM m a -> IdentityT m a) -> ShM m a -> IdentityT m a
    forall a b. (a -> b) -> a -> b
    $ ShM m a
    m
        {-# INLINE liftShWith #-}
        {-# INLINE restoreSh #-}

    instance (MonadShControl m, Monoid w)
             => MonadShControl (WriterT w m) where
        newtype ShM (WriterT w m) a = WriterTShM (ShM m (a, w))
        liftShWith :: ((forall x. WriterT w m x -> Sh (ShM (WriterT w m) x)) -> Sh a)
    -> WriterT w m a
    liftShWith f :: (forall x. WriterT w m x -> Sh (ShM (WriterT w m) x)) -> Sh a
    f =
            m (a, w) -> WriterT w m a
    forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
    WriterT (m (a, w) -> WriterT w m a) -> m (a, w) -> WriterT w m a
    forall a b. (a -> b) -> a -> b
    $ (a -> (a, w)) -> m a -> m (a, w)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM  (\x :: a
    x -> (a
    x, w
    forall a. Monoid a => a
    mempty :: w)) (m a -> m (a, w)) -> m a -> m (a, w)
    forall a b. (a -> b) -> a -> b
    $ ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    liftShWith (((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> (forall x. WriterT w m x -> Sh (ShM (WriterT w m) x)) -> Sh a
    f ((forall x. WriterT w m x -> Sh (ShM (WriterT w m) x)) -> Sh a)
    -> (forall x. WriterT w m x -> Sh (ShM (WriterT w m) x)) -> Sh a
    forall a b. (a -> b) -> a -> b
    $ \k :: WriterT w m x
    k ->
                (ShM m (x, w) -> ShM (WriterT w m) x)
    -> Sh (ShM m (x, w)) -> Sh (ShM (WriterT w m) x)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM ShM m (x, w) -> ShM (WriterT w m) x
    forall w (m :: * -> *) a. ShM m (a, w) -> ShM (WriterT w m) a
    WriterTShM (Sh (ShM m (x, w)) -> Sh (ShM (WriterT w m) x))
    -> Sh (ShM m (x, w)) -> Sh (ShM (WriterT w m) x)
    forall a b. (a -> b) -> a -> b
    $ m (x, w) -> Sh (ShM m (x, w))
    forall x. m x -> Sh (ShM m x)
    runInSh (m (x, w) -> Sh (ShM m (x, w))) -> m (x, w) -> Sh (ShM m (x, w))
    forall a b. (a -> b) -> a -> b
    $ WriterT w m x -> m (x, w)
    forall w (m :: * -> *) a. WriterT w m a -> m (a, w)
    runWriterT WriterT w m x
    k
        restoreSh :: ShM (WriterT w m) a -> WriterT w m a
    restoreSh (WriterTShM m) = m (a, w) -> WriterT w m a
    forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
    WriterT (m (a, w) -> WriterT w m a)
    -> (ShM m (a, w) -> m (a, w)) -> ShM m (a, w) -> WriterT w m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ShM m (a, w) -> m (a, w)
    forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
    restoreSh (ShM m (a, w) -> WriterT w m a) -> ShM m (a, w) -> WriterT w m a
    forall a b. (a -> b) -> a -> b
    $ ShM m (a, w)
    m
        {-# INLINE liftShWith #-}
        {-# INLINE restoreSh #-}

    instance (MonadShControl m, Monoid w)
             => MonadShControl (Strict.WriterT w m) where
        newtype ShM (Strict.WriterT w m) a = StWriterTShM (ShM m (a, w))
        liftShWith :: ((forall x. WriterT w m x -> Sh (ShM (WriterT w m) x)) -> Sh a)
    -> WriterT w m a
    liftShWith f :: (forall x. WriterT w m x -> Sh (ShM (WriterT w m) x)) -> Sh a
    f =
            m (a, w) -> WriterT w m a
    forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
    Strict.WriterT (m (a, w) -> WriterT w m a) -> m (a, w) -> WriterT w m a
    forall a b. (a -> b) -> a -> b
    $ (a -> (a, w)) -> m a -> m (a, w)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (\x :: a
    x -> (a
    x, w
    forall a. Monoid a => a
    mempty :: w)) (m a -> m (a, w)) -> m a -> m (a, w)
    forall a b. (a -> b) -> a -> b
    $ ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    liftShWith (((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> (forall x. WriterT w m x -> Sh (ShM (WriterT w m) x)) -> Sh a
    f ((forall x. WriterT w m x -> Sh (ShM (WriterT w m) x)) -> Sh a)
    -> (forall x. WriterT w m x -> Sh (ShM (WriterT w m) x)) -> Sh a
    forall a b. (a -> b) -> a -> b
    $ \k :: WriterT w m x
    k ->
                (ShM m (x, w) -> ShM (WriterT w m) x)
    -> Sh (ShM m (x, w)) -> Sh (ShM (WriterT w m) x)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM ShM m (x, w) -> ShM (WriterT w m) x
    forall w (m :: * -> *) a. ShM m (a, w) -> ShM (WriterT w m) a
    StWriterTShM (Sh (ShM m (x, w)) -> Sh (ShM (WriterT w m) x))
    -> Sh (ShM m (x, w)) -> Sh (ShM (WriterT w m) x)
    forall a b. (a -> b) -> a -> b
    $ m (x, w) -> Sh (ShM m (x, w))
    forall x. m x -> Sh (ShM m x)
    runInSh (m (x, w) -> Sh (ShM m (x, w))) -> m (x, w) -> Sh (ShM m (x, w))
    forall a b. (a -> b) -> a -> b
    $ WriterT w m x -> m (x, w)
    forall w (m :: * -> *) a. WriterT w m a -> m (a, w)
    Strict.runWriterT WriterT w m x
    k
        restoreSh :: ShM (WriterT w m) a -> WriterT w m a
    restoreSh (StWriterTShM m) = m (a, w) -> WriterT w m a
    forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
    Strict.WriterT (m (a, w) -> WriterT w m a)
    -> (ShM m (a, w) -> m (a, w)) -> ShM m (a, w) -> WriterT w m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ShM m (a, w) -> m (a, w)
    forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
    restoreSh (ShM m (a, w) -> WriterT w m a) -> ShM m (a, w) -> WriterT w m a
    forall a b. (a -> b) -> a -> b
    $ ShM m (a, w)
    m
        {-# INLINE liftShWith #-}
        {-# INLINE restoreSh #-}

    instance (MonadShControl m, Error e)
             => MonadShControl (ErrorT e m) where
        newtype ShM (ErrorT e m) a = ErrorTShM (ShM m (Either e a))
        liftShWith :: ((forall x. ErrorT e m x -> Sh (ShM (ErrorT e m) x)) -> Sh a)
    -> ErrorT e m a
    liftShWith f :: (forall x. ErrorT e m x -> Sh (ShM (ErrorT e m) x)) -> Sh a
    f =
            m (Either e a) -> ErrorT e m a
    forall e (m :: * -> *) a. m (Either e a) -> ErrorT e m a
    ErrorT (m (Either e a) -> ErrorT e m a) -> m (Either e a) -> ErrorT e m a
    forall a b. (a -> b) -> a -> b
    $ (a -> Either e a) -> m a -> m (Either e a)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM a -> Either e a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (m a -> m (Either e a)) -> m a -> m (Either e a)
    forall a b. (a -> b) -> a -> b
    $ ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    liftShWith (((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> (forall x. ErrorT e m x -> Sh (ShM (ErrorT e m) x)) -> Sh a
    f ((forall x. ErrorT e m x -> Sh (ShM (ErrorT e m) x)) -> Sh a)
    -> (forall x. ErrorT e m x -> Sh (ShM (ErrorT e m) x)) -> Sh a
    forall a b. (a -> b) -> a -> b
    $ \k :: ErrorT e m x
    k ->
                (ShM m (Either e x) -> ShM (ErrorT e m) x)
    -> Sh (ShM m (Either e x)) -> Sh (ShM (ErrorT e m) x)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM ShM m (Either e x) -> ShM (ErrorT e m) x
    forall e (m :: * -> *) a. ShM m (Either e a) -> ShM (ErrorT e m) a
    ErrorTShM (Sh (ShM m (Either e x)) -> Sh (ShM (ErrorT e m) x))
    -> Sh (ShM m (Either e x)) -> Sh (ShM (ErrorT e m) x)
    forall a b. (a -> b) -> a -> b
    $ m (Either e x) -> Sh (ShM m (Either e x))
    forall x. m x -> Sh (ShM m x)
    runInSh (m (Either e x) -> Sh (ShM m (Either e x)))
    -> m (Either e x) -> Sh (ShM m (Either e x))
    forall a b. (a -> b) -> a -> b
    $ ErrorT e m x -> m (Either e x)
    forall e (m :: * -> *) a. ErrorT e m a -> m (Either e a)
    runErrorT ErrorT e m x
    k
        restoreSh :: ShM (ErrorT e m) a -> ErrorT e m a
    restoreSh (ErrorTShM m) = m (Either e a) -> ErrorT e m a
    forall e (m :: * -> *) a. m (Either e a) -> ErrorT e m a
    ErrorT (m (Either e a) -> ErrorT e m a)
    -> (ShM m (Either e a) -> m (Either e a))
    -> ShM m (Either e a)
    -> ErrorT e m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ShM m (Either e a) -> m (Either e a)
    forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
    restoreSh (ShM m (Either e a) -> ErrorT e m a)
    -> ShM m (Either e a) -> ErrorT e m a
    forall a b. (a -> b) -> a -> b
    $ ShM m (Either e a)
    m
        {-# INLINE liftShWith #-}
        {-# INLINE restoreSh #-}

    instance MonadShControl m => MonadShControl (StateT s m) where
        newtype ShM (StateT s m) a = StateTShM (ShM m (a, s))
        liftShWith :: ((forall x. StateT s m x -> Sh (ShM (StateT s m) x)) -> Sh a)
    -> StateT s m a
    liftShWith f :: (forall x. StateT s m x -> Sh (ShM (StateT s m) x)) -> Sh a
    f = (s -> m (a, s)) -> StateT s m a
    forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
    StateT ((s -> m (a, s)) -> StateT s m a)
    -> (s -> m (a, s)) -> StateT s m a
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s ->
            (a -> (a, s)) -> m a -> m (a, s)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (\x :: a
    x -> (a
    x,s
    s)) (m a -> m (a, s)) -> m a -> m (a, s)
    forall a b. (a -> b) -> a -> b
    $ ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    liftShWith (((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> (forall x. StateT s m x -> Sh (ShM (StateT s m) x)) -> Sh a
    f ((forall x. StateT s m x -> Sh (ShM (StateT s m) x)) -> Sh a)
    -> (forall x. StateT s m x -> Sh (ShM (StateT s m) x)) -> Sh a
    forall a b. (a -> b) -> a -> b
    $ \k :: StateT s m x
    k ->
                (ShM m (x, s) -> ShM (StateT s m) x)
    -> Sh (ShM m (x, s)) -> Sh (ShM (StateT s m) x)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM ShM m (x, s) -> ShM (StateT s m) x
    forall s (m :: * -> *) a. ShM m (a, s) -> ShM (StateT s m) a
    StateTShM (Sh (ShM m (x, s)) -> Sh (ShM (StateT s m) x))
    -> Sh (ShM m (x, s)) -> Sh (ShM (StateT s m) x)
    forall a b. (a -> b) -> a -> b
    $ m (x, s) -> Sh (ShM m (x, s))
    forall x. m x -> Sh (ShM m x)
    runInSh (m (x, s) -> Sh (ShM m (x, s))) -> m (x, s) -> Sh (ShM m (x, s))
    forall a b. (a -> b) -> a -> b
    $ StateT s m x -> s -> m (x, s)
    forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
    runStateT StateT s m x
    k s
    s
        restoreSh :: ShM (StateT s m) a -> StateT s m a
    restoreSh (StateTShM m) = (s -> m (a, s)) -> StateT s m a
    forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
    StateT ((s -> m (a, s)) -> StateT s m a)
    -> (ShM m (a, s) -> s -> m (a, s)) -> ShM m (a, s) -> StateT s m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . m (a, s) -> s -> m (a, s)
    forall a b. a -> b -> a
    const (m (a, s) -> s -> m (a, s))
    -> (ShM m (a, s) -> m (a, s)) -> ShM m (a, s) -> s -> m (a, s)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ShM m (a, s) -> m (a, s)
    forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
    restoreSh (ShM m (a, s) -> StateT s m a) -> ShM m (a, s) -> StateT s m a
    forall a b. (a -> b) -> a -> b
    $ ShM m (a, s)
    m
        {-# INLINE liftShWith #-}
        {-# INLINE restoreSh #-}

    instance MonadShControl m => MonadShControl (Strict.StateT s m) where
        newtype ShM (Strict.StateT s m) a = StStateTShM (ShM m (a, s))
        liftShWith :: ((forall x. StateT s m x -> Sh (ShM (StateT s m) x)) -> Sh a)
    -> StateT s m a
    liftShWith f :: (forall x. StateT s m x -> Sh (ShM (StateT s m) x)) -> Sh a
    f = (s -> m (a, s)) -> StateT s m a
    forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
    Strict.StateT ((s -> m (a, s)) -> StateT s m a)
    -> (s -> m (a, s)) -> StateT s m a
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s ->
            (a -> (a, s)) -> m a -> m (a, s)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (\x :: a
    x -> (a
    x,s
    s)) (m a -> m (a, s)) -> m a -> m (a, s)
    forall a b. (a -> b) -> a -> b
    $ ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    liftShWith (((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> (forall x. StateT s m x -> Sh (ShM (StateT s m) x)) -> Sh a
    f ((forall x. StateT s m x -> Sh (ShM (StateT s m) x)) -> Sh a)
    -> (forall x. StateT s m x -> Sh (ShM (StateT s m) x)) -> Sh a
    forall a b. (a -> b) -> a -> b
    $ \k :: StateT s m x
    k ->
                (ShM m (x, s) -> ShM (StateT s m) x)
    -> Sh (ShM m (x, s)) -> Sh (ShM (StateT s m) x)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM ShM m (x, s) -> ShM (StateT s m) x
    forall s (m :: * -> *) a. ShM m (a, s) -> ShM (StateT s m) a
    StStateTShM (Sh (ShM m (x, s)) -> Sh (ShM (StateT s m) x))
    -> Sh (ShM m (x, s)) -> Sh (ShM (StateT s m) x)
    forall a b. (a -> b) -> a -> b
    $ m (x, s) -> Sh (ShM m (x, s))
    forall x. m x -> Sh (ShM m x)
    runInSh (m (x, s) -> Sh (ShM m (x, s))) -> m (x, s) -> Sh (ShM m (x, s))
    forall a b. (a -> b) -> a -> b
    $ StateT s m x -> s -> m (x, s)
    forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
    Strict.runStateT StateT s m x
    k s
    s
        restoreSh :: ShM (StateT s m) a -> StateT s m a
    restoreSh (StStateTShM m) = (s -> m (a, s)) -> StateT s m a
    forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
    Strict.StateT ((s -> m (a, s)) -> StateT s m a)
    -> (ShM m (a, s) -> s -> m (a, s)) -> ShM m (a, s) -> StateT s m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . m (a, s) -> s -> m (a, s)
    forall a b. a -> b -> a
    const (m (a, s) -> s -> m (a, s))
    -> (ShM m (a, s) -> m (a, s)) -> ShM m (a, s) -> s -> m (a, s)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ShM m (a, s) -> m (a, s)
    forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
    restoreSh (ShM m (a, s) -> StateT s m a) -> ShM m (a, s) -> StateT s m a
    forall a b. (a -> b) -> a -> b
    $ ShM m (a, s)
    m
        {-# INLINE liftShWith #-}
        {-# INLINE restoreSh #-}

    instance MonadShControl m => MonadShControl (ReaderT r m) where
        newtype ShM (ReaderT r m) a = ReaderTShM (ShM m a)
        liftShWith :: ((forall x. ReaderT r m x -> Sh (ShM (ReaderT r m) x)) -> Sh a)
    -> ReaderT r m a
    liftShWith f :: (forall x. ReaderT r m x -> Sh (ShM (ReaderT r m) x)) -> Sh a
    f = (r -> m a) -> ReaderT r m a
    forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
    ReaderT ((r -> m a) -> ReaderT r m a) -> (r -> m a) -> ReaderT r m a
    forall a b. (a -> b) -> a -> b
    $ \r :: r
    r ->
            (a -> a) -> m a -> m a
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM a -> a
    forall a. a -> a
    id (m a -> m a) -> m a -> m a
    forall a b. (a -> b) -> a -> b
    $ ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    liftShWith (((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> (forall x. ReaderT r m x -> Sh (ShM (ReaderT r m) x)) -> Sh a
    f ((forall x. ReaderT r m x -> Sh (ShM (ReaderT r m) x)) -> Sh a)
    -> (forall x. ReaderT r m x -> Sh (ShM (ReaderT r m) x)) -> Sh a
    forall a b. (a -> b) -> a -> b
    $ \k :: ReaderT r m x
    k ->
                (ShM m x -> ShM (ReaderT r m) x)
    -> Sh (ShM m x) -> Sh (ShM (ReaderT r m) x)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM ShM m x -> ShM (ReaderT r m) x
    forall r (m :: * -> *) a. ShM m a -> ShM (ReaderT r m) a
    ReaderTShM (Sh (ShM m x) -> Sh (ShM (ReaderT r m) x))
    -> Sh (ShM m x) -> Sh (ShM (ReaderT r m) x)
    forall a b. (a -> b) -> a -> b
    $ m x -> Sh (ShM m x)
    forall x. m x -> Sh (ShM m x)
    runInSh (m x -> Sh (ShM m x)) -> m x -> Sh (ShM m x)
    forall a b. (a -> b) -> a -> b
    $ ReaderT r m x -> r -> m x
    forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
    runReaderT ReaderT r m x
    k r
    r
        restoreSh :: ShM (ReaderT r m) a -> ReaderT r m a
    restoreSh (ReaderTShM m) = (r -> m a) -> ReaderT r m a
    forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
    ReaderT ((r -> m a) -> ReaderT r m a)
    -> (ShM m a -> r -> m a) -> ShM m a -> ReaderT r m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . m a -> r -> m a
    forall a b. a -> b -> a
    const (m a -> r -> m a) -> (ShM m a -> m a) -> ShM m a -> r -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ShM m a -> m a
    forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
    restoreSh (ShM m a -> ReaderT r m a) -> ShM m a -> ReaderT r m a
    forall a b. (a -> b) -> a -> b
    $ ShM m a
    m
        {-# INLINE liftShWith #-}
        {-# INLINE restoreSh #-}

    instance (MonadShControl m, Monoid w)
             => MonadShControl (RWS.RWST r w s m) where
        newtype ShM (RWS.RWST r w s m) a = RWSTShM (ShM m (a, s ,w))
        liftShWith :: ((forall x. RWST r w s m x -> Sh (ShM (RWST r w s m) x)) -> Sh a)
    -> RWST r w s m a
    liftShWith f :: (forall x. RWST r w s m x -> Sh (ShM (RWST r w s m) x)) -> Sh a
    f = (r -> s -> m (a, s, w)) -> RWST r w s m a
    forall r w s (m :: * -> *) a.
    (r -> s -> m (a, s, w)) -> RWST r w s m a
    RWS.RWST ((r -> s -> m (a, s, w)) -> RWST r w s m a)
    -> (r -> s -> m (a, s, w)) -> RWST r w s m a
    forall a b. (a -> b) -> a -> b
    $ \r :: r
    r s :: s
    s ->
            (a -> (a, s, w)) -> m a -> m (a, s, w)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (\x :: a
    x -> (a
    x,s
    s,w
    forall a. Monoid a => a
    mempty :: w)) (m a -> m (a, s, w)) -> m a -> m (a, s, w)
    forall a b. (a -> b) -> a -> b
    $ ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    liftShWith (((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> (forall x. RWST r w s m x -> Sh (ShM (RWST r w s m) x)) -> Sh a
    f ((forall x. RWST r w s m x -> Sh (ShM (RWST r w s m) x)) -> Sh a)
    -> (forall x. RWST r w s m x -> Sh (ShM (RWST r w s m) x)) -> Sh a
    forall a b. (a -> b) -> a -> b
    $ \k :: RWST r w s m x
    k ->
                (ShM m (x, s, w) -> ShM (RWST r w s m) x)
    -> Sh (ShM m (x, s, w)) -> Sh (ShM (RWST r w s m) x)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM ShM m (x, s, w) -> ShM (RWST r w s m) x
    forall r w s (m :: * -> *) a.
    ShM m (a, s, w) -> ShM (RWST r w s m) a
    RWSTShM (Sh (ShM m (x, s, w)) -> Sh (ShM (RWST r w s m) x))
    -> Sh (ShM m (x, s, w)) -> Sh (ShM (RWST r w s m) x)
    forall a b. (a -> b) -> a -> b
    $ m (x, s, w) -> Sh (ShM m (x, s, w))
    forall x. m x -> Sh (ShM m x)
    runInSh (m (x, s, w) -> Sh (ShM m (x, s, w)))
    -> m (x, s, w) -> Sh (ShM m (x, s, w))
    forall a b. (a -> b) -> a -> b
    $ RWST r w s m x -> r -> s -> m (x, s, w)
    forall r w s (m :: * -> *) a.
    RWST r w s m a -> r -> s -> m (a, s, w)
    RWS.runRWST RWST r w s m x
    k r
    r s
    s
        restoreSh :: ShM (RWST r w s m) a -> RWST r w s m a
    restoreSh (RWSTShM m) = (r -> s -> m (a, s, w)) -> RWST r w s m a
    forall r w s (m :: * -> *) a.
    (r -> s -> m (a, s, w)) -> RWST r w s m a
    RWS.RWST ((r -> s -> m (a, s, w)) -> RWST r w s m a)
    -> (ShM m (a, s, w) -> r -> s -> m (a, s, w))
    -> ShM m (a, s, w)
    -> RWST r w s m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (s -> m (a, s, w)) -> r -> s -> m (a, s, w)
    forall a b. a -> b -> a
    const ((s -> m (a, s, w)) -> r -> s -> m (a, s, w))
    -> (ShM m (a, s, w) -> s -> m (a, s, w))
    -> ShM m (a, s, w)
    -> r
    -> s
    -> m (a, s, w)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . m (a, s, w) -> s -> m (a, s, w)
    forall a b. a -> b -> a
    const (m (a, s, w) -> s -> m (a, s, w))
    -> (ShM m (a, s, w) -> m (a, s, w))
    -> ShM m (a, s, w)
    -> s
    -> m (a, s, w)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ShM m (a, s, w) -> m (a, s, w)
    forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
    restoreSh (ShM m (a, s, w) -> RWST r w s m a)
    -> ShM m (a, s, w) -> RWST r w s m a
    forall a b. (a -> b) -> a -> b
    $ ShM m (a, s, w)
    m
        {-# INLINE liftShWith #-}
        {-# INLINE restoreSh #-}

    instance (MonadShControl m, Monoid w)
             => MonadShControl (Strict.RWST r w s m) where
        newtype ShM (Strict.RWST r w s m) a = StRWSTShM (ShM m (a, s, w))
        liftShWith :: ((forall x. RWST r w s m x -> Sh (ShM (RWST r w s m) x)) -> Sh a)
    -> RWST r w s m a
    liftShWith f :: (forall x. RWST r w s m x -> Sh (ShM (RWST r w s m) x)) -> Sh a
    f = (r -> s -> m (a, s, w)) -> RWST r w s m a
    forall r w s (m :: * -> *) a.
    (r -> s -> m (a, s, w)) -> RWST r w s m a
    Strict.RWST ((r -> s -> m (a, s, w)) -> RWST r w s m a)
    -> (r -> s -> m (a, s, w)) -> RWST r w s m a
    forall a b. (a -> b) -> a -> b
    $ \r :: r
    r s :: s
    s ->
            (a -> (a, s, w)) -> m a -> m (a, s, w)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (\x :: a
    x -> (a
    x,s
    s,w
    forall a. Monoid a => a
    mempty :: w)) (m a -> m (a, s, w)) -> m a -> m (a, s, w)
    forall a b. (a -> b) -> a -> b
    $ ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    liftShWith (((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> (forall x. RWST r w s m x -> Sh (ShM (RWST r w s m) x)) -> Sh a
    f ((forall x. RWST r w s m x -> Sh (ShM (RWST r w s m) x)) -> Sh a)
    -> (forall x. RWST r w s m x -> Sh (ShM (RWST r w s m) x)) -> Sh a
    forall a b. (a -> b) -> a -> b
    $ \k :: RWST r w s m x
    k ->
                (ShM m (x, s, w) -> ShM (RWST r w s m) x)
    -> Sh (ShM m (x, s, w)) -> Sh (ShM (RWST r w s m) x)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM ShM m (x, s, w) -> ShM (RWST r w s m) x
    forall r w s (m :: * -> *) a.
    ShM m (a, s, w) -> ShM (RWST r w s m) a
    StRWSTShM (Sh (ShM m (x, s, w)) -> Sh (ShM (RWST r w s m) x))
    -> Sh (ShM m (x, s, w)) -> Sh (ShM (RWST r w s m) x)
    forall a b. (a -> b) -> a -> b
    $ m (x, s, w) -> Sh (ShM m (x, s, w))
    forall x. m x -> Sh (ShM m x)
    runInSh (m (x, s, w) -> Sh (ShM m (x, s, w)))
    -> m (x, s, w) -> Sh (ShM m (x, s, w))
    forall a b. (a -> b) -> a -> b
    $ RWST r w s m x -> r -> s -> m (x, s, w)
    forall r w s (m :: * -> *) a.
    RWST r w s m a -> r -> s -> m (a, s, w)
    Strict.runRWST RWST r w s m x
    k r
    r s
    s
        restoreSh :: ShM (RWST r w s m) a -> RWST r w s m a
    restoreSh (StRWSTShM m) = (r -> s -> m (a, s, w)) -> RWST r w s m a
    forall r w s (m :: * -> *) a.
    (r -> s -> m (a, s, w)) -> RWST r w s m a
    Strict.RWST ((r -> s -> m (a, s, w)) -> RWST r w s m a)
    -> (ShM m (a, s, w) -> r -> s -> m (a, s, w))
    -> ShM m (a, s, w)
    -> RWST r w s m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (s -> m (a, s, w)) -> r -> s -> m (a, s, w)
    forall a b. a -> b -> a
    const ((s -> m (a, s, w)) -> r -> s -> m (a, s, w))
    -> (ShM m (a, s, w) -> s -> m (a, s, w))
    -> ShM m (a, s, w)
    -> r
    -> s
    -> m (a, s, w)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . m (a, s, w) -> s -> m (a, s, w)
    forall a b. a -> b -> a
    const (m (a, s, w) -> s -> m (a, s, w))
    -> (ShM m (a, s, w) -> m (a, s, w))
    -> ShM m (a, s, w)
    -> s
    -> m (a, s, w)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ShM m (a, s, w) -> m (a, s, w)
    forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
    restoreSh (ShM m (a, s, w) -> RWST r w s m a)
    -> ShM m (a, s, w) -> RWST r w s m a
    forall a b. (a -> b) -> a -> b
    $ ShM m (a, s, w)
    m
        {-# INLINE liftShWith #-}
        {-# INLINE restoreSh #-}

    controlSh :: MonadShControl m => ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh :: ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m (ShM m a)
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
    liftShWith (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m (ShM m a))
    -> (ShM m a -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a))
    -> m a
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> ShM m a -> m a
    forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
    restoreSh
    {-# INLINE controlSh #-}

    tag :: (MonadShControl m, MonadSh m) => m a -> Text -> m a
    tag :: m a -> Text -> m a
    tag action :: m a
    action msg :: Text
    msg = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> Sh (ShM m a) -> Text -> Sh (ShM m a)
    forall a. Sh a -> Text -> Sh a
    S.tag (m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh m a
    action) Text
    msg

    chdir :: MonadShControl m => FilePath -> m a -> m a
    chdir :: FilePath -> m a -> m a
    chdir dir :: FilePath
    dir action :: m a
    action = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> FilePath -> Sh (ShM m a) -> Sh (ShM m a)
    forall a. FilePath -> Sh a -> Sh a
    S.chdir FilePath
    dir (m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh m a
    action)

    chdir_p :: MonadShControl m => FilePath -> m a -> m a
    chdir_p :: FilePath -> m a -> m a
    chdir_p dir :: FilePath
    dir action :: m a
    action = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> FilePath -> Sh (ShM m a) -> Sh (ShM m a)
    forall a. FilePath -> Sh a -> Sh a
    S.chdir_p FilePath
    dir (m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh m a
    action)

    silently :: MonadShControl m => m a -> m a
    silently :: m a -> m a
    silently a :: m a
    a = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> Sh (ShM m a) -> Sh (ShM m a)
    forall a. Sh a -> Sh a
    S.silently (m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh m a
    a)

    verbosely :: MonadShControl m => m a -> m a
    verbosely :: m a -> m a
    verbosely a :: m a
    a = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> Sh (ShM m a) -> Sh (ShM m a)
    forall a. Sh a -> Sh a
    S.verbosely (m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh m a
    a)

    log_stdout_with :: MonadShControl m => (Text -> IO ()) -> m a -> m a
    log_stdout_with :: (Text -> IO ()) -> m a -> m a
    log_stdout_with logger :: Text -> IO ()
    logger a :: m a
    a = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> (Text -> IO ()) -> Sh (ShM m a) -> Sh (ShM m a)
    forall a. (Text -> IO ()) -> Sh a -> Sh a
    S.log_stdout_with Text -> IO ()
    logger (m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh m a
    a)

    log_stderr_with :: MonadShControl m => (Text -> IO ()) -> m a -> m a
    log_stderr_with :: (Text -> IO ()) -> m a -> m a
    log_stderr_with logger :: Text -> IO ()
    logger a :: m a
    a = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> (Text -> IO ()) -> Sh (ShM m a) -> Sh (ShM m a)
    forall a. (Text -> IO ()) -> Sh a -> Sh a
    S.log_stderr_with Text -> IO ()
    logger (m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh m a
    a)

    print_stdout :: MonadShControl m => Bool -> m a -> m a
    print_stdout :: Bool -> m a -> m a
    print_stdout shouldPrint :: Bool
    shouldPrint a :: m a
    a = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> Bool -> Sh (ShM m a) -> Sh (ShM m a)
    forall a. Bool -> Sh a -> Sh a
    S.print_stdout Bool
    shouldPrint (m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh m a
    a)

    print_stderr :: MonadShControl m => Bool -> m a -> m a
    print_stderr :: Bool -> m a -> m a
    print_stderr shouldPrint :: Bool
    shouldPrint a :: m a
    a = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> Bool -> Sh (ShM m a) -> Sh (ShM m a)
    forall a. Bool -> Sh a -> Sh a
    S.print_stderr Bool
    shouldPrint (m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh m a
    a)

    print_commands :: MonadShControl m => Bool -> m a -> m a
    print_commands :: Bool -> m a -> m a
    print_commands shouldPrint :: Bool
    shouldPrint a :: m a
    a = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> Bool -> Sh (ShM m a) -> Sh (ShM m a)
    forall a. Bool -> Sh a -> Sh a
    S.print_commands Bool
    shouldPrint (m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh m a
    a)

    sub :: MonadShControl m => m a -> m a
    sub :: m a -> m a
    sub a :: m a
    a = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> Sh (ShM m a) -> Sh (ShM m a)
    forall a. Sh a -> Sh a
    S.sub (m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh m a
    a)

    trace :: MonadSh m => Text -> m ()
    trace :: Text -> m ()
    trace = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (Text -> Sh ()) -> Text -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Sh ()
    S.trace

    tracing :: MonadShControl m => Bool -> m a -> m a
    tracing :: Bool -> m a -> m a
    tracing shouldTrace :: Bool
    shouldTrace action :: m a
    action = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> Bool -> Sh (ShM m a) -> Sh (ShM m a)
    forall a. Bool -> Sh a -> Sh a
    S.tracing Bool
    shouldTrace (m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh m a
    action)

    escaping :: MonadShControl m => Bool -> m a -> m a
    escaping :: Bool -> m a -> m a
    escaping shouldEscape :: Bool
    shouldEscape action :: m a
    action = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> Bool -> Sh (ShM m a) -> Sh (ShM m a)
    forall a. Bool -> Sh a -> Sh a
    S.escaping Bool
    shouldEscape (m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh m a
    action)

    errExit :: MonadShControl m => Bool -> m a -> m a
    errExit :: Bool -> m a -> m a
    errExit shouldExit :: Bool
    shouldExit action :: m a
    action = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> Bool -> Sh (ShM m a) -> Sh (ShM m a)
    forall a. Bool -> Sh a -> Sh a
    S.errExit Bool
    shouldExit (m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh m a
    action)

    followSymlink :: MonadShControl m => Bool -> m a -> m a
    followSymlink :: Bool -> m a -> m a
    followSymlink enableFollowSymlink :: Bool
    enableFollowSymlink action :: m a
    action = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> Bool -> Sh (ShM m a) -> Sh (ShM m a)
    forall a. Bool -> Sh a -> Sh a
    S.followSymlink Bool
    enableFollowSymlink (m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh m a
    action)

    (-|-) :: (MonadShControl m, MonadSh m) => m Text -> m b -> m b
    one :: m Text
    one -|- :: m Text -> m b -> m b
    -|- two :: m b
    two = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m b)) -> m b
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m b)) -> m b)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m b)) -> m b
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> do
        ShM m Text
    x <- m Text -> Sh (ShM m Text)
    forall x. m x -> Sh (ShM m x)
    runInSh m Text
    one
        m b -> Sh (ShM m b)
    forall x. m x -> Sh (ShM m x)
    runInSh (m b -> Sh (ShM m b)) -> m b -> Sh (ShM m b)
    forall a b. (a -> b) -> a -> b
    $ ShM m Text -> m Text
    forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
    restoreSh ShM m Text
    x m Text -> (Text -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \x' :: Text
    x' ->
            ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m b)) -> m b
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m b)) -> m b)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m b)) -> m b
    forall a b. (a -> b) -> a -> b
    $ \runInSh' :: forall x. m x -> Sh (ShM m x)
    runInSh' -> Text -> Sh Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    x' Sh Text -> Sh (ShM m b) -> Sh (ShM m b)
    forall b. Sh Text -> Sh b -> Sh b
    S.-|- m b -> Sh (ShM m b)
    forall x. m x -> Sh (ShM m x)
    runInSh' m b
    two

    withTmpDir :: MonadShControl m => (FilePath -> m a) -> m a
    withTmpDir :: (FilePath -> m a) -> m a
    withTmpDir action :: FilePath -> m a
    action = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> (FilePath -> Sh (ShM m a)) -> Sh (ShM m a)
    forall a. (FilePath -> Sh a) -> Sh a
    S.withTmpDir ((m a -> Sh (ShM m a))
    -> (FilePath -> m a) -> FilePath -> Sh (ShM m a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh FilePath -> m a
    action)

    time :: MonadShControl m => m a -> m (Double, a)
    time :: m a -> m (Double, a)
    time what :: m a
    what = ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m (Double, a)))
    -> m (Double, a)
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m (Double, a)))
     -> m (Double, a))
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m (Double, a)))
    -> m (Double, a)
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> do
        (d :: Double
    d, a :: ShM m a
    a) <- Sh (ShM m a) -> Sh (Double, ShM m a)
    forall a. Sh a -> Sh (Double, a)
    S.time (m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh m a
    what)
        m (Double, a) -> Sh (ShM m (Double, a))
    forall x. m x -> Sh (ShM m x)
    runInSh (m (Double, a) -> Sh (ShM m (Double, a)))
    -> m (Double, a) -> Sh (ShM m (Double, a))
    forall a b. (a -> b) -> a -> b
    $ ShM m a -> m a
    forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
    restoreSh ShM m a
    a m a -> (a -> m (Double, a)) -> m (Double, a)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \x :: a
    x -> (Double, a) -> m (Double, a)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Double
    d, a
    x)

    toTextWarn :: MonadSh m => FilePath -> m Text
    toTextWarn :: FilePath -> m Text
    toTextWarn = Sh Text -> m Text
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh Text -> m Text) -> (FilePath -> Sh Text) -> FilePath -> m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh Text
    forall (m :: * -> *). MonadSh m => FilePath -> m Text
    toTextWarn

    transferLinesAndCombine :: MonadIO m => Handle -> (Text -> IO ()) -> m Text
    transferLinesAndCombine :: Handle -> (Text -> IO ()) -> m Text
    transferLinesAndCombine = (IO Text -> m Text
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text)
    -> ((Text -> IO ()) -> IO Text) -> (Text -> IO ()) -> m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .) (((Text -> IO ()) -> IO Text) -> (Text -> IO ()) -> m Text)
    -> (Handle -> (Text -> IO ()) -> IO Text)
    -> Handle
    -> (Text -> IO ())
    -> m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Handle -> (Text -> IO ()) -> IO Text
    S.transferLinesAndCombine

    get :: MonadSh m => m S.State
    get :: m State
    get = Sh State -> m State
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh Sh State
    S.get

    put :: MonadSh m => S.State -> m ()
    put :: State -> m ()
    put = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (State -> Sh ()) -> State -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . State -> Sh ()
    S.put

    catch_sh :: (Exception e) => Sh a -> (e -> Sh a) -> Sh a
    catch_sh :: Sh a -> (e -> Sh a) -> Sh a
    catch_sh = Sh a -> (e -> Sh a) -> Sh a
    forall (m :: * -> *) e a.
    (MonadBaseControl IO m, Exception e) =>
    m a -> (e -> m a) -> m a
    Control.Exception.Lifted.catch
    {-# DEPRECATED catch_sh "use Control.Exception.Lifted.catch instead" #-}

    handle_sh :: (Exception e) => (e -> Sh a) -> Sh a -> Sh a
    handle_sh :: (e -> Sh a) -> Sh a -> Sh a
    handle_sh = (e -> Sh a) -> Sh a -> Sh a
    forall (m :: * -> *) e a.
    (MonadBaseControl IO m, Exception e) =>
    (e -> m a) -> m a -> m a
    handle
    {-# DEPRECATED handle_sh "use Control.Exception.Lifted.handle instead" #-}

    finally_sh :: Sh a -> Sh b -> Sh a
    finally_sh :: Sh a -> Sh b -> Sh a
    finally_sh = Sh a -> Sh b -> Sh a
    forall (m :: * -> *) a b.
    MonadBaseControl IO m =>
    m a -> m b -> m a
    finally
    {-# DEPRECATED finally_sh "use Control.Exception.Lifted.finally instead" #-}

    bracket_sh :: Sh a -> (a -> Sh b) -> (a -> Sh c) -> Sh c
    bracket_sh :: Sh a -> (a -> Sh b) -> (a -> Sh c) -> Sh c
    bracket_sh = Sh a -> (a -> Sh b) -> (a -> Sh c) -> Sh c
    forall (m :: * -> *) a b c.
    MonadBaseControl IO m =>
    m a -> (a -> m b) -> (a -> m c) -> m c
    bracket
    {-# DEPRECATED bracket_sh "use Control.Exception.Lifted.bracket instead" #-}

    catches_sh :: Sh a -> [Handler Sh a] -> Sh a
    catches_sh :: Sh a -> [Handler Sh a] -> Sh a
    catches_sh = Sh a -> [Handler Sh a] -> Sh a
    forall (m :: * -> *) a.
    MonadBaseControl IO m =>
    m a -> [Handler m a] -> m a
    catches
    {-# DEPRECATED catches_sh "use Control.Exception.Lifted.catches instead" #-}

    catchany_sh :: Sh a -> (SomeException -> Sh a) -> Sh a
    catchany_sh :: Sh a -> (SomeException -> Sh a) -> Sh a
    catchany_sh = Sh a -> (SomeException -> Sh a) -> Sh a
    forall (m :: * -> *) a.
    MonadBaseControl IO m =>
    m a -> (SomeException -> m a) -> m a
    catchAny
    {-# DEPRECATED catchany_sh "use Control.Exception.Enclosed.catchAny instead" #-}

    handleany_sh :: (SomeException -> Sh a) -> Sh a -> Sh a
    handleany_sh :: (SomeException -> Sh a) -> Sh a -> Sh a
    handleany_sh = (SomeException -> Sh a) -> Sh a -> Sh a
    forall (m :: * -> *) a.
    MonadBaseControl IO m =>
    (SomeException -> m a) -> m a -> m a
    handleAny
    {-# DEPRECATED handleany_sh "use Control.Exception.Enclosed.handleAny instead" #-}

    cd :: MonadSh m => FilePath -> m ()
    cd :: FilePath -> m ()
    cd = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (FilePath -> Sh ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh ()
    S.cd

    mv :: MonadSh m => FilePath -> FilePath -> m ()
    mv :: FilePath -> FilePath -> m ()
    mv = (Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (FilePath -> Sh ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .) ((FilePath -> Sh ()) -> FilePath -> m ())
    -> (FilePath -> FilePath -> Sh ()) -> FilePath -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> FilePath -> Sh ()
    S.mv

    lsT :: MonadSh m => FilePath -> m [Text]
    lsT :: FilePath -> m [Text]
    lsT = Sh [Text] -> m [Text]
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh [Text] -> m [Text])
    -> (FilePath -> Sh [Text]) -> FilePath -> m [Text]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh [Text]
    S.lsT

    pwd :: MonadSh m => m FilePath
    pwd :: m FilePath
    pwd = Sh FilePath -> m FilePath
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh Sh FilePath
    S.pwd

    exit :: MonadSh m => Int -> m a
    exit :: Int -> m a
    exit = Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh a -> m a) -> (Int -> Sh a) -> Int -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Sh a
    forall a. Int -> Sh a
    S.exit

    errorExit :: MonadSh m => Text -> m a
    errorExit :: Text -> m a
    errorExit = Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh a -> m a) -> (Text -> Sh a) -> Text -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Sh a
    forall a. Text -> Sh a
    S.errorExit

    quietExit :: MonadSh m => Int -> m a
    quietExit :: Int -> m a
    quietExit = Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh a -> m a) -> (Int -> Sh a) -> Int -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Sh a
    forall a. Int -> Sh a
    S.quietExit

    terror :: MonadSh m => Text -> m a
    terror :: Text -> m a
    terror = Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh a -> m a) -> (Text -> Sh a) -> Text -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Sh a
    forall a. Text -> Sh a
    S.terror

    mkdir :: MonadSh m => FilePath -> m ()
    mkdir :: FilePath -> m ()
    mkdir = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (FilePath -> Sh ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh ()
    S.mkdir

    mkdir_p :: MonadSh m => FilePath -> m ()
    mkdir_p :: FilePath -> m ()
    mkdir_p = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (FilePath -> Sh ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh ()
    S.mkdir_p

    mkdirTree :: MonadSh m => Tree FilePath -> m ()
    mkdirTree :: Tree FilePath -> m ()
    mkdirTree = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ())
    -> (Tree FilePath -> Sh ()) -> Tree FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Tree FilePath -> Sh ()
    S.mkdirTree

    which :: MonadSh m => FilePath -> m (Maybe FilePath)
    which :: FilePath -> m (Maybe FilePath)
    which = Sh (Maybe FilePath) -> m (Maybe FilePath)
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh (Maybe FilePath) -> m (Maybe FilePath))
    -> (FilePath -> Sh (Maybe FilePath))
    -> FilePath
    -> m (Maybe FilePath)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh (Maybe FilePath)
    S.which

    test_e :: MonadSh m => FilePath -> m Bool
    test_e :: FilePath -> m Bool
    test_e = Sh Bool -> m Bool
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh Bool -> m Bool) -> (FilePath -> Sh Bool) -> FilePath -> m Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh Bool
    S.test_e

    test_f :: MonadSh m => FilePath -> m Bool
    test_f :: FilePath -> m Bool
    test_f = Sh Bool -> m Bool
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh Bool -> m Bool) -> (FilePath -> Sh Bool) -> FilePath -> m Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh Bool
    S.test_f

    test_px :: MonadSh m => FilePath -> m Bool
    test_px :: FilePath -> m Bool
    test_px = Sh Bool -> m Bool
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh Bool -> m Bool) -> (FilePath -> Sh Bool) -> FilePath -> m Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh Bool
    S.test_px

    rm_rf :: MonadSh m => FilePath -> m ()
    rm_rf :: FilePath -> m ()
    rm_rf = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (FilePath -> Sh ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh ()
    S.rm_rf

    rm_f :: MonadSh m => FilePath -> m ()
    rm_f :: FilePath -> m ()
    rm_f = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (FilePath -> Sh ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh ()
    S.rm_f

    rm :: MonadSh m => FilePath -> m ()
    rm :: FilePath -> m ()
    rm = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (FilePath -> Sh ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh ()
    S.rm

    setenv :: MonadSh m => Text -> Text -> m ()
    setenv :: Text -> Text -> m ()
    setenv = (Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (Text -> Sh ()) -> Text -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .) ((Text -> Sh ()) -> Text -> m ())
    -> (Text -> Text -> Sh ()) -> Text -> Text -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Text -> Sh ()
    S.setenv

    appendToPath :: MonadSh m => FilePath -> m ()
    appendToPath :: FilePath -> m ()
    appendToPath = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (FilePath -> Sh ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh ()
    S.appendToPath

    prependToPath :: MonadSh m => FilePath -> m ()
    prependToPath :: FilePath -> m ()
    prependToPath = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (FilePath -> Sh ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh ()
    S.prependToPath

    get_env_all :: MonadSh m => m [(String, String)]
    get_env_all :: m [(FilePath, FilePath)]
    get_env_all = Sh [(FilePath, FilePath)] -> m [(FilePath, FilePath)]
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh Sh [(FilePath, FilePath)]
    S.get_env_all

    get_env :: MonadSh m => Text -> m (Maybe Text)
    get_env :: Text -> m (Maybe Text)
    get_env = Sh (Maybe Text) -> m (Maybe Text)
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh (Maybe Text) -> m (Maybe Text))
    -> (Text -> Sh (Maybe Text)) -> Text -> m (Maybe Text)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Sh (Maybe Text)
    S.get_env

    get_env_text :: MonadSh m => Text -> m Text
    get_env_text :: Text -> m Text
    get_env_text = Sh Text -> m Text
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh Text -> m Text) -> (Text -> Sh Text) -> Text -> m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Sh Text
    S.get_env_text

    sshPairs_ :: MonadSh m => Text -> [(FilePath, [Text])] -> m ()
    sshPairs_ :: Text -> [(FilePath, [Text])] -> m ()
    sshPairs_ = (Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ())
    -> ([(FilePath, [Text])] -> Sh ()) -> [(FilePath, [Text])] -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .) (([(FilePath, [Text])] -> Sh ()) -> [(FilePath, [Text])] -> m ())
    -> (Text -> [(FilePath, [Text])] -> Sh ())
    -> Text
    -> [(FilePath, [Text])]
    -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> [(FilePath, [Text])] -> Sh ()
    S.sshPairs_

    sshPairs :: MonadSh m => Text -> [(FilePath, [Text])] -> m Text
    sshPairs :: Text -> [(FilePath, [Text])] -> m Text
    sshPairs = (Sh Text -> m Text
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh Text -> m Text)
    -> ([(FilePath, [Text])] -> Sh Text)
    -> [(FilePath, [Text])]
    -> m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .) (([(FilePath, [Text])] -> Sh Text)
     -> [(FilePath, [Text])] -> m Text)
    -> (Text -> [(FilePath, [Text])] -> Sh Text)
    -> Text
    -> [(FilePath, [Text])]
    -> m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> [(FilePath, [Text])] -> Sh Text
    S.sshPairs

    run :: MonadSh m => FilePath -> [Text] -> m Text
    run :: FilePath -> [Text] -> m Text
    run = (Sh Text -> m Text
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh Text -> m Text) -> ([Text] -> Sh Text) -> [Text] -> m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .) (([Text] -> Sh Text) -> [Text] -> m Text)
    -> (FilePath -> [Text] -> Sh Text) -> FilePath -> [Text] -> m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> [Text] -> Sh Text
    S.run

    command :: MonadSh m => FilePath -> [Text] -> [Text] -> m Text
    command :: FilePath -> [Text] -> [Text] -> m Text
    command com :: FilePath
    com args :: [Text]
    args more_args :: [Text]
    more_args =
        Sh Text -> m Text
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh Text -> m Text) -> Sh Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ FilePath -> [Text] -> [Text] -> Sh Text
    S.command FilePath
    com [Text]
    args [Text]
    more_args

    command_ :: MonadSh m => FilePath -> [Text] -> [Text] -> m ()
    command_ :: FilePath -> [Text] -> [Text] -> m ()
    command_ com :: FilePath
    com args :: [Text]
    args more_args :: [Text]
    more_args =
        Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> Sh () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FilePath -> [Text] -> [Text] -> Sh ()
    S.command_ FilePath
    com [Text]
    args [Text]
    more_args

    command1 :: MonadSh m => FilePath -> [Text] -> Text -> [Text] -> m Text
    command1 :: FilePath -> [Text] -> Text -> [Text] -> m Text
    command1 com :: FilePath
    com args :: [Text]
    args one_arg :: Text
    one_arg more_args :: [Text]
    more_args =
        Sh Text -> m Text
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh Text -> m Text) -> Sh Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ FilePath -> [Text] -> Text -> [Text] -> Sh Text
    S.command1 FilePath
    com [Text]
    args Text
    one_arg [Text]
    more_args

    command1_ :: MonadSh m => FilePath -> [Text] -> Text -> [Text] -> m ()
    command1_ :: FilePath -> [Text] -> Text -> [Text] -> m ()
    command1_ com :: FilePath
    com args :: [Text]
    args one_arg :: Text
    one_arg more_args :: [Text]
    more_args =
        Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> Sh () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FilePath -> [Text] -> Text -> [Text] -> Sh ()
    S.command1_ FilePath
    com [Text]
    args Text
    one_arg [Text]
    more_args

    run_ :: MonadSh m => FilePath -> [Text] -> m ()
    run_ :: FilePath -> [Text] -> m ()
    run_ = (Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> ([Text] -> Sh ()) -> [Text] -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .) (([Text] -> Sh ()) -> [Text] -> m ())
    -> (FilePath -> [Text] -> Sh ()) -> FilePath -> [Text] -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> [Text] -> Sh ()
    S.run_

    runHandle :: MonadShControl m => FilePath -- ^ command
              -> [Text] -- ^ arguments
              -> (Handle -> m a) -- ^ stdout handle
              -> m a
    runHandle :: FilePath -> [Text] -> (Handle -> m a) -> m a
    runHandle exe :: FilePath
    exe args :: [Text]
    args withHandle :: Handle -> m a
    withHandle =
        ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh -> FilePath -> [Text] -> (Handle -> Sh (ShM m a)) -> Sh (ShM m a)
    forall a. FilePath -> [Text] -> (Handle -> Sh a) -> Sh a
    S.runHandle FilePath
    exe [Text]
    args ((m a -> Sh (ShM m a)) -> (Handle -> m a) -> Handle -> Sh (ShM m a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh Handle -> m a
    withHandle)

    runHandles :: MonadShControl m => FilePath -- ^ command
               -> [Text] -- ^ arguments
               -> [S.StdHandle] -- ^ optionally connect process i/o handles to existing handles
               -> (Handle -> Handle -> Handle -> m a) -- ^ stdin, stdout and stderr
               -> m a
    runHandles :: FilePath
    -> [Text]
    -> [StdHandle]
    -> (Handle -> Handle -> Handle -> m a)
    -> m a
    runHandles exe :: FilePath
    exe args :: [Text]
    args reusedHandles :: [StdHandle]
    reusedHandles withHandles :: Handle -> Handle -> Handle -> m a
    withHandles =
        ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall (m :: * -> *) a.
    MonadShControl m =>
    ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    controlSh (((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a)
    -> ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \runInSh :: forall x. m x -> Sh (ShM m x)
    runInSh ->
            FilePath
    -> [Text]
    -> [StdHandle]
    -> (Handle -> Handle -> Handle -> Sh (ShM m a))
    -> Sh (ShM m a)
    forall a.
    FilePath
    -> [Text]
    -> [StdHandle]
    -> (Handle -> Handle -> Handle -> Sh a)
    -> Sh a
    S.runHandles FilePath
    exe [Text]
    args [StdHandle]
    reusedHandles (((Handle -> Handle -> m a) -> Handle -> Handle -> Sh (ShM m a))
    -> (Handle -> Handle -> Handle -> m a)
    -> Handle
    -> Handle
    -> Handle
    -> Sh (ShM m a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (((Handle -> m a) -> Handle -> Sh (ShM m a))
    -> (Handle -> Handle -> m a) -> Handle -> Handle -> Sh (ShM m a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((m a -> Sh (ShM m a)) -> (Handle -> m a) -> Handle -> Sh (ShM m a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap m a -> Sh (ShM m a)
    forall x. m x -> Sh (ShM m x)
    runInSh)) Handle -> Handle -> Handle -> m a
    withHandles)

    runFoldLines :: MonadSh m => a -> S.FoldCallback a -> FilePath -> [Text] -> m a
    runFoldLines :: a -> FoldCallback a -> FilePath -> [Text] -> m a
    runFoldLines start :: a
    start cb :: FoldCallback a
    cb exe :: FilePath
    exe args :: [Text]
    args = Sh a -> m a
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh a -> m a) -> Sh a -> m a
    forall a b. (a -> b) -> a -> b
    $ a -> FoldCallback a -> FilePath -> [Text] -> Sh a
    forall a. a -> FoldCallback a -> FilePath -> [Text] -> Sh a
    S.runFoldLines a
    start FoldCallback a
    cb FilePath
    exe [Text]
    args

    lastStderr :: MonadSh m => m Text
    lastStderr :: m Text
    lastStderr = Sh Text -> m Text
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh Sh Text
    S.lastStderr

    lastExitCode :: MonadSh m => m Int
    lastExitCode :: m Int
    lastExitCode = Sh Int -> m Int
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh Sh Int
    S.lastExitCode

    setStdin :: MonadSh m => Text -> m ()
    setStdin :: Text -> m ()
    setStdin = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (Text -> Sh ()) -> Text -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Sh ()
    S.setStdin

    cp_r :: MonadSh m => FilePath -> FilePath -> m ()
    cp_r :: FilePath -> FilePath -> m ()
    cp_r = (Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (FilePath -> Sh ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .) ((FilePath -> Sh ()) -> FilePath -> m ())
    -> (FilePath -> FilePath -> Sh ()) -> FilePath -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> FilePath -> Sh ()
    S.cp_r

    cp :: MonadSh m => FilePath -> FilePath -> m ()
    cp :: FilePath -> FilePath -> m ()
    cp = (Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (FilePath -> Sh ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .) ((FilePath -> Sh ()) -> FilePath -> m ())
    -> (FilePath -> FilePath -> Sh ()) -> FilePath -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> FilePath -> Sh ()
    S.cp

    writefile :: MonadSh m => FilePath -> Text -> m ()
    writefile :: FilePath -> Text -> m ()
    writefile = (Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (Text -> Sh ()) -> Text -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .) ((Text -> Sh ()) -> Text -> m ())
    -> (FilePath -> Text -> Sh ()) -> FilePath -> Text -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Text -> Sh ()
    S.writefile

    touchfile :: MonadSh m => FilePath -> m ()
    touchfile :: FilePath -> m ()
    touchfile = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (FilePath -> Sh ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh ()
    S.touchfile

    appendfile :: MonadSh m => FilePath -> Text -> m ()
    appendfile :: FilePath -> Text -> m ()
    appendfile = (Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (Text -> Sh ()) -> Text -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .) ((Text -> Sh ()) -> Text -> m ())
    -> (FilePath -> Text -> Sh ()) -> FilePath -> Text -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Text -> Sh ()
    S.appendfile

    readfile :: MonadSh m => FilePath -> m Text
    readfile :: FilePath -> m Text
    readfile = Sh Text -> m Text
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh Text -> m Text) -> (FilePath -> Sh Text) -> FilePath -> m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh Text
    S.readfile

    readBinary :: MonadSh m => FilePath -> m ByteString
    readBinary :: FilePath -> m ByteString
    readBinary = Sh ByteString -> m ByteString
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh ByteString -> m ByteString)
    -> (FilePath -> Sh ByteString) -> FilePath -> m ByteString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh ByteString
    S.readBinary

    sleep :: MonadSh m => Int -> m ()
    sleep :: Int -> m ()
    sleep = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (Int -> Sh ()) -> Int -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Sh ()
    S.sleep

    echo, echo_n, echo_err, echo_n_err :: MonadSh m => Text -> m ()
    echo :: Text -> m ()
    echo       = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (Text -> Sh ()) -> Text -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Sh ()
    S.echo
    echo_n :: Text -> m ()
    echo_n     = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (Text -> Sh ()) -> Text -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Sh ()
    S.echo_n
    echo_err :: Text -> m ()
    echo_err   = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (Text -> Sh ()) -> Text -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Sh ()
    S.echo_err
    echo_n_err :: Text -> m ()
    echo_n_err = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (Text -> Sh ()) -> Text -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Sh ()
    S.echo_n_err

    relPath :: MonadSh m => FilePath -> m FilePath
    relPath :: FilePath -> m FilePath
    relPath = Sh FilePath -> m FilePath
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh FilePath -> m FilePath)
    -> (FilePath -> Sh FilePath) -> FilePath -> m FilePath
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh FilePath
    S.relPath

    relativeTo :: MonadSh m => FilePath -- ^ anchor path, the prefix
               -> FilePath -- ^ make this relative to anchor path
               -> m FilePath
    relativeTo :: FilePath -> FilePath -> m FilePath
    relativeTo = (Sh FilePath -> m FilePath
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh FilePath -> m FilePath)
    -> (FilePath -> Sh FilePath) -> FilePath -> m FilePath
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .) ((FilePath -> Sh FilePath) -> FilePath -> m FilePath)
    -> (FilePath -> FilePath -> Sh FilePath)
    -> FilePath
    -> FilePath
    -> m FilePath
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> FilePath -> Sh FilePath
    S.relativeTo

    canonic :: MonadSh m => FilePath -> m FilePath
    canonic :: FilePath -> m FilePath
    canonic = Sh FilePath -> m FilePath
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh FilePath -> m FilePath)
    -> (FilePath -> Sh FilePath) -> FilePath -> m FilePath
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh FilePath
    forall (m :: * -> *). MonadSh m => FilePath -> m FilePath
    canonic

    -- | Obtain a (reasonably) canonic file path to a filesystem object. Based on
    -- "canonicalizePath" in system-fileio.
    canonicalize :: MonadSh m => FilePath -> m FilePath
    canonicalize :: FilePath -> m FilePath
    canonicalize = Sh FilePath -> m FilePath
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh FilePath -> m FilePath)
    -> (FilePath -> Sh FilePath) -> FilePath -> m FilePath
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh FilePath
    S.canonicalize

    absPath :: MonadSh m => FilePath -> m FilePath
    absPath :: FilePath -> m FilePath
    absPath = Sh FilePath -> m FilePath
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh FilePath -> m FilePath)
    -> (FilePath -> Sh FilePath) -> FilePath -> m FilePath
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh FilePath
    S.absPath

    test_d :: MonadSh m => FilePath -> m Bool
    test_d :: FilePath -> m Bool
    test_d = Sh Bool -> m Bool
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh Bool -> m Bool) -> (FilePath -> Sh Bool) -> FilePath -> m Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh Bool
    S.test_d

    test_s :: MonadSh m => FilePath -> m Bool
    test_s :: FilePath -> m Bool
    test_s = Sh Bool -> m Bool
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh Bool -> m Bool) -> (FilePath -> Sh Bool) -> FilePath -> m Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh Bool
    S.test_s

    ls :: MonadSh m => FilePath -> m [FilePath]
    ls :: FilePath -> m [FilePath]
    ls = Sh [FilePath] -> m [FilePath]
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh [FilePath] -> m [FilePath])
    -> (FilePath -> Sh [FilePath]) -> FilePath -> m [FilePath]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> Sh [FilePath]
    S.ls

    inspect :: (Show s, MonadSh m) => s -> m ()
    inspect :: s -> m ()
    inspect = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (s -> Sh ()) -> s -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . s -> Sh ()
    forall s. Show s => s -> Sh ()
    S.inspect

    inspect_err :: (Show s, MonadSh m) => s -> m ()
    inspect_err :: s -> m ()
    inspect_err = Sh () -> m ()
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
    liftSh (Sh () -> m ()) -> (s -> Sh ()) -> s -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . s -> Sh ()
    forall s. Show s => s -> Sh ()
    S.inspect_err

    catchany :: MonadBaseControl IO m => m a -> (SomeException -> m a) -> m a
    catchany :: m a -> (SomeException -> m a) -> m a
    catchany = m a -> (SomeException -> m a) -> m a
    forall (m :: * -> *) e a.
    (MonadBaseControl IO m, Exception e) =>
    m a -> (e -> m a) -> m a
    Control.Exception.Lifted.catch