Moduleshelly-1.12.1Haskell2010

Shelly.Pipe

This module is a wrapper for the module Shelly. The only difference is a main type Sh. In this module Sh contains a list of results. Actual definition of the type Sh is:

import qualified Shelly as S

newtype Sh a = Sh { unSh :: S.Sh [a] }

This definition can simplify some filesystem commands. A monad bind operator becomes a pipe operator and we can write

findExt ext = findWhen (pure . hasExt ext)

main :: IO ()
main = shs $ do
    mkdir "new"
    findExt "hs"  "." >>= flip cp "new"
    findExt "cpp" "." >>= rm_f
    liftIO $ putStrLn "done"

Documentation in this module mostly just reference documentation from the main Shelly module.

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ExtendedDefaultRules #-}
{-# OPTIONS_GHC -fno-warn-type-defaults #-}
import Shelly
import Data.Text as T
default (T.Text)

4 types
106 values

Packageshelly-1.12.1
Exports111
LanguageHaskell2010
LicenceBSD-3-Clause
SourcePipe.hs

Entering Sh

15 declarations

newtypenewtype Sh a

This type is a simple wrapper for a type Shelly.Sh. Sh contains a list of results.

Instances8Monad, Functor, Applicative, Alternative, MonadPlus, MonadIO, …

Monad ShDefined in shelly-1.12.1 · Shelly.Pipe
Functor ShDefined in shelly-1.12.1 · Shelly.Pipe
Applicative ShDefined in shelly-1.12.1 · Shelly.Pipe
Alternative ShDefined in shelly-1.12.1 · Shelly.Pipe
MonadPlus ShDefined in shelly-1.12.1 · Shelly.Pipe
MonadIO ShDefined in shelly-1.12.1 · Shelly.Pipe
ShellCommand (Sh Text)Defined in shelly-1.12.1 · Shelly.Pipe
s ~ () => ShellCommand (Sh s)Defined in shelly-1.12.1 · Shelly.Pipe

valueshs :: MonadIO m => Sh () -> m ()

Performs shelly and then an empty action return ().

valueshelly :: MonadIO m => Sh a -> m [a]

see shelly

valueshellyFailDir :: MonadIO m => Sh a -> m [a]

see shellyFailDir

valueshsFailDir :: MonadIO m => Sh () -> m ()

Performs shellyFailDir and then an empty action return ().

valuesub :: Sh a -> Sh a

see sub

valuesilently :: Sh a -> Sh a

valueverbosely :: Sh a -> Sh a

valueescaping :: Bool -> Sh a -> Sh a

see escaping

valueprint_stdout :: Bool -> Sh a -> Sh a

see print_stdout

valueprint_commands :: Bool -> Sh a -> Sh a

see 'S.print_commands

valuetracing :: Bool -> Sh a -> Sh a

see tracing

valueerrExit :: Bool -> Sh a -> Sh a

see errExit

valuelog_stdout_with :: (Text -> IO ()) -> Sh a -> Sh a

see log_stdout_with

valuelog_stderr_with :: (Text -> IO ()) -> Sh a -> Sh a

see log_stderr_with

List functions

3 declarations

valueroll :: Sh [a] -> Sh a

Pack list of results. It performs concat inside Sh.

valueunroll :: Sh a -> Sh [a]

Unpack list of results.

valueliftSh :: ([a] -> [b]) -> Sh a -> Sh b

Transform result as list. It can be useful for filtering.

Running external commands

15 declarations

typetype FoldCallback a = a -> Text -> a

valuerun :: FilePath -> [Text] -> Sh Text

see run

valuerun_ :: FilePath -> [Text] -> Sh ()

see run_

valuerunFoldLines :: a -> FoldCallback a -> FilePath -> [Text] -> Sh a

see runFoldLines

valuecmd :: ShellCommand result => FilePath -> result

see cmd

value(-|-) :: Sh Text -> Sh b -> Sh b

see -|-

valuelastStderr :: Sh Text

see lastStderr

valuesetStdin :: Text -> Sh ()

see setStdin

valuelastExitCode :: Sh Int

see lastExitCode

valuecommand :: FilePath -> [Text] -> [Text] -> Sh Text

see command

valuecommand_ :: FilePath -> [Text] -> [Text] -> Sh ()

see command_

valuecommand1 :: FilePath -> [Text] -> Text -> [Text] -> Sh Text

see command1

valuecommand1_ :: FilePath -> [Text] -> Text -> [Text] -> Sh ()

see command1_

valuesshPairs :: Text -> [(FilePath, [Text])] -> Sh Text

see sshPairs

valuesshPairs_ :: Text -> [(FilePath, [Text])] -> Sh ()

see sshPairs_

Modifying and querying environment

6 declarations

valuesetenv :: Text -> Text -> Sh ()

see setenv

valueget_env :: Text -> Sh (Maybe Text)

see get_env

valueget_env_text :: Text -> Sh Text

see get_env_text

valueget_env_def :: Text -> Text -> Sh Text

Deprecated. use fromMaybe DEFAULT get_env

see get_env_def

valueappendToPath :: FilePath -> Sh ()

see appendToPath

valueprependToPath :: FilePath -> Sh ()

see prependToPath

Environment directory

3 declarations

valuecd :: FilePath -> Sh ()

see cd

valuechdir :: FilePath -> Sh a -> Sh a

see chdir

valuepwd :: Sh FilePath

see pwd

Printing

9 declarations

valueecho :: Text -> Sh ()

Echo text to standard (error, when using _err variants) output. The _n variants do not print a final newline.

valueecho_n :: Text -> Sh ()

Echo text to standard (error, when using _err variants) output. The _n variants do not print a final newline.

valueecho_err :: Text -> Sh ()

Echo text to standard (error, when using _err variants) output. The _n variants do not print a final newline.

valueecho_n_err :: Text -> Sh ()

Echo text to standard (error, when using _err variants) output. The _n variants do not print a final newline.

valueinspect :: Show s => s -> Sh ()

see inspect

valueinspect_err :: Show s => s -> Sh ()

see inspect_err

valuetag :: Sh a -> Text -> Sh a

see tag

valuetrace :: Text -> Sh ()

see trace

valueshow_command :: FilePath -> [Text] -> Text

see show_command

Querying filesystem

7 declarations

valuels :: FilePath -> Sh FilePath

see ls

valuelsT :: FilePath -> Sh Text

see lsT

valuetest_e :: FilePath -> Sh Bool

see test_e

valuetest_f :: FilePath -> Sh Bool

see test_f

valuetest_d :: FilePath -> Sh Bool

see test_d

valuetest_s :: FilePath -> Sh Bool

see test_s

valuewhich :: FilePath -> Sh (Maybe FilePath)

see 'S.which

Filename helpers

8 declarations

valueabsPath :: FilePath -> Sh FilePath

see absPath

value(</>)

:: (ToFilePath filepath1, ToFilePath filepath2)
=> filepath1
-> filepath2
-> FilePath

Uses System.FilePath, but can automatically convert a Text.

value(<.>) :: ToFilePath filepath => filepath -> Text -> FilePath

Uses System.FilePath, but can automatically convert a Text.

valuecanonic :: FilePath -> Sh FilePath

see canonic

valuecanonicalize :: FilePath -> Sh FilePath

see canonicalize

valuerelPath :: FilePath -> Sh FilePath

see relPath

valuerelativeTo

:: FilePath
anchor path, the prefix
-> FilePath
make this relative to anchor path
-> Sh FilePath

see relativeTo

valuehasExt :: Text -> FilePath -> Bool

Flipped hasExtension for Text.

Manipulating filesystem

9 declarations

valuemv :: FilePath -> FilePath -> Sh ()

see mv

valuerm :: FilePath -> Sh ()

see rm

valuerm_f :: FilePath -> Sh ()

see rm_f

valuerm_rf :: FilePath -> Sh ()

see rm_rf

valuecp :: FilePath -> FilePath -> Sh ()

see cp

valuecp_r :: FilePath -> FilePath -> Sh ()

see cp_r

valuemkdir :: FilePath -> Sh ()

see mkdir

valuemkdir_p :: FilePath -> Sh ()

see mkdir_p

valuemkdirTree :: Tree FilePath -> Sh ()

see mkdirTree

reading/writing Files

6 declarations

valuereadfile :: FilePath -> Sh Text

see S.readFile

valuereadBinary :: FilePath -> Sh ByteString

see readBinary

valuewritefile :: FilePath -> Text -> Sh ()

see S.writeFile

valueappendfile :: FilePath -> Text -> Sh ()

see S.appendFile

valuetouchfile :: FilePath -> Sh ()

see S.touchFile

valuewithTmpDir :: (FilePath -> Sh a) -> Sh a

see withTmpDir

exiting the program

4 declarations

valueexit :: Int -> Sh ()

see exit

valueerrorExit :: Text -> Sh ()

see errorExit

valuequietExit :: Int -> Sh ()

see quietExit

valueterror :: Text -> Sh a

see terror

Exceptions

6 declarations

valuecatchany :: IO a -> (SomeException -> IO a) -> IO a

A helper to catch any exception (same as ... catch (e :: SomeException) -> ...).

valuecatch_sh :: Exception e => Sh a -> (e -> Sh a) -> Sh a

see catch_sh

valuefinally_sh :: Sh a -> Sh b -> Sh a

see finally_sh

datadata ShellyHandler a

see ShellyHandler

Constructors

forall e. Exception e => ShellyHandler (e -> Sh a)

valuecatches_sh :: Sh a -> [ShellyHandler a] -> Sh a

see catches_sh

valuecatchany_sh :: Sh a -> (SomeException -> Sh a) -> Sh a

see catchany_sh

convert between Text and FilePath

3 declarations

valuetoTextIgnore :: FilePath -> Text

valuetoTextWarn :: FilePath -> Sh Text

see toTextWarn

valuefromText :: Text -> FilePath

Convert Text to a FilePath.

Utilities

4 declarations

value(<$>) :: Functor f => (a -> b) -> f a -> f b

An infix synonym for fmap.

The name of this operator is an allusion to $. Note the similarities between their types:

 ($)  ::              (a -> b) ->   a ->   b
(<$>) :: Functor f => (a -> b) -> f a -> f b

Whereas $ is function application, <$> is function application lifted over a Functor.

Examples

Convert from a Maybe Int to a Maybe String using show:

Example1 expression

>>> show <$> NothingNothing

Example1 expression

>>> show <$> Just 3Just "3"

Convert from an Either Int Int to an Either Int String using show:

Example1 expression

>>> show <$> Left 17Left 17

Example1 expression

>>> show <$> Right 17Right "17"

Double each element of a list:

Example1 expression

>>> (*2) <$> [1,2,3][2,4,6]

Apply even to the second element of a pair:

Example1 expression

>>> even <$> (2,2)(2,True)

valuewhenM :: Monad m => m Bool -> m () -> m ()

A monadic-conditional version of the when guard.

valueunlessM :: Monad m => m Bool -> m () -> m ()

A monadic-conditional version of the unless guard.

valuetime :: Sh a -> Sh (Double, a)

see time

Re-exported for your convenience

4 declarations

methodliftIO :: IO a -> m a

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

Had we omitted liftIO, we would have ended up with this error:

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

The important part here is the mismatch between StateT s IO () and IO ().

Luckily, we know of a function that takes an IO a and returns an (m a): liftIO, enabling us to run the program and see the expected results:

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

valuewhen :: Applicative f => Bool -> f () -> f ()

Conditional execution of Applicative expressions. For example,

Examples

when debug (putStrLn "Debugging")

will output the string Debugging if the Boolean value debug is True, and otherwise do nothing.

Example1 expression

>>> putStr "pi:" >> when False (print 3.14159)pi:

valueunless :: Applicative f => Bool -> f () -> f ()

The reverse of when.

Examples

Example1 expression

>>> do x <- getLine       unless (x == "hi") (putStrLn "hi!")comingupwithexamplesisdifficulthi!

Example1 expression

>>> unless (pi > exp 1) NothingJust ()

typetype FilePath = String

File and directory names are values of type String, whose precise meaning is operating system dependent. Files can be opened, yielding a handle which can then be used to operate on the contents of that file.

Instances1ToFilePath