ShIO is Deprecated in favor of Sh, which is easier to type.

Enter a Sh from (Monad)IO. The environment and working directories are inherited from the current process-wide values. Any subsequent changes in processwide working directory or environment are not reflected in the running Sh.

Deprecated now, just use shelly, whose default has been changed. Using this entry point does not create a .shelly directory in the case of failure. Instead it logs directly into the standard error stream (stderr).

Using this entry point creates a .shelly directory in the case of failure where errors are recorded.

Since: 1.12.1

Variadic argument version of run. Please see the documenation for run.

The syntax is more convenient, but more importantly it also allows the use of a FilePath as a command argument. So an argument can be a Text or a FilePath without manual conversions. a FilePath is automatically converted to Text with toTextIgnore.

Convenient usage of cmd requires the following:

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

For the variadic function cmd.

Partially applied variadic functions require type signatures.

Argument converter for the variadic argument version of run called cmd. Useful for a type signature of a function that uses cmd.

Transfer from one handle to another For example, send contents of a process output to stdout. Does not close the write handle.

Also, fold over the contents being streamed line by line.

Since: 1.12.1

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

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

Obtain a (reasonably) canonic file path to a filesystem object. Based on "canonicalizePath".

Flipped hasExtension for Text.

Convert Text to a FilePath.

A monadic-conditional version of the when guard.

A monadic-conditional version of the unless guard.

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

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

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

Conditional execution of Applicative expressions. For example,

Examples

when debug (putStrLn "Debugging")

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

The reverse of when.

Examples

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

>>> unless (pi > exp 1) Nothing
Just ()

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.

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

>>> show <$> Nothing
Nothing

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

>>> show <$> Left 17
Left 17

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

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

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

List directory recursively (like the POSIX utility "find"). listing is relative if the path given is relative. If you want to filter out some results or fold over them you can do that with the returned files. A more efficient approach is to use one of the other find functions.

find that filters the found files as it finds. Files must satisfy the given filter to be returned in the result.

Fold an arbitrary folding function over files froma a find. Like findWhen but use a more general fold rather than a filter.

find that filters out directories as it finds. Filtering out directories can make a find much more efficient by avoiding entire trees of files.

Similar to findWhen, but also filter out directories. Alternatively, similar to findDirFilter, but also filter out files. Filtering out directories makes the find much more efficient.

Like findDirFilterWhen but use a folding function rather than a filter. The most general finder: you likely want a more specific one.