    {- HSH -- The Haskell Shell
    Copyright (C) 2004-2007 John Goerzen <jgoerzen@complete.org>
    Please see the COPYRIGHT file
    -}

    {- |
       Module     : HSH
       Copyright  : Copyright (C) 2006 John Goerzen
       License    : GNU LGPL, version 2.1 or above

       Maintainer : John Goerzen <jgoerzen@complete.org>
       Stability  : provisional
       Portability: portable

    Copyright (c) 2006 John Goerzen, jgoerzen\@complete.org

    Welcome to HSH, the Haskell Shell infrastructure.

    <http://software.complete.org/hsh>

    HSH is designed to let you mix and match shell expressions with Haskell
    programs.

    Here are a few examples to get you started:

    >run $ "echo /etc/pass*" :: IO String
    > -> "/etc/passwd /etc/passwd-"
    >
    >runIO $ "ls -l" -|- "wc -l"
    > -> 12
    >
    >runIO $ "ls -l" -|- wcL
    > -> 12
    >
    >runIO $ ("ls", ["-l", "file with spaces.txt"])
    >glob "~jgoerzen" >>= cd . head

    wcL is a pure Haskell function defined in "HSH.ShellEquivs.wcL" as:

    >wcL :: [String] -> [String]
    >wcL inp = [show $ genericLength inp]

    Here's another example:

    > let countLines = (zipWith (\i line -> printf "%-5d %s" i line)
    >      [(1::Int)..])::([String] -> [String])
    >
    > runIO $ ("ls", ["-l"]) -|- countLines -|- filter (isSuffixOf "hs")
    >   6     -rw-r--r-- 1 jgoerzen jgoerzen  1285 Jun  6 09:43 HSH.hs
    >   11    -rw-r--r-- 1 jgoerzen jgoerzen   565 Jun  6 09:43 test.hs

    To use HSH, you\'ll just want to import the HSH module.  To learn more,
    please see the information in "HSH.Command" and "HSH.ShellEquivs".

    You can run a command with HSH in several ways:

     * By using 'run' in a context that expects IO (), which will leave
       the final standard output going
       to the normal standard output of the program

     * By using 'run' in a context that expects a String, which will
       capture standard output into a buffer and present it as a String

     * Any of the numerous other methods documented in 'RunResult'.

     * The shortcut functions 'runIO' and 'runSL'.  'runIO' lets you run
       a command and force the context IO (), which is a frequently-useful
       shortcut when you don't care about the result.  'runSL' grabs the
       first line of output in the result.

    You can then specify a command, which could be a single command or a command
    joined together with pipes.

    There are many different items that make valid types; see the list of
    instances of 'ShellCommand' for a full list.  Here are a few:

     * A simple bare string is passed to the shell for execution.  The shell
       will then typically expand wildcards, parse parameters, etc.

     * A @(String, [String])@ tuple.  The first item in the tuple gives
       the name of a program to run, and the second gives its arguments.
       The shell is never involved.  This is ideal for passing filenames,
       since there is no security risk involving special shell characters.

     * A Haskell function.  This function will accept input representing
       its standard input and generate output to go to stdout.  Function
       types that are supported natively include @(String -> String)@,
       @(String -> IO String)@, plus many more involving ByteStrings and functions
       that take no input.  See 'HSH.Command.ShellCommand' for more.

    Pipes can be constructed by using the -|- operator, as illustrated above.
    It is quite possible to pipe data between Haskell functions and
    shell commands at will.

    In addition, "HSH.ShellEquivs" provides a number of useful pure-Haskell
    equivalents of regular shell commands.

    For more information, please consult the other modules in HSH as well as
    the HSH wiki at:

    <http://software.complete.org/hsh>
    -}

    module HSH (
                module HSH.Command,
                module HSH.ShellEquivs
               )
    where
    import HSH.Command
    import HSH.ShellEquivs