{-# 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, print_commands_with
         , 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, echoWith, 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 qualified Shelly.Base as S
import Shelly.Base     ( Sh(..), ShIO, Text, (>=>) )

import Control.Monad   ( liftM )
import Data.ByteString ( ByteString )
import Data.Tree       ( Tree )
import System.IO       ( Handle )

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.Maybe
import Control.Monad.Trans.Cont
import Control.Monad.Trans.Except
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 :: forall a. Sh a -> Sh a
liftSh = forall a. a -> a
id

instance MonadSh m => MonadSh (IdentityT m) where
    liftSh :: forall a. Sh a -> IdentityT m a
liftSh = forall {k} (f :: k -> *) (a :: k). f a -> IdentityT f a
IdentityT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh

instance MonadSh m => MonadSh (MaybeT m) where
    liftSh :: forall a. Sh a -> MaybeT m a
liftSh = forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh

instance MonadSh m => MonadSh (ContT r m) where
    liftSh :: forall a. Sh a -> ContT r m a
liftSh Sh a
m = forall {k} (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh Sh a
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=)

instance (MonadSh m) => MonadSh (ExceptT e m) where
    liftSh :: forall a. Sh a -> ExceptT e m a
liftSh Sh a
m = forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT forall a b. (a -> b) -> a -> b
$ do
        a
a <- forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh Sh a
m
        forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. b -> Either a b
Right a
a)

instance MonadSh m => MonadSh (ReaderT r m) where
    liftSh :: forall a. Sh a -> ReaderT r m a
liftSh = forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> b -> a
const forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh

instance MonadSh m => MonadSh (StateT s m) where
    liftSh :: forall a. Sh a -> StateT s m a
liftSh Sh a
m = forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
StateT forall a b. (a -> b) -> a -> b
$ \s
s -> do
        a
a <- forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh Sh a
m
        forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, s
s)

instance MonadSh m => MonadSh (Strict.StateT s m) where
    liftSh :: forall a. Sh a -> StateT s m a
liftSh Sh a
m = forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
Strict.StateT forall a b. (a -> b) -> a -> b
$ \s
s -> do
        a
a <- forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh Sh a
m
        forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, s
s)

instance (Monoid w, MonadSh m) => MonadSh (WriterT w m) where
    liftSh :: forall a. Sh a -> WriterT w m a
liftSh Sh a
m = forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
WriterT forall a b. (a -> b) -> a -> b
$ do
        a
a <- forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh Sh a
m
        forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, forall a. Monoid a => a
mempty :: w)

instance (Monoid w, MonadSh m) => MonadSh (Strict.WriterT w m) where
    liftSh :: forall a. Sh a -> WriterT w m a
liftSh Sh a
m = forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
Strict.WriterT forall a b. (a -> b) -> a -> b
$ do
        a
a <- forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh Sh a
m
        forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, forall a. Monoid a => a
mempty :: w)

instance (Monoid w, MonadSh m) => MonadSh (RWS.RWST r w s m) where
    liftSh :: forall a. Sh a -> RWST r w s m a
liftSh Sh a
m = forall r w s (m :: * -> *) a.
(r -> s -> m (a, s, w)) -> RWST r w s m a
RWS.RWST forall a b. (a -> b) -> a -> b
$ \r
_ s
s -> do
        a
a <- forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh Sh a
m
        forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, s
s, forall a. Monoid a => a
mempty :: w)

instance (Monoid w, MonadSh m) => MonadSh (Strict.RWST r w s m) where
    liftSh :: forall a. Sh a -> RWST r w s m a
liftSh Sh a
m = forall r w s (m :: * -> *) a.
(r -> s -> m (a, s, w)) -> RWST r w s m a
Strict.RWST forall a b. (a -> b) -> a -> b
$ \r
_ s
s -> do
        a
a <- forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh Sh a
m
        forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, s
s, forall a. Monoid a => a
mempty :: w)

instance MonadSh m => S.ShellCmd (m Text) where
    cmdAll :: FilePath -> [Text] -> m Text
cmdAll = (forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall b c a. (b -> c) -> (a -> b) -> a -> c
.) 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 = (forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall b c a. (b -> c) -> (a -> b) -> a -> c
.) 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 = (forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall b c a. (b -> c) -> (a -> b) -> a -> c
.) 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 a. ((forall x. Sh x -> Sh (ShM Sh x)) -> Sh a) -> Sh a
liftShWith (forall x. Sh x -> Sh (ShM Sh x)) -> Sh a
f = (forall x. Sh x -> Sh (ShM Sh x)) -> Sh a
f forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall a. a -> ShM Sh a
ShSh
     restoreSh :: forall a. ShM Sh a -> Sh a
restoreSh (ShSh a
x) = forall (m :: * -> *) a. Monad m => a -> m a
return a
x
     {-# INLINE liftShWith #-}
     {-# INLINE restoreSh #-}

instance MonadShControl m => MonadShControl (MaybeT m) where
    newtype ShM (MaybeT m) a = MaybeTShM (ShM m (Maybe a))
    liftShWith :: forall a.
((forall x. MaybeT m x -> Sh (ShM (MaybeT m) x)) -> Sh a)
-> MaybeT m a
liftShWith (forall x. MaybeT m x -> Sh (ShM (MaybeT m) x)) -> Sh a
f =
        forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
liftShWith forall a b. (a -> b) -> a -> b
$ \forall x. m x -> Sh (ShM m x)
runInSh -> (forall x. MaybeT m x -> Sh (ShM (MaybeT m) x)) -> Sh a
f forall a b. (a -> b) -> a -> b
$ \MaybeT m x
k ->
            forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall (m :: * -> *) a. ShM m (Maybe a) -> ShM (MaybeT m) a
MaybeTShM forall a b. (a -> b) -> a -> b
$ forall x. m x -> Sh (ShM m x)
runInSh forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
runMaybeT MaybeT m x
k
    restoreSh :: forall a. ShM (MaybeT m) a -> MaybeT m a
restoreSh (MaybeTShM ShM m (Maybe a)
m) = forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
restoreSh 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 a.
((forall x. IdentityT m x -> Sh (ShM (IdentityT m) x)) -> Sh a)
-> IdentityT m a
liftShWith (forall x. IdentityT m x -> Sh (ShM (IdentityT m) x)) -> Sh a
f =
        forall {k} (f :: k -> *) (a :: k). f a -> IdentityT f a
IdentityT forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall a. a -> a
id forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
liftShWith forall a b. (a -> b) -> a -> b
$ \forall x. m x -> Sh (ShM m x)
runInSh -> (forall x. IdentityT m x -> Sh (ShM (IdentityT m) x)) -> Sh a
f forall a b. (a -> b) -> a -> b
$ \IdentityT m x
k ->
            forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall (m :: * -> *) a. ShM m a -> ShM (IdentityT m) a
IdentityTShM forall a b. (a -> b) -> a -> b
$ forall x. m x -> Sh (ShM m x)
runInSh forall a b. (a -> b) -> a -> b
$ forall {k} (f :: k -> *) (a :: k). IdentityT f a -> f a
runIdentityT IdentityT m x
k
    restoreSh :: forall a. ShM (IdentityT m) a -> IdentityT m a
restoreSh (IdentityTShM ShM m a
m) = forall {k} (f :: k -> *) (a :: k). f a -> IdentityT f a
IdentityT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
restoreSh 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 a.
((forall x. WriterT w m x -> Sh (ShM (WriterT w m) x)) -> Sh a)
-> WriterT w m a
liftShWith (forall x. WriterT w m x -> Sh (ShM (WriterT w m) x)) -> Sh a
f =
        forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
WriterT forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  (\a
x -> (a
x, forall a. Monoid a => a
mempty :: w)) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
liftShWith forall a b. (a -> b) -> a -> b
$ \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 a b. (a -> b) -> a -> b
$ \WriterT w m x
k ->
            forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall w (m :: * -> *) a. ShM m (a, w) -> ShM (WriterT w m) a
WriterTShM forall a b. (a -> b) -> a -> b
$ forall x. m x -> Sh (ShM m x)
runInSh forall a b. (a -> b) -> a -> b
$ forall w (m :: * -> *) a. WriterT w m a -> m (a, w)
runWriterT WriterT w m x
k
    restoreSh :: forall a. ShM (WriterT w m) a -> WriterT w m a
restoreSh (WriterTShM ShM m (a, w)
m) = forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
WriterT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
restoreSh 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 a.
((forall x. WriterT w m x -> Sh (ShM (WriterT w m) x)) -> Sh a)
-> WriterT w m a
liftShWith (forall x. WriterT w m x -> Sh (ShM (WriterT w m) x)) -> Sh a
f =
        forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
Strict.WriterT forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (\a
x -> (a
x, forall a. Monoid a => a
mempty :: w)) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
liftShWith forall a b. (a -> b) -> a -> b
$ \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 a b. (a -> b) -> a -> b
$ \WriterT w m x
k ->
            forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall w (m :: * -> *) a. ShM m (a, w) -> ShM (WriterT w m) a
StWriterTShM forall a b. (a -> b) -> a -> b
$ forall x. m x -> Sh (ShM m x)
runInSh forall a b. (a -> b) -> a -> b
$ forall w (m :: * -> *) a. WriterT w m a -> m (a, w)
Strict.runWriterT WriterT w m x
k
    restoreSh :: forall a. ShM (WriterT w m) a -> WriterT w m a
restoreSh (StWriterTShM ShM m (a, w)
m) = forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
Strict.WriterT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
restoreSh forall a b. (a -> b) -> a -> b
$ ShM m (a, w)
m
    {-# INLINE liftShWith #-}
    {-# INLINE restoreSh #-}

instance MonadShControl m => MonadShControl (ExceptT e m) where
    newtype ShM (ExceptT e m) a = ExceptTShM (ShM m (Either e a))
    liftShWith :: forall a.
((forall x. ExceptT e m x -> Sh (ShM (ExceptT e m) x)) -> Sh a)
-> ExceptT e m a
liftShWith (forall x. ExceptT e m x -> Sh (ShM (ExceptT e m) x)) -> Sh a
f =
        forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
liftShWith forall a b. (a -> b) -> a -> b
$ \forall x. m x -> Sh (ShM m x)
runInSh -> (forall x. ExceptT e m x -> Sh (ShM (ExceptT e m) x)) -> Sh a
f forall a b. (a -> b) -> a -> b
$ \ExceptT e m x
k ->
            forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall e (m :: * -> *) a. ShM m (Either e a) -> ShM (ExceptT e m) a
ExceptTShM forall a b. (a -> b) -> a -> b
$ forall x. m x -> Sh (ShM m x)
runInSh forall a b. (a -> b) -> a -> b
$ forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT ExceptT e m x
k
    restoreSh :: forall a. ShM (ExceptT e m) a -> ExceptT e m a
restoreSh (ExceptTShM ShM m (Either e a)
m) = forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
restoreSh 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 a.
((forall x. StateT s m x -> Sh (ShM (StateT s m) x)) -> Sh a)
-> StateT s m a
liftShWith (forall x. StateT s m x -> Sh (ShM (StateT s m) x)) -> Sh a
f = forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
StateT forall a b. (a -> b) -> a -> b
$ \s
s ->
        forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (\a
x -> (a
x,s
s)) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
liftShWith forall a b. (a -> b) -> a -> b
$ \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 a b. (a -> b) -> a -> b
$ \StateT s m x
k ->
            forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall s (m :: * -> *) a. ShM m (a, s) -> ShM (StateT s m) a
StateTShM forall a b. (a -> b) -> a -> b
$ forall x. m x -> Sh (ShM m x)
runInSh forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT StateT s m x
k s
s
    restoreSh :: forall a. ShM (StateT s m) a -> StateT s m a
restoreSh (StateTShM ShM m (a, s)
m) = forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
StateT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> b -> a
const forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
restoreSh 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 a.
((forall x. StateT s m x -> Sh (ShM (StateT s m) x)) -> Sh a)
-> StateT s m a
liftShWith (forall x. StateT s m x -> Sh (ShM (StateT s m) x)) -> Sh a
f = forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
Strict.StateT forall a b. (a -> b) -> a -> b
$ \s
s ->
        forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (\a
x -> (a
x,s
s)) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
liftShWith forall a b. (a -> b) -> a -> b
$ \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 a b. (a -> b) -> a -> b
$ \StateT s m x
k ->
            forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall s (m :: * -> *) a. ShM m (a, s) -> ShM (StateT s m) a
StStateTShM forall a b. (a -> b) -> a -> b
$ forall x. m x -> Sh (ShM m x)
runInSh forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
Strict.runStateT StateT s m x
k s
s
    restoreSh :: forall a. ShM (StateT s m) a -> StateT s m a
restoreSh (StStateTShM ShM m (a, s)
m) = forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
Strict.StateT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> b -> a
const forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
restoreSh 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 a.
((forall x. ReaderT r m x -> Sh (ShM (ReaderT r m) x)) -> Sh a)
-> ReaderT r m a
liftShWith (forall x. ReaderT r m x -> Sh (ShM (ReaderT r m) x)) -> Sh a
f = forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT forall a b. (a -> b) -> a -> b
$ \r
r ->
        forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall a. a -> a
id forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
liftShWith forall a b. (a -> b) -> a -> b
$ \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 a b. (a -> b) -> a -> b
$ \ReaderT r m x
k ->
            forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall r (m :: * -> *) a. ShM m a -> ShM (ReaderT r m) a
ReaderTShM forall a b. (a -> b) -> a -> b
$ forall x. m x -> Sh (ShM m x)
runInSh forall a b. (a -> b) -> a -> b
$ forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ReaderT r m x
k r
r
    restoreSh :: forall a. ShM (ReaderT r m) a -> ReaderT r m a
restoreSh (ReaderTShM ShM m a
m) = forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> b -> a
const forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
restoreSh 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 a.
((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 (forall x. RWST r w s m x -> Sh (ShM (RWST r w s m) x)) -> Sh a
f = forall r w s (m :: * -> *) a.
(r -> s -> m (a, s, w)) -> RWST r w s m a
RWS.RWST forall a b. (a -> b) -> a -> b
$ \r
r s
s ->
        forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (\a
x -> (a
x,s
s,forall a. Monoid a => a
mempty :: w)) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
liftShWith forall a b. (a -> b) -> a -> b
$ \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 a b. (a -> b) -> a -> b
$ \RWST r w s m x
k ->
            forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall r w s (m :: * -> *) a.
ShM m (a, s, w) -> ShM (RWST r w s m) a
RWSTShM forall a b. (a -> b) -> a -> b
$ forall x. m x -> Sh (ShM m x)
runInSh forall a b. (a -> b) -> a -> b
$ 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 :: forall a. ShM (RWST r w s m) a -> RWST r w s m a
restoreSh (RWSTShM ShM m (a, s, w)
m) = forall r w s (m :: * -> *) a.
(r -> s -> m (a, s, w)) -> RWST r w s m a
RWS.RWST forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> b -> a
const forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> b -> a
const forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
restoreSh 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 a.
((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 (forall x. RWST r w s m x -> Sh (ShM (RWST r w s m) x)) -> Sh a
f = forall r w s (m :: * -> *) a.
(r -> s -> m (a, s, w)) -> RWST r w s m a
Strict.RWST forall a b. (a -> b) -> a -> b
$ \r
r s
s ->
        forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (\a
x -> (a
x,s
s,forall a. Monoid a => a
mempty :: w)) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
liftShWith forall a b. (a -> b) -> a -> b
$ \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 a b. (a -> b) -> a -> b
$ \RWST r w s m x
k ->
            forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall r w s (m :: * -> *) a.
ShM m (a, s, w) -> ShM (RWST r w s m) a
StRWSTShM forall a b. (a -> b) -> a -> b
$ forall x. m x -> Sh (ShM m x)
runInSh forall a b. (a -> b) -> a -> b
$ 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 :: forall a. ShM (RWST r w s m) a -> RWST r w s m a
restoreSh (StRWSTShM ShM m (a, s, w)
m) = forall r w s (m :: * -> *) a.
(r -> s -> m (a, s, w)) -> RWST r w s m a
Strict.RWST forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> b -> a
const forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> b -> a
const forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
restoreSh 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 (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
controlSh = forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a
liftShWith forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall (m :: * -> *) a. MonadShControl m => ShM m a -> m a
restoreSh
{-# INLINE controlSh #-}

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

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

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

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

verbosely :: MonadShControl m => m a -> m a
verbosely :: forall (m :: * -> *) a. MonadShControl m => m a -> m a
verbosely m a
a = forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
controlSh forall a b. (a -> b) -> a -> b
$ \forall x. m x -> Sh (ShM m x)
runInSh -> forall a. Sh a -> Sh a
S.verbosely (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 :: forall (m :: * -> *) a.
MonadShControl m =>
(Text -> IO ()) -> m a -> m a
log_stdout_with Text -> IO ()
logger m a
a = forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
controlSh forall a b. (a -> b) -> a -> b
$ \forall x. m x -> Sh (ShM m x)
runInSh -> forall a. (Text -> IO ()) -> Sh a -> Sh a
S.log_stdout_with Text -> IO ()
logger (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 :: forall (m :: * -> *) a.
MonadShControl m =>
(Text -> IO ()) -> m a -> m a
log_stderr_with Text -> IO ()
logger m a
a = forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
controlSh forall a b. (a -> b) -> a -> b
$ \forall x. m x -> Sh (ShM m x)
runInSh -> forall a. (Text -> IO ()) -> Sh a -> Sh a
S.log_stderr_with Text -> IO ()
logger (forall x. m x -> Sh (ShM m x)
runInSh m a
a)

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

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

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

-- | @since 1.12.1
print_commands_with :: MonadShControl m => (Text -> IO ()) -> m a -> m a
print_commands_with :: forall (m :: * -> *) a.
MonadShControl m =>
(Text -> IO ()) -> m a -> m a
print_commands_with Text -> IO ()
fn m a
a = forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
controlSh forall a b. (a -> b) -> a -> b
$ \forall x. m x -> Sh (ShM m x)
runInSh -> forall a. (Text -> IO ()) -> Sh a -> Sh a
S.print_commands_with Text -> IO ()
fn (forall x. m x -> Sh (ShM m x)
runInSh m a
a)

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

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

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

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

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

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

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

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

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

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

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

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

put :: MonadSh m => S.State -> m ()
put :: forall (m :: * -> *). MonadSh m => State -> m ()
put = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh 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 :: forall e a. Exception e => Sh a -> (e -> Sh a) -> Sh a
catch_sh = 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 :: forall e a. Exception e => (e -> Sh a) -> Sh a -> Sh a
handle_sh = 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 :: forall a b. Sh a -> Sh b -> Sh a
finally_sh = 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 :: forall a b c. Sh a -> (a -> Sh b) -> (a -> Sh c) -> Sh c
bracket_sh = 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 :: forall a. Sh a -> [Handler Sh a] -> Sh a
catches_sh = 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 :: forall a. Sh a -> (SomeException -> Sh a) -> Sh a
catchany_sh = 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 :: forall a. (SomeException -> Sh a) -> Sh a -> Sh a
handleany_sh = 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 :: forall (m :: * -> *). MonadSh m => FilePath -> m ()
cd = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> Sh ()
S.cd

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

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

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

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

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

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

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

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

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

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

which :: MonadSh m => FilePath -> m (Maybe FilePath)
which :: forall (m :: * -> *). MonadSh m => FilePath -> m (Maybe FilePath)
which = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh 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 :: forall (m :: * -> *). MonadSh m => FilePath -> m Bool
test_e = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh 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 :: forall (m :: * -> *). MonadSh m => FilePath -> m Bool
test_f = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh 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 :: forall (m :: * -> *). MonadSh m => FilePath -> m Bool
test_px = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> Sh Bool
S.test_px

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

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

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

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

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

prependToPath :: MonadSh m => FilePath -> m ()
prependToPath :: forall (m :: * -> *). MonadSh m => FilePath -> m ()
prependToPath = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh 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 :: forall (m :: * -> *). MonadSh m => m [(FilePath, FilePath)]
get_env_all = 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 :: forall (m :: * -> *). MonadSh m => Text -> m (Maybe Text)
get_env = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh 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 :: forall (m :: * -> *). MonadSh m => Text -> m Text
get_env_text = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh 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_ :: forall (m :: * -> *).
MonadSh m =>
Text -> [(FilePath, [Text])] -> m ()
sshPairs_ = (forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall b c a. (b -> c) -> (a -> b) -> a -> c
.) 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 :: forall (m :: * -> *).
MonadSh m =>
Text -> [(FilePath, [Text])] -> m Text
sshPairs = (forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall b c a. (b -> c) -> (a -> b) -> a -> c
.) 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 :: forall (m :: * -> *). MonadSh m => FilePath -> [Text] -> m Text
run = (forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall b c a. (b -> c) -> (a -> b) -> a -> c
.) 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 :: forall (m :: * -> *).
MonadSh m =>
FilePath -> [Text] -> [Text] -> m Text
command FilePath
com [Text]
args [Text]
more_args =
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh 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_ :: forall (m :: * -> *).
MonadSh m =>
FilePath -> [Text] -> [Text] -> m ()
command_ FilePath
com [Text]
args [Text]
more_args =
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh 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 :: forall (m :: * -> *).
MonadSh m =>
FilePath -> [Text] -> Text -> [Text] -> m Text
command1 FilePath
com [Text]
args Text
one_arg [Text]
more_args =
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh 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_ :: forall (m :: * -> *).
MonadSh m =>
FilePath -> [Text] -> Text -> [Text] -> m ()
command1_ FilePath
com [Text]
args Text
one_arg [Text]
more_args =
    forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh 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_ :: forall (m :: * -> *). MonadSh m => FilePath -> [Text] -> m ()
run_ = (forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall b c a. (b -> c) -> (a -> b) -> a -> c
.) 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 :: forall (m :: * -> *) a.
MonadShControl m =>
FilePath -> [Text] -> (Handle -> m a) -> m a
runHandle FilePath
exe [Text]
args Handle -> m a
withHandle =
    forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
controlSh forall a b. (a -> b) -> a -> b
$ \forall x. m x -> Sh (ShM m x)
runInSh -> forall a. FilePath -> [Text] -> (Handle -> Sh a) -> Sh a
S.runHandle FilePath
exe [Text]
args (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap 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 :: forall (m :: * -> *) a.
MonadShControl m =>
FilePath
-> [Text]
-> [StdHandle]
-> (Handle -> Handle -> Handle -> m a)
-> m a
runHandles FilePath
exe [Text]
args [StdHandle]
reusedHandles Handle -> Handle -> Handle -> m a
withHandles =
    forall (m :: * -> *) a.
MonadShControl m =>
((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a
controlSh forall a b. (a -> b) -> a -> b
$ \forall x. m x -> Sh (ShM m x)
runInSh ->
        forall a.
FilePath
-> [Text]
-> [StdHandle]
-> (Handle -> Handle -> Handle -> Sh a)
-> Sh a
S.runHandles FilePath
exe [Text]
args [StdHandle]
reusedHandles (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap 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 :: forall (m :: * -> *) a.
MonadSh m =>
a -> FoldCallback a -> FilePath -> [Text] -> m a
runFoldLines a
start FoldCallback a
cb FilePath
exe [Text]
args = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall a b. (a -> b) -> a -> b
$ 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 :: forall (m :: * -> *). MonadSh m => m Text
lastStderr = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh Sh Text
S.lastStderr

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

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

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

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

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

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

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

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

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

sleep :: MonadSh m => Int -> m ()
sleep :: forall (m :: * -> *). MonadSh m => Int -> m ()
sleep = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh 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 :: forall (m :: * -> *). MonadSh m => Text -> m ()
echo       = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Sh ()
S.echo
echo_n :: forall (m :: * -> *). MonadSh m => Text -> m ()
echo_n     = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Sh ()
S.echo_n
echo_err :: forall (m :: * -> *). MonadSh m => Text -> m ()
echo_err   = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Sh ()
S.echo_err
echo_n_err :: forall (m :: * -> *). MonadSh m => Text -> m ()
echo_n_err = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Sh ()
S.echo_n_err

-- | @since 1.12.1
echoWith :: MonadSh m => (Text -> IO ()) -> Text -> m ()
echoWith :: forall (m :: * -> *). MonadSh m => (Text -> IO ()) -> Text -> m ()
echoWith Text -> IO ()
f Text
msg = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall a b. (a -> b) -> a -> b
$ (Text -> IO ()) -> Text -> Sh ()
S.echoWith Text -> IO ()
f Text
msg

relPath :: MonadSh m => FilePath -> m FilePath
relPath :: forall (m :: * -> *). MonadSh m => FilePath -> m FilePath
relPath = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh 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 :: forall (m :: * -> *).
MonadSh m =>
FilePath -> FilePath -> m FilePath
relativeTo = (forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> FilePath -> Sh FilePath
S.relativeTo

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

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

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

test_d :: MonadSh m => FilePath -> m Bool
test_d :: forall (m :: * -> *). MonadSh m => FilePath -> m Bool
test_d = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh 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 :: forall (m :: * -> *). MonadSh m => FilePath -> m Bool
test_s = forall (m :: * -> *) a. MonadSh m => Sh a -> m a
liftSh forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> Sh Bool
S.test_s

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

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

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

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