Data.Conduit.Shell

Shell scripting with Conduit

This module consists only of re-exports, including a few thousand top-level names based on PATH. If you don't want that, you can cherry-pick specific modules to import from the library.

See Data.Conduit.Shell.PATH for all binaries. But you should be able to use whatever executables are in your PATH when the library is compiled.

Examples

The monad instance of Conduit will simply pass along all stdout results:

Piping with Conduit's normal pipe will predictably pipe things together, as in Bash:

>>> run (do shell "echo Hello" $| sed "s/l/a/"; echo "OK!")
Healo
OK!

Streaming pipes (aka lazy pipes) is also possible:

>>> run (tail' "/tmp/foo.txt" "-f" $| grep "--line-buffered" "Hello")
Hello, world!
Oh, hello!

(Remember that grep needs --line-buffered if it is to output things line-by-line).

Run custom processes via the proc function:

>>> run (proc "ls" [])
dist  LICENSE  README.md  Setup.hs  shell-conduit.cabal  src  TAGS  TODO.org

Run shell commands via the shell function:

>>> run (shell "ls")
dist  LICENSE  README.md  Setup.hs  shell-conduit.cabal  src  TAGS  TODO.org

Run conduits via the conduit function:

>>> run (cat "/tmp/foo.txt" $| conduit (do Just x <- await; yield x))
Hello!

How it works

All executable names in the PATH at compile-time are brought into scope as runnable process conduits e.g. ls or grep.

All processes are bound as variadic process calling functions, like this:

rmdir :: ProcessType r => r
ls :: ProcessType r => r

But ultimately the types end up being:

rmdir "foo" :: Segment ()
ls :: Segment ()
ls "." :: Segment ()

Etc.

Run all shell scripts with run:

run :: Segment r -> IO r

String types

If using OverloadedStrings so that you can use Text for arguments, then also enable ExtendedDefaultRules, otherwise you'll get ambiguous type errors.

{--}

But this isn't necessary if you don't need to use Text yet. Strings literals will be interpreted as String. Though you can pass a value of type Text or any instance of CmdArg without needing conversions.

Running scripts

run :: Segment r -> IO r

Run a segment.

Making segments

shell :: String -> Segment ()

Run a shell command.

proc :: String -> [String] -> Segment ()

Run a process command.

conduit :: (a ~ ByteString, m ~ IO) => ConduitT a ByteString m r -> Segment r

Lift a conduit into a segment.

text :: (r ~ (), m ~ IO) => ConduitT Text Text m r -> Segment r

Work on the stream as Text values from UTF-8.

bytes :: (a ~ ByteString, m ~ IO) => ConduitT a ByteString m r -> Segment r

Lift a conduit into a segment.

Composition of segments

($|) :: Segment () -> Segment b -> Segment b infixl 0

Fuse two segments (either processes or conduits).

data Segment r

A pipeable segment. Either a conduit or a process.

Instances

Monad Segment

Methods

(>>=) :: Segment a -> (a -> Segment b) -> Segment b

(>>) :: Segment a -> Segment b -> Segment b

return :: a -> Segment a

fail :: String -> Segment a

Functor Segment

Methods

fmap :: (a -> b) -> Segment a -> Segment b

(<$) :: a -> Segment b -> Segment a

Applicative Segment

Methods

pure :: a -> Segment a

(<*>) :: Segment (a -> b) -> Segment a -> Segment b

liftA2 :: (a -> b -> c) -> Segment a -> Segment b -> Segment c

(*>) :: Segment a -> Segment b -> Segment b

(<*) :: Segment a -> Segment b -> Segment a

Alternative Segment

Methods

empty :: Segment a

(<|>) :: Segment a -> Segment a -> Segment a

some :: Segment a -> Segment [a]

many :: Segment a -> Segment [a]

MonadIO Segment

Methods

liftIO :: IO a -> Segment a

(~) * r () => ProcessType (Segment r)

Methods

spr :: String -> [Text] -> Segment r

data ProcessException

Process running exception.

Constructors

ProcessException CreateProcess ExitCode

ProcessEmpty

Instances

Show ProcessException

Methods

showsPrec :: Int -> ProcessException -> ShowS

show :: ProcessException -> String

showList :: [ProcessException] -> ShowS

Exception ProcessException

Methods

toException :: ProcessException -> SomeException

fromException :: SomeException -> Maybe ProcessException

displayException :: ProcessException -> String

Re-exports

The following modules are exported for scripting convenience. Data.Conduit and Data.Conduit.Filesystem are re-exported from other libraries because they are typical uses. If you want a stream of the contents of a directory, recursively, sourceDirectoryDeep is handy. A program like find is strict, whereas a Conduit can stop processing whenever you wish.

You might want to import the regular Conduit modules qualified, too:

import qualified Data.Conduit.List as CL

Which contains handy functions for working on streams in a list-like way. See the rest of the handy modules for Conduit in conduit-extra: http://hackage.haskell.org/package/conduit-extra

Also of interest is csv-conduit: http://hackage.haskell.org/package/csv-conduit And html-conduit: http://hackage.haskell.org/package/html-conduit And http-conduit: http://hackage.haskell.org/package/http-conduit

Finally, see the Conduit category on Hackage for other useful libraries: http://hackage.haskell.org/packages/#cat:Conduit

All of these general purpose Conduits can be used in shell scripting.

module Data.Conduit.Shell.PATH

module Data.Conduit.Shell.Types

module Data.Conduit.Shell.Variadic

module Data.Conduit