нУЁh) 8} 1БН                   	  
                                               !  "  #  $  %  &  '  (  )  *  +  ,  -  .  /  0  1  2  3  4  5  6  7  8  9  :  ;  <  =  >  ?  @  A  B  C  D  E  F  G  H  I  J  K  L  M  N  O  P  Q  R  S  T  U  V  W  X  Y  Z  [  \  ]  ^  _  `  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  p  q  r  s  t  u  v  w  x  y  z  {  |  }  ~    ─  │  ┌  ┐  └  ┘  ├  ┤  ┬  ┴  ┼  ▀  ▄  █  ▌  ▐  ░  ▒  ▓  ⌠  ■  ∙  √  ≈  ≤  ≥     ⌡  °  ²  ·  ÷  ═  ║  ╒  ё  є  ╔  і  ї  ╗  ╘  ╙  ╚  ╛  ґ  ў  ╞  ╟  ╠  ╡  Ё  Є  ╣  І  Ї  ╦  ╧  ╨  ╩  ╪  Ґ  Ў  ©  ю  а  б  ц  д  е  ф  г  х  и  й  к  л  м  н  о  п  я  р  с  т  у  ж  в  ь  ы  з  ш  э  щ  ч  ъ  Ю  А  Б  Ц  Д  Е  Ф  Г  Х  И  Й  К  Л  М  3.6.4         Safe-Inferred%&'56э   	 Н hsshellscriptС Describes whether an option takes an argument or not, and if so
 how the argument is injected into a value of type a.О hsshellscriptno argument expectedП hsshellscriptoption requires argumentЯ hsshellscriptoptional argumentР hsshellscriptEach  Р describes a single option.The arguments to  С are:list of short option characters*list of long option strings (without "--")argument descriptorexplanation of option for userТ hsshellscript-What to do with options following non-optionsУ hsshellscript+no option processing after first non-optionЖ hsshellscript*freely intersperse options and non-optionsВ hsshellscriptwrap non-options into optionsЬ hsshellscript░Return a string describing the usage of a command, derived from
 the header (first argument) and the options described by the 
 second argument.Ы hsshellscriptП Process the command-line, and return the list of values that matched
(and those that didn't). The arguments are:The order requirements (see  Т)The option descriptions (see  Р):The actual command line arguments (presumably got from 
    ). ЫЬ  returns a triple, consisting of the argument values, a list
of options that didn't match, and a list of error messages. ЫЬТУЖВРСНОПЯ            Safe-Inferred%&'56э   <w  hsshellscript&Split a path in components. Repeated "/." characters don't lead to empty
components. ".щ " path components are removed. If the path is absolute, the first component
will start with "/". "..Ч " components are left intact. They can't be simply
removed, because the preceding component might be a symlink. In this case,
 	 
 is probably what you need.1The case that the path is empty is treated like ".*", yielding an empty path components list.	Examples:≥slice_path "/"        = ["/"]
slice_path "/foo/bar" = ["/foo","bar"]
slice_path "..//./"   = [".."]
slice_path "."        = []
slice_path ""         = []See  ,  	 
,  	 . hsshellscript<Form a path from path components. This isn't the inverse
of   , since   .   
normalises the path.ц unslice_path [] = "."
unslice_path cs = concat (intersperse "/" cs)See   ,  
. hsshellscript4Normalise a path. This is done by reducing repeated /! characters to one, and removing
. path components. ..? path components are left intact, because of possible symlinks.АNote that the normalised path isn't 100% equivalent to the original one. Any trailing slash is removed. When the
last path component is a symbolic link, then both paths denote the same thing, except for in the context of the
 	 ╔ call. It will fail when the trailing slash is present (because then the path
denotes the directory which the link points to), but it will succeed when it is absent.*normalise_path = unslice_path . slice_pathSee  ,   . hsshellscript├Split a file name in components. This are the base file name and the
suffixes, which are separated by dots. If the name starts with a dot, it is
regarded as part of the base name. The result is a list of file name
components. The filename may be a path. In this case, everything up to the
last path component will be returned as part of the base file name. The
path gets normalised thereby.▓No empty suffixes are returned. If the file name contains several
consecutive dots, they are regared as part of the preceding file name
component.И Concateneting the name components and adding dots, reproduces the
original name, with a normalised path:
concat . intersperse "." .   ==  	 .,Note that the last path component might be "..┼". Then it is not
possible to deduce the refered directory's name from the path. An IO
action for getting the real path is then necessary.	Examples:Я slice_filename "a.b//./.foo.tar.gz" = ["a.b/.foo","tar","gz"]
slice_filename ".x..y."             = [".x.", "y."]See  , slice_filename'. hsshellscriptThis is a variant of  . It is like  З , except for
being more efficient, and the filename must not contain any preceding path,
since this case isn't considered.See  ,  . hsshellscriptу Form file name from file name components, interspersing dots. This is
the inverse of  ', except for normalisation of any path.+unslice_filename = concat . intersperse "."See  . hsshellscript└Split a path in directory and file name. Only in the case that the
supplied path is empty, both parts are empty strings. Otherwise, "."ц is filled in
for the corresponding part, if necessary. Unless the path is empty,
concatenating the returned path and file name components with a slash in
between, makes a valid path to the file.
split_pathт  splits off the last path component. This
isn't the same as the text after the last /.+Note that the last path component might be ".."┴. Then it is not
possible to deduce the refered directory's name from the path. Then an IO
action for getting the real path is necessary.	Examples:юsplit_path "/a/b/c"      == ("/a/b", "c")
split_path "foo"         == (".", "foo")
split_path "foo/bar"     == ("foo", "bar")
split_path "foo/.."      == ("foo", "..")
split_path "."           == (".", ".")
split_path ""            == ("", "")
split_path "/foo"        == ("/", "foo")
split_path "foo/"        == (".", "foo")
split_path "foo/."       == (".", "foo")
split_path "foo///./bar" == ("foo", "bar")
split_path "/"           == ("/", ".")See   . hsshellscript!Get the directory part of a path.dir_part = fst . split_pathSee  . hsshellscript&Get the last path component of a path. filename_part = snd . split_path	Examples:?filename_part "foo/bar" == "bar"
filename_part "."       == "."See  .	 hsshellscriptInverse of  , except for normalisation.4This forms a path from two parts, and takes care of "."г  and empty parts. When the two components are in
normalised form, then unsplit_path creates a normalised path.The definition:г unsplit_path ("", "") = ""
unsplit_path (p, q)   = unsplit_parts [p, q]	Examples:└unsplit_path ("", "")     == ""
unsplit_path (".", "")    == "."
unsplit_path (".", ".")   == "."
unsplit_path ("foo", ".") == "foo"See  ,   ,  
.
 hsshellscript·Concatenate a list of path parts. The idea is that you can throw in reasonably formed parts, and get a
reasonably formed version of the concatenated path out."."/ parts are removed. Empty parts are treated as "."Ґ parts. One leading slash in each of any but the first
part is removed. The result is then interspersed with slashes and string wise concatenated. The interior of the
parts isn't examined. ".."% components aren't treated specially.	Examples:Ыunsplit_parts []                       == "."
unsplit_parts [""]                     == "."
unsplit_parts ["/"]                    == "/"
unsplit_parts ["/", "foo"]             == "/foo"
unsplit_parts ["", "/foo"]             == "foo"
unsplit_parts ["/foo", "bar"]          == "/foo/bar"
unsplit_parts ["/foo", "/bar"]         == "/foo/bar"
unsplit_parts ["foo/", "bar"]          == "foo//bar"
unsplit_parts ["foo", "", ".", "bar"]  == "foo/bar"
unsplit_parts ["foo", "bar//./baz/"]   == "foo/bar//./baz/"See  	,  ,  . hsshellscriptЎSplit a file name in prefix and suffix. If there isn't any suffix in
the file name, then return an empty suffix. A dot at the beginning or at
the end is not regarded as introducing a suffix.ОThe last path component is what is being split. This isn't the same as
splitting the string at the last dot. For instance, if the file name
doesn't contain any dot, dots in previous path component's aren't mistaken
as introducing suffixes.:The path part is returned in normalised form. This means, "."' components
are removed, and multiple "/"s are reduced to one.ЎNote that there isn't any plausibility check performed on the suffix. If the file name doesn't have a suffix, but
happens to contain a dot, then this dot is mistaken as introducing a suffix.	Examples:┘split_filename "path/to/foo.bar"                             = ("path/to/foo","bar")
split_filename "path/to/foo"                                 = ("path/to/foo","")
split_filename "/path.to/foo"                                = ("/path.to/foo","")
split_filename "a///./x"                                     = ("a/x","")
split_filename "dir.suffix/./"                               = ("dir","suffix")
split_filename "Photographie, Das 20. Jahrhundert (300 dpi)" = ("Photographie, Das 20", " Jahrhundert (300 dpi)")See   , 'split_filename'' hsshellscriptVariant of  &. This is a more efficient version
of  с , for the case that you know the string is
is a pure file name without any slashes.See  . hsshellscriptInverse of  │. Concatenate prefix and suffix, adding
a dot in between, iff the suffix is not empty. The path part of the prefix is
normalised.See  . hsshellscript5Split a path in directory, base file name and suffix. hsshellscript:Form path from directory, base file name and suffix parts. hsshellscript3Test a path for a specific suffix and split it off.5If the path ends with the suffix, then the result is Just
prefix, where prefix; is the normalised path
without the suffix. Otherwise it's Nothing. hsshellscript:Make a path absolute, using the current working directory.Ш This makes a relative path absolute with respect to the current
working directory. An absolute path is returned unmodified.1The current working directory is determined with getCurrentDirectoryГ 
which means that symbolic links in it are expanded and the path is
normalised. This is different from pwd. hsshellscriptMake a path absolute.С This makes a relative path absolute with respect to a specified
directory. An absolute path is returned unmodified.'The directory must be an absolute path.Ю absolute_path_by absdir path@('/':p) = path
absolute_path_by absdir path = absdir ++ "/" ++ path hsshellscriptMake a path absolute.С This makes a relative path absolute with respect to a specified
directory. An absolute path is returned unmodified.ц The order of the arguments can be confusing. You should rather use  . absolute_path') is
included for backwards compatibility. hsshellscript
Guess the ".."Т-component free form of a path, specified as a list of path components, by syntactically
removing them, along with the preceding path components. This will produce erroneous results when the path contains
symlinks. If the path contains leading ".." components, or more ".."8 components than preceeding normal
components, then the ".."б  components can't be normalised away. In this case, the result is Nothing. hsshellscript
Guess the ".."т -component free, normalised form of a path. The transformation is purely syntactic. ".."╟
path components will be removed, along with their preceding path components. This will produce erroneous results
when the path contains symlinks. If the path contains leading ".." components, or more ".."8 components than
preceeding normal components, then the ".."б  components can't be normalised away. In this case, the result is
Nothing.б guess_dotdot = fmap unslice_path . guess_dotdot_comps . slice_path guess_dotdot "foo/../bar"    = Just "bar"
guess_dotdot "foo/..//bar/." = Just "bar"
guess_dotdot "foo/../../bar" = Nothing
guess_dotdot "../bar" = Nothing   hsshellscript$The path to be broken to components. hsshellscriptList of path components.  hsshellscriptList of path components hsshellscript7The path which consists of the supplied path components  hsshellscriptPath to be normalised hsshellscriptPath in normalised form  hsshellscriptPath hsshellscript.List of components the file name is made up of  hsshellscriptFile name without path hsshellscript.List of components the file name is made up of  hsshellscriptList of file name components hsshellscript:Name of the file which consists of the supplied components  hsshellscriptPath to be split hsshellscriptт Directory and file name components of the path. The directory path is
   normalized.	  hsshellscriptDirectory and file name hsshellscript2Path formed from the directory and file name parts
  hsshellscript"List of path parts to concatenate. hsshellscript*Formed path, which concatenates the parts.  hsshellscript(Path including the file name to be split hsshellscript>The normalised path with the file prefix, and the file suffix.  hsshellscriptFilename to be split hsshellscriptBase name and the last suffix  hsshellscriptFile name prefix and suffix hsshellscriptPath  hsshellscriptPath to split hsshellscript3Directory part, base file name part and suffix part  hsshellscript3Directory part, base file name part and suffix part hsshellscript'Path consisting of dir, base and suffix  hsshellscriptSuffix to split off hsshellscriptPath to test hsshellscriptPrefix without the suffix or Nothing  hsshellscriptThe path to be made absolute hsshellscriptAbsulte path  hsshellscriptц In case the path is relative, the directory relative to which it is hsshellscript/The path to be made absolute (must be absolute) hsshellscriptAbsolute path  hsshellscriptThe path to be made absolute hsshellscript9The directory relative to which the path is made absolute hsshellscriptAbsolute path  hsshellscriptList of path components hsshellscript+In case the path could be transformed, the ".."+-component free
   list of path components.  hsshellscriptPath to be normalised hsshellscript7In case the path could be transformed, the normalised, ".."!-component free form of the path. 	
 	
           Safe-Inferred%&'56э   H/ hsshellscriptнGenerate command (for a shell) which corresponds to the specified program
 name and argument list. The program name and arguments are the usual
 parameters for calling an external program, like when using
 
runProcess or runУ . The generated shell command
 would achieve the same effect. The name and the arguments are properly
 quoted, using  .█Note: The quoted strings are correctly recognized in shell scripts. But the shell bash has an annoying history
 expansion "feature", which causes it to choke on exclamation marks, when in interactive mode, even when quoted
 with double quotes. You can turn it off with set +o histexpand. hsshellscriptQuote shell metacharacters.ЯThis function quotes strings, such that they are not misinterpreted by
 the shell. It tries to be friendly to a human reader - when special
 characters are present, then the string is quoted with double quotes. If
 not, it is left unchanged.дThe list of exacly which characters need to be quoted has been taken
 from the bash source code. Bash in turn, implements POSIX 1003.2. So the
 result produced should be correct. From the bash info pages:
 "... the rules for evaluation and quoting are taken from the POSIX
 1003.2 specification for the standard Unix shell."█Note: The quoted strings are correctly recognized in shell scripts. But the shell bash has an annoying history
 expansion "feature", which causes it to choke on exclamation marks, when in interactive mode, even when quoted
 with double quotes. You can turn it off with set +o histexpand.See  . hsshellscript6Quote special characters inside a string for the shellіThis quotes special characters inside a string, such that it is
 recognized as one string by the shell when enclosed in double quotes.
 Doesn't add the double quotes.█Note: The quoted strings are correctly recognized in shell scripts. But the shell bash has an annoying history
 expansion "feature", which causes it to choke on exclamation marks, when in interactive mode, even when quoted
 with double quotes. You can turn it off with set +o histexpand.See  ,  . hsshellscriptQuote a string for the shellыThis encloses a string in double quotes and quotes any special
 characters inside, such that it will be recognized as one string by a
 shell. The double quotes are added even when they aren't needed for this
 purpose.█Note: The quoted strings are correctly recognized in shell scripts. But the shell bash has an annoying history
 expansion "feature", which causes it to choke on exclamation marks, when in interactive mode, even when quoted
 with double quotes. You can turn it off with set +o histexpand.See  ,  .  hsshellscriptname or path of the executable hsshellscriptcommand line arguments hsshellscriptshell command           Safe-Inferred%&'56э   ґЩд  hsshellscriptб Error thrown when there is an error in the command line arguments.Я The usage information is generated by the deprecated function usage_info. Better ignore this, and use the newer
 make_usage_info or print_usage_info.See  a,  b,  ^. hsshellscriptError message  hsshellscriptк Deprecated. Usage information, as generated by the now deprecated function  ^.! hsshellscriptп This represents the parsed contents of the command line. It is returned
 by the getargsл ... functions, and passed on to the
 value extraction functions by the user.See  K,  L!, 'getargs'', 'getargs_ordered''." hsshellscriptц A property of a command line argument. These are generated by the
 desc_?... functions, and condensed to argument
 descriptions of type ArgumentDescription by argdesc. This type is abstract.% hsshellscriptб Description of one command line argument. These are generated by
 argdescй  from a list of argument properties, and subsequently used by one of the
 getargs... functions.' hsshellscriptShort option names( hsshellscriptLong option names) hsshellscript,What about a possible value of the argument?* hsshellscript3Minimum and maximum of number of occurences allowed+ hsshellscript1Name for argument's value, for message generation, hsshellscript2Descrition of the argument, for message generation- hsshellscriptArgument value tester. hsshellscriptЧ Argument value tester function. This tests the format of an argument's value for errors. The tester function
 is specified by  B. or such, as part of the argument description.с The tester is passed the argument value. If the format is correct, then it returns Nothing). If there is an
 error, then it returns 	Just msgf, with msgfЦ being an error message generation function. This function gets
 passed the argument description, and produces the error message. The argument description typically is used to
 extract a descriptive name of the argument (using  F or  G&) to be included in the error message./ hsshellscript-Does the command line argument take an value?0 hsshellscriptNo value1 hsshellscriptValue required2 hsshellscriptValue optional3 hsshellscriptпWhether the specified argument is the direct argument. Direct arguments are
 the ones which are specified without introducing "-" or "--", in the command
 line, or which occur after the special argument "--".See  J,  6.4 hsshellscriptч Short name of the argument. This specifies a character for a
 one letter style argument, like -xУ . There can be specified
 several for the same argument. Each argument needs at least
 either a short or a long name.5 hsshellscriptШ Long name of the argument. This specifies a GNU style long name for the argument, which is introduced by two
 dashes, like --arg or 	--arg=...╟. There can be specified several names for the same argument. Each argument
 needs at least either a short or a long name. Except for direct arguments, which don't have a name.See  66 hsshellscript▒Signal that this is the description of direct arguments. Direct arguments are the ones not
 introduced by any short or long argument names (like -x or --arg). After the special argument
 --ю , also everything is a direct argument, even when starting with - or --. The presence of
 desc_direct) in the argument properties list signals argdescБ  that this is the description of
 the direct arguments. There may be at most one such description.The 	is_directш  function can be used in order to determine if a specific
 argument is the direct argument.See  3.7 hsshellscript*Signal that the argument requires a value.8 hsshellscriptК Signal that the argument optionally has a value. The user may or may
 not specify a value to this argument.9 hsshellscriptл Specify lower and upper bound on the number of times an argument may
 occur.: hsshellscriptУ Signal that the argument must be present exactly once. This is
 meaningful only for arguments which can take a value.; hsshellscript6Signal that the argument must occur at least one time.< hsshellscript5Signal that the argument must occur at most one time.= hsshellscriptЖ Signal that the argument must have at least the specified number of
 occurences, and has no upper limit of occurences.> hsshellscript7Signal that the argument may occur any number of times.? hsshellscriptК Signal that the argument does not need to be present, and may occur at most
 the specified number of times.@ hsshellscript█Specify the descriptive name for command line argument's value. Used for the
 generation of the usage message. The name should be very short.A hsshellscript┼Specify a description of what the argument does. Used for usage message
 generation. This can be arbitratily long, long lines are wrapped.B hsshellscript╒Specify a tester for this argument. The tester is a function which tests the argument value for format errors.
 Typically, it tests whether the value can be parsed to some target type. If the test fails, the tester produces
 an error message. When parsing the command line arguments (which getargsу  or related), all the testers are
 applied to the respective argument values, and an  © is thrown in case of failure. By using a tester, it
 can be ensured that the argument values abide a specific format when extracting them, such that they can be
 parsed without errors, e.g. &myarg = read (reqarg_req args d_myarg).)An argument tester is a function of type  ..See  C,  D,  E,  ..C hsshellscript Build an argument tester from a readsн  like function. Typically, a specialisation of the standard prelude
 function read is used. Example: 3readtester "Integer expected." (reads :: ReadS Int)D hsshellscript╨Specify that the value of this argument, if present, is a positive integer. This will cause an error when the
command line is parsed, and the argument's value doesn't specify an integer.п desc_integer = desc_tester (readtester (reads :: ReadS Int) "Integer expected.")See  B.E hsshellscript©Specify that the value of this argument, if present, is a non-negative integer. This will cause an error when
the command line is parsed, and the value doesn't specify a non-negative integer.╗desc_nonneg_integer = desc_tester (readtester ((filter (\(a,_) -> a >= 0) . reads) :: ReadS Int) \
                                   "Non-negative integer expected." )See  B.F hsshellscript╪Generate a descriptive argument name from an argument description, suitable
 for use in error messages and usage information. This uses the long and short
 argument names (as specified by  4 and  5і) and generates
 descriptive names of the argument like "-f", "--myflag",
 "-f/--myflag", etc. All the argument names are included. In case of direct
 arguments (see  6), the descriptive name is "(direct
 argument)".See  J.G hsshellscript²Generate a descriptive argument name from an argument description, beginning
 with "argument". This uses the long and short argument names (as specified
 by  4 and  5а) and generates descriptive names of the
 argument like "argument -f", "argument --myflag", "argument
 -f/--myflag", etc. All the argument names are included. In case of direct
 arguments (see  6-), the descriptive name is "direct argument".See  J.H hsshellscriptцCreate a string, which lists the short forms of one command line argument. If
it has an subargument, it's name is listed as well. For arguments without short
form, the result is the empty string.┌For the illegal command line argument, with neither short nor long forms, and
not being the direct argument either, the result is "yet unnamed argument"е .
Such argument descriptions are incomplete, and will be rejected by getargs and
unsafe_getargs.з This is meant for refering to an argument, such as in error messages or usage
information.	Examples:уargname_short (argdesc [ desc_short 'a'
                       , desc_short 'b'
                       , desc_value_required
                       , desc_argname "Name"
                       ])
  == "-a/-b Name"See  J,  6.  I.I hsshellscriptаCreate a string, which lists the long forms of one command line argument. If
it has an subargument, it's name is listed as well. For arguments without long
form, the result is the empty string.┌For the illegal command line argument, with neither short nor long forms, and
not being the direct argument either, the result is "yet unnamed argument"е .
Such argument descriptions are incomplete, and will be rejected by getargs and
unsafe_getargs.з This is meant for refering to an argument, such as in error messages or usage
information.	Examples:ьargname_long (argdesc [ desc_long "foo"
                      , desc_long "bar"
                      , desc_value_required
                      , desc_argname "Name"
                      ])
  == "--foo/--bar Name"See  J,  6.  I.J hsshellscript░Make an argument description from a list of argument properties. This
 condenses the list to an argument description,
 which can be used by the getargs;... functions and the
 argument value extraction functions.K hsshellscriptф Parse command line arguments. The arguments are taken from a call to
 getArgs' and parsed. Any error is thrown as a
 ArgErrorЙ  exception. The result is a value from which the
 information in the command line can be extracted by the arg...,
 reqarg... and optarg... functions.*The header is used only by the deprecated 
usage_infoъ  function. If you don't
 use it, you don't need to specify a header. Just pass an empty string.Named arguments (like -x or --arg/) and direct
 arguments may occur in any order.See  ^,  a,  b.L hsshellscriptф Parse command line arguments. The arguments are taken from a call to
 getArgs' and parsed. Any error is thrown as a
 ArgErrorЙ  exception. The result is a value from which the
 information in the command line can be extracted by the arg...,
 reqarg... and optarg... functions.*The header is used only by the deprecated 
usage_infoъ  function. If you don't
 use it, you don't need to specify a header. Just pass an empty string.Ч All arguments after the first direct argument are regarded as direct
 arguments. This means that argument names introduced by -
 or -- no longer take effect.See  ^,  a,  b.M hsshellscript;Parse the specified command line. Any error is returned as Left
 argerror1. In case of success, the result is returned as
 	Right resп . From the result, the information in the command
 line can be extracted by the arg..., reqarg	...
 and optarg... functions.*The header is used only by the deprecated 
usage_infoъ  function. If you don't
 use it, you don't need to specify a header. Just pass an empty string.Named arguments (like -x or --arg/) and direct
 arguments may occur in any order.See  ^,  a,  b.N hsshellscript;Parse the specified command line. Any error is returned as Left
 argerror1. In case of success, the result is returned as
 	Right resп . From the result, the information in the command
 line can be extracted by the arg..., reqarg	...
 and optarg... functions.*The header is used only by the deprecated 
usage_infoъ  function. If you don't
 use it, you don't need to specify a header. Just pass an empty string.Ч All arguments after the first direct argument are regarded as direct
 arguments. This means that argument names introduced by -
 or -- no longer take effect.See  ^,  a,  b.O hsshellscript▌Query whether a certain switch is specified on the command line. A switch is an
 argument which is allowed zero or one time, and has no value.P hsshellscript.Query the number of occurences of an argument.Q hsshellscript╣Query the values of an argument with optional value. This is for
 arguments which take an optional value, and may occur several times. The
 occurences with value are represented as 
Just value-, the occurences
 without are represented as Nothing.R hsshellscriptЪ Query the values of an argument with required value. This is for
 arguments which require a value, and may occur several times.S hsshellscriptґQuery the optional value of a required argument. This is for arguments
 which must occur once, and may have a value. If the argument is
 specified, its value is returned as 
Just value. If it isn't, the result
 is Nothing.T hsshellscriptР Query the value of a required argument. This is for arguments which must
 occur exactly once, and require a value.U hsshellscriptюQuery the optional value of an optional argument. This is for arguments
 which may occur zero or one time, and which may or may not have a value.
 If the argument doesn't occur, the result is Nothing:. If it does occur,
 but has no value, then the result is Just Nothing.. If it does occur with
 value, the result is Just (Just value).V hsshellscript▀Query the value of an optional argument. This is for optional arguments
 which require a value, and may occur at most once. The result is
 
Just value if the argument occurs, and Nothing
 if it doesn't occur.W hsshellscript.None of the specifed arguments may be present.7Throws an ArgError if any of the arguments are present.X hsshellscript/All of the specified arguments must be present.%Throws an ArgError if any is missing.Y hsshellscript7Exactly one of the specified arguments must be present.Otherwise throw an ArgError.Z hsshellscript6At most one of the specified arguments may be present.Otherwise throw an ArgError.[ hsshellscript8At least one of the specified arguments must be present.Otherwise throw an ArgError.\ hsshellscriptь When the specified argument is present, then none of the other arguments may be present.Otherwise throw an ArgError.] hsshellscript:Whether the specified argument occurs in the command line.^ hsshellscript
Deprecatedи . This is left here for backwards compatibility. New programs should use make_usage_info	 and/or
 print_usage_info.Ь Get the usage information from the parsed arguments. The usage info
 contains the header specified to the corresponding 
getargs...;
 function, and descriptions of the command line arguments.г Descriptions can be several lines long. Lines get wrapped at column 80.See  a,  b,  c._ hsshellscriptgetargsЩ  as a pure function, instead of an IO action. This allows to make evaluated command line arguments
global values. This calls getargs& to parse the command line arguments. GHC.IO.unsafePerformIO0 is used to take
the result out of the IO monad.г unsafe_getargs header descs = GHC.IO.unsafePerformIO $ getargs "" descsThe getargsь  action is performed on demand, when the parse result is evaluated. It may result in an  л 
   being thrown. In order to avoid this happening at unexpected times, the main) function should, start with the
   line seq args (return ()), where args is the result of unsafe_getargs≥,. This will trigger any command line
   argument errors at the beginning of the program. (See section 6.2 of the Hakell Report for the definition of
   seq).*The header is used only by the deprecated 
usage_infoА  function. If you don't
   use it, you don't need to specify a header. Just pass an empty string.A typical use of unsafe_getargs looks like this:╞descs = [ d_myflag, ... ]

d_myflag = argdesc [ ... ]

args = unsafe_getargs "" descs
myflag = arg_switch args d_myflag

main = mainwrapper $ do
   seq args (return ())
   ...See  K,  `.` hsshellscriptgetargs_orderedц  as a pure function, instead of an IO action. This is exactly like unsafe_getargs, but
   using getargs_ordered instead of getargs.*The header is used only by the deprecated 
usage_infoА  function. If you don't
   use it, you don't need to specify a header. Just pass an empty string.The definition is:й unsafe_getargs_ordered = GHC.IO.unsafePerformIO $ getargs_ordered "" descsSee  _,  ^,  a,  b.a hsshellscript≤Generate pretty-printed information about the command line arguments. This
 function gives you much control on how the usage information is generated.
 print_usage_info" might be more like what you need.5The specified argument descriptions (as taken by the getargs╒... functions)
 are processed in the given order. Each one is formatted as a paragraph,
 detailing the argument. This is done according to the specified geometry.▌The direct argument, in case there is one, is omitted. You should detail the
 direct command line arguments separatly, such as in some header.К The specified maximum breadths must fit in the specified width, or an error
 is raised. This happens, when 4colsleft + colsshort + 2 + colslong + 2 + 2 >
 width.See  b,  K,  ^,  %,
  A,  J,  ,  .b hsshellscriptЯPrint the usage information (about the command line arguments), for the
 specified header and arguments to the specified handle. When the handle is
 connected to a terminal, the terminal's width (in columns) is used to format
 the output, such that it fits the terminal. Both the header and the argument
 descriptions are adapted to the width of the terminal (by using wrap).ш When the handle does not connected to a terminal, 80 columns are used. This
 may happen to stdout or stderrэ , for instance, when the program is in a
 pipe, or the output has been redirected to a file.Л When the terminal is too narrow for useful output, then instead of the usage
 information, a short message ("Terminal too narrow"ф ) is printed. This
 applies to terminals with a width of less than 12.иYou should specify one long line for each paragraph in the header and the
 argument descriptions, and let print_usage_info do the wrapping. When you
 have several paragraphs, separate them by a double \n\nь . This also applies
 for an empty line, which should be printed after the actual header.ч The arguments are printed in the order, in which they occur in the argument
 description list. This function is a front end to terminal_width and make_usage_info.See  J,  A,  ,  a,  ^,  c.c hsshellscriptп Break down a text to lines, such that each one has the specified
 maximum width.Ж Newline characters in the input text are respected. They terminate the line,
 without it being filled up to the width.Й The text is wrapped at space characters. Words remain intact, except when
 they are too long for one line.g hsshellscriptMake ArgError an instance of 	Exceptionх , so we can throw and catch it, using GHC-6.10's new exception
 library.*3  hsshellscript%Argument description, as returned by argdesc.4  hsshellscript#The character to name the argument. hsshellscript$The corresponding argument property.5  hsshellscriptThe long name of the argument. hsshellscript$The corresponding argument property.9  hsshellscript3Lower bound of the allowed number of argdesc_times. hsshellscript3Upper bound of the allowed number of argdesc_times. hsshellscript$The corresponding argument property.:  hsshellscript$The corresponding argument property.;  hsshellscript$The corresponding argument property.<  hsshellscript$The corresponding argument property.=  hsshellscriptNumber of times. hsshellscript$The corresponding argument property.>  hsshellscript$The corresponding argument property.?  hsshellscriptNumber of times. hsshellscript$The corresponding argument property.@  hsshellscriptName of the argument's value. hsshellscript$The corresponding argument property.A  hsshellscript"Short description of the argument. hsshellscript$The corresponding argument property.B  hsshellscript)Argument tester to apply to this argument hsshellscript$The corresponding argument property.F  hsshellscript%Argument description, as returned by argdesc hsshellscriptPrintable name for the argumentG  hsshellscript%Argument description, as returned by argdesc hsshellscriptPrintable name for the argumentH  hsshellscript%Argument description, as returned by argdesc hsshellscriptPrintable name for the argumentI  hsshellscript%Argument description, as returned by argdesc hsshellscriptPrintable name for the argumentJ  hsshellscript=List of properties, which describe the command line argument. hsshellscript'The corresponding argument description.K  hsshellscript$Header to be used by the deprecated 
usage_info
 function. hsshellscriptThe argument descriptions. hsshellscript!The contents of the command line.L  hsshellscript$Header to be used by the deprecated 
usage_info
 function. hsshellscriptDescriptions of the arguments. hsshellscript!The contents of the command line.M  hsshellscript$Header to be used by the deprecated 
usage_info
 function. hsshellscriptCommand line to be parsed. hsshellscriptThe argument descriptions. hsshellscript!The contents of the command line.N  hsshellscript$Header to be used by the deprecated 
usage_info
 function. hsshellscriptCommand line to be parsed. hsshellscriptThe argument descriptions. hsshellscript!The contents of the command line.O  hsshellscriptCommand line parse result. hsshellscript#Argument description of the switch. hsshellscript2Whether the switch is present in the command line.P  hsshellscriptCommand line parse result. hsshellscriptDescription of the argument. hsshellscript$Number of times the argument occurs.Q  hsshellscriptCommand line parse result. hsshellscriptDescription of the argument. hsshellscriptThe occurences of the argument.R  hsshellscriptCommand line parse result. hsshellscriptDescription of the argument. hsshellscriptThe values of the argument.S  hsshellscriptCommand line parse result. hsshellscriptDescription of the argument. hsshellscript(The value of the argument, if it occurs.T  hsshellscriptCommand line parse result. hsshellscriptDescription of the argument. hsshellscriptThe value of the argument.U  hsshellscriptCommand line parse result. hsshellscriptDescription of the argument. hsshellscript8The occurence of the argument and its value (see above).V  hsshellscriptCommand line parse result. hsshellscriptDescription of the argument. hsshellscript(The value of the argument, if it occurs.W  hsshellscript0List of the arguments which must not be present. hsshellscriptCommand line parse result.X  hsshellscript,List of the arguments which must be present. hsshellscriptCommand line parse result.Y  hsshellscript<List of the arguments, of which exactly one must be present. hsshellscriptCommand line parse result.Z  hsshellscript;List of the arguments, of which at most one may be present. hsshellscriptCommand line parse result.[  hsshellscript=List of the arguments, of which at least one must be present. hsshellscriptCommand line parse result.\  hsshellscript3Argument which doesn't tolerate the other arguments hsshellscript:Arguments which aren't tolerated by the specified argument hsshellscriptCommand line parse result.]  hsshellscriptCommand line parse result. hsshellscript'Description of the respective argument. hsshellscript:Whether the specified argument occurs in the command line._  hsshellscript$Header to be used by the deprecated 
usage_info
 function. hsshellscriptThe argument descriptions hsshellscript!The parsed command line arguments`  hsshellscript$Header to be used by the deprecated 
usage_info
 function. hsshellscriptThe argument descriptions hsshellscript!The parsed command line argumentsa  hsshellscript/List of argument descriptions, as created by a argdesc hsshellscript8The output is indented this many columns. Probably zero. hsshellscriptН Maximum width of the column of the short form of each argument.
   When this many aren'tneeded, less are used. hsshellscriptН Maximum width of the column of the long form of each argument.
   When this many aren't needed, less are used. hsshellscriptи Wrap everything at this column. Should probably be the
   terminal width. hsshellscriptЬ Pretty printed usage information, in paragraphs, which contain
   one or several lines, which are separated by newlines.b  hsshellscript+To which handle to print the
   usage info. hsshellscript+The header to print first.
   Can be empty. hsshellscriptи The argument description of
   the arguments, which should be documented.c  hsshellscriptц Maximum width for the lines of the text, which is to be broken down hsshellscriptText to break down hsshellscriptThe broken down text in columnsг "#$%&'()*+,-/012.J456789:;<>=?@ABDEC3!KLMN_`OPQRSTUV]WXYZ[\ ^abFGHIcг "#$%&'()*+,-/012.J456789:;<>=?@ABDEC3!KLMN_`OPQRSTUV]WXYZ[\ ^abFGHIc           Safe-Inferred%&'56э  Ўдй  hsshellscript)Determine the terminal width in columns. <This value can be used to format output to fit the terminal.ЁThis queries the terminal which is connected to stdout. It may happen, that
 stdout isn't connected to a terminal, for instance when the program is part of
 a pipe. In this case, Nothing% is returned. No exception is thrown.See  ,  a,  b,  ^,  c. hsshellscript)Determine the terminal width in columns. <This value can be used to format output to fit the terminal.хThis queries the terminal which is connected to stdout. It may happen, that
 stdout isn't connected to a terminal. For instance when the program is part of
 a pipe. In this case, an IOError is thrown.See  ,  a,  b,  ^,  c. hsshellscriptCreate and throw an IOError from the current errno5 value, an optional handle and an optional file name.#This is an extended version of the Foreign.C.Error.throwErrnoТ  function
 from the GHC libraries, which additionally allows to specify a handle and a file
 name to include in the IOError thrown.See Foreign.C.Error.throwErrno, Foreign.C.Error.errnoToIOError.k hsshellscriptХ An error which occured when calling an external program.
   The fields specifiy the details of the call.See  x,  z,  {, System.Posix.ProcessStatus.m hsshellscriptProgram namen hsshellscriptProgram argumentso hsshellscript-The environment in use when the call was donep hsshellscript,The working directory when the call was doneq hsshellscript!The process status of the failurer hsshellscriptThe error (errno) codes hsshellscriptImproved version of System.Posix.Files.setFileMode", which sets the file name in the IOErrorз  which is
thrown in case of an error. The implementation in GHC 6.2.2 neglects to do this.о setFileMode' path mode =
   fill_in_filename path $
      setFileMode path modet hsshellscriptД Execute an IO action as a separate process, and wait for it to finish.
 Report errors as exceptions.▐This forks a child process, which performs the specified IO action. In case
 the child process has been stopped by a signal, the parent blocks.If the action throws an IOError▌, it is transmitted to the parent.
 It is then raised there, as if it happened locally. The child then aborts
 quietly with an exit code of 0.,Exceptions in the child process, other than IOError"s, result in an error
 message on stderr, and a ProcessStatus- exception in the parent, with the
 value of Exited (ExitFailure 1).. The following exceptions are understood by
 subproc(, and result in corresponding messages: ArgError, ProcessStatus,
 RunError, IOError and ExitCodeб . Other exceptions result in the generic
 message, as produced by show.Р If the child process exits with an exit code other than zero, or it is
 terminated by a signal, the corresponding ProcessStatus8 is raised as an
 exception in the parent program. Only IOError s are transmitted to the parent.!When used in conjunction with an execщ  variant, this means that the parent
 process can tell the difference between failure of the execъ  call itself,
 and failure of the child program being executed after a successful call of
 the exec$ variant. In case of failure of the exec
 call, You get the IOError,, which
 happened in the child when calling executeFileэ  (from the GHC hierarchical
 libraries). In case of the called program failing, you get the ProcessStatus.1Unless you replace the child process, calling an execА  variant, the child
 should let the control flow leave the action normally (unless it throws an
 IOError4). The child process is then properly terminated by subprocь , such
 that no resources, which have been duplicated by the fork, cause problems.
 See HsShellScript#subr  for details.>If you want to run an external program, by calling one of the exec7
 variants in the child action, you might want to call runprog instead of subproc.	Examples:,Run a program with the environment replaced:/subproc (execpe "foobar" ["1","2","3"] new_env)This results in a ProcessStatus exception:subproc (exec "/bin/false" [])This results in an IOError (unless you actually have /frooble):subproc (exec "/frooble" [])See  |,  v,  ~,  ,  ─,  │.u hsshellscriptД Execute an IO action as a separate process, and wait for it to finish.
 Report errors as exceptions.к This function is included only for backwards compatibility. New code should
 use  t instead", which has better error handling.╚The program forks a child process and performs the specified action.
 Then it waits for the child process to finish. If it exits in any way
 which indicates an error, the ProcessStatus is thrown.в The parent process waits for the child processes, which have been stopped by
 a signal.See HsShellScript#subr  for further details.See  t,  v.v hsshellscriptш Execute an IO action as a separate process, and continue without waiting
 for it to finish.Ш The program forks a child process, which performs the specified action and terminates.
 The child's process ID is returned.See HsShellScript#subr  for further details.See  t.w hsshellscript└Run an external program. This starts a program as a child
 process, and waits for it to finish. The executable is searched via the
 PATH.к This function is included for backwards compatibility only. New code should
 use  |', which has much better error handling.Х When the specified program can't be executed, an error message is printed, and the main process
 gets a ProcessStatus thrown, with the value Exited
 (ExitFailure 1)Ч. This means that the main program can't distinguish between
 failure of calling the program and the program exiting with an exit code of
 1. However, an error message "Error calling ...", including the description in the IOError produced
 by the failed execp call, is printed on stderr.run prog par is essentially call (execp prog par).Example:в run "/usr/bin/foobar" ["some", "args"]
   `catch` (\ps -> do -- oops...
              )See  |,  t,  v.x hsshellscriptю Make a readable error message. This includes all the
 fields of RunError except for the environment.See  k.y hsshellscript+Generate a human-readable description of a ProcessStatus.See  ~,  | and System.Posix.ProcessStatus0 in the GHC hierarchical
 library documentation.z hsshellscript
Convert a RunError to an IOError.The IOErrorл  type isn't capable of holding all the information which is
 contained in a RunErrorН . The environment is left out, and most of the other
 fields are included only informally, in the description.The fields of the generated IOError are:The handle (ioeGetHandle): NothingThe error type (ioeGetErrorType): GHC.IO.Exception.SystemErrorioe_location: 	"runprog"ioe_description$: The error message, as procuded by show_runerror.ioe_filename
: This is Just (shell_command prog pars), with prog
   and pars% being the program and its arguments.See  {,  |,  x.{ hsshellscriptе Call the specified IO action (which is expected to contain calls of
 runprog) and convert any RunError exceptions to IOErrors.The conversion is done by to_ioe.See  z,  |.| hsshellscriptч Run an external program, and report errors as exceptions. The executable is
 searched via the PATHм . In case the child process has been stopped by a
 signal, the parent blocks.ъ In case the program exits in an way which indicates an error, or is
 terminated by a signal, a RunError6 is thrown. It
 contains the details of the call. The runprog( action can also be converted
 to throw IOErrors instaed, by applying as_ioeе  to it. Either can be used
 to generate an informative error message.2In case of starting the program itself failed, an IOError is thrown.runprog prog par is a simple front end to subproc. It is essentially
 subproc (execp prog par), apart from building a RunError	 from a
 ProcessStatus.
Example 1:З do runprog "foo" ["some", "args"]
   ...
`catch` (\re -> do errm (show_runerror re)
                      ...
           )
Example 2:┘do as_ioe $ runprog "foo" ["some", "args"]
   ...
`catch` (\ioe -> do errm (show_ioerror ioe)
                       ...
           )See  t,  v,  k,  x,  z,  {.} hsshellscript4Print an action as a shell command, then perform it."This is used with actions such as  |,  ~ or  t. For instance,
 echo runprog prog args is a variant of runprog prog args3, which prints what
 is being done before doing it.See  |,  t,  ~.~ hsshellscript╒Execute an external program. This replaces the running process. The path isn't searched, the environment
 isn't changed. In case of failure, an IOError is thrown.8exec path args =
   execute_file path False args NothingSee  ╟, HsShellScript#exec . hsshellscript÷Execute an external program. This replaces the running process. The path is searched, the environment
 isn't changed. In case of failure, an IOError is thrown.8execp prog args =
   execute_file prog True args NothingSee  ╟, HsShellScript#exec .─ hsshellscriptЇExecute an external program. This replaces the running process. The path isn't searched, the environment
 of the program is set as specified. In case of failure, an IOError is thrown.ю exece path args env =
   execute_file path False args (Just env)See  ╟, HsShellScript#exec .│ hsshellscriptЄExecute an external program. This replaces the running process. The path is searched, the environment of
 the program is set as specified. In case of failure, an IOError is thrown.ю execpe prog args env =
   execute_file prog True args (Just env)See  ╟, HsShellScript#exec .┌ hsshellscript!Build left handed pipe of stdout."p -|- q." builds an IO action from the two IO actions p and q.
   q< is executed in an external process. The standard output of p% is sent
   to the standard input of q> through a pipe. The result action consists
   of forking off q (connected with a pipe), and p.The result action does not run pп  in a separate process. So, the pipe
   itself can be seen as a modified action p, forking a connected q/. The
   pipe is called "left handed", because p remains unforked, and not q.'The exit code of q is silently ignored.) The process ID of the forked
   copy of q, isn't returned to the caller, so it's lost.The pipe, which connects p and q, is in 	text mode$. This means that the 
   output of pЛ  is converted from Unicode to the system character set, which 
   is determined by the environment variable LANG.See HsShellScript#subr  and
   HsShellScript#exec  for further details.	Examples:;subproc (exec "/usr/bin/foo" [] -|- exec "/usr/bin/bar" [])╚sunproc (    execp "foo" ["..."]
         -|= ( -- Do something with foo's output
               do cnt <- lazy_contents "-"
                  ...
             )
        )с sunproc ( err_to_out foo
          -|- exec "/usr/bin/tee" ["-a", "/tmp/foo.log"] )See  t, ┐, └,  ├┐ hsshellscript!Build left handed pipe of stderr."p =|- q." builds an IO action from the two IO actions p and q.
   qб  is executed in an external process. The standard error output of p% is sent
   to the standard input of q> through a pipe. The result action consists
   of forking off q (connected with a pipe), and p.The result action does not run pп  in a separate process. So, the pipe
   itself can be seen as a modified action p, forking a connected q/. The
   pipe is called "left handed", because p has this property, and not q.'The exit code of q is silently ignored.) The process ID of the forked
   copy of q, isn't returned to the caller, so it's lost.The pipe, which connects p and q, is in 	text mode$. This means that the 
   output of pЛ  is converted from Unicode to the system character set, which 
   is determined by the environment variable LANG.See HsShellScript#subr  and
   HsShellScript#exec  for further details.Example:;subproc (exec "/usr/bin/foo" [] =|- exec "/usr/bin/bar" [])See  t, ┌, └.└ hsshellscript"Build right handed pipe of stdout."p -|= q." builds an IO action from the two IO actions p and q.
   p< is executed in an external process. The standard output of p% is sent
   to the standard input of q> through a pipe. The result action consists
   of forking off p (connected with a pipe), and q.The result action does not run qп  in a separate process. So, the pipe
   itself can be seen as a modified action q, forking a connected p3.
   The pipe is called "right
   handed", because q has this property, and not p.'The exit code of p is silently ignored.) The process ID of the forked
   copy of q, isn't returned to the caller, so it's lost.The pipe, which connects p and q, is in 	text mode$. This means that the 
   output of pЛ  is converted from Unicode to the system character set, which 
   is determined by the environment variable LANG.See HsShellScript#subr  and
   HsShellScript#exec  for further details.Example:е subproc (exec \"\/usr\/bin\/foo\" [] -|= exec \"\/usr\/bin\/bar\" [])See  t, ┐, ┘.┘ hsshellscript"Build right handed pipe of stderr."p =|= q." builds an IO action from the two IO actions p and q.
   pб  is executed in an external process. The standard error output of p% is sent
   to the standard input of q> through a pipe. The result action consists
   of forking off p (connected with a pipe), and q.The result action does not run qп  in a separate process. So, the pipe
   itself can be seen as a modified action q, forking a connected p3.
   The pipe is called "right
   handed", because q has this property, and not p.'The exit code of p is silently ignored.) The process ID of the forked
   copy of q, isn't returned to the caller, so it's lost.The pipe, which connects p and q, is in 	text mode$. This means that the 
   output of pЛ  is converted from Unicode to the system character set, which 
   is determined by the environment variable LANG.See HsShellScript#subr  and
   HsShellScript#exec  for further details.Example:;subproc (exec "/usr/bin/foo" [] =|= exec "/usr/bin/bar" [])See  t,  ┐,  └.├ hsshellscriptьTemporarily replace a handle. This makes a backup copy of the original handle (typically a standard
 handle), overwrites it with the specified one, runs the specified action, and restores the handle from the
 backup.Example:ф   h <- openFile "/tmp/log" WriteMode
  redirect stdout h io
  hClose hThis is the same as  io ->- "/tmp/log"See  ┌,  ┐.┤ hsshellscriptЖ Redirect the standard output of the specified IO action to a file. The file will be overwritten, if it
already exists. What's actually modified is the stdout( handle, not the file descriptor 1. The
exec  functions know about this. See HsShellScript#fdpipes  and
HsShellScript#exec  for details.The file is written in 	text mode└. This means that the
output is converted from Unicode to the system character set, which
is determined by the environment variable LANG.Example:,runprog "/some/program" [] ->- "/tmp/output"Note: You can't redirect to "/dev/null" this way, because GHC 6.4's openFileы  throws an "invalid argument"
IOError. (This may be a bug in the GHC 6.4 libraries). Use ->>-	 instead.See  t,  |,  ┬,  ┴.┬ hsshellscriptШ Redirect the standard output of the specified IO action to a file. If the file already exists, the output
will be appended. What's actually modified is the stdout( handle, not the file descriptor 1. The
exec  functions know about this. See HsShellScript#fdpipes  and
HsShellScript#exec  for details.The file is written in 	text mode└. This means that the
output is converted from Unicode to the system character set, which
is determined by the environment variable LANG.Example:-run "/some/noisy/program" [] ->>- "/dev/null"See  t,  |, ┤, ┼.┴ hsshellscriptЭ Redirect the standard error output of the specified IO action to a file. If the file already exists, it
will be overwritten. What's actually modified is the stderr( handle, not the file descriptor 2. The
exec  functions know about this. See HsShellScript#fdpipes  and
HsShellScript#exec  for details.Note: You can't redirect to "/dev/null" this way, because GHC 6.4's openFileы  throws an "invalid argument"
IOError. (This may be a bug in the GHC 6.4 libraries). Use =>>-	 instead.The file is written in 	text mode└. This means that the
output is converted from Unicode to the system character set, which
is determined by the environment variable LANG.Example:'run "/path/to/foo" [] =>- "/tmp/errlog"See  t,  |, ┤, ┼.┼ hsshellscript│Redirect the standard error output of the specified IO action to a file. If the file already exists, the
output will be appended. What's actually modified is the stderr( handle, not the file descriptor 2. The
exec  functions know about this. See HsShellScript#fdpipes  and
HsShellScript#exec  for details.The file is written in 	text mode└. This means that the
output is converted from Unicode to the system character set, which
is determined by the environment variable LANG.Example:'run "/some/program" [] =>>- "/dev/null"See  t,  |, ┬, ┴.▀ hsshellscriptм Redirect both stdout and stderr to a file. This is equivalent to the
shell's &>> operator. If the file already exists, it will be overwritten.!What's actually modified are the stdout and stderr0 handles, not the file
descriptors 1 and 2. The exec  functions know about this. See
HsShellScript#fdpipes  and
HsShellScript#exec  for details.Note: You can't redirect to "/dev/null" this way, because GHC 6.4's openFileы  throws an "invalid argument"
IOError. (This may be a bug in the GHC 6.4 libraries). Use -&>>-	 instead.The file is written in 	text mode└. This means that the
output is converted from Unicode to the system character set, which
is determined by the environment variable LANG.'(-&>-) io path = err_to_out io ->- pathExample:+subproc (exec "/path/to/foo" [] -&>- "log")See ▄,  ▌.▄ hsshellscriptФ Redirect both stdout and stderr to a file. If the file already exists, the
   output will be appended.!What's actually modified are the stdout and stderr0 handles, not the file
descriptors 1 and 2. The exec  functions know about this. See
HsShellScript#fdpipes  and
HsShellScript#exec  for details.The file is written in 	text mode└. This means that the
output is converted from Unicode to the system character set, which
is determined by the environment variable LANG..(-&>>-) io path = (err_to_out >> io) ->>- pathExample:.run "/some/noisy/program" [] -&>>- "/dev/null"See ▀,  ▐.█ hsshellscriptЯ Redirect stdin from a file. This modifies the specified action, such
that the standard input is read from a file. What's actually modified is the stdin+ handle, not the file
   descriptor 0. The exec# functions know about this. See
   HsShellScript#fdpipes  and
HsShellScript#exec  for details.The file is read in 	text mode≤. This means that the input is converted from the
system character set to Unicode. The system's character set is determined by the
environment variable LANG.Example:*subproc (exec "/path/to/foo" [] -<- "bar")See  ~,  |, ┤, ┴.▌ hsshellscriptе Send the error output of the specified action to its standard output. What's actually modified is the stdout( handle, not the file descriptor 1. The
exec  functions know about this. See HsShellScript#fdpipes  and
HsShellScript#exec  for details.#err_to_out = redirect stderr stdoutSee  ├.▐ hsshellscriptе Send the output of the specified action to its standard error output. What's actually modified is the stderr( handle, not the file descriptor 2. The
exec  functions know about this. See HsShellScript#fdpipes  and
HsShellScript#exec  for details.redirect stdout stderrSee  ├.░ hsshellscriptб Run an IO action as a separate process, and pipe some text to its stdinю .
 Then close the pipe and wait for the child process to finish.М This forks a child process, which executes the specified action. The specified
 text is sent to the action's stdinА  through a pipe. Then the pipe is closed.
 In case the action replaces the process by calling an execт  variant, it is
 made sure that the process gets the text on it's file descriptor 0.Ф In case the action fails (exits with an exit status other than 0, or is
 terminated by a signal), the ProcessStatus! is thrown, such as reported by
  Зо . No attempt is made to create more meaningful
 exceptions, like it is done by runprog/subproc.7Exceptions in the action result in an error message on stderr7, and the
 termination of the child. The parent gets a ProcessStatus exception, with
 the value of Exited (ExitFailure 1)р . The following exceptions are
 understood, and result in corresponding messages: ArgError,
 ProcessStatus, RunError, IOError and ExitCodeб . Other exceptions
 result in the generic message, as produced by show.1Unless you replace the child process, calling an execр variant, the child
 should let the control flow leave the action normally.
 The child process is then properly terminated, such
 that no resources, which have been duplicated by the fork, cause problems.
 See HsShellScript#subr  for details.The pipe is set to 	text mode▓. This means that the Unicode characters in
 the text are converted to the system character set. If you need to pipe binary
 data, you should use 	h_pipe_toг , and set the returned handle to binary
 mode. This is accomplished by  Ш h Trueф . The system
 character set is determined by the environment variable LANG.Example:,pipe_to "blah" (exec "/usr/bin/foo" ["bar"])Example: Access both stdin and stdout of an external program.░import HsShellScript

main = mainwrapper $ do

   res <- pipe_from $
      pipe_to "2\n3\n1" $
         exec "/usr/bin/sort" []

   putStrLn resSee  t,  |,  █,  ▒.▒ hsshellscriptн Run an IO action as a separate process, and get a connection (a pipe) to
 its stdin as a file handle.Х This forks a subprocess, which executes the specified action. A file handle,
 which is connected to its stdin, is returned. The child's 	ProcessIDп 
 is returned as well. If the action replaces the child process, by calling an
 execъ  variant, it is made sure that its file descriptor 0 is connected to
 the returned file handle.Щ This gives you full control of the pipe, and of the forked process. But you
 need to deal with the child process by yourself.1Unless you replace the child process, calling an execр variant, the child
 should let the control flow leave the action normally.
 The child process is then properly terminated, such
 that no resources, which have been duplicated by the fork, cause problems.
 See HsShellScript#subr  for details.л Errors can only be detected by examining the child's process status (using
   л ). If the child action throws an
 exception, an error message is printed on stderr&, and the child process
 exits with a ProcessStatus of Exited
 (ExitFailure 1)р . The following exceptions are understood, and
 result in corresponding messages: ArgError, ProcessStatus, RunError,
 IOError and ExitCodeб . Other exceptions result in the generic message, as
 produced by show.о If the child process exits in a way which signals an error, the
 corresponding ProcessStatus is returned by getProcessStatus. See
    for details.The pipe is set to 	text mode². This means that the Unicode characters in the
 text are converted to the system character set. You can set the returned
 handle to binary mode, by calling  Ш handle Trueф . The system
 character set is determined by the environment variable LANG.Example:г(handle, pid) <- h_pipe_to $ exec "/usr/bin/foo" ["bar"]
hPutStrLn handle "Some text to go through the pipe"
(Just ps) <- getProcessStatus True False pid
when (ps /= Exited ExitSuccess) $
   throw psSee  █,  ░,  ▓,  ⌠. See HsShellScript#fdpipes  for more details.▓ hsshellscript5Run an IO action as a separate process, and read its stdoutЕ  strictly.
 Then wait for the child process to finish. This is like the backquote feature
 of shells.╚This forks a child process, which executes the specified action. The output
 of the child is read from its standard output. In case it replaces the
 process by calling an execш  variant, it is make sure that the output is
 read from the new process' file descriptor 1.дThe end of the child's output is reached when either the standard output is
 closed, or the child process exits. The program blocks until the action
 exits, even if the child closes its standard output earlier. So the parent
 process always notices a failure of the action (when it exits in a way which
 indicates an error).р When the child action exits in a way which indicates an error, the
 corresponding ProcessStatus is thrown. See
   о . No attempt is made to create more
 meaningful exceptions, like it is done by runprog/subproc.7Exceptions in the action result in an error message on stderr>, and the
 proper termination of the child. The parent gets a ProcessStatus exception, with
 the value of Exited (ExitFailure 1)р . The following exceptions are
 understood, and result in corresponding messages: ArgError,
 ProcessStatus, RunError, IOError and ExitCodeб . Other exceptions
 result in the generic message, as produced by show.1Unless you replace the child process, calling an execя variant, the child
 should let the control flow leave the action normally. The child process is
 then properly terminated, such that no resources, which have been duplicated
 by the fork, cause problems. See HsShellScript#subr  for details."Unlike shells' backquote feature, 	pipe_fromЫ  does not remove any trailing
 newline characters. The entire output of the action is returned. You might want
 to apply chomp to the result.The pipe is set to 	text modeм. This means that the Unicode characters in the
 text, which is read from stdin, is converted from the system character set to
 Unicode. The system character set is determined by the environment variable
 LANGк . If you need to read binary data from the forked process, you should use
 h_pipe_fromф  and set the returned handle to binary mode. This is
 accomplished by  Ш h True.Example:*output <- pipe_from $ exec "/bin/mount" []Example: Access both stdin and stdout of an external program.░import HsShellScript

main = mainwrapper $ do

   res <- pipe_from $
      pipe_to "2\n3\n1" $
         exec "/usr/bin/sort" []

   putStrLn resSee  ~,  ░,  ⌠,  ■,  √,   ,  ╔.⌠ hsshellscriptжRun an IO action as a separate process, and read its standard error output
 strictly. Then wait for the child process to finish. This is like the
 backquote feature of shells. This function is exactly the same as
 	pipe_fromя , except that the standard error output is read, instead of the
 standard output.ЇThis forks a child process, which executes the specified action. The error output
 of the child is read from its standard error output. In case it replaces the
 process by calling an execш  variant, it is made sure that the output is
 read from the new process' file descriptor 2.щThe end of the child's error output is reached when either the standard error
 output is closed, or the child process exits. The program blocks until the
 action exits, even if the child closes its standard error output earlier. So
 the parent process always notices a failure of the action (which means it
 exits in a way which indicates an error).р When the child action exits in a way which indicates an error, the
 corresponding ProcessStatus is thrown. See
   п .
 No attempt is made to create
 more meaningful exceptions, like it is done by runprog/subproc.7Exceptions in the action result in an error message on stderrС, and the
 proper termination of the child. This means that the error message is sent
 through the pipe, to the parent process. The message can be found in the text
 which has been read from the child process. It doesn't appear on the console.The parent gets a ProcessStatus exception, with
 the value of Exited (ExitFailure 1)р . The following exceptions are
 understood, and result in corresponding messages: ArgError,
 ProcessStatus, RunError, IOError and ExitCodeб . Other exceptions
 result in the generic message, as produced by show.1Unless you replace the child process, calling an execя variant, the child
 should let the control flow leave the action normally. The child process is
 then properly terminated, such that no resources, which have been duplicated
 by the fork, cause problems. See HsShellScript#subr  for details."Unlike shells' backquote feature, 
pipe_from2Ъ  does not remove any trailing
 newline characters. The entire error output of the action is returned. You might want
 to apply chomp to the result.The pipe is set to 	text modeм. This means that the Unicode characters in the
 text, which is read from stdin, is converted from the system character set to
 Unicode. The system character set is determined by the environment variable
 LANGк . If you need to read binary data from the forked process, you should use
 h_pipe_fromф  and set the returned handle to binary mode. This is
 accomplished by  Ш h True.Example:*output <- pipe_from $ exec "/bin/mount" []Example: Access both stdin and stdout of an external program.░import HsShellScript

main = mainwrapper $ do

   res <- pipe_from $
      pipe_to "2\n3\n1" $
         exec "/usr/bin/sort" []

   putStrLn resSee  ~,  ░,  ▓,  ∙,  ≈,  ╔.
 See HsShellScript#fdpipes  for more details.■ hsshellscript;Run an IO action as a separate process, and connect to its stdoutд 
 with a file handle.
 This is like the backquote feature of shells.Х This forks a subprocess, which executes the specified action. A file handle,
 which is connected to its stdout, is returned. The child's 	ProcessIDп 
 is returned as well. If the action replaces the child process, by calling an
 execъ  variant, it is made sure that its file descriptor 1 is connected to
 the returned file handle.Щ This gives you full control of the pipe, and of the forked process. But you
 need to deal with the child process by yourself.When you call getProcessStatusх blockingly, you must first ensure that all
 data has been read, or close the handle. Otherwise you'll get a deadlock.
 When you close the handle before all data has been read, then the child gets
 a SIGPIPE signal.1Unless you replace the child process, calling an execр variant, the child
 should let the control flow leave the action normally.
 The child process is then properly terminated, such
 that no resources, which have been duplicated by the fork, cause problems.
 See HsShellScript#subr  for details.л Errors can only be detected by examining the child's process status (using
   п ). No attempt is made to create more
 meaningful exceptions, like it is done by runprog/subprocк . If the child
 action throws an exception, an error message is printed on stderr&, and the
 child process exits with a ProcessStatus of Exited (ExitFailure 1)с . The
 following exceptions are understood, and result in corresponding messages:
 ArgError, ProcessStatus, RunError, IOError and ExitCodeб . Other
 exceptions result in the generic message, as produced by show.The pipe is set to 	text modeм. This means that the Unicode characters in the
 text, which is read from stdin, is converted from the system character set to
 Unicode. The system character set is determined by the environment variable
 LANG└. If you need to read binary data from the forked process, you can set
 the returned handle to binary mode. This is accomplished by  Ш
 h True.Example:4(h,pid) <- h_pipe_from $ exec "/usr/bin/foo" ["bar"]See  ~,  ░,  ∙,  ▓,  √,   ,  ╔.
 See HsShellScript#fdpipes  for more details.∙ hsshellscript;Run an IO action as a separate process, and connect to its stderr
 with a file handle.Х This forks a subprocess, which executes the specified action. A file handle,
 which is connected to its stderr, is returned. The child's 	ProcessIDп 
 is returned as well. If the action replaces the child process, by calling an
 execъ  variant, it is made sure that its file descriptor 2 is connected to
 the returned file handle.Щ This gives you full control of the pipe, and of the forked process. But you
 need to deal with the child process by yourself.When you call getProcessStatusх blockingly, you must first ensure that all
 data has been read, or close the handle. Otherwise you'll get a deadlock.
 When you close the handle before all data has been read, then the child gets
 a SIGPIPE signal.1Unless you replace the child process, calling an execя variant, the child
 should let the control flow leave the action normally. The child process is
 then properly terminated, such that no resources, which have been duplicated
 by the fork, cause problems. See HsShellScript#subr  for details.л Errors can only be detected by examining the child's process status (using
   п ). No attempt is made to create more
 meaningful exceptions, like it is done by runprog/subprocк . If the child
 action throws an exception, an error message is printed on stderrЯ . This
 means that the message goes through the pipe to the parent process. Then the
 child process exits with a ProcessStatus of Exited (ExitFailure 1)с . The
 following exceptions are understood, and result in corresponding messages:
 ArgError, ProcessStatus, RunError, IOError and ExitCodeб . Other
 exceptions result in the generic message, as produced by show.The pipe is set to 	text modeм. This means that the Unicode characters in the
 text, which is read from stdin, is converted from the system character set to
 Unicode. The system character set is determined by the environment variable
 LANG└. If you need to read binary data from the forked process, you can set
 the returned handle to binary mode. This is accomplished by  Ш
 h True.Example:4(h,pid) <- h_pipe_from $ exec "/usr/bin/foo" ["bar"]See  ~,  ▓,  ⌠,  ■,  ░,
  √,   ,  ╔.√ hsshellscriptбRun an IO action in a separate process, and read its standard output, The output
 is read lazily, as the returned string is evaluated. The child's output along
 with its process ID are returned.жThis forks a child process, which executes the specified action. The output
 of the child is read lazily through a pipe, which connncts to its standard
 output. In case the child replaces the process by calling an execэ  variant,
 it is make sure that the output is read from the new process' file descriptor
 1.lazy_pipe_from calls  Э╔, in order to read the pipe
 lazily. This means that the file handle goes to semi-closed state. The handle
 holds a file descriptor, and as long as the string isn't fully evaluated,
 this file descriptor won't be closed. For the file descriptor to be closed,
 first its standard output needs to be closed on the child side. This happens
 when the child explicitly closes it, or the child process exits. When
 afterwards the string on the parent side is completely evaluated, the handle,
 along with the file descritor it holds, are closed and freed.▓If you use the string in such a way that you only access the beginning of the
 string, the handle will remain in semi-closed state, holding a file
 descriptor, even when the pipe is closed on the child side. When you do that
 repeatedly, you may run out of file descriptors.┬Unless you're sure that your program will reach the string's end, you should
 take care for it explicitly, by doing something like this:Б (output, pid) <- lazy_pipe_from (exec "\/usr\/bin\/foobar" [])
...
seq (length output) (return ())▐This will read the entire standard output of the child, even if it isn't
 needed. You can't cut the child process' output short, when you use
 lazy_pipe_from). If you need to do this, you should use h_pipe_from;, which
 gives you the handle, which can then be closed by  Щ., even
 if the child's output isn't completed:²(h, pid) <- h_pipe_from io

-- Lazily read io's output
output <- hGetContents h
...
-- Not eveyting read yet, but cut io short.
hClose h

-- Wait for io to finish, and detect errors
(Just ps) <- System.Posix.getProcessStatus True False pid
when (ps /= Exited ExitSuccess) $
   throw psп When you close the handle before all data has been read, then the child gets
 a SIGPIPE signal.4After all the output has been read, you should call getProcessStatusЗ  on the
 child's process ID, in order to detect errors. Be aware that you must
 evaluate the whole string, before calling getProcessStatus' blockingly, or
 you'll get a deadlock.мYou won't get an exception, if the child action exits in a way which
 indicates an error. Errors occur asynchronously, when the output string is
 evaluated. You must detect errors by yourself, by calling
   .ёIn case the action doesn't replace the child process with an external
 program, an exception may be thrown out of the action. This results in an error
 message on stderr0, and the proper termination of the child. The
 ProcessStatus2, which can be accessed in the parent process by
 getProcessStatus, is Exited (ExitFailure 1)р . The following exceptions are
 understood, and result in corresponding messages: ArgError,
 ProcessStatus, RunError, IOError and ExitCodeб . Other exceptions
 result in the generic message, as produced by show.1Unless you replace the child process, calling an execя variant, the child
 should let the control flow leave the action normally. The child process is
 then properly terminated, such that no resources, which have been duplicated
 by the fork, cause problems. See HsShellScript#subr  for details."Unlike shells' backquote feature, lazy_pipe_fromЫ  does not remove any trailing
 newline characters. The entire output of the action is returned. You might want
 to apply chomp to the result.The pipe is set to 	text modeъ. This means that the Unicode characters in the
 text, which is read from the IO action's stdout, are converted from the system
 character set to Unicode. The system character set is determined by the
 environment variable LANG°. If you need to read binary data from the forked
 process, you should use h_pipe_from and set the returned handle to binary mode.
 This is accomplished by  Ш h Trueф . Then you can lazily read 
 the output of the action from the handle.М Example: Lazily read binary data from an IO action. Don't forget to collect 
 the child process later, using  З True False pid.└(h, pid) <- h_pipe_from io
hSetBinaryMode h True
txt <- hGetContents h
...
(Just ps) <- System.Posix.getProcessStatus True False pidSee  ~,  ░,  ▓,  ■,  ≈,  ╔.≈ hsshellscriptнRun an IO action in a separate process, and read its standard error output, The output
 is read lazily, as the returned string is evaluated. The child's error output along
 with its process ID are returned.БThis forks a child process, which executes the specified action. The error output
 of the child is read lazily through a pipe, which connncts to its standard error
 output. In case the child replaces the process by calling an execэ  variant,
 it is make sure that the output is read from the new process' file descriptor
 1.lazy_pipe_from calls  Э╚, in order to read the pipe
 lazily. This means that the file handle goes to semi-closed state. The handle
 holds a file descriptor, and as long as the string isn't fully evaluated,
 this file descriptor won't be closed. For the file descriptor to be closed,
 first its standard error output needs to be closed on the child side. This happens
 when the child explicitly closes it, or the child process exits. When
 afterwards the string on the parent side is completely evaluated, the handle,
 along with the file descritor it holds, are closed and freed.▓If you use the string in such a way that you only access the beginning of the
 string, the handle will remain in semi-closed state, holding a file
 descriptor, even when the pipe is closed on the child side. When you do that
 repeatedly, you may run out of file descriptors.┬Unless you're sure that your program will reach the string's end, you should
 take care for it explicitly, by doing something like this:Ю (errmsg, pid) <- lazy_pipe_from2 (exec "/usr/bin/foobar" [])
...
seq (length errmsg) (return ())∙This will read the entire standard error output of the child, even if it isn't
 needed. You can't cut the child process' output short, when you use
 lazy_pipe_from). If you need to do this, you should use h_pipe_from;, which
 gives you the handle, which can then be closed by  Щ., even
 if the child's output isn't completed:²(h, pid) <- h_pipe_from io

-- Lazily read io's output
output <- hGetContents h
...
-- Not eveyting read yet, but cut io short.
hClose h

-- Wait for io to finish, and detect errors
(Just ps) <- System.Posix.getProcessStatus True False pid
when (ps /= Exited ExitSuccess) $
   throw psп When you close the handle before all data has been read, then the child gets
 a SIGPIPE signal.4After all the output has been read, you should call getProcessStatusЗ  on the
 child's process ID, in order to detect errors. Be aware that you must
 evaluate the whole string, before calling getProcessStatus' blockingly, or
 you'll get a deadlock.мYou won't get an exception, if the child action exits in a way which
 indicates an error. Errors occur asynchronously, when the output string is
 evaluated. You must detect errors by yourself, by calling
   .ёIn case the action doesn't replace the child process with an external
 program, an exception may be thrown out of the action. This results in an
 error message on stderr└. This means that the message is sent through the
 pipe, to the parent process. Then the child process is properly terminated.
 The ProcessStatus2, which can be accessed in the parent process by
 getProcessStatus, is Exited (ExitFailure 1)р . The following exceptions are
 understood, and result in corresponding messages: ArgError,
 ProcessStatus, RunError, IOError and ExitCodeб . Other exceptions
 result in the generic message, as produced by show.1Unless you replace the child process, calling an execя variant, the child
 should let the control flow leave the action normally. The child process is
 then properly terminated, such that no resources, which have been duplicated
 by the fork, cause problems. See HsShellScript#subr  for details.The pipe is set to 	text modeм. This means that the Unicode characters in the
 text, which is read from stdin, is converted from the system character set to
 Unicode. The system character set is determined by the environment variable
 LANG└. If you need to read binary data from the forked process, you can set
 the returned handle to binary mode. This is accomplished by  Ш
 h True."Unlike shells' backquote feature, lazy_pipe_fromЫ  does not remove any trailing
 newline characters. The entire output of the action is returned. You might want
 to apply chomp to the result.The pipe is set to 	text modeъ. This means that the Unicode characters in the
 text, which is read from the IO action's stdout, are converted from the
 system character set to Unicode. The system character set is determined by
 the environment variable LANGЄ. If you need to read binary data from the
 forked process' standard error output, you should use h_pipe_from2 and set
 the returned handle to binary mode. This is accomplished by  Ш
 h Trueд . Then you can lazily read the output of the action from the handle.М Example: Lazily read binary data from an IO action. Don't forget to collect 
 the child process later, using  З True False pid.┘(h, pid) <- h_pipe_from2 io
hSetBinaryMode h True
txt <- hGetContents h
...
(Just ps) <- System.Posix.getProcessStatus True False pidSee  ~,  ░,  ⌠,  ∙,  √,  ╔.≤ hsshellscript5Run an IO action as a separate process, and read its stdoutм  strictly. All
 the output is read, until the action terminates. Contrary to  ▓▐,
 when the action signals an error (with a non-zero exit code), the error isn't
 thrown as an exception, but is returned alongside the output.╔The result consists of the output which has been read, alongside with the
 process status, with which the action has terminated. For success,
 the process status is Exited ExitSuccess. See
  .This is a frontend to the  ■& function. See there for more details.See  ≥,  ~,  ░,  ▓,  ■,  √,   .≥ hsshellscript5Run an IO action as a separate process, and read its stderrс  strictly. All
 the error output is read, until the action terminates. Contrary to  ⌠▐,
 when the action signals an error (with a non-zero exit code), the error isn't
 thrown as an exception, but is returned alongside the output.╚The result consists of the error output which has been read, alongside with
 the process status, with which the action has terminated. For success, the
 process status is Exited ExitSuccess. See
  .This is a frontend to the  ∙& function. See there for more details.See  ≤,  ~,  ░,  ▓,  ■,  √,
   .  hsshellscriptг Run an IO action as a separate process, and optionally connect to its
 stdin, its stdout	 and its stderr output with pipes.к This forks a subprocess, which executes the specified action. The child's
 	ProcessIDз is returned. Some of the action's standard handles are made to
 connected to pipes, which the caller can use in order to communicate with the
 new child process. Which, this is determined by the first three arguments.В You get full control of the pipes, and of the forked process. But you
 need to deal with the child process by yourself.ы Errors in the child process can only be detected by examining its process
 status (using   л ). If the child action
 throws an exception, an error message is printed on stderr&, and the child
 process exits with a ProcessStatus of Exited (ExitFailure 1)с . The
 following exceptions are understood, and result in corresponding messages:
 ArgError, ProcessStatus, RunError, IOError and ExitCodeб . Other
 exceptions result in the generic message, as produced by show.1Unless you replace the child process, calling an execО  variant, the child
 should let the control flow leave the action normally. It is then properly 
 take care of.The pipes are set to 	text mode!. When connecting to the child's stdin█,
 this means that the Unicode characters in the Haskell side text are converted
 to the system character set. When reading from the child's stdout or
 stderrё, the text is converted from the system character set to Unicode in
 the Haskell-side strings. The system character set is determined by the
 environment variable LANGп . If you need to read or write binary data, then
 this is no problem. Just call  Ш handle True3. This sets the
 corresponding pipe to binary mode.See  ▓,  ■,  ⌠,  ∙,  ░, 
  ▒,  √,  ≈⌡ hsshellscriptф Forcibly terminate the program, circumventing normal program shutdown.This is the _exit(2)0 system call. No cleanup actions installed with bracketе 
are performed, no data buffered by file handles is written out, etc.° hsshellscript"Generate an error message from an errno value. This is the POSIX
 strerror system library function.See the man page strerror(3).² hsshellscript7Read the global system error number. This is the POSIX errno) value. This
 function is redundant. Use Foreign.C.Error.getErrno	 instead.· hsshellscript3Print error message corresponding to the specified errnoе  error
 number. This is similar to the POSIX system library function perror.See the man page 	perror(3).÷ hsshellscript0Print error message corresponding to the global errnoф  error
 number. This is the same as the POSIX system library function perror.See the man page 	perror(3).═ hsshellscriptPrint a message to stderr1 and exit with an exit code
 indicating an error.0failIO msg = hPutStrLn stderr msg >> exitFailure║ hsshellscriptХ Modify an IO action to return the exit code of a failed program call,
 instead of throwing an exception.я This is used to modify the error reporting behaviour of an IO action which
 uses  w | or  u tЖ . When an external program exits with
 an exit code which indicates an error, normally an exception is thrown. After
 exitcode5 has been applied, the exit code is retruned instead.The caught exceptions are  k and  Чж . Termination by a
 signal is still reported by an exception, which is passed through.	Example: &ec <- exitcode $ runprog "foo" ["bar"]See  |,  t,  w,  u.╒ hsshellscriptConvert an IOError to a string.$There is an instance declaration of IOError in Show in the GHC.IO library, but show_ioerror7 produces a
 more readable, and more complete, message.ё hsshellscriptд Call the shell to execute a command. In case of an error, throw the ProcessStatus
 (such as (Exited
(ExitFailure ec))ф ) as an exception. This is like the Haskell standard library function systemр , except that error
handling is brought in accordance with HsShellScript's scheme.exitcode . system_throw is the same as the systemЙ  function, except that when the called shell is terminated or
stopped by a signal, this still lead to the ProcessStatusГ  being thrown. The Haskell library report says nothing
about what happens in this case, when using the system
 function.2system_throw cmd = run "/bin/sh" ["-c", "--", cmd]3This function is deprecated. You should rather use  є1, which provides for much better error
reporting.є hsshellscript<Call the shell to execute a command. In case of an error, a RunErrorю  ist thrown. This is like the Haskell
standard library function systemз , except that error handling is brought in accordance with HsShellScript's
scheme. (It is not a front end to system.)8system_runprog cmd = runprog "/bin/sh" ["-c", "--", cmd])Example: Call "foo" and report Errors as IOErrors, rather than RunErrors.,as_ioe $ system_runprog "foo" ["bar", "baz"]See  k,  {╔ hsshellscriptу Run a subroutine as a child process, but don't let it produce any messages.
Read its stdout and stderrб instead, and append it to the contents of a
mutable variable. The idea is that you can run some commands silently, and
report them and their messages to the user only when something goes wrong.Ы If the child process terminates in a way which indicates an error, then the
process status is thrown, in the same way as  |# does. If the subroutine
throws an (Exited ec) exception (of type ProcessStatus), such as thrown by
 |З , then the child process exits with the same exit code, such that the
parent process reports it to the caller, again as a ProcessStatus exception.ц When the subroutine finishes, the child process is terminated with  ⌡ 0у .
When it throws an exception, an error message is printed and it is terminated
with  ⌡ 1. See HsShellScript#subr  for details.┴The standard output (and the standard error output) of the parent process are
flushed before the fork, such that no output appears twice.Example:▄let handler :: IORef String -> ProcessStatus -> IO ()
    handler msgref ps = do hPutStrLn stderr ("Command failed with " ++ show ps ++ ". Actions so far: ")
                           msg <- readIORef msgref
                           hPutStrLn stderr msg
                           exitWith (ExitFailure 1)

msgref <- newIORef ""
do silently msgref $ do putStrLn "Now doing foobar:"
                        echo exec "/foo/bar" ["arguments"]
   silently msgref $ echo exec "/bar/baz" ["arguments"]
`catch` (handler msgref)See  √,  t,  |, Data.IORef.і hsshellscriptу Modify a subroutine action in order to make it suitable to run as a child
   process.This is used by functions like  u,  ╔,  ░ы  etc. The action
   is executed. When it returns, the (child) process is terminated with  ⌡ 0
   (after flushing stdout■), circumventing normal program shutdown. When it
   throws an exception, an error message is printed and the (child) process is
   terminated with  ⌡ 1.ї hsshellscriptPrint text to stdout.This is a shorthand for putStrLn, except for stderr┤ being flushed
   beforehand. This way normal output and error output appear in
   order, even when they aren't buffered as by default.,An additional newline is printed at the end..outm msg = do
   hFlush stderr
   putStrLn msg╗ hsshellscriptPrint text to stdout.This is a shorthand for putStr, except for stderr┤ being flushed
   beforehand. This way normal output and error output appear in
   order, even when they aren't buffered as by default.!No newline is printed at the end.-outm_ msg = do
   hFlush stderr
   putStr msg╘ hsshellscriptColorful log message to stderr.This prints a message to stderr. When stderr1 is connected to a terminal
   (as determined by 	isatty(3)░), additional escape sequences are printed,
   which make the message appear in cyan. Additionally, a newline character is
   output at the end.stdoutШ  is flushed beforehand. So normal output and error output appear in
   order, even when they aren't buffered as by default.See  ╙,  ╚,  ╛.╙ hsshellscriptColorful log message to stderr.This prints a message to stderr. When stderr1 is connected to a terminal
   (as determined by 	isatty(3)┌), additional escape sequences are printed,
   which make the message appear in cyan. No a newline character is output at the end.stdoutШ  is flushed beforehand. So normal output and error output appear in
   order, even when they aren't buffered as by default.See  ╘,  ╚,  ╛.╚ hsshellscriptColorful error message to stderr.This prints a message to stderr. When stderr1 is connected to a terminal
   (as determined by 	isatty(3)▐), additional escape sequences are printed,
   which make the message appear in red. Additionally, a newline character is
   output at the end.stdoutШ  is flushed beforehand. So normal output and error output appear in
   order, even when they aren't buffered as by default.See  ╘,  ╙,  ╛.╛ hsshellscriptColorful error message to stderr.This prints a message to stderr. When stderr1 is connected to a terminal
   (as determined by 	isatty(3)│), additional escape sequences are printed,
   which make the message appear in red. No a newline character is output at the end.stdoutШ  is flushed beforehand. So normal output and error output appear in
   order, even when they aren't buffered as by default.See  ╘,  ╙,  ╚.ґ hsshellscript│In case the specified action throws an IOError, fill in its filename field. This way, more useful error
messages can be produced.Example:┘-- Oh, the GHC libraries neglect to fill in the file name
executeFile' prog a b c =
   fill_in_filename prog $ executeFile prog a b cSee  ў,  ╞.ў hsshellscript│In case the specified action throws an IOError, fill in its location field. This way, more useful error
messages can be produced.Example:їmy_fun a b c = do
   -- ...
   fill_in_location "my_fun" $  -- Give the caller a more useful location information in case of failure
      rename "foo" "bar"
   -- ...See  ґ.╞ hsshellscriptеIn case the specified action throws an IOError, add a line to its location field. This way, more useful
error messages can be produced. The specified string is prepended to the old location, separating it with a
newline from the previous location, if any. When using this thoroughly, you get a reverse call stack in
IOErrors.Example:3my_fun =
   add_location "my_fun" $ do
      -- ...See  ґ,  ў.╟ hsshellscriptThis is a replacement for  System.Posix.Process.executeFile1. It does
   additional preparations, then calls executeFile. executeFile can't normally
   <be used directly, because it doesn't do the things which are
   outlined here.This are the differences to executeFile:	stdout and stderr are flushed.гThe standard file descriptors 0-2 are made copies of the file descriptors
   which the standard handles currently use. This is necessary because they
   might no longer use the standard handles. See HsShellScript#fdpipes .If the standard handles stdin, stdout, stderrе aren't in closed state,
   and they aren't already connected to the respective standard file
   descriptors, their file descriptors are copied to the respective standard
   file descriptors (with dup2╨). Backup copies are made of the file
   descriptors which are overwritten. If some of the standard handles are closed,
   the corresponding standard file descriptors are closed as well.	у All file descriptors, except for the standard ones, are set to close-on-exec
   (see fcntl(2)Ь ), and will be closed on successful replacement of
   the process. Before that, the old file descriptor flags are saved.ГThe standard file descriptors are set to blocking mode, since GHC 6.2.2
   sets file descriptors to non-blocking (except 0-2, which may get
   overwritten by a non-blocking one in step 2). The called program
   doesn't expect that.УIn case replacing the process fails, the file descriptors are reset to
   the original state. The file descriptors flags are restored, and the file
   descriptors 0-2 are overwritten again, with their backup copies. Then an
   IOError is thrown.;In any IOError, the program is filled in as the file name (executeFile
   neglects this).The return type is a generic a, rather than ().	Also see HsShellScript#exec .╠ hsshellscript-Check if a handle is connected to a terminal.This is a front end to the 	isatty(3)В  function (see man page). It is useful,
   for instance, to determine if color escape sequences should be
   generated.Ъ hsshellscript The GHC libraries don't declare Foreign.C.Error.Errno( as instance of
 Show. This makes it up.2  hsshellscript.Handle, which is connected to the terminal     hsshellscriptО The number of columns in the constrolling terminal. 
   Nothing, when the handle isn't connected to a terminal.  hsshellscript.Handle, which is connected to the terminal     hsshellscriptЬ The number of columns in the constrolling terminal. 
   Throws an IOError when the handle isn't connected to a terminal.  hsshellscriptа Description of the location where the error occurs in the program hsshellscriptOptional handle hsshellscript4Optional file name (for failing operations on files)t  hsshellscript$Action to execute in a child processu  hsshellscript$action to execute as a child processv  hsshellscript%Action to execute as a child process. hsshellscriptProcess ID of the new process.w  hsshellscriptName of the executable to run hsshellscriptCommand line arguments|  hsshellscriptName of the executable to run hsshellscriptCommand line arguments}  hsshellscriptAction to perform hsshellscript%Name or path of the executable to run hsshellscriptCommand line arguments~  hsshellscriptFull path to the executable hsshellscriptCommand line arguments hsshellscriptNever returns  hsshellscriptName or path of the executable hsshellscriptCommand line arguments hsshellscriptNever returns─  hsshellscriptFull path to the executable hsshellscriptCommand line arguments hsshellscriptNew environment hsshellscriptNever returns│  hsshellscriptName or path of the executable hsshellscriptCommand line arguments hsshellscriptNew environment hsshellscriptNever returns┌  hsshellscriptAction which won't be forked hsshellscript5Action which will be forked and connected with a pipe hsshellscriptResult action┐  hsshellscriptAction which won't be forked hsshellscript5Action which will be forked and connected with a pipe hsshellscriptResult action└  hsshellscript5Action which will be forked and connected with a pipe hsshellscriptAction which won't be forked hsshellscriptResult action┘  hsshellscript5Action which will be forked and connected with a pipe hsshellscriptAction which won't be forked hsshellscriptResult action├  hsshellscriptHandle to replace hsshellscriptHandle to replace it with hsshellscriptAction┤  hsshellscript'Action, whose output will be redirected hsshellscriptFile to redirect the output to hsshellscriptResult action┬  hsshellscript'Action, whose output will be redirected hsshellscriptFile to redirect the output to hsshellscriptResult action┴  hsshellscript-Action, whose error output will be redirected hsshellscript$File to redirect the error output to hsshellscriptResult action┼  hsshellscript-Action, whose error output will be redirected hsshellscript$File to redirect the error output to hsshellscriptResult action▀  hsshellscript8Action, whose output and error output will be redirected hsshellscriptFile to redirect to hsshellscriptResult action▄  hsshellscript8Action, whose output and error output will be redirected hsshellscriptFile to redirect to hsshellscriptResult action░  hsshellscriptText to pipe hsshellscript3Action to run as a separate process, and to pipe to▒  hsshellscript3Action to run as a separate process, and to pipe to hsshellscriptБ Returns handle connected to the standard input of the child process,
   and the child's process ID▓  hsshellscriptб Action to run as a separate process. Its
 return value is ignored. hsshellscriptThe action's standard output⌠  hsshellscript#Action to run as a separate process hsshellscript"The action's standard error output■  hsshellscript5Action to run as a separate process, and to pipe from hsshellscriptА Returns handle connected to the standard output of the child
 process, and the child's process ID∙  hsshellscript5Action to run as a separate process, and to pipe from hsshellscriptА Returns handle connected to the standard output of the child
 process, and the child's process ID√  hsshellscript#Action to run as a separate process hsshellscriptа The action's lazy output and the process ID of the child
 process≈  hsshellscript#Action to run as a separate process hsshellscriptа The action's lazy output and the process ID of the child
 process≤  hsshellscriptа Action to run as a separate process. Its return value is ignored. hsshellscriptА The output of the IO action until it terminated and
 the process status of the terminated action.≥  hsshellscriptа Action to run as a separate process. Its return value is ignored. hsshellscriptГ The error output of the IO action until it terminated and
 the process status of the terminated action.   hsshellscriptAction to run in a new process hsshellscriptWhether to make stdin pipe hsshellscriptWhether to make stdout pipe hsshellscriptWhether to make stderr pipe hsshellscriptPipes to the new process's stdin, stdout and stderr%, if applicable;
 and its process id.⌡  hsshellscript	Exit code hsshellscriptNever returns°  hsshellscripterrno value hsshellscriptCorresponding error message²  hsshellscripterrno value·  hsshellscripterrno error number hsshellscript+Text to precede the message, separated by ": "÷  hsshellscript+Text to precede the message, separated by ": "║  hsshellscriptAction to modify hsshellscriptModified action╔  hsshellscriptж A mutable variable, which gets the output (stdout and stderr) of the
 action appended. hsshellscriptThe IO action to run.ї  hsshellscriptMessage to print╗  hsshellscriptMessage to print╘  hsshellscriptMessage to printґ  hsshellscriptFile name to fill in hsshellscriptIO action to modify hsshellscriptModified IO actionў  hsshellscriptLocation name to fill in hsshellscriptIO action to modify hsshellscriptModified IO action╞  hsshellscriptLocation name to add hsshellscriptIO action to modify hsshellscriptModified IO action╟  hsshellscriptProgram to call hsshellscriptSearch PATH? hsshellscript	Arguments hsshellscriptOptionally new environment hsshellscriptNever returns╠  hsshellscriptHandle to check hsshellscript-Whether the handle is connected to a terminalЦ krqponml─│┌┐└┘├┤┬┴┼stuv▀wxyz{|}~─│┌┐└┘├▄┤┬┴┼▀▄█▌▐█░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟▌▐░╠▒▓⌠■∙√≈≤  ┌2┐2└2 ┘2 ┤3 ┬3 ┴3 ┼3 ▀3 ▄3 █3          None%&'56э  ЖЙ╡ hsshellscript4One entry of mount information. This is the same as struct mntent from 
<mntent.h>л . A list of these is
returned by the functions which read mount information.See  м,  н,  о.Є hsshellscript+Device file ("name of mounted file system")╣ hsshellscriptMount pointІ hsshellscript*Which kind of file system ("see mntent.h")Ї hsshellscriptMount options ("see mntent.h")╦ hsshellscriptDump frequency in days╧ hsshellscript"Pass number on parallel fsck"╨ hsshellscript
Format an Int9 with leading zeros. If the string representation of the InГА  is longer than the number of
 characters to fill up, this produces as many characters as needed.╩ hsshellscript4Remove trailing newlines. This is silimar to perl's chomp procedure.╪ hsshellscriptGet contents of a file or of stdin. This is a simple frontend to hGetContents. A file name of "-"к 
designates stdin. The contents are read lazily as the string is evaluated.╦(The handle which we read from will be in semi-closed state. Once all input has read, it is closed automatically
(Haskell Library Report 11.2.1). Therefore we don't need to return it).Р lazy_contents path = do
    h   <- if path == "-" then return stdin else openFile path ReadMode
    hGetContents hҐ hsshellscriptGet contents of a file or of stdin eagerly. This is the same as lazy_contents2, except for the contents
 being read immediately.Ў hsshellscript=Test for the existence of a path. This is the disjunction of Directory.doesDirectoryExist and
 Directory.doesFileExist,. For an dangling symlink, this will return False.© hsshellscript,Test for the existence of a path. This uses  System.Posix.Files.getFileStatusМ  to determine whether the path
 exists in any form in the file system. For a dangling symlink, the result is True.ю hsshellscript5Test if path points to a directory. This will return True= for a symlink pointing to a directory. It's a
 shortcut for Directory.doesDirectoryExist.а hsshellscript7Test if path points to a file. This is a shortcut for
 Directory.doesFileExist.б hsshellscriptThis is the  System.Posix.Files.getFileStatusЬ  function from the GHC libraries, with improved error reporting.
 The GHC function doesn't include the file name in the IOError? when the call fails, making error messages much
 less useful. getFileStatus' rectifies this.See   .ц hsshellscriptThis is the System.Posix.Files.fileAccessЬ  function from the GHC libraries, with improved error reporting.
 The GHC function doesn't include the file name in the IOError? when the call fails, making error messages much
 less useful. fileAccess' rectifies this.See   .д hsshellscriptыCreate a temporary file. This will create a new, empty file, with a path which did not previously exist in the
 file system. The path consists of the specified prefix, a sequence of random characters (digits and letters),
 and the specified suffix. The file is created with read-write permissions for the user, and no permissons for
 the group and others. The ownership is set to the effective user ID of the process. The group ownership is set
 either to the effective group ID of the process or to the group ID of the parent directory (depending on
 filesystem type and mount options on Linux - see open(2) for details).See  ф,  е,  х.е hsshellscriptиCreate a temporary directory. This will create a new directory, with a path which did not previously exist in
 the file system. The path consists of the specified prefix, a sequence of random characters (digits and
 letters), and the specified suffix. The directory is normally created with read-write-execute permissions for
 the user, and no permissons for the group and others. But this may be further restricted by the process's umask
 in the usual way.жThe newly created directory will be owned by the effective uid of the process. If the directory containing the
 it has the set group id bit set, or if the filesystem is mounted with BSD group semantics, the new directory
 will inherit the group ownership from its parent; otherwise it will be owned by the effective gid of the
 process. (See mkdir(2))See  г,  д,  и.ф hsshellscriptЖCreate a temporary file. This will create a new, empty file, with read-write permissions for the user, and no
 permissons for the group and others. The path consists of the specified prefix, a dot, and six random characters
 (digits and letters).0tmp_file prefix = temp_file 6 (prefix ++ ".") ""See  д,  г,  й.г hsshellscriptЄCreate a temporary directory. This will create a new directory, with read-write-execute permissions for the
 user (unless further restricted by the process's umask), and no permissons for the group and others. The path
 consists of the specified prefix, a dot, and six random characters (digits and letters)..tmp_dir prefix = temp_dir 6 (prefix ++ ".") ""See  е,  ф,  к.х hsshellscriptУ Create and open a temporary file, perform some action with it, and delete it afterwards. This is a front end
 to the  д╦ function. The file and its path are created in the same way. The IO action is passed a handle
 of the new file. When it finishes - normally or with an exception - the file is deleted.See  д,  й,  и.и hsshellscriptЯ Create a temporary directory, perform some action with it, and delete it afterwards. This is a front end to
 the  ег function. The directory and its path are created in the same way. The IO action is passed the
 path of the new directory. When it finishes - normally or with an exception - the directory is deleted.н The action must clean up any files it creates inside the directory by itself. with_temp_dirГ  doesn't delete any
 files inside, so the directory could be removed. If the directory isn't empty, an IOErrorб results (with the
 path filled in). When the action throws an exception, and the temporary directory cannot be removed, then the
 exception is passed through, rather than replacing it with the IOError. (This is because it's probably exactly
 because of that exception that the directory isn't empty and can't be removed).See  е,  к,  х.й hsshellscriptУ Create and open a temporary file, perform some action with it, and delete it afterwards. This is a front end
 to the  ф╦ function. The file and its path are created in the same way. The IO action is passed a handle
 of the new file. When it finishes - normally or with an exception - the file is deleted.See  ф,  х,  к.к hsshellscriptЯ Create a temporary directory, perform some action with it, and delete it afterwards. This is a front end to
 the  гг function. The directory and its path are created in the same way. The IO action is passed the path
 of the new directory. When it finishes - normally or with an exception - the directory is deleted.н The action must clean up any files it creates inside the directory by itself. with_temp_dirГ  doesn't delete any
 files inside, so the directory could be removed. If the directory isn't empty, an IOErrorб results (with the
 path filled in). When the action throws an exception, and the temporary directory cannot be removed, then the
 exception is passed through, rather than replacing it with the IOError. (This is because it's probably exactly
 because of that exception that the directory isn't empty and can't be removed).>with_tmp_dir prefix io = with_temp_dir 6 (prefix ++ ".") "" ioSee  г,  и,  й.л hsshellscriptуCreate a temporary path. This will generate a path which does not yet exist in the file system. It consists of
 the specified prefix, a sequence of random characters (digits and letters), and the specified suffix.д Avoid relying on the generated path not to exist in the file system.Ф  Or else you'll get a potential race
 condition, since some other process might create the path after 	temp_pathс , before you use it. This is a
 security risk. The global random number generator (Random.randomRIO┘) is used to generate the random
 characters. These might not be that random after all, and could potentially be guessed. Rather use 	temp_file
 or temp_dir.See  д,  е.м hsshellscript3Read mount information. This is a front end to the setmntent(3), getmntent(3), endmntent(3) system
library functions.	When the 	setmntent call fails, the errno value is converted to an IOError and thrown.See  н,  о.н hsshellscript'Get the currently mounted file systems.#read_mtab = read_mounts "/etc/mtab"See  м.о hsshellscript&Get the system wide file system table.%read_fstab = read_mounts "/etc/fstab"See  м.п hsshellscript"This is an interface to the POSIX globН function, which does wildcard expansion
 in paths. The sorted list of matched paths is returned. It's empty
 for no match (rather than the original pattern). In case anything goes wrong
 (such as permission denied), an IOError is thrown.
This does notй  do tilde expansion, which is done (among many unwanted other
 things) by wordexp%. The only flag used for the call to glob is GLOB_ERR.Л The behaviour in case of non-existing path components is inconsistent in the
 GNU version of the underlying glob function. glob "/doesnt_exist/foo"& will return
 the empty list, whereas glob "/doesnt_exist/*"/ causes a "No such file or directory"
 IOError.╨Note that it isn't clear if dangling symlinks are matched by glob. From the
 web: "Compared to other glob implementation (*BSD, bash, musl, and other
 shells as well), GLIBC seems the be the only one that does not match dangling
 symlinks. ... POSIX does not have any strict specification for dangling
 symlinks". Б You will have to work around this problem, probably using
 System.Directory.getDirectoryContents. See man pages glob(3) and 
wordexp(3).я hsshellscript*Quote special characters for use with the glob
 function.The characters *, ?, [ and \щ  must be quoted by preceding
 backslashs, when they souldn't have their special meaning. The 
glob_quote
 function does this.You can't use quote or shell_quote.See  п,   ,   ╨  hsshellscriptHow many characters to fill up hsshellscriptValue to represent as a string hsshellscriptл String representation of the value, using the specified number of characters╩  hsshellscriptString to be chomped hsshellscript8Same string, except for no newline characters at the end╪  hsshellscriptEither the name of a file, or "-" hsshellscript(The lazily read contents of the file or stdin.Ґ  hsshellscripteither the name of a file, or "-" for stdin hsshellscript-the contents of the file or of standard inputЎ  hsshellscriptPath hsshellscript*Whether the path exists in the file system©  hsshellscriptPath hsshellscript*Whether the path exists in the file systemю  hsshellscriptPath hsshellscript2Whether the path exists and points to a directory.а  hsshellscriptPath hsshellscript-Whether the path exists and points to a file.б  hsshellscript/Path of the file, whose status is to be queried hsshellscriptStatus of the fileд  hsshellscriptТ Number of random characters to intersperse. Must be large enough,
 such that most combinations can't already
 exist. hsshellscript Prefix for the path to generate. hsshellscript Suffix for the path to generate. hsshellscriptPath of the created file.е  hsshellscriptС Number of random characters to intersperse. Must be large enough,
 such that most combinations can't already exist. hsshellscript Prefix for the path to generate. hsshellscript Suffix for the path to generate. hsshellscriptGenerated path.ф  hsshellscript Prefix for the path to generate. hsshellscriptPath of the created file.г  hsshellscript Prefix for the path to generate. hsshellscriptPath of the created directory.х  hsshellscriptТ Number of random characters to intersperse. Must be large enough,
 such that most combinations can't
 already exist. hsshellscript Prefix for the path to generate. hsshellscript Suffix for the path to generate. hsshellscriptAction to perform. hsshellscript)Returns the value returned by the action.и  hsshellscriptУ Number of random characters to intersperse. Must be large enough,
   such that most combinations can't already exist. hsshellscript Prefix for the path to generate. hsshellscript Suffix for the path to generate. hsshellscriptAction to perform. hsshellscript)Returns the value returned by the action.й  hsshellscript Prefix for the path to generate. hsshellscriptAction to perform. hsshellscript)Returns the value returned by the action.к  hsshellscript Prefix for the path to generate. hsshellscriptAction to perform. hsshellscript)Returns the value returned by the action.л  hsshellscriptС Number of random characters to intersperse. Must be large enough,
 such that most combinations can't already exist. hsshellscript Prefix for the path to generate. hsshellscript Suffix for the path to generate. hsshellscriptGenerated path.м  hsshellscriptFile to read (typically 	/etc/mtab or 
/etc/fstab) hsshellscriptMount information in that fileп  hsshellscriptPattern hsshellscriptSorted list of matching paths+╡╧╦ЇІ╣ЄЁ≥ ⌡°²·÷═║╒╨╩╪ҐЎ©юабцдефгхийклёмнопя     	       Safe-Inferred%&'56э  -[р hsshellscriptDo a call to the realpath(3)Ъ  system library function. This makes the path absolute, normalizes it and
 expands all symbolic links. In case of an error, an IOError is thrown.с hsshellscript7Determine the target of a symbolic link. This uses the readlink(2)▄ system call. The result is a path which
 is either absolute, or relative to the directory which the symlink is in. In case of an error, an IOError; is
 thrown. The path is included and can be accessed with IO.ioeGetFileNameХ . Note that, if the path to the symlink
 ends with a slash, this path denotes the directory pointed to, notп  the symlink. In this case the call to will
 fail because of "Invalid argument".т hsshellscript7Determine the target of a symbolic link. This uses the readlink(2)ъ system call. The target is converted,
 such that it is relative to the current working directory, if it isn't absolute. Note that, if the path to the
 symlink ends with a slash, this path denotes the directory pointed to, not( the symlink. In this case the call
 to readlink will fail with an IOErrorю  because of "Invalid argument". In case of any error, a proper
 IOError is thrown.у hsshellscriptр Determine whether a path is a symbolic link. The result for a dangling symlink is Trueи . The path must exist
 in the file system. In case of an error, a proper IOError is thrown.ж hsshellscriptеReturn the normalised, absolute version of a specified path. The path is made absolute with the current
 working directory, and is syntactically normalised afterwards. This is the same as what the realpath program
 reports with the -s  option. It's almost the same as what it reports when called from a shell. The difference
 lies in the shell's idea of the current working directory. See  э for details.See  э,  .в hsshellscript"Make a symbolic link. This is the 
symlink(2)# function. Any error results in an IOError> thrown. The path of
 the intended symlink is included in the IOError and can be accessed with ioeGetFileName$ from the Haskell
 standard library IO.ь hsshellscript	Call the du program. See du(1).ы hsshellscript)Create directory. This is a shorthand to  System.Directory.createDirectoryж  from the Haskell standard library.
 In case of an error, the path is included in the IOError,, which GHC's implementation neglects to do.з hsshellscriptRemove directory. This is Directory.removeDirectoryж  from the Haskell standard library. In case of an error,
 the path is included in the IOError,, which GHC's implementation neglects to do.ш hsshellscriptRemove file. This is Directory.removeFileг  from the Haskell standard library, which is a direct frontend to
 the 	unlink(2) system call in GHC.э hsshellscript'Change directory. This is an alias for Directory.setCurrentDirectoryу  from the Haskell standard library. In
case of an error, the path is included in the IOError,, which GHC's implementation neglects to do.<Note that this command is subtly different from the shell's cdъ command. It changes the process' working
directory. This is always a realpath. Symlinks are expanded. The shell, on the other hand, keeps track of the
current working directory separately, in a different way: symlinks are notЯ  expanded. The shell's idea of the
working directory is different from the working directory which a process has.%This means that the same sequence of cd┘ commands, when done in a real shell script, will lead into the same
directory. But the working directory as reported by the shell's pwd< command may differ from the corresponding
one, reported by getCurrentDirectory.з (When talking about the "shell", I'm talking about bash, regardless of whether started as 	/bin/bash or in
compatibility mode, as /bin/shе . I presume it's the standard behavior for the POSIX standard shell.)See  щ,  чщ hsshellscript1Get program start working directory. This is the PWDж environent
 variable, which is kept by the shell (bash, at least). It records the
 directory path in which the program has been started. Symbolic links in
 this path aren't expanded. In this way, it differs from
 getCurrentDirectory# from the Haskell standard library.See  э,  чч hsshellscript²Change the working directory temporarily. This executes the specified IO action with a new working directory,
 and restores it afterwards (exception-safely).ъ hsshellscriptExecute 
/bin/chmodchmod = run "/bin/chmod"Ю hsshellscriptExecute 
/bin/chownchown = run "/bin/chown"А hsshellscriptExecute the cp programБ hsshellscriptExecute the mv program. This calls the /bin/mv╚ to rename a file, or move it to another directory. You can move a file to another
 file system with this. This starts a new process, which is rather slow. Consider using rename instead, when
 possible.See  Д.Ц hsshellscriptRun the command 	mt status; for querying the tape drive status, and
 parse its output.Д hsshellscriptThe 	rename(2)/ system call to rename and/or move a file. The 
renameFile└ action from the Haskell standard
 library doesn't do it, because the two paths may not refer to directories. Failure results in an IOError
 thrown. The new path is included in the IOError and can be accessed with IO.ioeGetFileName.Е hsshellscript Rename a file. This first tries  ДЩ , which is most efficient. If it fails, because source and target path
 point to different file systems (as indicated by the errno value EXDEV), then /bin/mv is called.See  Д,  Б.Ф hsshellscript8Rename a file or directory, and manage read only issues.(This renames a file or directory, using renameМ , sets the necessary write permissions beforehand, and restores
them afterwards. This is more efficient than force_mvП , because no external program needs to be called, but it can
rename files only inside the same file system. See 	force_cmd for a detailed description.┤The new path may be an existing directory. In this case, it is assumed that the old file is to be moved into this
directory (like with mvЬ ). The new path is then completed with the file name component of the old path. You won't
get an "already exists" error.force_rename = force_cmd renameSee  И,  Д.Г hsshellscript6Move a file or directory, and manage read only issues.;This moves a file or directory, using the external command mvМ , sets the necessary write permissions beforehand,
and restores them afterwards. This is less efficient than force_rename, because the external program mvе  needs
to be called, but it can move files between file systems. See 	force_cmd for a detailed description.О force_mv src tgt = fill_in_location "force_mv" $ force_cmd (\src tgt -> run "/bin/mv" ["--", src, tgt]) src tgtSee  И,  Г.Х hsshellscriptRename a file with  Д, or when necessary with  Б, and manage read only issues.Е The necessary write permissions are set, then the file is renamed, then the permissions are restored.First, the  Д▒ system call is tried, which is most efficient. If it fails, because source and target path
point to different file systems (as indicated by the errno value EXDEV), then /bin/mv is called.з force_rename_mv old new = fill_in_location "force_rename_mv" $ force_cmd rename_mv old newSee  Е,  Д,  Б,  И.И hsshellscriptл Call a command which moves a file or directory, and manage read only issues.эThis function is for calling a command, which renames files. Beforehand, write permissions are set in order to
enable the operation, and afterwards the permissions are restored. The command is meant to be something like
rename or run "/bin/mv".жIn order to change the name of a file or dirctory, but leave it in the super directory it is in, the super
directory must be writeable. In order to move a file or directory to a different super directory, both super
directories and the file/directory to be moved must be writeable. I don't know what this behaviour is supposed to
be good for.▄This function concerns itself with the case that the file/directory to be moved or renamed, or the super
directories are read only. It makes the necessary places writeable, calls the command, and makes them read only
again, if they were before. The user needs the necessary permissions for changing the corresponding write
permissions. If an error occurs (such as file not found, or insufficient permissions), then the write permissions
are restored to the state before, before the exception is passed through to the caller.дThe command must take two arguments, the old path and the new path. It is expected to create the new path in the
file system, such that the correct write permissions of the new path can be set by 	force_cmd after executing it.┤The new path may be an existing directory. In this case, it is assumed that the old file is to be moved into this
directory (like with mvї). The new path is completed with the file name component of the old path, before it is
passed to the command, such that the command is supplied the complete new path.	Examples:Ц force_cmd rename from to
force_cmd (\from to -> run "/bin/mv" ["-i", "-v", "--", from, to]) from toSee  Ф,  Г,  Д.Й hsshellscriptиMake a file or directory writeable for the user, perform an action, and restore its writeable status. An
IOError is raised when the user doesn't have permission to make the file or directory writeable.с force_writeable path io = force_writeable2 path (io >>= \res -> return (path, res))Example:Ъ -- Need to create a new directory in /foo/bar, even if that's write protected
force_writeable "/foo/bar" $ mkdir "/foo/bar/baz"See  И,  К.К hsshellscript│Make a file or directory writeable for the user, perform an action, and restore its writeable status. The
action may change the name of the file or directory. Therefore it returns the new name, along with another return
value, which is passed to the caller.д The writeable status is only changed back if it has been changed by force_writeable2░ before. An IOError is
raised when the user doesn'h have permission to make the file or directory writeable, or when the new path
doesn't exist.See  И,  Й.Л hsshellscript	Call the fdupes╦ program in order to find identical files. It outputs a list of groups of file names, such
 that the files in each group are identical. Each of these groups is further analysed by the fdupes≈ action.
 It is split to a list of lists of paths, such that each list of paths corresponds to one of the directories
 which have been searched by the fdupesа  program. If you just want groups of identical files, then apply map
 concat to the result.The fdupesЙ /program doesn't handle multiple occurences of the same directory, or in recursive mode one
 specified directory containing another, properly. The same file may get reported multiple times, and identical
 files may not get reported./ The paths are normalised (using  ).р  hsshellscriptpath hsshellscript7noramlized, absolute path, with symbolic links expandedс  hsshellscriptPath of the symbolic link hsshellscript3The link target - where the symbolic link points toт  hsshellscriptpath of the symbolic link hsshellscript)target; where the symbolic link points toу  hsshellscriptpath hsshellscript$Whether the path is a symbolic link.ж  hsshellscriptpath hsshellscript;noramlized, absolute path, with symbolic links not expandedв  hsshellscriptcontents of the symlink hsshellscriptpath of the symlinkь  hsshellscriptblock size, this is the --block-size option. hsshellscript6path of the file or directory to determine the size of hsshellscriptsize in blocksы  hsshellscriptpathз  hsshellscriptpathш  hsshellscriptpathэ  hsshellscriptpathч  hsshellscriptNew working directory hsshellscriptAction to runъ  hsshellscriptCommand line argumentsЮ  hsshellscriptCommand line argumentsА  hsshellscriptsource hsshellscriptdestinationБ  hsshellscriptsource hsshellscriptdestinationЦ  hsshellscriptfile and block numberД  hsshellscriptOld path hsshellscriptNew pathЕ  hsshellscriptOld path hsshellscriptNew pathФ  hsshellscriptOld path hsshellscriptNew pathГ  hsshellscriptOld path hsshellscriptNew path or target directoryХ  hsshellscriptOld path hsshellscriptNew pathИ  hsshellscript2Command to execute after preparing the permissions hsshellscriptOld path hsshellscriptNew path or target directoryЙ  hsshellscript#File or directory to make writeable hsshellscriptAction to perform hsshellscript&Returns the return value of the actionК  hsshellscript#File or directory to make writeable hsshellscriptAction to performЛ  hsshellscriptOptions for the fdupes program hsshellscript!Directories with files to compare hsshellscriptЭ For each set of identical files, and each of the specified directories,
 the paths of the identical files in this directory."є╔іїрстужвьызшэщчъЮАБ╗╘ЦДЕФГХИЙКЛ╙            Safe-Inferred%&'56э  /⌠М hsshellscript Error reporting wrapper for the mainг  function. This catches any
   HsShellScript generated exceptions, and IOError-s, prints
   an error message and exits with exitFailure. The main' function
   typically looks like this:main = mainwrapper $ do ...The exceptions caught are  ,  k,  Ч and IOError.М  hsshellscript
Should be main hsshellscriptWrapped mainГ"#$%-,+*)(&'/201.! J456789:;<>=?@ABDEC3KLMN_`OPQRSTUV]WXYZ[\^abFGHIcызщэржЎ©аюч 	
увстшъЮАБДЕФГХИЙКбцsЦЛьtv|klmnopqrxz{~─│}╔єё╟іyuw┤┬┴┼█▀▄▌▐┌┐└┘├░▒▓√■⌠≈∙≤≥ фгделйкхи╡ЁЄ╣ІЇ╦╧мної╗╘╙╚╛╠╨╩╪ҐпяМ²°·÷⌡═║╒ґў╞├ызщэржЎ©аючувстшъЮАБДЕФГХИЙКбцsЦЛьtv|klmnopqrxz{~─│}╔єё╟іyuw┤┬┴┼█▀▄▌▐┌┐└┘├░▒▓√■⌠≈∙≤≥ фгделйкхи╡ЁЄ╣ІЇ╦╧мної╗╘╙╚╛╠╨╩╪ҐпяМ²°·÷⌡═║╒ґў╞  ╚                            !   "   #   $   %   &   '   (   )   *   +   ,   -   .   /      0      1   2   3  4  4   5   6  7  8  8   9  :  :   ;   <   =   >   ?   @   A  B  C  D  E  F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Y   Z   [   \   ]   ^   _   `   a   b   c   d   e   f   g   h   i   j   k   l   m   n   o   p   q   r   s   t   u   v   w   x   y   z   {   |   }   ~       ─   │   ┌   ┐   └   ┘   ├   ┤   ┬   ┴   ┼   ▀   ▄   █   ▌   ▐   ░   ▒   ▓   ⌠   ■   ∙   √   ≈   ≤   ≥       ⌡   °   ²   ·   ÷   ═   ║   ╒   ё   є   ╔   і   ї   ╗   ╘   ╙   ╚   ╛   ґ   ў   ╞   ╟   ╠   ╡   Ё   Є   ╣   І   Ї   ╦   ╧   ╨   ╩   ╪   Ґ   Ў   ©   ю   а   б   ц   д  е  е   ф   г   х   и   й   к   л      м   н   о   п   я   р   с   т   у   ж   в   ь   ы   з   ш   э   щ   ч   ъ   Ю   А   Б  	 
  	   	 Ц  	 Д  	   	 Е  	 Ф  	 Г  	 Х  	 И  	 Й  	 К  	 Л  	 М  	 Н  	 О  	 П  	 Я  	 Р  	 С  	 Т  	 У  	 Ж  	 В  	 Ь  	 Ы  	 З   Ш  Э  Щ  Ч  Ъ  ─  │  ┌  ┐  └  ┘   ├   ┤ ┬┴  ┼▀ ▄ ┼█ ▌ ┼▀ ▐ ┬░   ▒   ▓   ⌠   ■   ∙   √   ≈   ≤   ≥       ⌡   °   ²   ·   ÷   ═   ║   ╒   ё   є   ╔   і   ї   ╗   ╘   ╙   ╚   ╛   ґ   ў   ╞   ╟   ╠   ╡   Ё   Є   ╣  	 І  	 Ї  	 ╦  	 ╧  	 ╨  	 ╩  	 ╪Ґhsshellscript-3.6.4-inplaceHsShellScript.PathsHsShellScript.ShellHsShellScriptHsShellScript.ArgshsshellscriptHsShellScript.GetOptSystem.EnvironmentgetArgsHsShellScript.Commandsrealpath
realpath_sreadlink	normaliseHsShellScript.ProcErrSystem.Posix.ProcessgetProcessStatusHsShellScript.MiscchompProcessStatusSystem.Posix.FilesgetFileStatus
fileAccessquoteshell_quote
slice_pathunslice_pathnormalise_pathslice_filenameslice_filename'unslice_filename
split_pathdir_partfilename_partunsplit_pathunsplit_partssplit_filenamesplit_filename'unsplit_filenamesplit3unsplit3test_suffixabsolute_pathabsolute_path_byabsolute_path'guess_dotdot_compsguess_dotdotshell_commandquote0terminal_widthterminal_width_ioethrowErrno'ArgErrorargerror_messageargerror_usageinfo	ArgumentsArgumentPropertyargumentpropertyArgumentDescriptionargdesc_short_argsargdesc_long_argsargdesc_argargargdesc_timesargdesc_argargnameargdesc_descriptionargdesc_argarg_tester	ArgtesterArgumentValueSpecArgumentValue_noneArgumentValue_requiredArgumentValue_optional	is_direct
desc_short	desc_longdesc_directdesc_value_requireddesc_value_optional
desc_times	desc_oncedesc_at_least_oncedesc_at_most_oncedesc_at_leastdesc_any_timesdesc_at_mostdesc_argnamedesc_descriptiondesc_tester
readtesterdesc_integerdesc_nonneg_integerargname	argname_aargname_shortargname_longargdescgetargsgetargs_orderedgetargs'getargs_ordered'
arg_switch	arg_timesargs_optargs_req
reqarg_opt
reqarg_req
optarg_opt
optarg_req	args_noneargs_allargs_oneargs_at_most_oneargs_at_least_onearg_conflicts
arg_occurs
usage_infounsafe_getargsunsafe_getargs_orderedmake_usage_infoprint_usage_infowrap$fOrdArgumentDescription$fEqArgumentDescription$fShowArgError$fExceptionArgError$fEqArgumentValueSpec$fShowArgumentValueSpec$fOrdArgumentValueSpecRunErrorre_progre_parsre_envre_wdre_psre_errnosetFileMode'subproccallspawnrunshow_runerrorexplain_processstatusto_ioeas_ioerunprogechoexecexecpexeceexecpe-|-=|--|==|=redirect->-->>-=>-=>>--&>--&>>--<-
err_to_out
out_to_errpipe_to	h_pipe_to	pipe_from
pipe_from2h_pipe_fromh_pipe_from2lazy_pipe_fromlazy_pipe_from2pipe_from_fullpipe_from_full2pipes_exitstrerrorerrnoperror'perrorfailIOexitcodeshow_ioerrorsystem_throwsystem_runprogsilentlychildoutmoutm_logmlogm_errmerrm_fill_in_filenamefill_in_locationadd_locationexecute_fileisattyMntent
mnt_fsnamemnt_dirmnt_typemnt_optsmnt_freq
mnt_passnozeroslazy_contentscontentspath_existspath_exists'is_diris_filegetFileStatus'fileAccess'	temp_filetemp_dirtmp_filetmp_dirwith_temp_filewith_temp_dirwith_tmp_filewith_tmp_dir	temp_pathread_mounts	read_mtab
read_fstabglob
glob_quote	readlink'
is_symlinksymlinkdumkdirrmdirrmcdpwdwith_wdchmodchowncpmv	mt_statusrename	rename_mvforce_renameforce_mvforce_rename_mv	force_cmdforce_writeableforce_writeable2fdupesmainwrapperArgDescrNoArgReqArgOptArgOptDescrOptionArgOrderRequireOrderPermuteReturnInOrder	usageInfogetOpt
unix-2.7.3System.Posix.Process.CommonbaseGHC.IO.HandlehSetBinaryModeGHC.IO.Handle.TexthGetContentshCloseSystem.Posix.Process.Internals$fShowErrnoc_terminal_widthhssh_c_isattydup2closec_fcntl_dupfdc_restore_fdflagsc_prepare_fd_flags_for_execc_save_fdflagsforeign_strerror
_exit_primc_close_on_exec	spawn_locredirect_helperpipe_fork_duphandleToFd_nocloseunsafeWithHandleFdunsafeWithHandleFd'flush_outerrreceive_ioerrorsend_ioerrorencode_ioerrordecode_ioerror	ioe_typesioetype_numnum_ioetypeglobfreedo_globc_getmntent	endmntent	setmntentc_mkdirc_closehsshellscript_open_nonvariadico_EXCLo_CREATuntilIOforeign_renameforeign_symlinkhsshellscript_get_readlinkhsshellscript_get_realpathnumberparse_mt_statusreplace_location