(      !"#$%&'()*+,-./012345678 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 pqrstuvwxyz{|}~      ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{!|!}!~!!!!!!!!!!!!!!!!!!!""""#############$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%&&&&&&&''''''''''''''(((())))))))))))))******+++++++++++++,,--../$Copyright (C) 2005-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;IN 1A type to standardize some common uses of GetOpt.@The first component of the tuple is the long name of the option.LThe second component is empty if there is no arg, or has the arg otherwise. Simple command line parser -- a basic wrapper around the system's default getOpt. See the System.Console.GetOpt manual for a description of the first two parameters.2The third parameter is a usage information header.ZThe return value consists of the list of parsed flags and a list of non-option arguments.  Similar to  , but takes an additional function that validates the post-parse command-line arguments. This is useful, for example, in situations where there are two arguments that are mutually-exclusive and only one may legitimately be given at a time.The return value of the function indicates whether or not it detected an error condition. If it returns Nothing, there is no error. If it returns Just String, there was an error, described by the String. Handle a required argument. Handle an optional argument.   Name of arg Name of arg   $Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;INLThe type representing a Debian version number. This type is an instance of , but you can also use  if you prefer. The type representing the contents of a Debian control file, or any control-like file (such as the output from apt-cache show, etc.) &Compare the versions of two packages.   Version 1Operator Version 2   /$Copyright (C) 2005-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;IN$Copyright (C) 2005-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;IN$Copyright (C) 2005-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;IN !"#$%&'()*+,-./ !"#$%&'()*+,-./ !"#$%&'()*+,-./   !"#$%&'()*+,-./$Copyright (C) 2005-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;IN0IThe name of the null device. NUL: on Windows, /dev/null everywhere else.0    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~000Copyright (C) 2004 Ian Lynagh  3-clause BSD Ian Lynagh, None 3457;IN4Returns (Data, Remainder)7123456123456346215-123456None 3457;IN 777 7 Copyright (C) 2001 Ian Lynagh Either BSD or GPLIan Lynagh <igloo@earth.li> provisionalportableNone 3457;IN8HAnything we want to work out the MD5 of must be an instance of class MD5ERThe simplest function, gives you the MD5 of a string as 4-tuple of 32bit words. F-Returns a hex number ala the md5sum program. G1Returns an integer equivalent to hex number from F. '89:;<=>?@ABCDEFG89:;<=>?@ABCDEFGEFG89:;BCD@A>?<= 89:;<=>?@ABCDEFG $Copyright (C) 2004-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;INHIJKHIJKHIJKHIJK 0Copyright (C) 2002 HardCore SoftWare, Doug HoyteGNU GPL%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;INLMNOLMNOLMNOLMNO $Copyright (C) 2004-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisional$portable to platforms with rawSystemNone 3457;INP@Returns a list representing the bytes that comprise a data type.Example: 6getBytes (0x12345678::Int) -> [0x12, 0x34, 0x56, 0x78]QThe opposite of P=, this function builds a number based on its component bytes.EResults are undefined if any components of the input list are > 0xff!RConverts a Char to a Word8. S Converts a String to a [Word8]. TConverts a Word8 to a Char. U Converts a [Word8] to a String. PQRSTUPQRSTUPQRSTUPQRSTU $Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;INV^A section represents a compressed component in a GZip file. Every GZip file has at least one. W+Stored on-disk at the end of each section. Y+The size of the original, decompressed dataZ9The stored GZip CRC-32 of the original, decompressed data[JWhether or not the stored CRC-32 matches the calculated CRC-32 of the data\WThe data structure representing the GZip header. This occurs at the beginning of each V on disk. ^2Compression method. Only 8 is defined at present.c&Modification time of the original filed Extra flagseCreating operating systemgCRC-32 check failedhCouldn't find a GZip headeri7Compressed with something other than method 8 (deflate)jOther problem aroseFirst two bytes of fileFlagsFlagsFlagsFlagsk3Read a GZip file, decompressing all sections found.?Writes the decompressed data stream to the given output handle.Returns Nothing if the action was successful, or Just GZipError if there was a problem. If there was a problem, the data written to the output handle should be discarded.l<Read a GZip file, decompressing all sections that are found.Returns a decompresed data stream and Nothing, or an unreliable string and Just (error). If you get anything other than Nothing, the String returned should be discarded.mRead all sections.n4Read one section, returning (ThisSection, Remainder)WRead the file's compressed data, returning (Decompressed, Calculated CRC32, Remainder)o2Read the GZip header. Return (Header, Remainder).#VWXYZ[\]^_`abcdefghijk Input handle Output handlelmnoVWXYZ[\]^_`abcdefghijklmno\]^_`abcdeVfghijWXYZ[lkmonVWXYZ[\ ]^_`abcdefghijklmno$Copyright (C) 2004-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;INp,Take the first item out of a 3 element tupleq-Take the second item out of a 3 element tupler,Take the third item out of a 3 element tuplepqrpqrpqrpqr$Copyright (C) 2005-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;INsiPulls a Just value out of a Maybe value. If the Maybe value is Nothing, raises an exception with error. tLike sJ, but lets you customize the error message raised if Nothing is supplied. stststst$Copyright (C) 2004-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;INurConverts a Maybe value to an Either value, using the supplied parameter as the Left value if the Maybe is Nothing.$This function can be interpreted as: +maybeToEither :: e -> Maybe a -> Either e aXIts definition is given as it is so that it can be used in the Error and related monads.vPulls a Right_ value out of an Either value. If the Either value is Left, raises an exception with "error". wLike v3, but can raise a specific message with the error. xWTakes an either and transforms it into something of the more generic MonadError class. y*Take a Left to a value, crashes on a Rightz*Take a Right to a value, crashes on a Left{.Take an Either, and return the value inside itu7(Left e) will be returned if the Maybe value is Nothing.(Right a) will be returned if this is (Just a)vwxyz{uvwxyz{uvwxyz{uvwxyz{$Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalsystems with networkingNone 3457;IN|Sets up the system for networking. Similar to the built-in withSocketsDo (and actually, calls it), but also sets the SIGPIPE handler so that signal is ignored.Example: !main = niceSocketsDo $ do { ... }|}~|}~|}~|}~$Copyright (C) 2004-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  experimentalsystems with networkingNone 3457;IN The main handler type.)The first parameter is the socket itself.1The second is the address of the remote endpoint./The third is the address of the local endpoint.Options for your server. 6Get Default options. You can always modify it later. #Takes some options and sets up the P. I will bind and begin listening, but will not accept any connections itself. FClose the socket server. Does not terminate active handlers, if any. +Handle one incoming request from the given . ,Handle all incoming requests from the given . 0Convenience function to completely set up a TCP " and handle all incoming requests. This function is literally this: mserveTCPforever options func = do sockserv <- setupSocketServer options serveForever sockserv func4Log each incoming connection using the interface in System.Log.Logger.-Log when the incoming connection disconnects.<Also, log any failures that may occur in the child handler. THandle each incoming connection in its own thread to make the server multi-tasking.8Give your handler function a Handle instead of a Socket.The Handle will be opened with ReadWriteMode (you use one handle for both directions of the Socket). Also, it will be initialized with LineBuffering.Unlike other handlers, the handle will be closed when the function returns. Therefore, if you are doing threading, you should to it before you call this handler. Port NumberServer optionsHandler functionName of logger to usePriority of logged messagesHandler to call after loggingResulting handler!Handler to call in the new threadResulting handlerHandler to call (c) by Bjrn BringertGPL2Bjrn Bringert provisionalportableNone 3457;IN$Parse a date string as formatted by .The resulting  will only have those fields set that are represented by a format specifier in the format string, and those fields will be set to the values given in the date string. If the same field is specified multiple times, the rightmost occurence takes precedence.The resulting date is not neccessarily a valid date. For example, if there is no day of the week specifier in the format string, the value of  will most likely be invalid.Format specifiers are % followed by some character. All other characters are treated literally. Whitespace in the format string matches zero or more arbitrary whitespace characters.WFormat specifiers marked with * are matched, but do not set any field in the output.Some of the format specifiers are marked as space-padded or zero-padded. Regardless of this, space-padded, zero-padded or unpadded inputs are accepted. Note that strings using unpadded fields without separating the fields may cause strange parsing.Supported format specfiers: $%%a % character.%a/locale's abbreviated weekday name (Sun ... Sat)%A/locale's full weekday name (Sunday .. Saturday)%b*locale's abbreviated month name (Jan..Dec)%B,locale's full month name (January..December)%c<locale's date and time format (Thu Mar 25 17:47:03 CET 2004)%Ccentury [00-99]%d"day of month, zero padded (01..31)%Ddate (%m/%d/%y)%e#day of month, space padded ( 1..31)%h same as %b%H)hour, 24-hour clock, zero padded (00..23)%I)hour, 12-hour clock, zero padded (01..12)%j'day of the year, zero padded (001..366)%k*hour, 24-hour clock, space padded ( 0..23)%l*hour, 12-hour clock, space padded ( 1..12)%mmonth, zero padded (01..12)%Mminute, zero padded (00..59)%na newline character%plocale's AM or PM indicator%r-locale's 12-hour time format (hh:mm:ss AM/PM)%R(hours and minutes, 24-hour clock (hh:mm)%s)* seconds since '00:00:00 1970-01-01 UTC'%Sseconds, zero padded (00..59)%ta horizontal tab character%Ttime, 24-hour clock (hh:mm:ss)%u,numeric day of the week (1=Monday, 7=Sunday)%U<* week number, weeks starting on Sunday, zero padded (01-53)%Vy* week number (as per ISO-8601), week 1 is the first week with a Thursday, zero padded, (01-53)%w-numeric day of the week, (0=Sunday, 6=Monday)%W<* week number, weeks starting on Monday, zero padded (01-53)%x3locale's preferred way of printing dates (%m/%d/%y)%X3locale's preferred way of printing time. (%H:%M:%S)%y*year, within century, zero padded (00..99)%Yyear, including century. Not padded (this is probably a bug, but formatCalendarTime does it this way). (0-9999)%ZWtime zone abbreviation (e.g. CET) or RFC-822 style numeric timezone (-0500) hRead up to a given number of digits, optionally left-padded with whitespace and interpret them as an . Time locale Date formatString to parse if parsing failed.Copyright (C) 2004 Volker WyskBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;IN&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, realpath is probably what you need.TThe case that the path is empty, is probably an error. However, it is treated like ".*", yielding an empty path components list. Examples: ~slice_path "/" = ["/"] slice_path "/foo/bar" = ["/foo","bar"] slice_path "..//./" = [".."] slice_path "." = []See , realpath,  realpath_s.<Form a path from path components. This isn't the inverse of , since  .  normalises the path.See .4Normalise a path. This is done by reducing repeated /! characters to one, and removing . path components. ..? path components are left intact, because of possible symlinks.  =  . 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.iConcateneting the name components and adding dots, reproduces the original name, with a normalised path: concat . intersperse "." .  ==  normalise.,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: 1 "a.b//./.foo.tar.gz" == ["a.b/.foo","tar","gz"] ' ".x..y." == [".x.", "y."] See , slice_filename'.This is a variant of  . It is like z, except for being more efficient, and the filename must not contain any preceding path, since this case isn't considered.See , .UForm file name from file name components, interspersing dots. This is the inverse of ', except for normalisation of any path. +unslice_filename = concat . intersperse "."See .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_pathT 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")See .!Get the directory part of a path. dir_part = fst . split_pathSee .&Get the last path component of a path.  filename_part = snd . split_path Examples: ?filename_part "foo/bar" == "bar" filename_part "." == "."See . Inverse of , except for normalisation./This concatenates two paths, and takes care of "."< and empty paths. When the two components are the result of  split_path, then  unsplit_pathD creates a normalised path. It is best documented by its definition: unsplit_path (".", "") = "." unsplit_path ("", ".") = "." unsplit_path (".", q) = q unsplit_path ("", q) = q unsplit_path (p, "") = p unsplit_path (p, ".") = p unsplit_path (p, q) = p ++ "/" ++ q Examples: unsplit_path ("", "") == "" unsplit_path (".", "") == "." unsplit_path (".", ".") == "." unsplit_path ("foo", ".") == "foo"See .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\'' Variant of &. This is a more efficient version of S, for the case that you know the string is is a pure file name without any slashes.See . 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 .5Split a path in directory, base file name and suffix.:Form path from directory, base file name and suffix parts.3Test 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.: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 getCurrentDirectoryg which means that symbolic links in it are expanded and the path is normalised. This is different from pwd.Make a path absolute.sThis makes a relative path absolute with respect to a specified directory. An absolute path is returned unmodified.Make a path absolute.sThis makes a relative path absolute with respect to a specified directory. An absolute path is returned unmodified.CThe order of the arguments can be confusing. You should rather use . absolute_path') is included for backwards compatibility. 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 ".."; components than preceeding normal components, then the ".."B components can't be normalised away. In this case, the result is Nothing. Guess the ".."T-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 ".."; components than preceeding normal components, then the ".."B components can't be normalised away. In this case, the result is Nothing. Bguess_dotdot = fmap unslice_path . guess_dotdot_comps . slice_path$The path to be broken to components.List of path components.List of path components7The path which consists of the supplied path componentsPath to be normalisedPath in normalised formPath.List of components the file name is made up ofFile name without path.List of components the file name is made up ofList of file name components:Name of the file which consists of the supplied componentsPath to be splitQDirectory and file name components of the path. The directory path is normalized.Directory and file name2Path formed from the directory and file name parts(Path including the file name to be split>The normalised path with the file prefix, and the file suffix.Filename to be splitBase name and the last suffixFile name prefix and suffixPath Path to split3Directory part, base file name part and suffix part3Directory part, base file name part and suffix part'Path consisting of dir, base and suffixSuffix to split off Path to testPrefix without the suffix or NothingThe path to be made absolute Absulte path9The directory relative to which the path is made absoluteThe path to be made absolute Absolute pathThe path to be made absolute9The directory relative to which the path is made absolute Absolute pathList of path components+In case the path could be transformed, the ".."(-component free list of path components.Path to be normalised7In case the path could be transformed, the normalised, ".."!-component free form of the path.$Copyright (C) 2006-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;IN The options for  and  )The base from which calculations are made.The increment to the power for each new suffix,The first power for which suffixes are givenThe suffixes themselvesOPredefined definitions for byte measurement in groups of 1024, from 0 to 2**80 CPredefined definitions for SI measurement, from 10**-24 to 10**24. Takes a number and returns a new (quantity, suffix) combination. The space character is used as the suffix for items around 0. Like , but takes a list of numbers. The first number in the list will be evaluated for the suffix. The same suffix and scale will be used for the remaining items in the list. Please see " for an example of how this works.5It is invalid to use this function on an empty list. Render a number into a string, based on the given quantities. This is useful for displaying quantities in terms of bytes or in SI units. Give this function the { for the desired output, and a precision (number of digits to the right of the decimal point), and you get a string output.Here are some examples: Data.Quantity> renderNum binaryOpts 0 1048576 "1M" Data.Quantity> renderNum binaryOpts 2 10485760 "10.00M" Data.Quantity> renderNum binaryOpts 3 1048576 "1.000M" Data.Quantity> renderNum binaryOpts 3 1500000 "1.431M" Data.Quantity> renderNum binaryOpts 2 (1500 ** 3) "3.14G" Data.Quantity> renderNum siOpts 2 1024 "1.02k" Data.Quantity> renderNum siOpts 2 1048576 "1.05M" Data.Quantity> renderNum siOpts 2 0.001 "1.00m" Data.Quantity> renderNum siOpts 2 0.0001 "100.00u".If you want more control over the output, see . Like , but operates on a list of numbers. The first number in the list will be evaluated for the suffix. The same suffix and scale will be used for the remaining items in the list. See  for more examples. Also, unlike d, the %f instead of %g printf format is used so that "scientific" notation is avoided in the output. Examples: *Data.Quantity> renderNums binaryOpts 3 [1500000, 10240, 104857600] ["1.431M","0.010M","100.000M"] *Data.Quantity> renderNums binaryOpts 3 [1500, 10240, 104857600] ["1.465K","10.000K","102400.000K"]'Parses a String, possibly generated by T. Parses the suffix and applies it to the number, which is read via the Read class.KReturns Left "error message" on error, or Right number on successful parse.9If you want an Integral result, the convenience function  is for you.Parse a number as with , but return the result as an G. Any type such as Integer, Int, etc. can be used for the result type.This function simply calls  on the result of . A = is used internally for the parsing of the numeric component.]By using this function, a user can still say something like 1.5M and get an integral result. Precision of the resultThe number to examinePrevision of the resultThe numbers to examineResult%Information on how to parse this data+Whether to perform a case-insensitive matchThe string to parse%Information on how to parse this data+Whether to perform a case-insensitive matchThe string to parse $Copyright (C) 2004-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;IN?January 1, 1970, midnight, UTC, represented as a CalendarTime. RConverts the specified CalendarTime (see System.Time) to seconds-since-epoch time.This conversion does respect the timezone specified on the input object. If you want a conversion from UTC, specify ctTZ = 0 and ctIsDST = False.When called like that, the behavior is equivolent to the GNU C function timegm(). Unlike the C library, Haskell's CalendarTime supports timezone information, so if such information is specified, it will impact the result.UConverts the specified CalendarTime (see System.Time) to seconds-since-epoch format.The input CalendarTime is assumed to be the time as given in your local timezone. All timezone and DST fields in the object are ignored.kThis behavior is equivolent to the timelocal() and mktime() functions that C programmers are accustomed to.Please note that the behavior for this function during the hour immediately before or after a DST switchover may produce a result with a different hour than you expect.DConverts the given timeDiff to the number of seconds it represents. 5Uses the same algorithm as normalizeTimeDiff in GHC. Converts an Epoch time represented with an arbitrary Real to a ClockTime. This input could be a CTime from Foreign.C.Types or an EpochTime from System.Posix.Types. Converts a ClockTime to something represented with an arbitrary Real. The result could be treated as a CTime from Foreign.C.Types or EpochTime from System.Posix.Types. The inverse of .:Fractions of a second are not preserved by this function. mRender a number of seconds as a human-readable amount. Shows the two most significant places. For instance: renderSecs 121 = "2m1s" See also ) for a function that works on a TimeDiff.Like ;, but takes a TimeDiff instead of an integer second count. $Copyright (C) 2006-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;INLets you examine the $ that is contained within a ' object. You can simply pass a  object and a function to  , and  will lock the  object (blocking any modifications while you are reading it), then pass the object to your function. If you happen to already have a e object, withStatus will also accept it and simply pass it unmodified to the function. The main Progress object. !The main progress status record. An identifying stringZThe type for a callback function for the progress tracker. When given at creation time to 'newProgress\'' or when added via J, these functions get called every time the status of the tracker changes.This function is passed two q records: the first reflects the status prior to the update, and the second reflects the status after the update.Please note that the owning n object will be locked while the callback is running, so the callback will not be able to make changes to it. GA function that, when called, yields the current time. The default is .  Create a new > object with the given name and number of total units initialized as given. The start time will be initialized with the current time at the present moment according to the system clock. The units completed will be set to 0, the time source will be set to the system clock, and the parents and callbacks will be empty.If you need more control, see 'newProgress\''.Example: $prog <- newProgress "mytracker" 1024 Create a new O object initialized with the given status and callbacks. No adjustment to the H will be made. If you want to use the system clock, you can initialize  with the return value of  and also pass  as the timing source. $Adds an new callback to an existing f. The callback will be called whenever the object's status is updated, except by the call to finishP.Please note that the Progress object will be locked while the callback is running, so the callback will not be able to make any modifications to it.!Adds a new parent to an existing . The parent will automatically have its completed and total counters incremented by the value of those counters in the existing . yCall this when you are finished with the object. It is especially important to do this when parent objects are involved.This will simply set the totalUnits to the current completedUnits count, but will not call the callbacks. It will additionally propogate any adjustment in totalUnits to the parents, whose callbacks will be called.This ensures that the total expected counts on the parent are always correct. Without doing this, if, say, a transfer ended earlier than expected, ETA values on the parent would be off since it would be expecting more data than actually arrived. *Increment the completed unit count in the  object by the amount given. If the value as given exceeds the total, then the total will also be raised to match this value so that the completed count never exceeds the total.OYou can decrease the completed unit count by supplying a negative number here. Like , but never modify the total. $Set the completed unit count in the ( object to the specified value. Unlike , this function sets the count to a specific value, rather than adding to the existing value. If this value exceeds the total, then the total will also be raised to match this value so that the completed count never exceeds teh total. Like , but never modify the total. &Increment the total unit count in the  object by the amount given. This would rarely be needed, but could be needed in some special cases when the total number of units is not known in advance.  Set the total unit count in the & object to the specified value. Like , this would rarely be needed. Returns the speed in units processed per time unit. (If you are using the default time source, this would be units processed per second). This obtains the current speed solely from analyzing the  object.&If no time has elapsed yet, returns 0."You can use this against either a  object or a Q object. This is in the IO monad because the speed is based on the current time.Example: getSpeed progressobj >>= printhDon't let the type of this function confuse you. It is a fancy way of saying that it can take either a  or a j object, and returns a number that is valid as any Fractional type, such as a Double, Float, or Rational. >Returns the estimated time remaining, in standard time units. Returns 0 whenever  would return 0.See the comments under 8 for information about this function's type and result. rReturns the estimated system clock time of completion, in standard time units. Returns the current time whenever  would return 0.See the comments under 8 for information about this function's type and result. <The default time source for the system. This is defined as: ,getClockTime >>= (return . clockTimeToEpoch))  Name of this trackerTotal units expectedThe child objectThe parent to add to this child        $Copyright (C) 2008-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;IN+The primary type for bin-packing functions.ZThese functions take a list of size of bins. If every bin is the same size, you can pass repeat binSize^ to pass an infinite list of bins if the same size. Any surplus bins will simply be ignored. d[size] is the sizes of bins [(size, obj)] is the sizes and objects result is Either error or results,Potential errors returned as Left values by  functions. Calling G on this value will produce a nice error message suitable for display. FRan out of bins; attached value is the list of objects that do not fit8Bin size1 exceeded by at least the given object and size Other errorUPack objects into bins, preserving order. Objects will be taken from the input list one by one, and added to each bin until the bin is full. Work will then proceed on the next bin. No attempt is made to optimize allocations to bins. This is the simplest and most naive bin-packing algorithm, but may not make very good use of bin space. Pack objects into bins. For each bin, start with the largest objects, and keep packing the largest object from the remainder until no object can be found to put in the bin. This is substantially more efficient than ", but requires sorting the input. ,Let us use this as part of the Either monad $Copyright (C) 2005-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;INParse a Comma-Separated Value (CSV) file. The return value is a list of lines; each line is a list of cells; and each cell is a String.Please note that CSV files may have a different number of cells on each line. Also, it is impossible to distinguish a CSV line that has a call with no data from a CSV line that has no cells.Here are some examples: Input (literal strings) Parses As (Haskell String syntax) -------------------------------- --------------------------------- 1,2,3 [["1", "2", "3"]] l1 [["l1"], ["l2"]] l2 (empty line) [[""]] NQ,"Quoted" [["NQ", "Quoted"]] NQ,"Embedded""Quote" [["NQ", "Embedded\"Quote"]]!To parse a String, you might use: Zimport Text.ParserCombinators.Parsec import Data.String.CSV .... parse csvFile "" mystring'To parse a file, you might instead use: 2do result <- parseFromFile csvFile "/path/to/file"Please note that the result of parsing will be of type (Either ParseError [[String]]). A Left result indicates an error. For more details, see the Parsec information.YGenerate CSV data for a file. The resulting string can be written out to disk directly. $Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisional6portable to platforms with POSIX process\/signal toolsNone 3457;INReturn value from , , , or c. Contains both a ProcessID and the original command that was executed. If you prefer not to use [ on the result of one of these pipe calls, you can use (processID ph), assuming ph is your , as a parameter to . Function that created itLike d, but returns data in lines instead of just a String. Shortcut for calling lines on the result from .%Note: this function logs as pipeFrom.Not available on Windows. /Read data from a pipe. Returns a Handle and a .;When done, you must hClose the handle, and then use either  or getProcessStatus on the !. Zombies will result otherwise.This function logs as pipeFrom.&Not available on Windows or with Hugs.4Read data from a pipe. Returns a lazy string and a .EONLY AFTER the string has been read completely, You must call either  or  on the  . Zombies will result otherwise.Not available on Windows.!Write data to a pipe. Returns a  and a new Handle to write to.;When done, you must hClose the handle, and then use either  or getProcessStatus on the !. Zombies will result otherwise.This function logs as pipeTo.Not available on Windows.+Write data to a pipe. Returns a ProcessID.You must call either  or 1 on the ProcessID. Zombies will result otherwise.Not available on Windows.Like a combination of  and ; returns a 3-tuple of ( , Data From Pipe, Data To Pipe).=When done, you must hClose both handles, and then use either  or getProcessStatus on the !. Zombies will result otherwise.lHint: you will usually need to ForkIO a thread to handle one of the Handles; otherwise, deadlock can result.This function logs as pipeBoth.Not available on Windows.Like a combination of  and e; forks an IO thread to send data to the piped program, and simultaneously returns its output stream.DThe same note about checking the return status applies here as with .Not available on Windows. Uses  to obtain the exit status of the given process ID. If the process terminated normally, does nothing. Otherwise, raises an exception with an appropriate error message.<This call will block waiting for the given pid to terminate.Not available on Windows. Invokes the specified command in a subprocess, waiting for the result. If the command terminated successfully, return normally. Otherwise, raises a userError with the problem.Implemented in terms of 7 where supported, and System.Posix.rawSystem otherwise.Invokes the specified command in a subprocess, waiting for the result. Return the result status. Never raises an exception. Only available on POSIX platforms.`Like system(3), this command ignores SIGINT and SIGQUIT and blocks SIGCHLD during its execution.(Logs as System.Cmd.Utils.posixRawSystem Invokes the specified command in a subprocess, without waiting for the result. Returns the PID of the subprocess -- it is YOUR responsibility to use getProcessStatus or getAnyProcessStatus on that at some point. Failure to do so will lead to resource leakage (zombie processes).@This function does nothing with signals. That too is up to you.'Logs as System.Cmd.Utils.forkRawSystem %Open a pipe to the specified command./Passes the handle on to the specified function.The 7 specifies what you will be doing. That is, specifing  sets up a pipe from stdin, and  sets up a pipe from stdout.Not available on Windows.,Runs a command, redirecting things to pipes.Not available on Windows.vNote that you may not use the same fd on more than one item. If you want to redirect stdout and stderr, dup it first.,Runs a command, redirecting things to pipes.Not available on Windows.6Returns immediately with the PID of the child. Using  waitProcess on it is YOUR responsibility!vNote that you may not use the same fd on more than one item. If you want to redirect stdout and stderr, dup it first.Send stdin to this fdGet stdout from this fdGet stderr from this fdCommand to run Command argsAction to run in parentPAction to run in child before execing (if you don't need something, set this to  return ()) -- IGNORED IN HUGSSend stdin to this fdGet stdout from this fdGet stderr from this fdCommand to run Command argsPAction to run in child before execing (if you don't need something, set this to  return ()) -- IGNORED IN HUGS  $Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;INDTransmits an e-mail message using the system's mail transport agent.This function takes a message, a list of recipients, and an optional sender, and transmits it using the system's MTA, sendmail.If sendmail is on the PATHR, it will be used; otherwise, a list of system default locations will be searched.3A failure will be logged, since this function uses  internally.This function will first try sendmail2. If it does not exist, an error is logged under System.Cmd.Utils.pOpen3 and various default sendmailW locations are tried. If that still fails, an error is logged and an exception raised.!"The envelope from address. If not specified, takes the system's default, which is usually based on the effective userid of the current process. This is not necessarily what you want, so I recommend specifying it.BA list of recipients for your message. An empty list is an error.The message itself.#!"#$Copyright (C) 2004-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;INTakes a IO action and a function. The IO action will be called in a separate thread. When it is completed, the specified function is called with its result. This is a simple way of doing callbacks. $Copyright (C) 2005-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;IN#Main class for readable mailboxes. The mailbox object a represents zero or more  )s. Each message has a unique identifier bZ in a format specific to each given mailbox. This identifier may or may not be persistent.VFunctions which return a list are encouraged -- but not guaranteed -- to do so lazily./Implementing classes must provide, at minimum,  .*Returns a list of all unique identifiers.  ?Returns a list of all unique identifiers as well as all flags.  _Returns a list of all messages, including their content, flags, and unique identifiers.  -Returns information about specific messages.  -A Message is represented as a simple String.  Convenience shortcut .The flags which may be assigned to a message.                     $Copyright (C) 2004-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;INGenerate (return) a . Retrieve the next token from a ` stream. The given function should return the value to use, or Nothing to cause an error. A shortcut to y; the test here is just a function that returns a Bool. If the result is true; return that value -- otherwise, an error.+Matches one item in a list and returns it. #Matches all items and returns them /Matches one item not in a list and returns it. +Matches one specific token and returns it. Running notMatching p msg will try to apply parser p. If it fails, returns (). If it succeds, cause a failure and raise the given error message. It will not consume input in either case.    $Copyright (C) 2005-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisional6portable to platforms with POSIX process\/signal toolsNone 3457;IN }Detach the process from a controlling terminal and run it in the background, handling it with standard Unix deamon semantics.;After running this, please note the following side-effects:*The PID of the running process will changeHstdin, stdout, and stderr will not work (they'll be set to /dev/null)CWD will be changed to /I highly; suggest running this function before starting any threads.BNote that this is not intended for a daemon invoked from inetd(1).$ %&  $ %& $Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;IN'!0The writing side of a Haskell pipe. Please see G for more details. "0The reading side of a Haskell pipe. Please see G for more details. #A #M simulates true I/O, but uses an in-memory buffer instead of on-disk storage.8It provides a full interface like Handle (it implements  HVIOReader,  HVIOWriter, and  HVIOSeekerE). However, it maintains an in-memory buffer with the contents of the file, rather than an actual on-disk file. You can access the entire contents of this buffer at any time. This can be quite useful for testing I/O code, or for cases where existing APIs use I/O, but you prefer a String representation. You can create a # with a call to D. The present # implementation is rather inefficient, particularly when reading towards the end of large files. It's best used for smallish data storage. This problem will be fixed eventually.$&Simulate I/O based on a string buffer.When a $: is created, it is initialized based on the contents of a 'V. Its contents are read lazily whenever a request is made to read something from the $. It can be used, therefore, to implement filters (simply initialize it with the result from, say, a map over hGetContents from another HVIO object), codecs, and simple I/O testing. Because it is lazy, it need not hold the entire string in memory. You can create a $ with a call to C.%wThis is the generic I/O support class. All objects that are to be used in the HVIO system must provide an instance of %.Functions in this class provide an interface with the same specification as the similar functions in System.IO. Please refer to that documentation for a more complete specification than is provided here. Instances of % must provide &, * , and either ' or (.9Implementators of readable objects must provide at least 0 and 4. An implementation of 2_ is also highly suggested, since the default cannot implement proper partial closing semantics.9Implementators of writable objects must provide at least 5 and :.9Implementators of seekable objects must provide at least >, <, and ;.& Close a file'Test if a file is open(Test if a file is closed)eRaise an error if the file is not open. This is a new HVIO function and is implemented in terms of '.*Whether or not we're at EOF. This may raise on exception on some items, most notably write-only Handles such as stdout. In general, this is most reliable on items opened for reading. vIsEOF implementations must implicitly call vTestOpen.+Detailed show output.,Make an IOError.-Throw an IOError..KGet the filename/object/whatever that this corresponds to. May be Nothing./Throw an isEOFError if we're at EOF; returns nothing otherwise. If an implementation overrides the default, make sure that it calls vTestOpen at some point. The default implementation is a wrapper around a call to *.0Read one character1 Read one line2Get the remaining contents. Please note that as a user of this function, the same partial-closing semantics as are used in the standard ( are  encouraged) from implementators, but are not required+. That means that, for instance, a 0 after a 2v may return some undefined result instead of the error you would normally get. You should use caution to make sure your code doesn't fall into that trap, or make sure to test your code with Handle or one of the default instances defined in this module. Also, some implementations may essentially provide a complete close after a call to 2*. The bottom line: after a call to 2I, you should do nothing else with the object save closing it with &.ZFor implementators, you are highly encouraged to provide a correct implementation. 3tIndicate whether at least one item is ready for reading. This will always be True for a great many implementations.4<Indicate whether a particular item is available for reading.5Write one character6Write a string7.Write a string with newline character after it8>Write a string representation of the argument, plus a newline.9Flush any output buffers. Note: implementations should assure that a vFlush is automatically performed on file close, if necessary to ensure all data sent is written.:@Indicate whether or not this particular object supports writing.;Seek to a specific location.<Get the current position.=YConvenience function to reset the file pointer to the beginning of the file. A call to  vRewind h is the same as ; h AbsoluteSeek 0.>0Indicate whether this instance supports seeking.?-Set buffering; the default action is a no-op.@=Get buffering; the default action always returns NoBuffering.AXBinary output: write the specified number of octets from the specified buffer location.B%Binary input: read the specified number of octets from the specified buffer location, continuing to read until it either consumes that much data or EOF is encountered. Returns the number of octets actually read. EOF errors are never raised; fewer bytes than requested are returned on EOF.C Create a new $ object. D Create a new #r instance. The buffer is initialized to the value passed, and the pointer is placed at the beginning of the file.-You can put things in it by using the normal 67 calls, and reset to the beginning by using the normal = call.The function is called when &Q is called, and is passed the contents of the buffer at close time. You can use E" if you don't want to do anything.2To create an empty buffer, pass the initial value "". E+Default (no-op) memory buf close function. F;Grab the entire contents of the buffer as a string. Unlike 2r, this has no effect on the open status of the item, the EOF status, or the current position of the file pointer. GCreate a Haskell pipe.These pipes are analogous to the Unix pipes that are available from System.Posix, but don't require Unix and work only in Haskell. When you create a pipe, you actually get two HVIO objects: a " and a !. You must use the ! in one thread and the "0 in another thread. Data that's written to the !- will then be available for reading with the ". The pipes are implemented completely with existing Haskell threading primitives, and require no special operating system support. Unlike Unix pipes, these pipes cannot be used across a fork(). Also unlike Unix pipes, these pipes are portable and interact well with Haskell threads. B!)"*+,-#.$/0%&'()*+,-./0123456789:;<=>?@AB1234CInitial contents of the $5DInitial Contents close funcE6FG789:;<=>?@ABC'!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG'%&'()*+,-./0123456789:;<=>?@AB$C#DEF"!G!)"*+,-#.$/0%&'()*+,-./0123456789:;<=>?@AB1234C5DE6FG789:;<=>?@ABC$Copyright (C) 2004-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;IN J]Types that can open a HVIO object should be instances of this class. You need only implement K. OThe main HVFS class.8Default implementations of these functions are provided:] -- implemented in terms of [^S -- implemented in terms of [T -- implemented in terms of [U -- implemented in terms of \\ -- set to call [.Default implementations of all other functions will generate an isIllegalOperation error, since they are assumed to be un-implemented.%You should always provide at least a [2 call, and almost certainly several of the others.Most of these functions correspond to functions in System.Directory or System.Posix.Files. Please see detailed documentation on them there.UxTrue if the file exists, regardless of what type it is. This is even True if the given path is a broken symlink. ^2Raise an error relating to actions on this class. b5Evaluating types of files and information about them.kThis corresponds to the System.Posix.Types.FileStatus type, and indeed, that is one instance of this class.+Inplementators must, at minimum, implement r and q.UDefault implementations of everything else are provided, returning reasonable values.EA default implementation of this is not currently present on Windows.e?Refers to file permissions, NOT the st_mode field from stat(2) u Similar to w , but for K result.wEncapsulate a bW result. This is required due to Haskell typing restrictions. You can get at it with: 0case encap of HVFSStatEncap x -> -- now use xywConvenience function for working with stat -- takes a stat result and a function that uses it, and returns the result. (Here is an example from the HVFS source:  vGetModificationTime fs fp = do s <- vGetFileStatus fs fp return $ epochToClockTime (withStat s vModificationTime)See  for more information.z Similar to y, but for the K result. DError handler helper8HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzDEFGH= HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz=OPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstJKLMNuvwxyzHI  HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzDEFGH!$Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisional,portable to platforms supporting binary I\/ONone 3457;IN{BProvides support for handling binary blocks with convenient types.TThis module provides implementations for Strings and for [Word8] (lists of Word8s). ~*As a wrapper around the standard function I), this function takes a standard Haskell '$ instead of the far less convenient Ptr aN. The entire contents of the string will be written as a binary buffer using IL. The length of the output will be the length of the passed String or list.=If it helps, you can thing of this function as being of type Handle -> String -> IO ()  An alias for ~ J,Acts a wrapper around the standard function K, this function returns a standard Haskell String (or [Word8]) instead of modifying a 'Ptr a' buffer. The length is the maximum length to read and the semantice are the same as with Kz; namely, the empty string is returned with EOF is reached, and any given read may read fewer bytes than the given length.!(Actually, it's a wrapper around B)  An alias for  LLike l, but guarantees that it will only return fewer than the requested number of bytes when EOF is encountered.  An alias for  LMGWrites the list of blocks to the given file handle -- a wrapper around ~.Think of this function as: Handle -> [String] -> IO ()(You can use it that way)  An alias for M JT putBlocks :: (BinaryConvertible b) => [[b]] -> IO () putBlocks = hPutBlocks stdout LReturns a lazily-evaluated list of all blocks in the input file, as read by N. There will be no 0-length block in this list. The list simply ends at EOF.  An alias for  LSame as  , but using  underneath.  An alias for  LBinary block-based interaction. This is useful for scenarios that take binary blocks, manipulate them in some way, and then write them out. Take a look at _ for an example. The integer argument is the size of input binary blocks. This function uses  internally. An alias for  over L and JSame as  , but uses  instead of  internally.  An alias for  over L and JCopies everything from the input handle to the output handle using binary blocks of the given size. This was once the following beautiful implementation: 6hBlockCopy bs hin hout = hBlockInteract bs hin hout id(NL is the built-in Haskell function that just returns whatever is given to it)In more recent versions of MissingH, it uses a more optimized routine that avoids ever having to convert the binary buffer at all. Copies from L to J5 using binary blocks of the given size. An alias for  over L and J.Copies one filename to another in binary mode.nPlease note that the Unix permission bits on the output file cannot be set due to a limitation of the Haskell OQ function. Therefore, you may need to adjust those bits after the copy yourself.#This function is implemented using  internally. Like the built-in P5, but opens the file in binary instead of text mode. QSame as , but works with HVFS objects. Like the built-in R5, but opens the file in binary instead of text mode. SLike , but works on HVFS objects. {|}~MTUQSVW{|}~{|}~{|}~MTUQSVW"$Copyright (C) 2004-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;INObtain a recursive listing of all files/directories beneath the specified directory. The traversal is depth-first and the original item is always present in the returned list.LIf the passed value is not a directory, the return value be only that value.<The "." and ".." entries are removed from the data returned.Like , but return the stat() (System.Posix.Files.FileStatus) information with them. This is an optimization if you will be statting files yourself later.The items are returned lazily.WARNING: do not change your current working directory until you have consumed all the items. Doing so could cause strange effects.FAlternatively, you may wish to pass an absolute path to this function.]Removes a file or a directory. If a directory, also removes all its child files/directories.?Provide a result similar to the command ls -l over a directory.FKnown bug: setuid bit semantics are inexact compared with standard ls.HIHI#$Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;IN Given a list of strings, output a line containing each item, adding newlines as appropriate. The list is not expected to have newlines already.Given a handle, returns a list of all the lines in that handle. Thanks to lazy evaluation, this list does not have to be read all at once.Combined with <, this can make a powerful way to develop filters. See the # function for more on that concept.Example: Zmain = do l <- hGetLines stdin hPutStrLns stdout $ filter (startswith "1") l This is similar to the built-in X5, but works on any handle, not just stdin and stdout.In other words: !interact = hInteract stdin stdoutRLine-based interaction. This is similar to wrapping your interact functions with Y and Z. This equality holds: )lineInteract = hLineInteract stdin stdoutHere's an example: -main = lineInteract (filter (startswith "1"))wThis will act as a simple version of grep -- all lines that start with 1 will be displayed; all others will be ignored.[Line-based interaction over arbitrary handles. This is similar to wrapping hInteract with Y and Z.'One could view this function like this: rhLineInteract finput foutput func = let newf = unlines . func . lines in hInteract finput foutput newf8Though the actual implementation is this for efficiency: lhLineInteract finput foutput func = do lines <- hGetLines finput hPutStrLns foutput (func lines)CCopies from one handle to another in raw mode (using hGetContents).}Copies from one handle to another in raw mode (using hGetContents). Takes a function to provide progress updates to the user.BCopies from one handle to another in text mode (with lines). Like  hBlockCopy, this implementation is nice: .hLineCopy hin hout = hLineInteract hin hout id Copies from L to J using lines. An alias for  over L and J. ,Copies one filename to another in text mode.tPlease note that the Unix permission bits are set at a default; you may need to adjust them after the copy yourself.#This function is implemented using  internally. Sets stdin and stdout to be block-buffered. This can save a huge amount of system resources since far fewer syscalls are made, and can make programs run much faster. Sets stdin and stdout to be line-buffered. This saves resources on stdout, but not many on stdin, since it it still looking for newlines. Applies a given function to every item in a list, and returns the new list. Unlike the system's mapM, items are evaluated lazily.  Input handle Output handleKProgress function -- the bool is always False unless this is the final call   $$Copyright (C) 2004-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;IN  The type used for functions for . See  for details.3Merge two sorted lists into a single, sorted whole.Example: *merge [1,3,5] [1,2,4,6] -> [1,1,2,3,4,5,6]QuickCheck test property:gprop_merge xs ys = merge (sort xs) (sort ys) == sort (xs ++ ys) where types = xs :: [Int]uMerge two sorted lists using into a single, sorted whole, allowing the programmer to specify the comparison function.QuickCheck test property:prop_mergeBy xs ys = mergeBy cmp (sortBy cmp xs) (sortBy cmp ys) == sortBy cmp (xs ++ ys) where types = xs :: [ (Int, Int) ] cmp (x1,_) (x2,_) = compare x1 x2Returns true if the given list starts with the specified elements; false otherwise. (This is an alias for "Data.List.isPrefixOf".)Example: startswith "He" "Hello" -> TrueReturns true if the given list ends with the specified elements; false otherwise. (This is an alias for "Data.List.isSuffixOf".)Example: endswith "lo" "Hello" -> TruePReturns true if the given list contains any of the elements in the search list. Similar to Data.List.takeWhile, takes elements while the func is true. The function is given the remainder of the list to examine. Similar to Data.List.dropWhile, drops elements while the func is true. The function is given the remainder of the list to examine. kSimilar to Data.List.span, but performs the test on the entire remaining list instead of just one element.  spanList p xs is the same as ((takeWhileList p xs, dropWhileList p xs) kSimilar to Data.List.break, but performs the test on the entire remaining list instead of just one element.@Given a delimiter and a list (or string), split into components.Example: :split "," "foo,bar,,baz," -> ["foo", "bar", "", "baz", ""] 3split "ba" ",foo,bar,,baz," -> [",foo,","r,,","z,"]Given a list and a replacement list, replaces each occurance of the search list with the replacement list in the operation list.Example: *replace "," "." "127,0,0,1" -> "127.0.0.1"&This could logically be thought of as: ,replace old new l = join new . split old $ lZGiven a delimiter and a list of items (or strings), join the items by using the delimiter.Example: /join "|" ["foo", "bar", "baz"] -> "foo|bar|baz"Like H, but works with a list of anything showable, converting it to a String. Examples: pgenericJoin ", " [1, 2, 3, 4] -> "1, 2, 3, 4" genericJoin "|" ["foo", "bar", "baz"] -> "\"foo\"|\"bar\"|\"baz\""TReturns true if the given parameter is a sublist of the given list; false otherwise.Example: acontains "Haskell" "I really like Haskell." -> True contains "Haskell" "OCaml is great." -> False6This function was submitted to GHC and was applied as [P. This function therefore is deprecated and will be removed in future versions.vAdds the specified (key, value) pair to the given list, removing any existing pair with the same key already present. XRemoves all (key, value) pairs from the given list where the key matches the given one. FReturns the keys that comprise the (key, value) pairs of the given AL.Same as: map fstGReturns the values the comprise the (key, value) pairs of the given AL.Same as: map snd5Indicates whether or not the given key is in the AL. \Flips an association list. Converts (key1, val), (key2, val) pairs to (val, [key1, key2]). Converts an association list to a string. The string will have one pair per line, with the key and value both represented as a Haskell string.tThis function is designed to work with [(String, String)] association lists, but may work with other types as well. The inverse of M, this function reads a string and outputs the appropriate association list. Like , this is designed to work with [(String, String)] association lists but may also work with other objects with simple representations.TReturns a count of the number of times the given element occured in the given list. DReturns the rightmost index of the given element in the given list. ;Like elemRIndex, but returns -1 if there is nothing found. *Forces the evaluation of the entire list. LThis is an enhanced version of the concatMap or map functions in Data.List.!Unlike those functions, this one:UCan consume a varying number of elements from the input list during each iteration3Can arbitrarily decide when to stop processing dataFCan return a varying number of elements to insert into the output list3Can actually switch processing functions mid-stream:Is not even restricted to processing the input list intact'The function used by wholeMap, of type , is repeatedly called with the input list. The function returns three things: the function to call for the next iteration (if any), what remains of the input list, and the list of output elements generated during this iteration. The return value of F is the concatenation of the output element lists from all iterations.JProcessing stops when the remaining input list is empty. An example of a  is . DA parser designed to process fixed-width input fields. Use it with .The Int list passed to this function is the list of the field widths desired from the input. The result is a list of those widths, if possible. If any of the input remains after processing this list, it is added on as the final element in the result list. If the input is less than the sum of the requested widths, then the result list will be short the appropriate number of elements, and its final element may be shorter than requested. Examples: 5wholeMap (fixedWidth [1, 2, 3]) "1234567890" --> ["1","23","456","7890"] wholeMap (fixedWidth (repeat 2)) "123456789" --> ["12","34","56","78","9"] wholeMap (fixedWidth []) "123456789" --> ["123456789"] wholeMap (fixedWidth [5, 3, 6, 1]) "Hello, This is a test." --> ["Hello",", T","his is"," ","a test."]6Helps you pick out fixed-width components from a list.Example: conv :: String -> (String,String) conv = runState $ do f3 <- grab 3 n2 <- grab 2 return $ f3 ++ "," ++ n2 main = print $ conv "TestIng"Prints: ("Tes,tI","ng")Similar to Data.List.elemIndex. Instead of looking for one element in a list, this function looks for the first occurance of a sublist in the list, and returns the index of the first element of that occurance. If there is no such list, returns Nothing.nIf the list to look for is the empty list, will return Just 0 regardless of the content of the list to search. Examples: subIndex "foo" "asdfoobar" -> Just 3 subIndex "foo" [] -> Nothing subIndex "" [] -> Just 0 subIndex "" "asdf" -> Just 0 subIndex "test" "asdftestbartest" -> Just 4 subIndex [(1::Int), 2] [0, 5, 3, 2, 1, 2, 4] -> Just 4RGiven a list, returns a new list with all duplicate elements removed. For example: uniq "Mississippi" -> "Misp"pYou should not rely on this function necessarily preserving order, though the current implementation happens to.4This function is not compatible with infinite lists.,This is presently an alias for Data.List.nub!List of elements to look forList to searchResult!! %$Copyright (C) 2004-2011 John GoerzenBSD3%John Goerzen <jgoerzen@complete.org>  provisionalportableNone 3457;IN@Converts a String, String Map into a string representation. See X for more on the similar function for association lists. This implementation is simple: &strFromM = strFromAL . Data.Map.toListThis function is designed to work with Map String String objects, but may also work with other objects with simple representations. 2Converts a String into a String, String Map. See 8 for more on the similar function for association lists.This implementation is simple: $strToM = Data.Map.fromList . strToALThis function is designed to work with Map String String objects, but may work with other key/value combinations if they have simple representations. Flips a Map. See - for more on the similar function for lists. Returns a list of all keys in the Map whose value matches the parameter. If the value does not occur in the Map, the empty list is returned. Performs a lookup, and raises an exception (with an error message prepended with the given string) if the key could not be found.&$Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;INSplits a pathname into a tuple representing the root of the name and the extension. The extension is considered to be all characters from the last dot after the last slash to the end. Either returned string may be empty. hMake an absolute, normalized version of a path with all double slashes, dot, and dotdot entries removed.The first parameter is the base for the absolut calculation; in many cases, it would correspond to the current working directory.nThe second parameter is the pathname to transform. If it is already absolute, the first parameter is ignored.DNothing may be returned if there's an error; for instance, too many .. entries for the given path.uLike absNormPath, but returns Nothing if the generated result is not the passed base path or a subdirectory thereof. +Creates a temporary directory for your use.OThe passed string should be a template suitable for mkstemp; that is, end with "XXXXXX".fYour string should probably start with the value returned from System.Directory.getTemporaryDirectory.3The name of the directory created will be returned./Creates a temporary directory for your use via , runs the specified action (passing in the directory name), then removes the directory and all its contents when the action completes (or raises an exception. Changes the current working directory to the given path, executes the given I/O action, then changes back to the original directory, even if the I/O action raised an exception. Runs the given I/O action with the CWD set to the given tmp dir, removing the tmp dir and changing CWD back afterwards, even if there was an exception. -Absolute path for use with starting directoryThe path name to make absoluteResult-Absolute path for use with starting directoryThe path to make absolute  '$Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;IN hAn in-memory read/write filesystem. Think of it as a dynamically resizable ramdisk written in Haskell. (The content of a file or directory in a . The basic node of a J. The String corresponds to the filename, and the entry to the contents.  A simple System.IO.HVFS.HVFSStatE class that assumes that everything is either a file or a directory.  True if file, False if directory"Set to 0 if unknown or a directory Create a new L object from an existing tree. An empty filesystem may be created by using [] for the parameter. Create a new , object using an IORef to an existing tree. Similar to &0 but the first element won't be /. <nice_slice "/" -> [] nice_slice "/foo/bar" -> ["foo", "bar"].Gets a full path, after investigating the cwd.Gets the full path via , then splits it via .\7Find an element on the tree, assuming a normalized path]7Find an element on the tree, normalizing the path first^_`\]abcd^_`\]abcd($Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;INUAccess a subdirectory of a real filesystem as if it was the root of that filesystem. vRestrict access to the underlying filesystem to be strictly read-only. Any write-type operations will cause an error.%No constructor is required; just say HVFSReadOnly fs, to make a new read-only wrapper around the O instance fs. Create a new  object. eGet the embedded object f.Convert a local (chroot) path to a full path. g.Convert a full path to a local (chroot) path. .Convert a local (chroot) path to a full path. hij!The object to pass requests on to&The path of the directory to make rootThe resulting new objectefgklmno hijefgklmno)$Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;IN )Return value from guessing a file's type.fThe first element of the tuple gives the MIME type. It is Nothing if no suitable type could be found.The second element gives the encoding. It is Nothing if there was no particular encoding for the file, or if no encoding could be found.A mapping used to expand common suffixes into equivolent, better-parsed versions. For instance, ".tgz" would expand into ".tar.gz".hA mapping used to determine the encoding of a file. This is used, for instance, to map ".gz" to "gzip"./A mapping used to map extensions to MIME types.A mapping used to augment the # when non-strict lookups are used.URead the given mime.types file and add it to an existing object. Returns new object. 4Load a mime.types file from an already-open handle. kGuess the type of a file given a filename or URL. The file is not opened; only the name is considered. cGuess the extension of a file based on its MIME type. The return value includes the leading dot./Returns Nothing if no extension could be found.In the event that multiple possible extensions are available, one of them will be picked and returned. The logic to select one of these should be considered undefined.  Similar to e, but returns a list of all possible matching extensions, or the empty list if there are no matches. pAdds a new type to the data structures, replacing whatever data may exist about it already. That is, it overrides existing information about the given extension, but the same type may occur more than once. Default MIME type data to use ~Read the system's default mime.types files, and add the data contained therein to the passed object, then return the new one. Data to work withWhether to work on strict data File to read New objectData to work withWhether to work on strict dataHandle to read from New objectSource data for guessingWhether to limit to strict dataFile or URL name to considerResult of guessing (see  for details on interpreting it)Source data for guessingWhether to limit to strict dataMIME type to consider3Result of guessing, or Nothing if no match possibleSource data for guessingWhether to limit to strict dataMIME type to considerResult of guessingp Source data!Whether to add to strict data setMIME type to addExtension to addResult of additionqrstuvwpqrstuvw*$Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;INRemoves any whitespace characters that are present at the start or end of a string. Does not alter the internal contents of a string. If no whitespace characters are present at the start or end of a string, returns the original string unmodified. Safe to use on any string.WNote that this may differ from some other similar functions from other authors in that: QIf multiple whitespace characters are present all in a row, they are all removed;9If no whitespace characters are present, nothing is done.Same as 2, but applies only to the left side of the string.Same as 3, but applies only to the right side of the string.aSplits a string around whitespace. Empty elements in the result list are automatically removed. EEscape all characters in the input pattern that are not alphanumeric.fDoes not make special allowances for NULL, which isn't valid in a Haskell regular expression pattern. 7Attempts to parse a value from the front of the string.x  x+$Copyright (C) 2006-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;INy+The main data type for the progress meter. z The master  object for overall status{Individual component statuses|Width of the meter}Units of display~Function to render numbersAuto-updating display'Set up a new status bar using defaults:The given trackerWidth 80%Data.Quantity.renderNums binaryOpts 1Unit inticator BSet up a new status bar. &Adjust the list of components of this . /Add a new component to the list of components. Remove a component by name. Adjusts the width of this . FLike renderMeter, but prints it to the screen instead of returning it.-This function will output CR, then the meter.=Pass stdout as the handle for regular display to the screen. OClears the meter -- outputs CR, spaces equal to the width - 1, then another CR.=Pass stdout as the handle for regular display to the screen. xClears the meter, writes the given string, then restores the meter. The string is assumed to contain a trailing newline.=Pass stdout as the handle for regular display to the screen. aStarts a thread that updates the meter every n seconds by calling the specified function. Note: displayMeter stdout is an ideal function here.,Save this threadID and use it later to call stopAutoDisplayMeter.*Stops the specified meter from displaying.You should probably call  after a call to this. Render the current status. yz{|}~The top-level Unit indicator string#Width of the terminal -- usually 80A function to render sizesThe meter to displayUpdate interval in secondsFunction to display itResulting thread id  yz{|}~,$Copyright (C) 2006-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;IN9Convert a wildcard to an (uncompiled) regular expression.ECheck the given name against the given pattern, being case-sensitive.NThe given pattern is forced to match the given name starting at the beginning.'The wildcard pattern to use as the base The filename to check against itResult-$Copyright (C) 2006-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;IN_Takes a pattern. Returns a list of names that match that pattern. The pattern is evaluated by System.Path.WildMatchJ. This function does not perform tilde or environment variable expansion.Filenames that begin with a dot are not included in the result set unless that component of the pattern also begins with a dot.)In MissingH, this function is defined as: glob = vGlob SystemFSLike F, but works on both the system ("real") and HVFS virtual filesystems. .$Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone 3457;IN!Main parser for the control file Dependency parser.0Returns (package name, Maybe version, arch list)version is (operator, operand)  12314514614714814914:14;14<1=>?@ABCDEFGHIJKLMNOPPQRSTUVWXYZ[\]^_`abcdefghijk l m n o p p q q r r s s k t u v w x y z { y | } ~     |        1      !"#$%&'()*+,-./0123456789:;<=>?@ABCDE 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 lmmnopqrstuvwxyz{|}~!!!!!!!!!!!!!!!!!!!!!!""""#############$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%&&&&&&&'''''''''X'''''(((()))))))))))) ) ) * * ****+++++++++++++,, -!-".#.$%&'D(14)14)14*14*14+14+14,14,14-14-14.14.14/14/14014014114114214214314314414414514514614614714814914:14;<=><=?<=@<=A<=B<=C<=D<=E<=F<=G<=H<=I<=J<=K<=L<=M<=N<=O<=P<=Q<=R<ST<SU<SV<SW<SX<SY<Sc<Sb<Sa<S`<S_<S^<S]<SZ<S[<S\<S[<SZ<SY<SX<SW<SV<SU<ST<SS<SR<SQ<S]<S^<SN<SO<SL<SK<SJ<SI<SH<SM<S_<S`<Sa<Sb<Sc<Sd<Se<Sf<Sg<Sh<Si<Sj<Sk<Sl<Sm<Sn<So<Sp<Sq<Sr<Ss<St<Su<Sv<Sw<Sx<Sy<Sz<S{<S|<S}<S~<S<S<Se                                %111%1     < 1!1"# F G $ $ % H I & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9:;<=>1"?1@A1"B1@C!D1E1@F1GH!I1GJ!K!L!M!N!O1GP1QR1QS1QT'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+p+w+x,y,z-{-|-}..~.....Missi_2DZ5RJkS7wK5BwiMvP3mQYSystem.IO.HVFSSystem.Console.GetOpt.Utils System.DebianSystem.Posix.ConstsSystem.IO.StatCompatSystem.IO.PlafCompatData.Compression.InflateData.Hash.MD5.Zord64_HARD Data.Hash.MD5Data.Hash.CRC32.GZipData.Hash.CRC32.PosixData.Bits.UtilsSystem.FileArchive.GZipData.Tuple.UtilsData.Maybe.UtilsData.Either.Utils Network.UtilsNetwork.SocketServerSystem.Time.ParseDateSystem.Path.NameManip Data.QuantitySystem.Time.UtilsData.Progress.TrackerData.BinPackingData.CSVSystem.Cmd.UtilsNetwork.Email.SendmailControl.Concurrent.Thread.UtilsNetwork.Email.Mailbox#Text.ParserCombinators.Parsec.Utils System.DaemonSystem.IO.HVIOSystem.IO.BinarySystem.IO.HVFS.UtilsSystem.IO.UtilsData.List.UtilsData.Map.Utils System.PathSystem.IO.HVFS.InstanceHelpersSystem.IO.HVFS.CombinatorsData.MIME.TypesData.String.UtilsData.Progress.MeterSystem.Path.WildMatchSystem.Path.GlobSystem.Debian.ControlParserSystem.IO.WindowsCompat NameManipbase GHC.IO.IOModeIOModeSystem.Posix.Types LinkCountUserIDGroupID EpochTimeDeviceIDFileIDFileMode FileOffsetGHC.IOFilePath StdOption parseCmdLinevalidateCmdLine stdRequired stdOptional DebVersion ControlFilecompareDebVersioncheckDebVersionblockSpecialModecharacterSpecialMode namedPipeModeregularFileMode directoryMode fileTypeModes socketModesymbolicLinkModeFileStatusCompatdeviceIDfileIDfileMode linkCount fileOwner fileGroupspecialDeviceIDfileSize accessTimemodificationTimestatusChangeTime sc_helper isBlockDeviceisCharacterDevice isNamedPipe isRegularFile isDirectoryisSymbolicLinkisSocket nullFileNameBitOutputinflate_stringinflate_string_remainderbits_to_word32inflateZord64MD5get_nextlen_padfinishedWordListBoolListStrABCDmd5md5smd5i update_crcupdate_crc_list calc_crc32 gzipcrctab iter_crc32crc32crctabgetBytes fromBytesc2w8s2w8w82cw82sSectionFootersize crc32validHeadermethodflagsextrafilenamecommentmtimexflos GZipErrorCRCError NotGZIPFile UnknownMethod UnknownError hDecompress decompress read_sections read_section read_headerfst3snd3thd3 forceMaybe forceMaybeMsg maybeToEither forceEitherforceEitherMsgeitherToMonadErrorfromLeft fromRight fromEither niceSocketsDo connectTCPconnectTCPAddr listenTCPAddr showSockAddr SocketServer optionsSSsockSSHandlerTInetServerOptionslistenQueueSize portNumber interfacereusefamilysockTypeprotoStrsimpleTCPOptionssetupSocketServercloseSocketServer handleOne serveForeverserveTCPforeverloggingHandlerthreadedHandler handleHandlerparseCalendarTime slice_path unslice_pathnormalise_pathslice_filenameslice_filename'unslice_filename split_pathdir_part filename_part unsplit_pathsplit_filenamesplit_filename'unsplit_filenamesplit3unsplit3 test_suffix absolute_pathabsolute_path_byabsolute_path'guess_dotdot_comps guess_dotdotSizeOpts powerIncr firstPowersuffixes binaryOptssiOpts quantifyNum quantifyNums renderNum renderNumsparseNum parseNumIntepochtimegm timelocaltimeDiffToSecsepochToClockTimeclockTimeToEpoch renderSecsrenderTDProgressStatuses withStatusProgressProgressStatuscompletedUnits totalUnits startTime trackerName timeSourceProgressCallbackProgressTimeSource newProgress newProgress' addCallback addParentfinishPincrPincrP'setPsetP' incrTotalsetTotalgetSpeedgetETRgetETAdefaultTimeSource BinPackerBinPackerError BPTooFewBinsBPSizeTooLargeBPOther packByOrderpackLargeFirstcsvFile genCsvFile PipeHandle processID phCommandphArgs phCreatorPipeMode ReadFromPipe WriteToPipe pipeLinesFrom hPipeFrompipeFromhPipeTopipeTo hPipeBothpipeBoth forceSuccess safeSystemposixRawSystem forkRawSystempOpenpOpen3 pOpen3Rawsendmail runInThread MailboxWriterappendMessagesdeleteMessagesaddFlags removeFlagssetFlags MailboxReaderlistIDslistMessageFlagsgetAll getMessagesMessageFlagsFlagSEENANSWEREDFLAGGEDDELETEDDRAFT FORWARDED OTHERFLAGGeneralizedTokenParserGeneralizedTokentogtoktokengsatisfygoneOfgallgnoneOfg specificg notMatching detachDaemon PipeWriter PipeReader MemoryBuffer StreamReaderHVIOvClosevIsOpen vIsClosed vTestOpenvIsEOFvShow vMkIOErrorvThrowvGetFPvTestEOFvGetCharvGetLine vGetContentsvReady vIsReadablevPutCharvPutStr vPutStrLnvPrintvFlush vIsWritablevSeekvTellvRewind vIsSeekable vSetBuffering vGetBufferingvPutBufvGetBufnewStreamReadernewMemoryBuffermbDefaultCloseFuncgetMemoryBuffer newHVIOPipeSystemFS HVFSOpenablevOpen vReadFile vWriteFilevOpenBinaryFileHVFSvGetCurrentDirectoryvSetCurrentDirectoryvGetDirectoryContentsvDoesFileExistvDoesDirectoryExist vDoesExistvCreateDirectoryvRemoveDirectoryvRenameDirectory vRemoveFile vRenameFilevGetFileStatusvGetSymbolicLinkStatusvGetModificationTime vRaiseErrorvCreateSymbolicLinkvReadSymbolicLink vCreateLinkHVFSStat vDeviceIDvFileID vFileMode vLinkCount vFileOwner vFileGroupvSpecialDeviceID vFileSize vAccessTimevModificationTimevStatusChangeTimevIsBlockDevicevIsCharacterDevice vIsNamedPipevIsRegularFile vIsDirectoryvIsSymbolicLink vIsSocket HVFSOpenEncap HVFSStatEncapwithStatwithOpenBinaryConvertibletoBuffromBuf hPutBufStr putBufStr hGetBufStr getBufStrhFullGetBufStr fullGetBufStr hGetBlocks getBlockshFullGetBlocks fullGetBlockshBlockInteract blockInteracthFullBlockInteractfullBlockInteract hBlockCopy blockCopycopyFileBlocksToFilereadBinaryFilewriteBinaryFile recurseDirrecurseDirStatrecursiveRemovelsl hPutStrLns hGetLines hInteract lineInteract hLineInteracthCopy hCopyProgress hLineCopylineCopycopyFileLinesToFileoptimizeForBatchoptimizeForInteractionlazyMapM WholeFuncmergemergeBy startswithendswithhasAny takeWhileList dropWhileListspanList breakListsplitreplacejoin genericJoincontainsaddToAL delFromALkeysALvaluesALhasKeyALflipAL strFromALstrToAL countElem elemRIndexalwaysElemRIndexseqListwholeMap fixedWidthgrabsubIndexuniqstrFromMstrToMflipMflippedLookupM forceLookupMsplitExt absNormPathsecureAbsNormPathmktmpdir brackettmpdir bracketCWDbrackettmpdirCWD MemoryVFS MemoryEntryMemoryDirectory MemoryFile MemoryNode SimpleStatisFile newMemoryVFSnewMemoryVFSRef nice_slice getFullPath getFullSlice HVFSChroot HVFSReadOnly newHVFSChroot MIMEResults MIMETypeData suffixMap encodingsMaptypesMapcommonTypesMap readMIMETypeshReadMIMETypes guessTypeguessExtensionguessAllExtensions defaultmtdreadSystemMIMETypesstriplstriprstripsplitWsescapeRe maybeRead ProgressMetersimpleNewMeternewMeter setComponents addComponentremoveComponentsetWidth displayMeter clearMeterwriteMeterStringautoDisplayMeterkillAutoDisplayMeter renderMeter wildToRegex wildCheckCaseglobvGlobcontroldepPartghc-prim GHC.ClassesOrd$fOrdDebVersionCDevCInoCModeCOffCPidCSsizeCGidCNlinkCUidCCcCSpeedCTcflagCRLimFd ByteCount ClockTick ProcessIDProcessGroupIDLimitunix_KZL8h98IqDM57kQSPo1mKxSystem.Posix.Files getPathVar setFileSizetouchSymbolicLink touchFilesetSymbolicLinkTimesHiRessetFileTimesHiRes setFileTimessetSymbolicLinkOwnerAndGroupsetOwnerAndGrouprenamereadSymbolicLinkcreateSymbolicLink removeLink createLink createDevicecreateNamedPipegetSymbolicLinkStatus getFileStatus fileExist fileAccess setFileModeSystem.Posix.Files.Common getFdPathVar setFdSizesetFdOwnerAndGrouptouchFdsetFdTimesHiRes getFdStatusstatusChangeTimeHiResmodificationTimeHiResaccessTimeHiRessetFileCreationMask setFdModeintersectFileModesunionFileModes accessModes otherModes groupModes ownerModes stdFileModesetGroupIDMode setUserIDModeotherExecuteModeotherWriteMode otherReadModegroupExecuteModegroupWriteMode groupReadModeownerExecuteModeownerWriteMode ownerReadMode nullFileMode FileStatusSyncIOAvailablePrioIOAvailableAsyncIOAvailable VDisableCharFileNamesAreNotTruncatedSetOwnerAndGroupIsRestrictedSymbolicLinkLimitPipeBufferLimit PathNameLimit FileNameLimitInputQueueLimitInputLineLimit LinkLimit FileSizeBitsPathVarTreeBranchLeafNullInfMStatebitsoffsethistorylocTablesTableLengthLitLenDistCodeshow_b int_to_bits word8_to_bitsset_bits align_8_bitsget_bits extract_InfM output_w32 repeat_w32s get_word32sget_w32get_bitinflate_blocksinflate_tablestriplemake_lit_dist_lengths meta_code inflate_codeslitlens dist_codedistsmk_basesinflate_trees_fixed make_tableget_code make_tree $fFunctorInfM$fApplicativeInfM $fMonadInfM $fShowBitW64lohi w64ToInteger integerToW64 $fEnumZord64 $fRealZord64$fIntegralZord64 $fBitsZord64 $fNumZord64 $fReadZord64 $fShowZord64RotationXYZmd5_main md5_do_block md5_roundmd5_inner_functionmd5_fmd5_gmd5_hmd5_i magic_numbersroundsabcd_to_stringdisplay_32bits_as_hexabcd_to_integerrev_numstring_to_word32sbools_to_word32slength_to_chars $fNumABCD $fMD5WordList$fMD5Str $fMD5BoolListmagicfFHCRCfFEXTRAfFNAME fFCOMMENT read_datasplit1 parseword$fErrorGZipErroroldti_JVjJvknZJ0JKghfag2Jw2L System.TimeformatCalendarTime CalendarTimectWDayreadN GHC.TypesIntGHC.BaseNothing pCalendarTime parseEnumsetYearsetMonthsetDaysetHoursetMinsetSecsetWDaysetYDay setTZNamesetTZ updateYear updateHour setHour12read2read3intsignGHC.RealIntegralroundDoubleProgressRecords withRecordProgressRecordparents callbacksstatusnow modStatus callParents!$fProgressStatusesProgressStatusb$fProgressRecordsProgressIO$fProgressStatusesProgressIOGHC.Showshow$fErrorBinPackerErrorpackLargeFirst'$fShowBinPackerErroreolcell quotedchar quotedcelllineSystem.Posix.Process.CommongetProcessStatuslogbase logRunningwarnFail cmdfailed cmdsignalledshowCmd sendmails findsendmailsendmail_workertrapchild1child2StringGHC.IO.Handle.Text hGetContentsPipeBitPipeEOFVIOCloseSupport vioc_isopenvioc_get vioc_closevioc_setsrvvrvprvpr_getcpwvpwmv$fHVIOPipeWriter$fShowPipeWriter$fHVIOPipeReader$fShowPipeReader$fHVIOMemoryBuffer$fShowMemoryBuffer$fHVIOStreamReader$fShowStreamReader $fHVIOHandleeh$fHVFSOpenableSystemFS$fHVFSSystemFS$fHVFSStatFileStatus$fShowFileStatushPutBufGHC.IO.Handle.FDstdouthGetBufstdin hPutBlocksidopenBinaryFile System.IOreadFilevReadBinaryFile writeFilevWriteBinaryFilehGetBlocksUtilhBlockInteractUtil$fBinaryConvertibleWord8$fBinaryConvertibleCharinteract Data.OldListlinesunlines isInfixOf findMelemgetMelemcontentcwd$fHVFSOpenableMemoryVFS$fHVFSMemoryVFS$fShowMemoryVFS$fHVFSStatSimpleStatdchdch2fpfp2dchwithroroerrordch2fph$fHVFSOpenableHVFSChroot$fHVFSHVFSChroot$fHVFSOpenableHVFSReadOnly$fHVFSHVFSReadOnlyaddType getStrict setStrictdefaultfilelocationsdefault_encodings_mapdefault_suffix_mapdefault_types_mapdefault_common_typeswscharsProgressMeterRmasterP componentswidthunitrendererautoDisplayers clearmeterstr renderMeterRconvwildconvpathasWild expandGlobrunGlobextlineentry headerPGP blankLine headerHashheader