h&mZ      !"#$%&'()*+,-./0123 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 { | } ~                      !!!!!!!!""####$$$$$$$%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&''''''''''''(((((((((((((((((((((((()))))))))))))))))))))))))))))*************++++++++++-$Copyright (C) 2004-2011 John Goerzen BSD-3-ClausestableportableSafe  1 MissingHTakes 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) 2008-2011 John Goerzen BSD-3-ClausestableportableSafe  MissingH+The primary type for bin-packing functions.These 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. [size] is the sizes of bins [(size, obj)] is the sizes and objects result is Either error or results MissingH,Potential errors returned as Left values by   functions. Calling  on this value will produce a nice error message suitable for display. MissingHRan out of bins; attached value is the list of objects that do not fitMissingH8Bin size1 exceeded by at least the given object and sizeMissingH Other errorMissingHPack 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. MissingHPack 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.   $Copyright (C) 2004-2011 John Goerzen BSD-3-Clausestable$portable to platforms with rawSystemSafe MissingHReturns a list representing the bytes that comprise a data type.Example: 6getBytes (0x12345678::Int) -> [0x12, 0x34, 0x56, 0x78]MissingHThe opposite of =, this function builds a number based on its component bytes.Results are undefined if any components of the input list are > 0xff!MissingHConverts a Char to a Word8. MissingH Converts a String to a [Word8]. MissingHConverts a Word8 to a Char. MissingH Converts a [Word8] to a String. $Copyright (C) 2005-2011 John Goerzen BSD-3-ClausestableportableSafe MissingHParse 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 cell 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: import 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.MissingHGenerate CSV data for a file. The resulting string can be written out to disk directly. Copyright (C) 2004 Ian Lynagh BSD-3-ClausestableportableSafe  MissingHReturns (Data, Remainder) !" "!$Copyright (C) 2004-2011 John Goerzen BSD-3-ClausestableportableSafe (MissingHConverts 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 aIts definition is given as it is so that it can be used in the Error and related monads.)MissingHPulls a Right value out of an Either value. If the Either value is Left, raises an exception with "error". *MissingHLike )3, but can raise a specific message with the error. +MissingHTakes an either and transforms it into something of the more generic MonadError class. ,MissingH*Take a Left to a value, crashes on a Right-MissingH*Take a Right to a value, crashes on a Left.MissingH.Take an Either, and return the value inside it(MissingH7(Left e) will be returned if the Maybe value is NothingMissingH.(Right a) will be returned if this is (Just a)()*+,-.()*+,-.$Copyright (C) 2004-2011 John Goerzen BSD-3-ClausestableportableSafe ;/012/012 Copyright (C) 2001 Ian Lynagh BSD-3-Clause OR GPL-2.0-or-laterIan Lynagh stableportableSafe !3MissingHAnything we want to work out the MD5 of must be an instance of class MD5?MissingH Synonym for  due to historic reasons@MissingHThe simplest function, gives you the MD5 of a string as 4-tuple of 32bit words. AMissingH-Returns a hex number ala the md5sum program. BMissingH1Returns an integer equivalent to hex number from A. CMissingHWARNING!: This instance only defines the  operation3645789:;<=>?@AB@AB3645=>?;<9:78,Safe ! $Copyright (C) 2004-2011 John Goerzen BSD-3-ClausestableportableSafe ? IMissingH The type used for functions for e. See e for details.KMissingH3Merge 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:prop_merge xs ys = merge (sort xs) (sort ys) == sort (xs ++ ys) where types = xs :: [Int]LMissingHMerge 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 x2MMissingHReturns true if the given list starts with the specified elements; false otherwise. (This is an alias for .)Example: startswith "He" "Hello" -> TrueNMissingHReturns true if the given list ends with the specified elements; false otherwise. (This is an alias for .)Example: endswith "lo" "Hello" -> TrueOMissingHReturns true if the given list contains any of the elements in the search list. PMissingH Similar to -., takes elements while the func is true. The function is given the remainder of the list to examine. QMissingH Similar to -/, drops elements while the func is true. The function is given the remainder of the list to examine. RMissingH Similar to -0, 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)SMissingH Similar to -1, but performs the test on the entire remaining list instead of just one element.TMissingHGiven 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,"]UMissingHGiven 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 $ lVMissingHGiven a delimiter and a list of items (or strings), join the items by using the delimiter. Alias for .Example: /join "|" ["foo", "bar", "baz"] -> "foo|bar|baz"WMissingHLike V, but works with a list of anything showable, converting it to a String. Examples: genericJoin ", " [1, 2, 3, 4] -> "1, 2, 3, 4" genericJoin "|" ["foo", "bar", "baz"] -> "\"foo\"|\"bar\"|\"baz\""XMissingHReturns true if the given parameter is a sublist of the given list; false otherwise. Alias for .Example: contains "Haskell" "I really like Haskell." -> True contains "Haskell" "OCaml is great." -> FalseYMissingHAdds the specified (key, value) pair to the given list, removing any existing pair with the same key already present. ZMissingHRemoves all (key, value) pairs from the given list where the key matches the given one. [MissingHReturns the keys that comprise the (key, value) pairs of the given AL.Same as: map fst\MissingHReturns the values the comprise the (key, value) pairs of the given AL.Same as: map snd]MissingH5Indicates whether or not the given key is in the AL. ^MissingHFlips an association list. Converts (key1, val), (key2, val) pairs to (val, [key1, key2]). _MissingHConverts 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.This function is designed to work with [(String, String)] association lists, but may work with other types as well. `MissingHThe inverse of _, 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.aMissingHReturns a count of the number of times the given element occured in the given list. bMissingHReturns the rightmost index of the given element in the given list. cMissingH;Like elemRIndex, but returns -1 if there is nothing found. dMissingH*Forces the evaluation of the entire list. eMissingHThis is an enhanced version of the concatMap or map functions in Data.List.!Unlike those functions, this one:Can consume a varying number of elements from the input list during each iteration3Can arbitrarily decide when to stop processing dataCan 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 I, 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 e is the concatenation of the output element lists from all iterations.Processing stops when the remaining input list is empty. An example of a I is f. fMissingHA parser designed to process fixed-width input fields. Use it with e.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: wholeMap (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."]gMissingH6Helps 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")hMissingHSimilar 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.If 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 4iMissingHGiven a list, returns a new list with all duplicate elements removed. For example: uniq "Mississippi" -> "Misp"You 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 .OMissingHList of elements to look forMissingHList to searchMissingHResult!IJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi!KLMNXOYZ^[\]_`TVUWPQRSIJefgabcdhi $Copyright (C) 2004-2011 John Goerzen BSD-3-ClausestableportableSafe DjMissingHConverts a String, String Map into a string representation. See _ 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. kMissingH2Converts 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. lMissingHFlips a Map. See ^- for more on the similar function for lists. mMissingHReturns 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. nMissingHPerforms a lookup, and raises an exception (with an error message prepended with the given string) if the key could not be found.jklmnlmnkj $Copyright (C) 2005-2011 John Goerzen BSD-3-ClausestableportableSafe F\oMissingHPulls a  value out of a  value. If the  value is !, raises an exception with error. Alias of . pMissingHLike o5, but lets you customize the error message raised if  is supplied. opop $Copyright (C) 2006-2011 John Goerzen BSD-3-ClausestableportableSafe T qMissingHThe options for y and { sMissingH)The base from which calculations are madetMissingH.The increment to the power for each new suffixuMissingH,The first power for which suffixes are givenvMissingHThe suffixes themselveswMissingHPredefined definitions for byte measurement in groups of 1024, from 0 to 2**80 xMissingHPredefined definitions for SI measurement, from 10**-24 to 10**24. yMissingHTakes a number and returns a new (quantity, suffix) combination. The space character is used as the suffix for items around 0. zMissingHLike y, 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. {MissingHRender 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 q 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 y. |MissingHLike {, 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 {, 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"]}MissingH'Parses a String, possibly generated by {. Parses the suffix and applies it to the number, which is read via the Read class.Returns Left "error message" on error, or Right number on successful parse.9If you want an Integral result, the convenience function ~ is for you.~MissingHParse a number as with }, but return the result as an . 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. {MissingHPrecision of the resultMissingHThe number to examine|MissingHPrevision of the resultMissingHThe numbers to examineMissingHResult}MissingH%Information on how to parse this dataMissingH+Whether to perform a case-insensitive matchMissingHThe string to parse~MissingH%Information on how to parse this dataMissingH+Whether to perform a case-insensitive matchMissingHThe string to parseqrstuvwxyz{|}~{|}~yzqrstuvwx$Copyright (C) 2004-2011 John Goerzen BSD-3-ClausestableportableSafe YGMissingHRemoves 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.Note that this may differ from some other similar functions from other authors in that: If multiple whitespace characters are present all in a row, they are all removed;9If no whitespace characters are present, nothing is done.MissingHSame as 2, but applies only to the left side of the string.MissingHSame as 3, but applies only to the right side of the string.MissingHSplits a string around whitespace. Empty elements in the result list are automatically removed. MissingHEscape all characters in the input pattern that are not alphanumeric.Does not make special allowances for NULL, which isn't valid in a Haskell regular expression pattern. MissingH7Attempts to parse a value from the front of the string. MNTUV MNVTU$Copyright (C) 2004-2011 John Goerzen BSD-3-ClausestableportableSafe [MissingH1Construct a pair by duplication of a single valueMissingH'Construct a 3-tuple from a single valueMissingH,Take the first item out of a 3 element tupleMissingH-Take the second item out of a 3 element tupleMissingH,Take the third item out of a 3 element tuple$Copyright (C) 2005-2011 John Goerzen BSD-3-ClausestableportableSafe _MissingH"Main class for readable mailboxes.The mailbox object a represents zero or more )s. Each message has a unique identifier b in a format specific to each given mailbox. This identifier may or may not be persistent.Functions which return a list are encouraged -- but not guaranteed -- to do so lazily./Implementing classes must provide, at minimum, .MissingH*Returns a list of all unique identifiers. MissingH?Returns a list of all unique identifiers as well as all flags. MissingHReturns a list of all messages, including their content, flags, and unique identifiers. MissingH-Returns information about specific messages. MissingH-A Message is represented as a simple String. MissingHConvenience shortcut MissingH.The flags which may be assigned to a message. $Copyright (C) 2004-2011 John Goerzen BSD-3-Clausestablesystems with networking Trustworthy `MissingHSets 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 Goerzen BSD-3-Clause experimentalsystems with networking Trustworthy i' MissingHThe 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.MissingHOptions for your server. MissingH6Get Default options. You can always modify it later. MissingH#Takes some options and sets up the . I will bind and begin listening, but will not accept any connections itself. MissingHClose the socket server. Does not terminate active handlers, if any. MissingH+Handle one incoming request from the given . MissingH,Handle all incoming requests from the given . MissingH0Convenience function to completely set up a TCP " and handle all incoming requests. This function is literally this: serveTCPforever options func = do sockserv <- setupSocketServer options serveForever sockserv funcMissingH4Log each incoming connection using the interface in System.Log.Logger.-Log when the incoming connection disconnects.Write a string representation of the argument, plus a newline.MissingHFlush 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.MissingHIndicate whether or not this particular object supports writing.MissingHSeek to a specific location.MissingHGet the current position.MissingHConvenience function to reset the file pointer to the beginning of the file. A call to  vRewind h is the same as  h AbsoluteSeek 0.MissingH0Indicate whether this instance supports seeking.MissingH-Set buffering; the default action is a no-op.MissingH=Get buffering; the default action always returns NoBuffering.MissingHBinary output: write the specified number of octets from the specified buffer location.MissingHBinary 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.MissingH Create a new  object. MissingH Create a new  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 7 calls, and reset to the beginning by using the normal  call.The function is called when  is called, and is passed the contents of the buffer at close time. You can use " if you don't want to do anything.2To create an empty buffer, pass the initial value "". MissingH+Default (no-op) memory buf close function. MissingH;Grab the entire contents of the buffer as a string. Unlike , this has no effect on the open status of the item, the EOF status, or the current position of the file pointer. MissingHCreate 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. MissingHInitial contents of the MissingHInitial ContentsMissingH close func''$Copyright (C) 2005-2011 John Goerzen BSD-3-ClausestableportableSafe aMissingHThe name of the null device. NUL: on Windows, /dev/null everywhere else.$Copyright (C) 2004-2011 John Goerzen BSD-3-Clausestableportable Trustworthy › MissingHGiven a list of strings, output a line containing each item, adding newlines as appropriate. The list is not expected to have newlines already.MissingHGiven 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: main = do l <- hGetLines stdin hPutStrLns stdout $ filter (startswith "1") lMissingH This is similar to the built-in 345, but works on any handle, not just stdin and stdout.In other words: !interact = hInteract stdin stdoutMissingHLine-based interaction. This is similar to wrapping your interact functions with  and . This equality holds: )lineInteract = hLineInteract stdin stdoutHere's an example: -main = lineInteract (filter (startswith "1"))This will act as a simple version of grep -- all lines that start with 1 will be displayed; all others will be ignored.MissingHLine-based interaction over arbitrary handles. This is similar to wrapping hInteract with  and .'One could view this function like this: hLineInteract finput foutput func = let newf = unlines . func . lines in hInteract finput foutput newf8Though the actual implementation is this for efficiency: hLineInteract finput foutput func = do lines <- hGetLines finput hPutStrLns foutput (func lines)MissingHCopies from one handle to another in raw mode (using hGetContents).MissingHCopies from one handle to another in raw mode (using hGetContents). Takes a function to provide progress updates to the user.MissingHCopies from one handle to another in text mode (with lines). Like  hBlockCopy, this implementation is nice: .hLineCopy hin hout = hLineInteract hin hout idMissingH Copies from  to  using lines. An alias for  over  and . MissingH,Copies one filename to another in text mode.Please 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. MissingHSets 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. MissingHSets stdin and stdout to be line-buffered. This saves resources on stdout, but not many on stdin, since it it still looking for newlines. MissingHApplies a given function to every item in a list, and returns the new list. Unlike the system's mapM, items are evaluated lazily. MissingH Input handleMissingH Output handleMissingHProgress function -- the bool is always False unless this is the final call  5$Copyright (C) 2005-2011 John Goerzen BSD-3-ClausestableportableSafe CCopyright (C) 2004 Volker Wysk BSD-3-ClausestableportableSafe MissingH&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.The 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.MissingH
The normalised path with the file prefix, and the file suffix.MissingHFilename to be splitMissingHBase name and the last suffixMissingHFile name prefix and suffixMissingHPathMissingH Path to splitMissingH3Directory part, base file name part and suffix partMissingH3Directory part, base file name part and suffix partMissingH'Path consisting of dir, base and suffixMissingHSuffix to split offMissingH Path to testMissingHPrefix without the suffix or NothingMissingHThe path to be made absoluteMissingH Absulte pathMissingH9The directory relative to which the path is made absoluteMissingHThe path to be made absoluteMissingH Absolute pathMissingHThe path to be made absoluteMissingH9The directory relative to which the path is made absoluteMissingH Absolute pathMissingHList of path componentsMissingH+In case the path could be transformed, the ".."(-component free list of path components.MissingHPath to be normalisedMissingH7In case the path could be transformed, the normalised, ".."!-component free form of the path.$Copyright (C) 2006-2011 John Goerzen BSD-3-ClausestableportableSafe .MissingH9Convert a wildcard to an (uncompiled) regular expression.MissingHCheck the given name against the given pattern, being case-sensitive.The given pattern is forced to match the given name starting at the beginning.MissingH'The wildcard pattern to use as the baseMissingH The filename to check against itMissingHResult$Copyright (C) 2005-2011 John Goerzen BSD-3-ClausestableportableSafe  $Copyright (C) 2005-2011 John Goerzen BSD-3-ClausestableportableSafe =!$Copyright (C) 2004-2011 John Goerzen BSD-3-ClausestableportableSafe MissingH?January 1, 1970, midnight, UTC, represented as a CalendarTime. MissingHConverts 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.MissingHConverts 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.This 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.MissingHConverts the given timeDiff to the number of seconds it represents.5Uses the same algorithm as normalizeTimeDiff in GHC. MissingHConverts 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. MissingHConverts 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. MissingHRender 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.MissingHLike ;, but takes a TimeDiff instead of an integer second count. $Copyright (C) 2004-2011 John Goerzen BSD-3-ClausestableportableSafe  MissingHTypes that can open a HVIO object should be instances of this class. You need only implement . MissingHThe main HVFS class.8Default implementations of these functions are provided: -- implemented in terms of  -- implemented in terms of  -- implemented in terms of  -- 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.MissingHTrue if the file exists, regardless of what type it is. This is even True if the given path is a broken symlink. MissingH2Raise an error relating to actions on this class. MissingH5Evaluating types of files and information about them.This corresponds to the System.Posix.Types.FileStatus type, and indeed, that is one instance of this class.+Inplementators must, at minimum, implement  and .Default implementations of everything else are provided, returning reasonable values.A default implementation of this is not currently present on Windows.MissingH?Refers to file permissions, NOT the st_mode field from stat(2) MissingH Similar to  , but for  result.MissingHEncapsulate a  result. This is required due to Haskell typing restrictions. You can get at it with: 0case encap of HVFSStatEncap x -> -- now use xMissingHConvenience 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.MissingH Similar to , but for the  result. MissingHError handler helper= = "$Copyright (C) 2006-2011 John Goerzen BSD-3-ClausestableportableSafe ?MissingHTakes a pattern. Returns a list of names that match that pattern. The pattern is evaluated by System.Path.WildMatch. 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 SystemFSMissingHLike , but works on both the system ("real") and HVFS virtual filesystems. #$Copyright (C) 2004-2011 John Goerzen BSD-3-Clausestableportable Trustworthy  MissingHObtain 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.If the passed value is not a directory, the return value be only that value. [] nice_slice "/foo/bar" -> ["foo", "bar"]MissingH.Gets a full path, after investigating the cwd.MissingHGets the full path via , then splits it via .MissingH7Find an element on the tree, assuming a normalized pathMissingH7Find an element on the tree, normalizing the path first'$Copyright (C) 2004-2011 John Goerzen BSD-3-ClausestableportableSafe (MissingHAccess a subdirectory of a real filesystem as if it was the root of that filesystem. MissingHRestrict 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  instance fs.MissingH Create a new  object. MissingHGet the embedded object MissingH.Convert a local (chroot) path to a full path. MissingH.Convert a full path to a local (chroot) path. .Convert a local (chroot) path to a full path. MissingH!The object to pass requests on toMissingH&The path of the directory to make rootMissingHThe resulting new object($Copyright (C) 2004-2011 John Goerzen BSD-3-Clausestable,portable to platforms supporting binary I\/O Trustworthy 7(MissingHProvides support for handling binary blocks with convenient types.This module provides implementations for Strings and for [Word8] (lists of Word8s). MissingH*As a wrapper around the standard function 37), this function takes a standard Haskell $ instead of the far less convenient Ptr a. The entire contents of the string will be written as a binary buffer using hPutBuf. 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 () MissingH An alias for  MissingH,Acts a wrapper around the standard function 38, 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 hGetBuf; 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 ) MissingH An alias for  MissingHLike , but guarantees that it will only return fewer than the requested number of bytes when EOF is encountered. MissingH An alias for  MissingHWrites 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) MissingH An alias for   putBlocks :: (BinaryConvertible b) => [[b]] -> IO () putBlocks = hPutBlocks stdout Returns a lazily-evaluated list of all blocks in the input file, as read by . There will be no 0-length block in this list. The list simply ends at EOF. MissingH An alias for  MissingHSame as  , but using  underneath. MissingH An alias for  MissingHBinary 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.MissingH An alias for  over  and MissingHSame as  , but uses  instead of  internally. MissingH An alias for  over  and MissingHCopies 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( 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.MissingH Copies from  to 5 using binary blocks of the given size. An alias for  over  and MissingH.Copies one filename to another in binary mode.Please note that the Unix permission bits on the output file cannot be set due to a limitation of the Haskell  function. Therefore, you may need to adjust those bits after the copy yourself.#This function is implemented using  internally. MissingHLike the built-in 5, but opens the file in binary instead of text mode. MissingHSame as , but works with HVFS objects. MissingHLike the built-in 5, but opens the file in binary instead of text mode. MissingHLike , but works on HVFS objects. )$Copyright (C) 2006-2011 John Goerzen BSD-3-ClausestableportableSafe N'MissingHLets 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  object, withStatus will also accept it and simply pass it unmodified to the function. MissingHThe main Progress object. MissingH!The main progress status record. MissingHAn identifying stringMissingHThe type for a callback function for the progress tracker. When given at creation time to 'newProgress'' or when added via , these functions get called every time the status of the tracker changes.This function is passed two  records: the first reflects the status prior to the update, and the second reflects the status after the update.Please note that the owning  object will be locked while the callback is running, so the callback will not be able to make changes to it. MissingHA function that, when called, yields the current time. The default is . MissingH 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" 1024MissingH Create a new  object initialized with the given status and callbacks. No adjustment to the  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. MissingH$Adds an new callback to an existing . 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.MissingH!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 . MissingHCall 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. MissingH*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.You can decrease the completed unit count by supplying a negative number here. MissingHLike , but never modify the total. MissingH$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. MissingHLike , but never modify the total. MissingH&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. MissingH Set the total unit count in the & object to the specified value. Like , this would rarely be needed. MissingHReturns 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  object. This is in the IO monad because the speed is based on the current time.Example: getSpeed progressobj >>= printDon't let the type of this function confuse you. It is a fancy way of saying that it can take either a  or a  object, and returns a number that is valid as any Fractional type, such as a Double, Float, or Rational. MissingH=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. MissingHReturns 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. MissingH>= (return . clockTimeToEpoch)MissingHName of this trackerMissingHTotal units expectedMissingHThe child objectMissingHThe parent to add to this child*$Copyright (C) 2006-2011 John Goerzen BSD-3-ClausestableportableSafe VMissingH+The main data type for the progress meter. MissingH The master  object for overall statusMissingHIndividual component statusesMissingHWidth of the meterMissingHUnits of displayMissingHFunction to render numbersMissingHAuto-updating displayMissingH'Set up a new status bar using defaults:The given trackerWidth 80%Data.Quantity.renderNums binaryOpts 1Unit inticator BMissingHSet up a new status bar. MissingH&Adjust the list of components of this . MissingH/Add a new component to the list of components. MissingHRemove a component by name. MissingHAdjusts the width of this . MissingHLike 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. MissingHClears the meter -- outputs CR, spaces equal to the width - 1, then another CR.=Pass stdout as the handle for regular display to the screen. MissingHClears 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. MissingHStarts 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.MissingH*Stops the specified meter from displaying.You should probably call  after a call to this. MissingHRender the current status. MissingHThe top-level MissingHUnit indicator stringMissingH#Width of the terminal -- usually 80MissingHA function to render sizesMissingHThe meter to displayMissingHUpdate interval in secondsMissingHFunction to display itMissingHResulting thread id  +$Copyright (C) 2004-2011 John Goerzen BSD-3-ClausestableportableSafe ZMissingHGenerate (return) a . MissingHRetrieve the next token from a  stream. The given function should return the value to use, or Nothing to cause an error. MissingHA shortcut to ; the test here is just a function that returns a Bool. If the result is true; return that value -- otherwise, an error.MissingH+Matches one item in a list and returns it. MissingH#Matches all items and returns them MissingH/Matches one item not in a list and returns it. MissingH+Matches one specific token and returns it. MissingHRunning 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.  9:;9:<9:=9:>9:?9:@9:A9:B9CD9EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno p q r s t t u u v v w w x y z { | } ~                                              9           2                     !!!!!!!!""####$$$$$$$%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&''''''''''''(((((((((((((((((((((((()))))))))))))))))))))))))))))*************++++++++++999,x99999999999999:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9:9999%&&'''(9993(93(*******MissingH-1.5.0.1-inplaceSystem.IO.HVFSControl.Concurrent.Thread.UtilsData.BinPackingData.Bits.UtilsData.CSVData.Compression.InflateData.Either.UtilsData.Hash.CRC32.GZip Data.Hash.MD5Data.List.UtilsData.Map.UtilsData.Maybe.Utils Data.QuantityData.String.UtilsData.Tuple.UtilsNetwork.Email.Mailbox Network.UtilsNetwork.SocketServerSystem.Cmd.UtilsNetwork.Email.SendmailSystem.Console.GetOpt.Utils System.Daemon System.DebianSystem.Debian.ControlParserSystem.FileArchive.GZipSystem.IO.HVIOSystem.IO.PlafCompatSystem.IO.UtilsSystem.Path.NameManipSystem.Path.WildMatchSystem.Posix.ConstsSystem.IO.StatCompatSystem.Time.UtilsSystem.Path.GlobSystem.IO.HVFS.Utils System.PathData.MIME.TypesSystem.IO.HVFS.InstanceHelpersSystem.IO.HVFS.CombinatorsSystem.IO.BinaryData.Progress.TrackerData.Progress.Meter#Text.ParserCombinators.Parsec.UtilsData.Hash.MD5.Zord64_HARD Data.List takeWhile dropWhilespanbreak safeSystem System.IOinteractSystem.IO.WindowsCompat NameManiphPutBufhGetBufbaseSystem.Posix.TypesUserID LinkCountGroupID FileOffsetFileModeFileID EpochTimeDeviceIDGHC.IOFilePath GHC.IO.IOModeIOMode runInThread BinPackerBinPackerError BPTooFewBinsBPSizeTooLargeBPOther packByOrderpackLargeFirst$fShowBinPackerError$fEqBinPackerError$fReadBinPackerErrorgetBytes fromBytesc2w8s2w8w82cw82scsvFile genCsvFileBitOutputinflate_stringinflate_string_remainderbits_to_word32inflate $fShowBit $fFunctorInfM$fApplicativeInfM $fMonadInfM$fEqBit maybeToEither forceEitherforceEitherMsgeitherToMonadErrorfromLeft fromRight fromEither update_crcupdate_crc_list calc_crc32 gzipcrctabMD5get_nextlen_padfinishedWordListBoolListStrABCDZord64md5md5smd5i $fNumABCD $fMD5WordList$fMD5Str $fMD5BoolList$fEqABCD $fShowABCD WholeFuncmergemergeBy startswithendswithhasAny takeWhileList dropWhileListspanList breakListsplitreplacejoin genericJoincontainsaddToAL delFromALkeysALvaluesALhasKeyALflipAL strFromALstrToAL countElem elemRIndexalwaysElemRIndexseqListwholeMap fixedWidthgrabsubIndexuniqstrFromMstrToMflipMflippedLookupM forceLookupM forceMaybe forceMaybeMsgSizeOpts powerIncr firstPowersuffixes binaryOptssiOpts quantifyNum quantifyNums renderNum renderNumsparseNum parseNumIntstriplstriprstripsplitWsescapeRe maybeReadduptriplefst3snd3thd3 MailboxWriterappendMessagesdeleteMessagesaddFlags removeFlagssetFlags MailboxReaderlistIDslistMessageFlagsgetAll getMessagesMessageFlagsFlagSEENANSWEREDFLAGGEDDELETEDDRAFT FORWARDED OTHERFLAG$fEqFlag $fShowFlag niceSocketsDo connectTCPconnectTCPAddr listenTCPAddr showSockAddr SocketServer optionsSSsockSSHandlerTInetServerOptionslistenQueueSize portNumber interfacereusefamilysockTypeprotoStrsimpleTCPOptionssetupSocketServercloseSocketServer handleOne serveForeverserveTCPforeverloggingHandlerthreadedHandler handleHandler$fEqSocketServer$fShowSocketServer$fEqInetServerOptions$fShowInetServerOptions PipeHandle processID phCommandphArgs phCreatorPipeMode ReadFromPipe WriteToPipe pipeLinesFrom hPipeFrompipeFromhPipeTopipeTo hPipeBothpipeBoth forceSuccessposixRawSystem forkRawSystempOpenpOpen3 pOpen3Raw$fEqPipeHandle$fShowPipeHandlesendmail StdOption parseCmdLinevalidateCmdLine stdRequired stdOptional detachDaemon DebVersion ControlFilecompareDebVersioncheckDebVersion$fOrdDebVersion$fEqDebVersioncontroldepPartSectionFootersizecrc32 crc32validHeadermethodflagsextrafilenamecommentmtimexflos GZipErrorCRCError NotGZIPFile UnknownMethod UnknownError hDecompress decompress read_sections read_section read_header $fEqHeader $fShowHeader $fEqGZipError$fShowGZipError PipeWriter PipeReader MemoryBuffer StreamReaderHVIOvClosevIsOpen vIsClosed vTestOpenvIsEOFvShow vMkIOErrorvThrowvGetFPvTestEOFvGetCharvGetLine vGetContentsvReady vIsReadablevPutCharvPutStr vPutStrLnvPrintvFlush vIsWritablevSeekvTellvRewind vIsSeekable vSetBuffering vGetBufferingvPutBufvGetBufnewStreamReadernewMemoryBuffermbDefaultCloseFuncgetMemoryBuffer newHVIOPipe $fHVIOHandle$fHVIOStreamReader$fShowStreamReader$fHVIOMemoryBuffer$fShowMemoryBuffer$fHVIOPipeReader$fShowPipeReader$fHVIOPipeWriter$fShowPipeWriter $fEqPipeBit $fShowPipeBit nullFileName hPutStrLns hGetLines hInteract lineInteract hLineInteracthCopy hCopyProgress hLineCopylineCopycopyFileLinesToFileoptimizeForBatchoptimizeForInteractionlazyMapM 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_dotdot wildToRegex wildCheckCaseblockSpecialModecharacterSpecialMode namedPipeModeregularFileMode directoryMode fileTypeModes socketModesymbolicLinkModeFileStatusCompatdeviceIDfileIDfileMode linkCount fileOwner fileGroupspecialDeviceIDfileSize accessTimemodificationTimestatusChangeTime sc_helper isBlockDeviceisCharacterDevice isNamedPipe isRegularFile isDirectoryisSymbolicLinkisSocketepochtimegm timelocaltimeDiffToSecsepochToClockTimeclockTimeToEpoch renderSecsrenderTDSystemFS HVFSOpenablevOpen vReadFile vWriteFilevOpenBinaryFileHVFSvGetCurrentDirectoryvSetCurrentDirectoryvGetDirectoryContentsvDoesFileExistvDoesDirectoryExist vDoesExistvCreateDirectoryvRemoveDirectoryvRenameDirectory vRemoveFile vRenameFilevGetFileStatusvGetSymbolicLinkStatusvGetModificationTime vRaiseErrorvCreateSymbolicLinkvReadSymbolicLink vCreateLinkHVFSStat vDeviceIDvFileID vFileMode vLinkCount vFileOwner vFileGroupvSpecialDeviceID vFileSize vAccessTimevModificationTimevStatusChangeTimevIsBlockDevicevIsCharacterDevice vIsNamedPipevIsRegularFile vIsDirectoryvIsSymbolicLink vIsSocket HVFSOpenEncap HVFSStatEncapwithStatwithOpen$fShowFileStatus$fHVFSStatFileStatus$fHVFSOpenableSystemFS$fHVFSSystemFS $fEqSystemFS$fShowSystemFSglobvGlob recurseDirrecurseDirStatrecursiveRemovelslsplitExt absNormPathsecureAbsNormPathmktmpdir brackettmpdir bracketCWDbrackettmpdirCWD MIMEResults MIMETypeData suffixMap encodingsMaptypesMapcommonTypesMap readMIMETypeshReadMIMETypes guessTypeguessExtensionguessAllExtensions defaultmtdreadSystemMIMETypes MemoryVFS MemoryEntryMemoryDirectory MemoryFile MemoryNode SimpleStatisFile newMemoryVFSnewMemoryVFSRef nice_slice getFullPath getFullSlice$fHVFSStatSimpleStat$fHVFSOpenableMemoryVFS$fHVFSMemoryVFS$fShowMemoryVFS$fEqMemoryEntry$fShowMemoryEntry$fShowSimpleStat$fEqSimpleStat HVFSChroot HVFSReadOnly newHVFSChroot$fHVFSOpenableHVFSReadOnly$fHVFSHVFSReadOnly$fHVFSOpenableHVFSChroot$fHVFSHVFSChroot$fEqHVFSChroot$fShowHVFSChroot$fEqHVFSReadOnly$fShowHVFSReadOnlyBinaryConvertibletoBuffromBuf hPutBufStr putBufStr hGetBufStr getBufStrhFullGetBufStr fullGetBufStr hGetBlocks getBlockshFullGetBlocks fullGetBlockshBlockInteract blockInteracthFullBlockInteractfullBlockInteract hBlockCopy blockCopycopyFileBlocksToFilereadBinaryFilewriteBinaryFile$fBinaryConvertibleWord8$fBinaryConvertibleCharProgressStatuses withStatusProgressProgressStatuscompletedUnits totalUnits startTime trackerName timeSourceProgressCallbackProgressTimeSource newProgress newProgress' addCallback addParentfinishPincrPincrP'setPsetP' incrTotalsetTotalgetSpeedgetETRgetETAdefaultTimeSource!$fProgressStatusesProgressStatusb$fProgressStatusesProgressIO ProgressMetersimpleNewMeternewMeter setComponents addComponentremoveComponentsetWidth displayMeter clearMeterwriteMeterStringautoDisplayMeterkillAutoDisplayMeter renderMeterGeneralizedTokenParserGeneralizedTokentogtoktokengsatisfygoneOfgallgnoneOfg specificg notMatchingGHC.ShowshowGHC.WordWord64GHC.Num+ Data.OldList isPrefixOf isSuffixOf intercalate isInfixOfnub GHC.MaybeJustMaybeNothing Data.MaybefromJustGHC.RealIntegralroundghc-prim GHC.TypesDouble unix-2.7.2.2System.Posix.Process.CommongetProcessStatus GHC.ClassesOrdmagicfFHCRCfFEXTRAfFNAME fFCOMMENT read_dataGHC.BaseStringGHC.IO.Handle.Text hGetContents ProcessIDProcessGroupIDLimitFd ClockTickCUidCTcflagCSsizeCSpeedCSocklenCRLimCPidCOffCNlinkCNfdsCModeCKeyCInoCIdCGid CFsFilCnt CFsBlkCntCDevCClockIdCCcCBlkSizeCBlkCnt ByteCountSystem.Posix.FilestouchSymbolicLink touchFilesetSymbolicLinkTimesHiRessetSymbolicLinkOwnerAndGroupsetOwnerAndGroupsetFileTimesHiRes setFileTimes setFileSize setFileModerename removeLinkreadSymbolicLinkgetSymbolicLinkStatus getPathVar getFileStatus fileExist fileAccesscreateSymbolicLinkcreateNamedPipe createLink createDeviceSystem.Posix.Files.CommonPathVar VDisableCharSyncIOAvailableSymbolicLinkLimitSetOwnerAndGroupIsRestrictedPrioIOAvailablePipeBufferLimit PathNameLimit LinkLimitInputQueueLimitInputLineLimit FileSizeBitsFileNamesAreNotTruncatedAsyncIOAvailable FileNameLimit FileStatusunionFileModestouchFd stdFileModestatusChangeTimeHiRes setUserIDModesetGroupIDModesetFileCreationMasksetFdTimesHiRes setFdSizesetFdOwnerAndGroup setFdModeownerWriteMode ownerReadMode ownerModesownerExecuteModeotherWriteMode otherReadMode otherModesotherExecuteMode nullFileModemodificationTimeHiResintersectFileModesgroupWriteMode groupReadMode groupModesgroupExecuteMode getFdStatus getFdPathVaraccessTimeHiRes accessModeslinesunlinesGHC.IO.StdHandlesstdinstdoutehaddType findMelemgetMelemdchdch2fpfp2dch hPutBlocksidopenBinaryFilereadFilevReadBinaryFile writeFilevWriteBinaryFileProgressMeterRmasterP componentswidthunitrendererautoDisplayers