h*U      ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                  1.7.15 Safe-Inferredextra#Evaluates the value before calling .extra#Evaluates the value before calling .extra Variant of  which ignores the return valueextra Variant of  which ignores the return value Safe-Inferred extraLike , but operating on a . If the first argument is ' returns the second, otherwise returns . 5mwhen True "test" == "test" mwhen False "test" == ""$   Safe-Inferred  extra%Update the first component of a pair. #first succ (1,"test") == (2,"test") extra&Update the second component of a pair. 'second reverse (1,"test") == (1,"tset") extra%Update the first component of a pair. ?firstM (\x -> [x-1, x+1]) (1,"test") == [(0,"test"),(2,"test")] extra&Update the second component of a pair. secondM (\x -> [reverse x, x]) (1,"test") == [(1,"tset"),(1,"test")]extraGiven two functions, apply one to the first component and one to the second. A specialised version of . +(succ *** reverse) (1,"test") == (2,"tset")extraGiven two functions, apply both to a single argument to form a pair. A specialised version of . (succ &&& pred) 1 == (2,0)extra%Duplicate a single value into a pair. dupe 12 == (12, 12)extra5Apply a single function to both components of a pair. both succ (1,2) == (2,3)extra Extract the  of a triple.extra Extract the  of a triple.extra&Extract the final element of a triple.extra5Converts an uncurried function to a curried function.extra6Converts a curried function to a function on a triple.extra'Update the first component of a triple. first3 succ (1,1,1) == (2,1,1)extra(Update the second component of a triple. second3 succ (1,1,1) == (1,2,1)extra'Update the third component of a triple. third3 succ (1,1,1) == (1,1,2)    33 Safe-Inferred .& Safe-Inferredcextra2Show a number to a fixed number of decimal places. showDP 4 pi == "3.1416" showDP 0 pi == "3" showDP 2 3 == "3.00"extra;Specialised numeric conversion, type restricted version of .extra;Specialised numeric conversion, type restricted version of .extra;Specialised numeric conversion, type restricted version of .extra;Specialised numeric conversion, type restricted version of .3 Safe-Inferred/extraA constraint which documents that a function is partial, and on GHC 8.0 and above produces a stack trace on failure. For example:  myHead :: 7 => [a] -> a myHead [] = error "bad" myHead (x:xs) = x  When using  with GHC 7.8 or below you need to enable the language feature ConstraintKinds, e.g.  {-# LANGUAGE ConstraintKinds #-} at the top of the file.  Safe-Inferred/V extraApply some operation repeatedly, producing an element of output and the remainder of the list.When the empty list is reached it is returned, so the operation is never applied to the empty input. That fact is encoded in the type system with ! \xs -> repeatedly (splitAt 3) xs == chunksOf 3 xs \xs -> repeatedly word1 (trim xs) == words xs \xs -> repeatedly line1 xs == lines xs!extraApply some operation repeatedly, producing an element of output and the remainder of the list. Identical to  (, but has a more precise type signature."extra3Are two lists disjoint, with no elements in common. >disjoint [1,2,3] [4,5] == True disjoint [1,2,3] [4,1] == False#extraO((m+n) log m), m <= n5. Are two lists disjoint, with no elements in common. disjointOrd is more strict than ". For example,  disjointOrd5 cannot terminate if both lists are infinite, while " can. disjointOrd [1,2,3] [4,5] == True disjointOrd [1,2,3] [4,1] == False$extra A version of # with a custom predicate. disjointOrdBy (compare `on` (`mod` 7)) [1,2,3] [4,5] == True disjointOrdBy (compare `on` (`mod` 7)) [1,2,3] [4,8] == False%extra1Is there any element which occurs more than once. anySame [1,1,2] == True anySame [1,2,3] == False anySame (1:2:1:undefined) == True anySame [] == False \xs -> anySame xs == (length (nub xs) < length xs)&extraAre all elements the same. allSame [1,1,2] == False allSame [1,1,1] == True allSame [1] == True allSame [] == True allSame (1:1:2:undefined) == False \xs -> allSame xs == (length (nub xs) <= 1)'extraA total  with a default value. headDef 1 [] == 1 headDef 1 [2,3,4] == 2 \x xs -> headDef x xs == fromMaybe x (listToMaybe xs)(extraA total  with a default value. lastDef 1 [] == 1 lastDef 1 [2,3,4] == 4 \x xs -> lastDef x xs == last (x:xs))extra+A total variant of the list index function . [2,3,4] !? 1 == Just 3 [2,3,4] !? (-1) == Nothing [] !? 0 == Nothing*extraA composition of  and . notNull [] == False notNull [1] == True \xs -> notNull xs == not (null xs)+extra*Non-recursive transform over a list, like . list 1 (\v _ -> v - 2) [5,6,7] == 3 list 1 (\v _ -> v - 2) [] == 1 \nil cons xs -> maybe nil (uncurry cons) (uncons xs) == list nil cons xs,extraIf the list is empty returns , otherwise returns the  and the . unsnoc "test" == Just ("tes",'t') unsnoc "" == Nothing \xs -> unsnoc xs == if null xs then Nothing else Just (init xs, last xs)-extra7Append an element to the start of a list, an alias for (:). cons 't' "est" == "test" \x xs -> uncons (cons x xs) == Just (x,xs).extra.Append an element to the end of a list, takes O(n) time. snoc "tes" 't' == "test" \xs x -> unsnoc (snoc xs x) == Just (xs,x)/extraEnumerate all the values of an , from  to . enumerate == [False, True]0extra3Take a number of elements from the end of the list. takeEnd 3 "hello" == "llo" takeEnd 5 "bye" == "bye" takeEnd (-1) "bye" == "" \i xs -> takeEnd i xs `isSuffixOf` xs \i xs -> length (takeEnd i xs) == min (max 0 i) (length xs)1extra3Drop a number of elements from the end of the list. dropEnd 3 "hello" == "he" dropEnd 5 "bye" == "" dropEnd (-1) "bye" == "bye" \i xs -> dropEnd i xs `isPrefixOf` xs \i xs -> length (dropEnd i xs) == max 0 (length xs - max 0 i) \i -> take 3 (dropEnd 5 [i..]) == take 3 [i..]2extra2 n xs> returns a split where the second element tries to contain n elements. splitAtEnd 3 "hello" == ("he","llo") splitAtEnd 3 "he" == ("", "he") \i xs -> uncurry (++) (splitAt i xs) == xs \i xs -> splitAtEnd i xs == (dropEnd i xs, takeEnd i xs)3extra against an enumeration. Truncates the output if the enumeration runs out. \i xs -> zip [i..] xs == zipFrom i xs zipFrom False [1..3] == [(False,1),(True, 2)]4extra3 generalised to any combining operation. Truncates the output if the enumeration runs out. -\i xs -> zipWithFrom (,) i xs == zipFrom i xs5extra A merging of  and . 4concatUnzip [("a","AB"),("bc","C")] == ("abc","ABC")6extra A merging of  and . concatUnzip3 [("a","AB",""),("bc","C","123")] == ("abc","ABC","123")7extra A version of  operating from the end. $takeWhileEnd even [2,3,4,6] == [4,6]8extra.Remove spaces from the start of a string, see :.9extra,Remove spaces from the end of a string, see :.:extra=Remove spaces from either side of a string. A combination of 9 and 8. trim " hello " == "hello" trimStart " hello " == "hello " trimEnd " hello " == " hello" \s -> trim s == trimEnd (trimStart s);extraConvert a string to lower case. 9lower "This is A TEST" == "this is a test" lower "" == ""<extraConvert a string to upper case. 9upper "This is A TEST" == "THIS IS A TEST" upper "" == ""=extraSplit the first word off a string. Useful for when starting to parse the beginning of a string, but you want to accurately preserve whitespace in the rest of the string. word1 "" == ("", "") word1 "keyword rest of string" == ("keyword","rest of string") word1 " keyword\n rest of string" == ("keyword","rest of string") \s -> fst (word1 s) == concat (take 1 $ words s) \s -> words (snd $ word1 s) == drop 1 (words s)>extra"Split the first line off a string. line1 "" == ("", "") line1 "test" == ("test","") line1 "test\n" == ("test","") line1 "test\nrest" == ("test","rest") line1 "test\nrest\nmore" == ("test","rest\nmore")?extraEscape a string such that it can be inserted into an HTML document or " attribute without any special interpretation. This requires escaping the <, >, & and ") characters. Note that it will escape " and ' even though that is not required in an HTML body (but is not harmful). escapeHTML "this is a test" == "this is a test" escapeHTML "\"g&t\"" == "<b>"g&t"</n>" escapeHTML "t'was another test" == "t'was another test"@extra Invert of ?& (does not do general HTML unescaping) )\xs -> unescapeHTML (escapeHTML xs) == xsAextraEscape a string so it can form part of a JSON literal. This requires escaping the special whitespace and control characters. Additionally, Note that it does not( add quote characters around the string. escapeJSON "this is a test" == "this is a test" escapeJSON "\ttab\nnewline\\" == "\\ttab\\nnewline\\\\" escapeJSON "\ESC[0mHello" == "\\u001b[0mHello"Bextra&General JSON unescaping, inversion of A and all other JSON escapes. )\xs -> unescapeJSON (escapeJSON xs) == xsCextra A version of 4 where the equality is done on some extracted value. %groupOn abs [1,-1,2] == [[1,-1], [2]]Dextra A version of C which pairs each group with its "key" - the extracted value used for equality testing. 2groupOnKey abs [1,-1,2] == [(1, [1,-1]), (2, [2])]Eextra DEPRECATED Use i", since this function is _O(n^2)_. A version of 8 where the equality is done on some extracted value. nubOn f is equivalent to  nubBy ((==)  f):, but has the performance advantage of only evaluating f, once for each element in the input list.Fextra A version of  where the comparison is done on some extracted value. Raises an error if the list is empty. Only calls the function once per element. maximumOn id [] == undefined maximumOn length ["test","extra","a"] == "extra"Gextra A version of  where the comparison is done on some extracted value. Raises an error if the list is empty. Only calls the function once per element. minimumOn id [] == undefined minimumOn length ["test","extra","a"] == "a"HextraA combination of  and . groupSort [(1,'t'),(3,'t'),(2,'e'),(2,'s')] == [(1,"t"),(2,"es"),(3,"t")] \xs -> map fst (groupSort xs) == sort (nub (map fst xs)) \xs -> concatMap snd (groupSort xs) == map snd (sortOn fst xs)IextraA combination of  and *, using a part of the value to compare on. groupSortOn length ["test","of","sized","item"] == [["of"],["test","item"],["sized"]]JextraA combination of  and ", using a predicate to compare on. groupSortBy (compare `on` length) ["test","of","sized","item"] == [["of"],["test","item"],["sized"]]KextraA strict version of  . Unlike ' this function is always strict in the  argument, whereas the standard version is only strict if the optimiser kicks in. sum' [1, 2, 3] == 6LextraA strict version of $, using a custom valuation function.  sumOn' read ["1", "2", "3"] == 6MextraA strict version of . product' [1, 2, 4] == 8NextraA strict version of $, using a custom valuation function. $productOn' read ["1", "2", "4"] == 8Oextra0Merge two lists which are assumed to be ordered. merge "ace" "bd" == "abcde" \xs ys -> merge (sort xs) (sort ys) == sort (xs ++ ys)PextraLike O&, but with a custom ordering function.Qextra+Replace a subsequence everywhere it occurs. replace "el" "_" "Hello Bella" == "H_lo B_la" replace "el" "e" "Hello" == "Helo" replace "" "x" "Hello" == "xHxexlxlxox" replace "" "x" "" == "x" \xs ys -> replace xs xs ys == ysRextraBreak, but from the end. breakEnd isLower "youRE" == ("you","RE") breakEnd isLower "youre" == ("youre","") breakEnd isLower "YOURE" == ("","YOURE") \f xs -> breakEnd (not . f) xs == spanEnd f xsSextraSpan, but from the end. spanEnd isUpper "youRE" == ("you","RE") spanEnd (not . isSpace) "x y z" == ("x y ","z") \f xs -> uncurry (++) (spanEnd f xs) == xs \f xs -> spanEnd f xs == swap (both reverse (span f (reverse xs)))Textra A variant of  with a custom test. In particular, adjacent separators are discarded, as are leading or trailing separators. wordsBy (== ':') "::xyz:abc::123::" == ["xyz","abc","123"] \s -> wordsBy isSpace s == words sUextra A variant of  with a custom test. In particular, if there is a trailing separator it will be discarded. linesBy (== ':') "::xyz:abc::123::" == ["","","xyz","abc","","123",""] \s -> linesBy (== '\n') s == lines s linesBy (== ';') "my;list;here;" == ["my","list","here"]VextraFind the first element of a list for which the operation returns 2, along with the result of the operation. Like  but useful where the function also computes some expensive information that can be reused. Particular useful when the function is monadic, see  firstJustM. firstJust id [Nothing,Just 3] == Just 3 firstJust id [Nothing,Nothing] == NothingWextraEquivalent to drop 1., but likely to be faster and a single lexeme. drop1 "" == "" drop1 "test" == "est" \xs -> drop 1 xs == drop1 xsXextraEquivalent to  dropEnd 1., but likely to be faster and a single lexeme. dropEnd1 "" == "" dropEnd1 "test" == "tes" \xs -> dropEnd 1 xs == dropEnd1 xsYextra Version on  generalised to a  rather than just a list. mconcatMap Sum [1,2,3] == Sum 6 \f xs -> mconcatMap f xs == concatMap f xsZextraFind the first instance of needle in haystack=. The first element of the returned tuple is the prefix of haystack before needle. is matched. The second is the remainder of haystack6, starting with the match. If you want the remainder without the match, use b. breakOn "::" "a::b::c" == ("a", "::b::c") breakOn "/" "foobar" == ("foobar", "") \needle haystack -> let (prefix,match) = breakOn needle haystack in prefix ++ match == haystack[extra Similar to Z+, but searches from the end of the string.9The first element of the returned tuple is the prefix of haystack( up to and including the last match of needle#. The second is the remainder of haystack, following the match. ,breakOnEnd "::" "a::b::c" == ("a::b::", "c")\extraBreak a list into pieces separated by the first list argument, consuming the delimiter. An empty delimiter is invalid, and will cause an error to be raised. splitOn "\r\n" "a\r\nb\r\nd\r\ne" == ["a","b","d","e"] splitOn "aaa" "aaaXaaaXaaaXaaa" == ["","X","X","X",""] splitOn "x" "x" == ["",""] splitOn "x" "" == [""] \s x -> s /= "" ==> intercalate s (splitOn s x) == x \c x -> splitOn [c] x == split (==c) x]extraSplits a list into components delimited by separators, where the predicate returns True for a separator element. The resulting components do not contain the separators. Two adjacent separators result in an empty component in the output. split (== 'a') "aabbaca" == ["","","bb","c",""] split (== 'a') "" == [""] split (== ':') "::xyz:abc::123::" == ["","","xyz","abc","","123","",""] split (== ',') "my,list,here" == ["my","list","here"]^extra A version of ; but with different strictness properties. The function  can be used on an infinite list and tests the property on each character. In contrast, ^ is strict in the spine of the list but only tests the trailing suffix. This version usually outperforms  if the list is short or the test is expensive. Note the tests below cover both the prime and non-prime variants. dropWhileEnd isSpace "ab cde " == "ab cde" dropWhileEnd' isSpace "ab cde " == "ab cde" last (dropWhileEnd even [undefined,3]) == undefined last (dropWhileEnd' even [undefined,3]) == 3 head (dropWhileEnd even (3:undefined)) == 3 head (dropWhileEnd' even (3:undefined)) == undefined_extraDrops the given prefix from a list. It returns the original sequence if the sequence doesn't start with the given prefix. dropPrefix "Mr. " "Mr. Men" == "Men" dropPrefix "Mr. " "Dr. Men" == "Dr. Men"`extraDrops the given suffix from a list. It returns the original sequence if the sequence doesn't end with the given suffix. dropSuffix "!" "Hello World!" == "Hello World" dropSuffix "!" "Hello World!!" == "Hello World!" dropSuffix "!" "Hello World." == "Hello World."aextraReturn the prefix of the second list if its suffix matches the entire first list. Examples: stripSuffix "bar" "foobar" == Just "foo" stripSuffix "" "baz" == Just "baz" stripSuffix "foo" "quux" == NothingbextraReturn the the string before and after the search string, or % if the search string is not present. Examples: stripInfix "::" "a::b::c" == Just ("a", "b::c") stripInfix "/" "foobar" == Nothingcextra Similar to b+, but searches from the end of the string. 2stripInfixEnd "::" "a::b::c" == Just ("a::b", "c")dextraSplit a list into chunks of a given size. The last chunk may contain fewer than n elements. The chunk size must be positive. chunksOf 3 "my test" == ["my ","tes","t"] chunksOf 3 "mytest" == ["myt","est"] chunksOf 8 "" == [] chunksOf 0 "test" == undefinedeextra O(n log n). The e function sorts and removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. nubSort "this is a test" == " aehist" \xs -> nubSort xs == nub (sort xs)fextra A version of e* which operates on a portion of the value. >nubSortOn length ["a","test","of","this"] == ["a","of","test"]gextra A version of e with a custom predicate. nubSortBy (compare `on` length) ["a","test","of","this"] == ["a","of","test"]hextra O(n log n). The h function removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. Unlike the standard $ operator, this version requires an 7 instance and consequently runs asymptotically faster. nubOrd "this is a test" == "this ae" nubOrd (take 4 ("this" ++ undefined)) == "this" \xs -> nubOrd xs == nub xsiextra A version of h* which operates on a portion of the value. =nubOrdOn length ["a","test","of","this"] == ["a","test","of"]jextra A version of h with a custom predicate. nubOrdBy (compare `on` length) ["a","test","of","this"] == ["a","test","of"]kextraLike , but keep going to the longest value. The function argument will always be given at least one *, and while both lists have items, two  values. zipWithLongest (,) "a" "xyz" == [(Just 'a', Just 'x'), (Nothing, Just 'y'), (Nothing, Just 'z')] zipWithLongest (,) "a" "x" == [(Just 'a', Just 'x')] zipWithLongest (,) "" "x" == [(Nothing, Just 'x')]lextraLazily compare the length of a  with a number. compareLength [1,2,3] 1 == GT compareLength [1,2] 2 == EQ \(xs :: [Int]) n -> compareLength xs n == compare (length xs) n compareLength (1:2:3:undefined) 2 == GTmextra!Lazily compare the length of two s. > comparingLength [1,2,3] [False] == GT > comparingLength [1,2] "ab" == EQ > (xs :: [Int]) (ys :: [Int]) -> comparingLength xs ys == Data.Ord.comparing length xs ys > comparingLength  1:2:3:undefined1,27 == LT > comparingLength (1:2:3:undefined) [1,2] == GT;<:89=>?A@B102RS^7abc_`TUZ[\]d'()*+,-.WXYlm/HIJhjiECDegfFGKMLN"#$&% !V5634kQOP;<:89=>?A@B102RS^7abc_`TUZ[\]d'()*+,-.WXYlm/HIJhjiECDegfFGKMLN"#$&% !V5634kQOP  Safe-Inferred/XoextraRead a  or throw an exception. \x -> readVersion (showVersion x) == x readVersion "hello" == undefinedoo  Safe-InferredapextraO(n)(. Append an element to a non-empty list. ((1 :| [2,3]) |> 4 |> 5 == 1 :| [2,3,4,5]qextra Synonym for p.rextraO(n). Append an element to a list. #[1,2,3] |: 4 |> 5 == 1 :| [2,3,4,5]sextra+A total variant of the list index function s. (2 :| [3,4]) !? 1 == Just 3 (2 :| [3,4]) !? (-1) == Nothing (1 :| []) !? 1 == Nothingtextra"Append a list to a non-empty list. ,appendl (1 :| [2,3]) [4,5] == 1 :| [2,3,4,5]uextra"Append a non-empty list to a list. ,appendr [1,2,3] (4 :| [5]) == 1 :| [2,3,4,5]vextraSort by comparing the results of a function applied to each element. The sort is stable, and the function is evaluated only once for each element.wextraReturn the union of two non-empty lists. Duplicates, and elements of the first list, are removed from the the second list, but if the first list contains duplicates, so will the result. (1 :| [3, 5, 3]) `union` (4 :| [5, 3, 5, 2]) == 1 :| [3, 5, 3, 4, 2]xextranubOrd for . Behaves the same as  . Data.List.NonEmpty.Extra.nubOrd (1 :| [2, 3, 3, 4, 1, 2]) == 1 :| [2, 3, 4] \xs -> Data.List.NonEmpty.Extra.nubOrd xs == Data.List.NonEmpty.Extra.nub xsyextranubOrdBy for . Behaves the same as  . Data.List.NonEmpty.Extra.nubOrdBy (compare `on` Data.List.length) ("a" :| ["test","of","this"]) == "a" :| ["test","of"]zextranubOrdOn for . Behaves the same as  . Data.List.NonEmpty.Extra.nubOrdOn Data.List.length ("a" :| ["test","of","this"]) == "a" :| ["test","of"]{extraThe non-overloaded version of w.|extra(The largest element of a non-empty list.}extra&The least element of a non-empty list.~extraThe largest element of a non-empty list with respect to the given comparison function.extraThe least element of a non-empty list with respect to the given comparison function.extra A version of |6 where the comparison is done on some extracted value.extra A version of }6 where the comparison is done on some extracted value.extraA strict variant of variant extraApply some operation repeatedly, producing an element of output and the remainder of the list.rpqstuvw{xyz|}~rpqstuvw{xyz|}~p5r5s9  Safe-Inferred/hextraThe ( function extracts the element out of a + and throws an error if its argument is . Much like fromJust=, using this function in polished code is usually a bad idea. \x -> fromLeft' (Left x) == x \x -> fromLeft' (Right x) == undefinedextraThe ( function extracts the element out of a + and throws an error if its argument is . Much like fromJust=, using this function in polished code is usually a bad idea. \x -> fromRight' (Right x) == x \x -> fromRight' (Left x) == undefinedextraPull the value out of an / where both alternatives have the same type. ?\x -> fromEither (Left x ) == x \x -> fromEither (Right x) == xextraGiven a , convert it to an (, providing a suitable value for the  should the value be . \a b -> maybeToEither a (Just b) == Right b \a -> maybeToEither a Nothing == Left aextra Given an , convert it to a , where  becomes . \x -> eitherToMaybe (Left x) == Nothing \x -> eitherToMaybe (Right x) == Just xextraThe  function takes a function and applies it to an Either value iff the value takes the form  _. mapLeft show (Left 1) == Left "1" mapLeft show (Right True) == Right TrueextraThe  function takes a function and applies it to an Either value iff the value takes the form  _. mapRight show (Left 1) == Left 1 mapRight show (Right True) == Right "True"  Safe-Inferred/s_extraFully evaluate an input String. If the String contains embedded exceptions it will produce  . stringException "test" == pure "test" stringException ("test" ++ undefined) == pure "test" stringException ("test" ++ undefined ++ "hello") == pure "test" stringException ['t','e','s','t',undefined] == pure "test"extraShow a value, but if the result contains exceptions, produce   . Defined as  . show. Particularly useful for printing exceptions to users, remembering that exceptions can themselves contain undefined values.extra+Ignore any exceptions thrown by the action. =ignore (print 1) == print 1 ignore (fail "die") == pure ()extraAn " action that when evaluated calls  , in the  monad. Note that while  in  raises an , this function raises an  exception with a call stack. catch (errorIO "Hello") (\(ErrorCall x) -> pure x) == pure "Hello" seq (errorIO "foo") (print 1) == print 1extraAn " action that when evaluated calls  in the  monad, which throws an  exception if the argument is %. With optimizations enabled (and -fgnore-asserts6) this function ignores its argument and does nothing. catch (assertIO True >> pure 1) (\(x :: AssertionFailed) -> pure 2) == pure 1 seq (assertIO False) (print 1) == print 1extraRetry an operation at most n times (n2 must be positive). If the operation fails the n+th time it will throw that final exception. retry 1 (print "x") == print "x" retry 3 (fail "die") == fail "die"extraRetry an operation at most n times (n must be positive), while the exception value and type match a predicate. If the operation fails the n+th time it will throw that final exception.extra A version of  without the  context, restricted to , so catches all exceptions.extraLike  but for extraLike  but for extraLike  but for extraLike  but for extraLike  but for extraCatch an exception if the predicate passes, then call the handler with the original exception. As an example: readFileExists x == catchBool isDoesNotExistError (readFile "myfile") (const $ pure "") extraLike  but for .extraLike  but for .  Safe-Inferred/!extraPerform some operation on , given the field inside the . This is a specialized . whenJust Nothing print == pure () whenJust (Just 1) print == print 1extraLike $, but where the test can be monadic.extraReturn either a  value if a condition is  , otherwise . pureIf @Maybe True 5 == Just 5 pureIf @Maybe False 5 == Nothing pureIf @[] True 5 == [5] pureIf @[] False 5 == []extraLike , but return either  if the predicate was , or $ with the result of the computation. whenMaybe True (print 1) == fmap Just (print 1) whenMaybe False (print 1) == pure NothingextraLike $, but where the test can be monadic.extra>The identity function which requires the inner argument to be ()7. Useful for functions with overloaded return types. \(x :: Maybe ()) -> unit x == xextraMonadic generalisation of .extraMonadic generalisation of .extraMonadic generalisation of .extra A variant of  that has no base case, and thus may only be applied to non-empty lists. fold1M (\x y -> Just x) [] == undefined fold1M (\x y -> Just $ x + y) [1, 2, 3] == Just 6extraLike  but discards the result.extra A version of  partition% that works with a monadic predicate. partitionM (Just . even) [1,2,3] == Just ([2], [1,3]) partitionM (const Nothing) [1,2,3] == Nothingextra A version of % that works with a monadic predicate.extraLike , but has its arguments flipped, so can be used instead of the common fmap concat $ forM pattern.extra A version of  mconcatMap% that works with a monadic predicate.extra A version of % that works with a monadic predicate.extra1A looping operation, where the predicate returns # as a seed for the next loop or  to abort the loop. loop (\x -> if x < 10 then Left $ x * 2 else Right $ show x) 1 == "16"extraA monadic version of , where the predicate returns # as a seed for the next loop or  to abort the loop.extra+Keep running an operation until it becomes . As an example: whileM $ do sleep 0.1; notM $ doesFileExist "foo.txt" readFile "foo.txt" 8If you need some state persisted between each test, use .extra-Keep running an operation until it becomes a 0, accumulating the monoid results inside the $s as the result of the overall loop.extra-Keep running an operation until it becomes a &, then return the value inside the # as the result of the overall loop.extraLike $, but where the test can be monadic.extraLike $, but where the test can be monadic.extraLike if$, but where the test can be monadic.extraLike $, but where the test can be monadic.extra The lazy  operator lifted to a monad. If the first argument evaluates to . the second argument will not be evaluated. Just True ||^ undefined == Just True Just False ||^ Just True == Just True Just False ||^ Just False == Just Falseextra The lazy  operator lifted to a monad. If the first argument evaluates to . the second argument will not be evaluated. Just False &&^ undefined == Just False Just True &&^ Just True == Just True Just True &&^ Just False == Just Falseextra A version of ; lifted to a monad. Retains the short-circuiting behaviour. anyM Just [False,True ,undefined] == Just True anyM Just [False,False,undefined] == undefined \(f :: Int -> Maybe Bool) xs -> anyM f xs == orM (map f xs)extra A version of ; lifted to a monad. Retains the short-circuiting behaviour. allM Just [True,False,undefined] == Just False allM Just [True,True ,undefined] == undefined \(f :: Int -> Maybe Bool) xs -> anyM f xs == orM (map f xs)extra A version of ; lifted to a monad. Retains the short-circuiting behaviour. orM [Just False,Just True ,undefined] == Just True orM [Just False,Just False,undefined] == undefined \xs -> Just (or xs) == orM (map Just xs)extra A version of ; lifted to a monad. Retains the short-circuiting behaviour. andM [Just True,Just False,undefined] == Just False andM [Just True,Just True ,undefined] == undefined \xs -> Just (and xs) == andM (map Just xs)extraLike find$, but where the test can be monadic. findM (Just . isUpper) "teST" == Just (Just 'S') findM (Just . isUpper) "test" == Just Nothing findM (Just . const True) ["x",undefined] == Just (Just "x")extraLike , but also allows you to compute some additional information in the predicate.!  Safe-Inferred extraComposition of  and extraA generalization of   to  instances.extraA generalization of  ! to  instances.extraA generalization of  " to  instances.extraA generalization of  # to  instances.extraA generalization of  $ to 3 instances. Retains the short-circuiting behaviour.extraA generalization of  % to 3 instances. Retains the short-circuiting behaviour.extraA generalization of  & to 3 instances. Retains the short-circuiting behaviour.extraA generalization of  ' to 3 instances. Retains the short-circuiting behaviour.extraA generalization of  ( to  instances.extraA generalization of  ) to  instances.1  Safe-Inferred/ extra=Starts out empty, then is filled exactly once. As an example: bar <-  forkIO $ do ...; val <- ...;  bar val print =<<  bar Here we create a barrier which will contain some computed value. A thread is forked to fill the barrier, while the main thread waits for it to complete. A barrier has similarities to a future or promise from other languages, has been known as an IVar in other Haskell work, and in some ways is like a manually managed thunk.extraLike an , but must always be full. Used to operate on a mutable variable in a thread-safe way. As an example: hits <-  0 forkIO $ do ...;  hits (+1); ... i <-  hits print ("HITS",i) Here we have a variable which we modify atomically, so modifications are not interleaved. This use of  never blocks on a put. No modifyVar operation should ever block, and they should always complete in a reasonable timeframe. A  should not be used to protect some external resource, only the variable contained within. Information from a 6 should not be subsequently inserted back into the .extraLike an , but has no value. Used to guarantee single-threaded access, typically to some system resource. As an example: lock <-  let output =  lock . putStrLn forkIO $ do ...; output "hello" forkIO $ do ...; output "world" Here we are creating a lock to ensure that when writing output our messages do not get interleaved. This use of  never blocks on a put. It is permissible, but rare, that a withLock contains a withLock inside it - but if so, watch out for deadlocks.extraOn GHC 7.6 and above with the  -threaded flag, brackets a call to #. On lower versions (which lack .) this function just runs the argument action.extraGiven an action, produce a wrapped action that runs at most once. If the function raises an exception, the same exception will be reraised each time. let x ||| y = do t1 <- onceFork x; t2 <- onceFork y; t1; t2 \(x :: IO Int) -> void (once x) == pure () \(x :: IO Int) -> join (once x) == x \(x :: IO Int) -> (do y <- once x; y; y) == x \(x :: IO Int) -> (do y <- once x; y ||| y) == xextraLike , but immediately starts running the computation on a background thread. \(x :: IO Int) -> join (onceFork x) == x \(x :: IO Int) -> (do a <- onceFork x; a; a) == xextra Create a new .extra%Perform some operation while holding 6. Will prevent all other operations from using the  while the action is ongoing.extraLike  but will never block. If the operation cannot be executed immediately it will return .extra Create a new  with a value.extraRead the current value of the .extra)Write a value to become the new value of .extraStrict variant of extra Modify a + producing a new value and a return result.extraStrict variant of extra Modify a , a restricted version of .extraStrict variant of extra.Perform some operation using the value in the , a restricted version of .extra Create a new .extra4Write a value into the Barrier, releasing anyone at +. Any subsequent attempts to signal the  will throw an exception.extra,Wait until a barrier has been signaled with .extra A version of  that never blocks, returning - if the barrier has not yet been signaled. Safe-InferredextraList the files and directories directly within a directory. Each result will be prefixed by the query directory, and the special directories . and ..9 will be ignored. Intended as a cleaned up version of . withTempDir $ \dir -> do writeFile (dir "test.txt") ""; (== [dir "test.txt"]) <$> listContents dir let touch = mapM_ $ \x -> createDirectoryIfMissing True (takeDirectory x) >> writeFile x "" let listTest op as bs = withTempDir $ \dir -> do touch $ map (dir ) as; res <- op dir; pure $ map (drop (length dir + 1)) res == bs listTest listContents ["bar.txt","foo/baz.txt","zoo"] ["bar.txt","foo","zoo"]extraLike , but only returns the directories in a directory, not the files. Each directory will be prefixed by the query directory. listTest listDirectories ["bar.txt","foo/baz.txt","zoo"] ["foo"]extraLike , but only returns the files in a directory, not other directories. Each file will be prefixed by the query directory. listTest listFiles ["bar.txt","foo/baz.txt","zoo"] ["bar.txt","zoo"]extraLike , but goes recursively through all subdirectories. This function will follow symlinks, and if they form a loop, this function will not terminate. listTest listFilesRecursive ["bar.txt","zoo","foo" "baz.txt"] ["bar.txt","zoo","foo" "baz.txt"]extraLike , but with a predicate to decide where to recurse into. Typically directories starting with . would be ignored. The initial argument directory will have the test applied to it. listTest (listFilesInside $ pure . not . isPrefixOf "." . takeFileName) ["bar.txt","foo" "baz.txt",".foo" "baz2.txt", "zoo"] ["bar.txt","zoo","foo" "baz.txt"] listTest (listFilesInside $ const $ pure False) ["bar.txt"] []extraCreate a directory with permissions so that only the current user can view it. On Windows this function is equivalent to .* Safe-Inferred  Safe-InferredextraLike , but setting an encoding.extraLike , but with the encoding .extraLike , but for binary files.extraA strict version of , see  for details.extraA strict version of , see  for details.extraA strict version of , see  for details.extra(Write a file with a particular encoding.extraWrite a file with the  encoding. \s -> withTempFile $ \file -> do writeFileUTF8 file s; fmap (== s) $ readFileUTF8' fileextraWrite a binary file. \(ASCIIString s) -> withTempFile $ \file -> do writeFileBinary file s; fmap (== s) $ readFileBinary' fileextra Capture the  and  of a computation. *captureOutput (print 1) == pure ("1\n",())extra Execute an action with a custom , a wrapper around .extraProvide a function to create a temporary file, and a way to delete a temporary file. Most users should use $ which combines these operations.extraLike ( but using a custom temporary directory.extraCreate a temporary file in the temporary directory. The file will be deleted after the action completes (provided the file is not still open). The  will not have any file extension, will exist, and will be zero bytes long. If you require a file with a specific name, use . withTempFile doesFileExist == pure True (doesFileExist =<< withTempFile pure) == pure False withTempFile readFile' == pure ""extraProvide a function to create a temporary directory, and a way to delete a temporary directory. Most users should use $ which combines these operations.extraLike ( but using a custom temporary directory.extraCreate a temporary directory inside the system temporary directory. The directory will be deleted after the action completes. withTempDir doesDirectoryExist == pure True (doesDirectoryExist =<< withTempDir pure) == pure False withTempDir listFiles == pure []extraReturns $ when both files have the same size.extraReturns - when the contents of both files is the same.extraReturns  if both files have the same content. Raises an error if either file is missing. fileEq "does_not_exist1" "does_not_exist2" == undefined fileEq "does_not_exist" "does_not_exist" == undefined withTempFile $ \f1 -> fileEq "does_not_exist" f1 == undefined withTempFile $ \f1 -> withTempFile $ \f2 -> fileEq f1 f2 withTempFile $ \f1 -> withTempFile $ \f2 -> writeFile f1 "a" >> writeFile f2 "a" >> fileEq f1 f2 withTempFile $ \f1 -> withTempFile $ \f2 -> writeFile f1 "a" >> writeFile f2 "b" >> notM (fileEq f1 f2) Safe-InferredextraReturn  on Windows and ! otherwise. A runtime version of #ifdef minw32_HOST_OS. Equivalent to os == "mingw32", but: more efficient; doesn't require typing an easily mistypeable string; actually asks about your OS not a library; doesn't bake in 32bit assumptions that are already false. isWindows == (os == "mingw32")extraReturn  on Mac OS X and  otherwise. Safe-Inferred/aextra A version of % that also captures the output, both  and . Returns a pair of the  and the output.extra A version of  that throws an error if the  is not .extra A version of  that captures the output (both  and  ) and throws an error if the  is not .; Safe-Inferred7extra.A type alias for seconds, which are stored as .extraSleep for a number of seconds. 1fmap (round . fst) (duration $ sleep 1) == pure 1extra A version of +, that takes ) and never overflows the bounds of an . In addition, the bug that negative timeouts run for ever has been fixed. timeout (-3) (print 1) == pure Nothing timeout 0.1 (print 1) == fmap Just (print 1) do (t, _) <- duration $ timeout 0.1 $ sleep 1000; print t; pure $ t < 1 timeout 0.1 (sleep 2 >> print 1) == pure NothingextraShow a number of seconds, typically a duration, in a suitable manner with reasonable precision for a human. showDuration 3.435 == "3.44s" showDuration 623.8 == "10m24s" showDuration 62003.8 == "17h13m" showDuration 1e8 == "27777h47m"extraCall once to start, then call repeatedly to get the elapsed time since the first call. The time is guaranteed to be monotonic. This function is robust to system time changes. ?do f <- offsetTime; xs <- replicateM 10 f; pure $ xs == sort xsextraA synonym for .extra'Record how long a computation takes in . 9do (a,_) <- duration $ sleep 1; pure $ a >= 1 && a <= 1.5 Safe-Inferred;<:89=>?A@B102RS^7abc_`TUZ[\]d'()*+,-.WXYlm/HIJhjiECDegfFGKMLN"#$&% !V5634kQOPrptu|}~  o;<:89=>?A@B102RS^7abc_`TUZ[\]d'()*+,-.WXYlm/HIJhjiECDegfFGKMLN"#$&% !V5634kQOPrptu|}~  o- Safe-Inferred)./0.12.13.456789:;<=>?@ABCDEFGHIJKLMNOP 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 { " ! # | } ~                                _  Z                Q                            $ % & ' ( ) [ ! " # $ % & ' ( ),................................................................................................................................................................................................................................................................................................................................^..............1.1.1..1.1.1.1.1.1./..............................................................................................................................................................................................................6767666666666666667676767676767676767676767676767676767676767676767676767676767676767676767676767676767676767676767676767............4....................................4.4.4.4...4....4..............................................4.4.4.4.4.4.4.4.4.4.4.4.4.4.4................................................#extra-1.7.15-7QX4U0zpBLiCeH7XGdrkFNControl.Exception.ExtraData.Either.ExtraSystem.IO.ExtraExtraData.IORef.ExtraData.Monoid.ExtraData.Tuple.Extra Numeric.ExtraData.List.ExtraData.Version.ExtraData.List.NonEmpty.ExtraControl.Monad.ExtraData.Foldable.ExtraControl.Concurrent.ExtraSystem.Directory.ExtraSystem.Info.ExtraSystem.Process.ExtraSystem.Time.Extraextra Control.Monadwhen Control.Arrow***&&&Data.Typeable.ExtraPartialnubOrdnubOrdBynubOrdOn Data.Foldablefor_sum'product'sumOn' productOn'anyMallMorMandMfindM firstJustMSystem.Environment.ExtraSystem.TimeouttimeoutText.Read.ExtrabaseGHC.ErrerrorWithoutStackTrace Data.EitherfromLeft fromRight System.IO readFile'directory-1.3.8.1System.DirectorywithCurrentDirectory writeIORef'atomicWriteIORef'atomicModifyIORef_atomicModifyIORef'_mwhenfirstsecondfirstMsecondMdupebothfst3snd3thd3curry3uncurry3first3second3third3showDP intToDouble intToFloat floatToDouble doubleToFloat repeatedly repeatedlyNEdisjoint disjointOrd disjointOrdByanySameallSameheadDeflastDef!?notNulllistunsnocconssnoc enumeratetakeEnddropEnd splitAtEndzipFrom zipWithFrom concatUnzip concatUnzip3 takeWhileEnd trimStarttrimEndtrimlowerupperword1line1 escapeHTML unescapeHTML escapeJSON unescapeJSONgroupOn groupOnKeynubOn maximumOn minimumOn groupSort groupSortOn groupSortBymergemergeByreplacebreakEndspanEndwordsBylinesBy firstJustdrop1dropEnd1 mconcatMapbreakOn breakOnEndsplitOnsplit dropWhileEnd' dropPrefix dropSuffix stripSuffix stripInfix stripInfixEndchunksOfnubSort nubSortOn nubSortByzipWithLongest compareLengthcomparingLength$fShowRB readVersion|>|:appendlappendrsortOnunionunionBymaximum1minimum1 maximumBy1 minimumBy1 maximumOn1 minimumOn1foldl1' fromLeft' fromRight' fromEither maybeToEither eitherToMaybemapLeftmapRightstringException showExceptionignoreerrorIOassertIOretry retryBoolcatch_ catchJust_handle_ handleJust_try_tryJust_ catchBool handleBooltryBoolwhenJust whenJustMpureIf whenMaybe whenMaybeMunitmaybeM fromMaybeMeitherMfold1Mfold1M_ partitionM concatMapM concatForM mconcatMapM mapMaybeMlooploopMwhileM whileJustM untilJustMwhenMunlessMifMnotM||^&&^BarrierVarLockwithNumCapabilitiesonceonceForknewLockwithLock withLockTrynewVarreadVarwriteVar writeVar' modifyVar modifyVar' modifyVar_ modifyVar_'withVar newBarrier signalBarrier waitBarrierwaitBarrierMaybe listContentslistDirectories listFileslistFilesRecursivelistFilesInsidecreateDirectoryPrivatereadFileEncoding readFileUTF8readFileBinaryreadFileEncoding' readFileUTF8'readFileBinary'writeFileEncoding writeFileUTF8writeFileBinary captureOutput withBuffering newTempFilenewTempFileWithin withTempFile newTempDirnewTempDirWithin withTempDirfileEq isWindowsisMac systemOutputsystem_ systemOutput_Secondssleep showDuration offsetTimeoffsetTimeIncreaseduration$fExceptionTimeout $fShowTimeout $fEqTimeout GHC.IORef writeIORef Data.IORefatomicWriteIORefatomicModifyIORefatomicModifyIORef'IORefnewIORef readIORef mkWeakIORef modifyIORef modifyIORef'GHC.BaseMonoidghc-prim GHC.TypesTruememptyData.Semigroup.InternalAnygetAnySumgetSumProduct getProduct Data.MonoidLastgetLastFirstgetFirstmappendmconcatAltgetAltAllgetAllEndoappEndoDualgetDualApgetAp<> Data.Tuplefstsnd GHC.TupleSolouncurrycurryswapTyConData.Typeable.InternalTypeable Data.TypeableTypeRepData.Type.Equality:~~:HRefl:~:Refl Data.ProxyProxy tyConPackage tyConModule tyConNametyConFingerprintrnfTyContypeRepFingerprint trLiftedRep typeRepTyContypeReptypeOf rnfTypeRep showsTypeRepcasteqTheqTgcastgcast1gcast2 funResultTymkFunTy splitTyConApp typeRepArgstypeOf1typeOf2typeOf3typeOf4typeOf5typeOf6typeOf7GHC.Real fromIntegral realToFrac GHC.FloatFloatingpiexplogsqrt**logBasesincostanasinacosatansinhcoshtanhasinhacoshatanhlog1pexpm1log1pexplog1mexp showSigned showFloat floatToDigitsfromRatGHC.Read lexDigitsNumericreadIntreadBinreadOctreadDecreadHex readFloat readSignedshowInt showEFloat showFFloat showGFloat showFFloatAlt showGFloatAlt showHFloat showIntAtBaseshowHexshowOctshowBinGHC.Listheadlast!! GHC.Classesnotnull Data.Maybemaybe GHC.MaybeNothinginitGHC.EnumEnumminBoundmaxBoundzipunzipconcatunzip3 takeWhile Data.OldListgroupnub Data.FunctiononmaximumminimumsortsumGHC.NumNumproductwordslinesJustfind concatMap dropWhileEndOrdzipWithFoldablesortBy genericLength maximumBy minimumBygenericReplicate genericTake genericDropgenericSplitAt genericIndexlengthfoldlfoldrfoldl'foldl1foldr1elemgroupByfilterunfoldr transposecycle++mapunconstailscanlscanl1scanl'scanrscanr1iterateiterate'repeat replicate dropWhiletakedropsplitAtspanbreakreverseandoranyallnotElemlookupzip3zipWith3 stripPrefix elemIndex elemIndices findIndex findIndices isPrefixOf isSuffixOf isInfixOfnubBydeletedeleteBy\\ intersect intersectBy intersperse intercalate partitionData.Traversable mapAccumL mapAccumRinsertinsertByzip4zip5zip6zip7zipWith4zipWith5zipWith6zipWith7unzip4unzip5unzip6unzip7deleteFirstsByinitstails subsequences permutations singletonunlinesunwords Data.ListisSubsequenceOf Data.VersionVersion versionBranch versionTags makeVersion showVersion parseVersionNonEmpty:|Data.List.NonEmptyfromListtoListxorunfoldnonEmpty<|inits1tails1some1 groupWith groupAllWithgroup1groupBy1 groupWith1 groupAllWith1sortWithappend appendList prependListLeftRightEitherMaybeeitherleftsrightspartitionEithersisLeftisRightIOerrorControl.Monad.FailfailGHC.IO.Exception IOException GHC.Exception ErrorCallassertAssertionFailedFalseGHC.IOcatchGHC.Exception.Type Exception SomeExceptionControl.Exception.Base catchJusthandle handleJusttrytryJust toException fromExceptiondisplayExceptionBlockedIndefinitelyOnMVar TypeErrorArithException UnderflowOverflowLossOfPrecision DivideByZeroDenormalRatioZeroDenominatorErrorCallWithLocation MaskingStateUnmaskedMaskedInterruptibleMaskedUninterruptibleArrayExceptionIndexOutOfBoundsUndefinedElementAsyncException StackOverflow HeapOverflow ThreadKilled UserInterruptSomeAsyncExceptionCompactionFailedAllocationLimitExceededDeadlockBlockedIndefinitelyOnSTMNestedAtomicallyNonTermination NoMethodError RecUpdError RecConError RecSelErrorPatternMatchFailControl.ExceptionHandlerthrowbracket GHC.Conc.SyncthrowTomaskthrowIO interruptiblegetMaskingState onExceptionmask_uninterruptibleMask_uninterruptibleMaskfinallyevaluateasyncExceptionToExceptionasyncExceptionFromExceptionioError mapExceptionbracket_bracketOnErrorcatchesallowInterruptpureempty fromMaybefoldMmapMaybeunless||&& MonadPlusmzeromplusMonad>>=return>>Functorfmap<$ MonadFailmapMsequenceforMforeverliftMguardjoin=<<liftM2liftM3liftM4liftM5ap Data.FunctorvoidmapM_forM_ sequence_msumfilterM>=><=< mapAndUnzipMzipWithM zipWithM_foldM_ replicateM replicateM_<$!>mfilterfoldr'foldfoldMapfoldMap'foldrMfoldlM traverse_ sequenceA_asumGHC.MVarMVarsetNumCapabilitiesControl.Concurrent.ChanChanThreadIdControl.Concurrent.QSemNQSemNControl.Concurrent.QSemQSemforkIOWithUnmaskforkIO killThread GHC.Conc.IO threadDelayControl.ConcurrentforkOS forkFinally newEmptyMVarnewMVartakeMVarreadMVarputMVar tryTakeMVar tryPutMVar tryReadMVar isEmptyMVarControl.Concurrent.MVaraddMVarFinalizer myThreadIdforkOnforkOnWithUnmaskgetNumCapabilitiesyieldthreadCapabilitymkWeakThreadIdwithMVar modifyMVar_swapMVarwithMVarMasked modifyMVarmodifyMVarMasked_modifyMVarMasked mkWeakMVarthreadWaitReadthreadWaitWritethreadWaitReadSTMthreadWaitWriteSTMnewQSemN waitQSemN signalQSemNnewQSemwaitQSem signalQSemnewChan writeChanreadChandupChangetChanContentswriteList2ChanrtsSupportsBoundThreadsforkOSWithUnmaskisCurrentThreadBoundrunInBoundThreadrunInUnboundThreadgetDirectoryContentscreateDirectory System.Directory.Internal.CommonXdgDirectoryList XdgDataDirs XdgConfigDirs XdgDirectoryXdgData XdgConfigXdgCacheXdgState Permissionsreadablewritable executable searchableremoveDirectory removeFileemptyPermissionssetOwnerReadablesetOwnerWritablesetOwnerExecutablesetOwnerSearchablegetPermissionssetPermissionscopyPermissionscreateDirectoryIfMissingremoveDirectoryRecursiveremovePathForciblyrenameDirectory renameFile renamePathcopyFilecopyFileWithMetadatacanonicalizePath makeAbsolutemakeRelativeToCurrentDirectoryfindExecutablefindExecutablesfindExecutablesInDirectoriesfindFile findFiles findFileWith findFilesWith exeExtension listDirectorygetCurrentDirectorysetCurrentDirectory getFileSize doesPathExistdoesDirectoryExist doesFileExistcreateFileLinkcreateDirectoryLinkremoveDirectoryLinkpathIsSymbolicLinkgetSymbolicLinkTarget getAccessTimegetModificationTime setAccessTimesetModificationTimegetHomeDirectorygetXdgDirectorygetXdgDirectoryListgetAppUserDataDirectorygetUserDocumentsDirectorygetTemporaryDirectoryisSymbolicLinkSystem.EnvironmentgetArgsgetEnvsetEnv lookupEnvunsetEnv!System.Environment.ExecutablePathgetExecutablePathexecutablePath getProgNamewithArgs withProgNamegetEnvironmentreadFileGHC.IO.Encodingutf8GHC.IO.StdHandlesstdoutstderrGHC.IO.Handle.Types BufferMode GHC.IO.Handle hSetBufferingFilePathsameSize sameContentHandleGHC.IO.Encoding.Types TextEncoding GHC.IO.IOModeIOModeReadMode WriteMode AppendMode ReadWriteMode GHC.IO.DeviceSeekMode AbsoluteSeek RelativeSeek SeekFromEnd NewlineModeinputNLoutputNLNewlineLFCRLF NoBuffering LineBufferingBlockBuffering HandlePosnGHC.IO.Handle.Text hGetContentsopenFilestdinmkTextEncodinghSeekhFlush hLookAheadfixIO writeFilegetLineputStrLnhClosehSetBinaryModelocaleEncodinghGetBufhPutBuf hWaitForInputprint nativeNewlineuniversalNewlineModenativeNewlineModenoNewlineTranslationutf8_bomutf32utf32beutf32leutf16utf16beutf16lelatin1char8hGetCharhGetLine hGetContents'hPutCharhPutStr hPutStrLnhPutBufNonBlocking hGetBufSomehGetBufNonBlockingwithFileopenBinaryFilewithBinaryFile hFileSize hSetFileSizehIsEOFisEOF hSetEncoding hGetEncodinghGetPosnhSetPosnhTellhIsOpen hIsClosed hIsReadable hIsWritable hGetBuffering hIsSeekablehSetEchohGetEchohIsTerminalDevicehSetNewlineModehShowputCharputStrgetChar getContents getContents'interact appendFilereadLnreadIOhReadyhPrint openTempFileopenBinaryTempFile"openTempFileWithDefaultPermissions(openBinaryTempFileWithDefaultPermissions System.InfocompilerVersionfullCompilerVersionosarch compilerNameprocess-1.6.17.0System.ProcesssystemExitCode ExitSuccessSystem.Process.Common ProcessHandle StdStreamInherit UseHandle CreatePipeNoStreamCmdSpec ShellCommand RawCommand CreateProcesscmdspeccwdenvstd_instd_outstd_err close_fds create_group delegate_ctlcdetach_consolecreate_new_console new_session child_group child_useruse_process_jobsPidwaitForProcess createProcessSystem.Process.InternalscreateProcess_ createPipe createPipeFdinterruptProcessGroupOfprocshellwithCreateProcesscleanupProcess spawnProcess spawnCommand callProcess callCommand readProcessreadCreateProcessreadProcessWithExitCodereadCreateProcessWithExitCodeshowCommandForUsergetPid getCurrentPidgetProcessExitCodeterminateProcess runCommand runProcessrunInteractiveCommandrunInteractiveProcess rawSystemDoubleIntRead readsPrecreadListreadPrec readListPrecText.ParserCombinators.ReadPReadS Text.Read.LexLexemeCharSymbolStringNumberPuncIdentEOFText.ParserCombinators.ReadPrecPrecReadPrec Text.Read readMaybegetlookpfail+++<++choicelexminPrecliftstepresetprec readPrec_to_P readP_to_Prec readPrec_to_S readS_to_Prec readParenreadListDefaultreadListPrecDefaultlexPparensreads readEitherread