e      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH 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 vwxyz{|}~  Safe-Inferred Return  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. </rant> isWindows == (os == "mingw32")      Safe-Inferred  Safe-Inferred 2Show a number to a fixed number of decimal places. @showDP 4 pi == "3.1416" showDP 0 pi == "3" showDP 2 3 == "3.00" ;Specialised numeric conversion, type restricted version of .;Specialised numeric conversion, type restricted version of .;Specialised numeric conversion, type restricted version of .;Specialised numeric conversion, type restricted version of .     Safe-Inferred %Update the first component of a pair. #first succ (1,"test") == (2,"test")&Update the second component of a pair. 'second reverse (1,"test") == (1,"tset")iGiven two functions, apply one to the first component and one to the second. A specialised version of . +(succ *** reverse) (1,"test") == (2,"tset")aGiven two functions, apply both to a single argument to form a pair. A specialised version of . (succ &&& pred) 1 == (2,0)%Duplicate a single value into a pair. dupe 12 == (12, 12)5Apply a single function to both components of a pair. both succ (1,2) == (2,3) Extract the  of a triple. Extract the  of a triple.&Extract the final element of a triple.    Safe-InferredE)cApply some operation repeatedly, producing an element of output and the remainder of the list. b\xs -> repeatedly (splitAt 3) xs == chunksOf 3 xs \xs -> repeatedly word1 (trim xs) == words xs Flipped version of . for [1,2,3] (+1) == [2,3,4] 4Are two lists disjoint, with no elements in common. @disjoint [1,2,3] [4,5] == True disjoint [1,2,3] [4,1] == False 2Is 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) Are 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) *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 If the list is empty returns , otherwise returns the  and the . uncons "test" == Just ('t',"est") uncons "" == Nothing \xs -> uncons xs == if null xs then Nothing else Just (head xs, tail xs) !If 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) ">Append an element to the start of a list, an alias for '(:)'. Econs 't' "est" == "test" \x xs -> uncons (cons x xs) == Just (x,xs) #.Append an element to the end of a list, takes O(n) time. Esnoc "tes" 't' == "test" \xs x -> unsnoc (snoc xs x) == Just (xs,x) $4Take 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) %4Drop 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..] & A merging of  and . 5concatUnzip [("a","AB"),("bc","C")] == ("abc","ABC") ' A merging of  and . EconcatUnzip3 [("a","AB",""),("bc","C","123")] == ("abc","ABC","123") ( A version of  operating from the end. %takeWhileEnd even [2,3,4,6] == [4,6] ).Remove spaces from the start of a string, see +. *,Remove spaces from the end of a string, see +. +=Remove spaces from either side of a string. A combination of * and ). trim " hello " == "hello" trimStart " hello " == "hello " trimEnd " hello " == " hello" \s -> trim s == trimEnd (trimStart s) , Convert a string to lower case. ;lower "This is A TEST" == "this is a test" lower "" == "" - Convert a string to upper case. ;upper "This is A TEST" == "THIS IS A TEST" upper "" == "" .Split the first word off a string. Useful for when starting to parse the beginning of a string, but you want to accurately perserve 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) /SSort a list by comparing the results of a key function applied to each element. sortOn f is equivalent to sortBy (comparing f)9, but has the performance advantage of only evaluating f once for each element in the input list. This is called the decorate-sort-undecorate paradigm, or Schwartzian transform. @sortOn fst [(3,"z"),(1,""),(3,"a")] == [(1,""),(3,"z"),(3,"a")] 0 A version of 5 where the equality is done on some extracted value. 1 A version of 9 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. 2A 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) 31Merge two lists which are assumed to be ordered. Tmerge "ace" "bd" == "abcde" \xs ys -> merge (sort xs) (sort ys) == sort (xs ++ ys) 4Like 3', but with a custom ordering function. 5_Replace a subsequence everywhere it occurs. The first argument must not be the empty list. replace "el" "_" "Hello Bella" == "H_lo B_la" replace "el" "e" "Hello" == "Helo" replace "" "e" "Hello" == undefined \xs ys -> not (null xs) ==> replace xs xs ys == ys 6Break, but from the end. }breakEnd isLower "youRE" == ("you","RE") breakEnd isLower "youre" == ("youre","") breakEnd isLower "YOURE" == ("","YOURE") 7Span, but from the end. spanEnd isUpper "youRE" == ("you","RE") spanEnd (not . isSpace) "x y z" == ("x y ","z") \f xs-> spanEnd f xs == swap (both reverse (span f (reverse xs))) 8 A variant of r 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 s 9 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"] :AFind the first element of a list for which the operation returns 3, 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. TfirstJust id [Nothing,Just 3] == Just 3 firstJust id [Nothing,Nothing] == Nothing ;Equivalent to drop 1/, but likely to be faster and a single lexeme. Pdrop1 "" == "" drop1 "test" == "est" \xs -> drop 1 xs == drop1 xs <Find 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 haystack, starting with the match. breakOn "::" "a::b::c" == ("a", "::b::c") breakOn "/" "foobar" == ("foobar", "") \needle haystack -> let (prefix,match) = breakOn needle haystack in prefix ++ match == haystack = Similar to <-, 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") >Break 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. BsplitOn "\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 ?Splits 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"] @ 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, @q is strict in the spine of the list but only tests the trailing suffix. This version usually outperforms v 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 AXReturn the prefix of the second string if its suffix matches the entire first string.  Examples: zstripSuffix "bar" "foobar" == Just "foo" stripSuffix "" "baz" == Just "baz" stripSuffix "foo" "quux" == Nothing BSplit 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" == undefined ) !"#$%&'()*+,-./0123456789:;<=>?@AB      !"#$%&'()*+,-./012345 !"#$%&'()*+,-./0123456789:;<=>?@AB*,-+)*.%$67@(A89<=>?B !"#;210/:&'534) !"#$%&'()*+,-./0123456789:;<=>?@AB Safe-InferredC#Evaluates the value before calling 6. D#Evaluates the value before calling . CD 7896:;<CDCDCD Safe-InferredEThe E( 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. E\x -> fromLeft (Left x) == x \x -> fromLeft (Right x) == undefined FThe F( 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. G\x -> fromRight (Right x) == x \x -> fromRight (Left x) == undefined GPull the value out of an ?1 where both alternatives have the same type. A\x -> fromEither (Left x ) == x \x -> fromEither (Right x) == x EFG ?=> @ABCEFG EFGEFG  Safe-InferredHPerform some operation on , given the field inside the . IwhenJust Nothing print == return () whenJust (Just 1) print == print 1 I>The identity function which requires the inner argument to be ()9. Useful for functions with overloaded return times.  \(x :: Maybe ()) -> unit x == x J A version of  partition& that works with a monadic predicate. epartitionM (Just . even) [1,2,3] == Just ([2], [1,3]) partitionM (const Nothing) [1,2,3] == Nothing K A version of & that works with a monadic predicate. L A version of D& that works with a monadic predicate. M1A looping operation, where the predicate returns =$ as a seed for the next loop or > to abort the loop. N+Keep running an operation until it becomes . As an example:  KwhileM $ do sleep 0.1; notM $ doesFileExist "foo.txt" readFile "foo.txt" 8If you need some state persisted between each test, use M. OLike E%, but where the test can be monadic. PLike F%, but where the test can be monadic. QLike if%, but where the test can be monadic. RLike G%, but where the test can be monadic. S The lazy HD operator lifted to a monad. If the first argument evaluates to 0 the second argument will not be evaluated. xJust True ||^ undefined == Just True Just False ||^ Just True == Just True Just False ||^ Just False == Just False T The lazy ID operator lifted to a monad. If the first argument evaluates to 0 the second argument will not be evaluated. yJust False &&^ undefined == Just False Just True &&^ Just True == Just True Just True &&^ Just False == Just False U A version of  < lifted to a moand. 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) V A version of < lifted to a moand. 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) W A version of !< lifted to a moand. 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) X A version of "< lifted to a moand. 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) YLike 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") ZLike YO, but also allows you to compute some additional information in the predicate. HIJKLMNOPQRSTUVWXYZ<JKLMNOPQRSTUVWXYZFE[\]^_`abcdefghijklmnopHIJKLMNOPQRSTUVWXYZHIMNJKLYZOPQRSTWXUVHIJKLMNOPQRSTUVWXYZ  Safe-Inferred[Set the current directory, perform an operation, then change back. Remember that the current directory is a global variable, so calling this function multithreaded is almost certain to go wrong. Avoid changing the current directory if you can. nwithTempDir $ \dir -> do writeFile (dir </> "foo.txt") ""; withCurrentDirectory dir $ doesFileExist "foo.txt" \List the files and directories directly within a directory. Each result will be prefixed by the query directory, and the special directories . and ..: will be ignored. Intended as a cleaned up version of q. 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; return $ map (drop (length dir + 1)) res == bs listTest listContents ["bar.txt","foo/baz.txt","zoo"] ["bar.txt","foo","zoo"] ]Like \{, but only returns the files in a directory, not other directories. Each file will be prefixed by the query directory. ElistTest listFiles ["bar.txt","foo/baz.txt","zoo"] ["bar.txt","zoo"] ^Like ]3, but goes recursively through all subdirectories. hlistTest listFilesRecursive ["bar.txt","zoo","foo" </> "baz.txt"] ["bar.txt","zoo","foo" </> "baz.txt"] _Like ^`, but with a predicate to decide where to recurse into. Typically directories starting with .X would be ignored. The initial argument directory will have the test applied to it. listTest (listFilesInside $ return . not . isPrefixOf "." . takeFileName) ["bar.txt","foo" </> "baz.txt",".foo" </> "baz2.txt", "zoo"] ["bar.txt","zoo","foo" </> "baz.txt"] listTest (listFilesInside $ const $ return False) ["bar.txt"] [] `}Create a directory with permissions so that only the current user can view it. On Windows this function is equivalent to r. [\]^_`+stuvwxyz{q|}~r[\]^_`[`\]_^[\]^_`  Safe-Inferred a[Fully evaluate an input String. If the String contains embedded exceptions it will produce  <Exception>. (stringException "test" == return "test" stringException ("test" ++ undefined) == return "test<Exception>" stringException ("test" ++ undefined ++ "hello") == return "test<Exception>" stringException ['t','e','s','t',undefined] == return "test<Exception>"b@Show a value, but if the result contains exceptions, produce  <Exception> . Defined as a . show. Particularly useful for printing exceptions to users, remembering that exceptions can themselves contain undefined values.c+Ignore any exceptions thrown by the action. ?ignore (print 1) == print 1 ignore (fail "die") == return ()dRetry an operation at most n times (n2 must be positive). If the operation fails the n+th time it will throw that final exception. Dretry 1 (print "x") == print "x" retry 3 (fail "die") == fail "die"e A version of  without the  context, restricted to , so catches all exceptions.fLike e but for gLike e but for hLike e but for iLike e but for jLike e but for kpCatch an exception if the predicate passes, then call the handler with the original exception. As an example: ZreadFileExists x == catchBool isDoesNotExistError (readFile "myfile") (const $ return "") lLike k but for .mLike k but for .abcdefghijklm]abcdefghijklm dbacegifhjklmabcdefghijklm  Safe-Inferred+n.A type alias for seconds, which are stored as .oSleep for a number of seconds. 3fmap (round . fst) (duration $ sleep 1) == return 1p A version of  that takes n) and never overflows the bounds of an M. In addition, the bug that negative timeouts run for ever has been fixed. timeout (-3) (print 1) == return Nothing timeout 0.1 (print 1) == fmap Just (print 1) timeout 0.1 (sleep 2 >> print 1) == return Nothing do (t, _) <- duration $ timeout 0.1 $ sleep 1000; return $ t < 1qCalculate the difference between two times in seconds. Usually the first time will be the end of an event, and the second time will be the beginning. &\a b -> a > b ==> subtractTime a b > 0rnShow a number of seconds, typically a duration, in a suitable manner with responable precision for a human. showDuration 3.435 == "3.44s" showDuration 623.8 == "10m24s" showDuration 62003.8 == "17h13m" showDuration 1e8 == "27777h47m"sCall once to start, then call repeatedly to get the elapsed time since the first call. Values will usually increase, unless the system clock is updated (if you need the guarantee, see t).tLike sB, but results will never decrease (though they may stay the same). Ido f <- offsetTimeIncrease; xs <- replicateM 10 f; return $ xs == sort xsu'Record how long a computation takes in n. nopqrstunopqrstunopqrstu nopqrstu Safe-InferredEv>Starts out empty, then is filled exactly once. As an example:  bar <-  forkIO $ do ...; val <- ...;  bar val print =<<  bar UHere 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. wrLike an MVar, but must always be full. Used to 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 MVar never blocks on a put. No modifyVar operation should ever block, and they should always complete in a reasonable timeframe. A Var should not be used to protect some external resource, only the variable contained within. Information from a readVar should not be subsequently inserted back into the Var. xLike an MVar, but has no value. Used to guarantees single-threaded access, typically to some system resource. As an example:  lock <- { let output = |O . 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 MVar 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. yOn 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. zGiven 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. { Create a new x. |%Perform some operation while holding x7. Will prevent all other operations from using the x while the action is ongoing. }Like |Z but will never block. If the operation cannot be executed immediately it will return . ~ Create a new w with a value. Read the current value of the w.  Modify a w, producing a new value and a return result.  Modify a w, a restricted version of . .Perform some operation using the value in the w, a restricted version of .  Create a new v. 4Write a value into the Barrier, releasing anyone at ,. Any subsequent attempts to signal the v will throw an exception. ,Wait until a barrier has been signaled with .  A version of  that never blocks, returning / if the barrier has not yet been signaled. vwxyz{|}~M      !"#$%&'()*+vwxyz{|}~yzx{|}w~vvwxyz{|}~  Safe-InferredMLike ,, but setting an encoding.Like ,, but with the encoding -.Like ,, but for binary files.A strict version of ,. When the string is produced, the entire file will have been read into memory and the file handle will have been closed. Closing the file handle does not rely on the garbage collector. f\(filter isHexDigit -> s) -> fmap (== s) $ withTempFile $ \file -> do writeFile file s; readFile' fileA strict version of , see  for details.A strict version of , see  for details.A strict version of , see  for details.(Write a file with a particular encoding.Write a file with the - encoding. W\s -> withTempFile $ \file -> do writeFileUTF8 file s; fmap (== s) $ readFileUTF8' fileWrite a binary file. [\s -> withTempFile $ \file -> do writeFileBinary file s; fmap (== s) $ readFileBinary' file Capture the . and / of a computation. ,captureOutput (print 1) == return ("1\n",()) Execute an action with a custom 0, a warpper around 1.nProvide a function to create a temporary file, and a way to delete a temporary file. Most users should use $ which combines these operations.Create a temporary file in the temporary directory. The file will be deleted after the action completes (provided the file is not still open). The 2 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 == return True (doesFileExist =<< withTempFile return) == return False withTempFile readFile' == return ""xProvide a function to create a temporary directory, and a way to delete a temporary directory. Most users should use $ which combines these operations.Create a temporary directory inside the system temporary directory. The directory will be deleted after the action completes. withTempDir doesDirectoryExist == return True (doesDirectoryExist =<< withTempDir return) == return False withTempDir listFiles == return []z3456789:;<=>?@ABCD,EFGHIJKLM/NOPQRSTUVWXYZ[\]^_`1abcdefghijklmnopqrstuvwxyz{-|}~.02 Safe-InferredE A version of % that also captures the output, both . and /. Returns a pair of the  and the output. A version of  that throws an error if the  is not . A version of  that captures the output (both . and / ) and throws an error if the  is not .* Safe-Inferred  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~yzx{|}w~vdbacegifhjklmHIMNJKLYZOPQRSTWXUV EFGCD,-+)*.%$67@(A89<=>?B !"#;210/:&'534 [`\]_^ nopqrstu !"!#!$%&%'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab c d e f g h i j k l m n o p q r s t u v w x y z { | } ~           !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]!^!_!`\a\b\c%d%e%f%g%h%i%jklmlnopoqorstuvwlxlylz{|l}l~lllllllllllllllllllllllllll        !"#$%$&$'$($)$*$+$,$-./010203040506070809:;<=>?@ABCDEDFDGDHDIDJDKDLDMDNOPQRSTSUVWXYZO[\O]V^O_O`OaObOcOdOeOfOgOhOiOjOkOlOmOnOoOpOqOrSsStSuSvXwXxXyXzX{X|X}X~XXXXXXXXXXXXXXXXQQQQQQQQQQXVVVVVVVVVVVVVV extra-1.0.1System.Environment.ExtraControl.Concurrent.ExtraData.List.ExtraData.IORef.ExtraData.Either.ExtraSystem.Info.Extra Numeric.ExtraData.Tuple.ExtraControl.Monad.ExtraSystem.Directory.ExtraControl.Exception.ExtraSystem.Time.ExtraSystem.IO.ExtraSystem.Process.Extra Control.Arrow***&&&System.TimeouttimeoutExtrabaseSystem.Environment lookupEnv!System.Environment.ExecutablePathgetExecutablePathControl.Concurrent forkFinally GHC.Conc.SyncsetNumCapabilitiesgetNumCapabilities Data.List dropWhileEnd Data.IORefatomicWriteIORefatomicModifyIORef' modifyIORef' Data.EitherisRightisLeft isWindowsshowDP intToDouble intToFloat floatToDouble doubleToFloatfirstseconddupebothfst3snd3thd3 repeatedlyfordisjointanySameallSamelistunconsunsnocconssnoctakeEnddropEnd concatUnzip concatUnzip3 takeWhileEnd trimStarttrimEndtrimlowerupperword1sortOngroupOnnubOn groupSortmergemergeByreplacebreakEndspanEndwordsBylinesBy firstJustdrop1breakOn breakOnEndsplitOnsplit dropWhileEnd' stripSuffixchunksOf writeIORef'atomicWriteIORef'fromLeft fromRight fromEitherwhenJustunit partitionM concatMapM mapMaybeMloopMwhileMwhenMunlessMifMnotM||^&&^anyMallMorMandMfindM firstJustMwithCurrentDirectory listContents listFileslistFilesRecursivelistFilesInsidecreateDirectoryPrivatestringException showExceptionignoreretrycatch_ catchJust_handle_ handleJust_try_tryJust_ catchBool handleBooltryBoolSecondssleep subtractTime showDuration offsetTimeoffsetTimeIncreasedurationBarrierVarLockwithNumCapabilitiesoncenewLockwithLock withLockTrynewVarreadVar modifyVar modifyVar_withVar newBarrier signalBarrier waitBarrierwaitBarrierMaybereadFileEncoding readFileUTF8readFileBinary readFile'readFileEncoding' readFileUTF8'readFileBinary'writeFileEncoding writeFileUTF8writeFileBinary captureOutput withBuffering newTempFile withTempFile newTempDir withTempDir systemOutputsystem_ systemOutput_ghc-prim GHC.TypesTrueFalse System.Info compilerNamearchoscompilerVersiongetEnvironment withProgNamewithArgsunsetEnvsetEnvgetEnv getProgNamegetArgsGHC.Real fromIntegral realToFracNumericshowOctshowHex showIntAtBase showGFloatAlt showFFloatAlt showGFloat showFFloat showEFloatshowInt readSigned readFloatreadHexreadDecreadOctreadIntGHC.Read lexDigits GHC.FloatfromRat floatToDigits showFloat showSigned Data.TuplefstsndswapuncurrycurryGHC.Basemap Data.MaybemaybeNothingGHC.Listheadtailinitlastunzipconcatunzip3 takeWhilegroupnub Data.FunctiononsortwordslinesJustfind++foldrfilterzipunwordsunlinesproductsumfoldl1'foldl1foldl'unfoldrsortBy permutations subsequencestailsinitsgroupBydeleteFirstsByunzip7unzip6unzip5unzip4zipWith7zipWith6zipWith5zipWith4zip7zip6zip5zip4genericReplicate genericIndexgenericSplitAt genericDrop genericTake genericLength minimumBy maximumByminimummaximuminsertByinsert mapAccumR mapAccumL partition transpose intercalate intersperse intersectBy intersectunionByunion\\deleteBydeletenubBy isInfixOf isSuffixOf isPrefixOf findIndices findIndex elemIndices elemIndex stripPrefixzipWith3zipWithzip3!! concatMaplookupnotElemelemallanyorandreversebreakspansplitAtdroptake dropWhilecycle replicaterepeatiteratescanr1scanrfoldr1scanl1scanlfoldllengthnull GHC.IORef writeIORefatomicModifyIORef modifyIORef mkWeakIORef readIORefnewIORefIORefLeftRightEitherpartitionEithersrightsleftseithermapMaybe Control.Monadwhenunless GHC.Classesnot||&&fail>>=>>fmapreturnguardliftMjoinMonadFunctor MonadPlusmfilterapliftM5liftM4liftM3liftM2 replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMvoidforever<=<>=>msumforM_forMfilterMmapM_mapM sequence_sequence=<<mplusmzerodirectory-1.2.1.0System.DirectorygetDirectoryContentscreateDirectorygetTemporaryDirectorygetUserDocumentsDirectorygetAppUserDataDirectorygetHomeDirectorygetModificationTime doesFileExistdoesDirectoryExistsetCurrentDirectorygetCurrentDirectory findFilesWith findFilesfindFilefindExecutablemakeRelativeToCurrentDirectorycanonicalizePathcopyFile renameFilerenameDirectory removeFileremoveDirectoryRecursiveremoveDirectorycreateDirectoryIfMissingcopyPermissionssetPermissionsgetPermissionssetOwnerSearchablesetOwnerExecutablesetOwnerWritablesetOwnerReadableemptyPermissions searchable executablewritablereadable PermissionsControl.Exception.Basecatch GHC.Exception Exception SomeException catchJusthandle handleJusttrytryJustboolassertControl.ExceptionallowInterruptcatchesHandlerbracketOnErrorbracket_finallybracket onException mapExceptionPatternMatchFail RecSelError RecConError RecUpdError NoMethodErrorNonTerminationNestedAtomicallythrowToGHC.IO.ExceptionioErrorasyncExceptionFromExceptionasyncExceptionToExceptionBlockedIndefinitelyOnMVarBlockedIndefinitelyOnSTMDeadlockAssertionFailedSomeAsyncException StackOverflow HeapOverflow ThreadKilled UserInterruptAsyncExceptionIndexOutOfBoundsUndefinedElementArrayExceptionGHC.IOevaluateuninterruptibleMaskuninterruptibleMask_maskmask_getMaskingStatethrowIOUnmaskedMaskedInterruptibleMaskedUninterruptible MaskingState IOExceptionthrow fromException toException ErrorCallOverflow UnderflowLossOfPrecision DivideByZeroDenormalRatioZeroDenominatorArithExceptionDoubleIntTimeout$fExceptionTimeout $fShowTimeoutOnceOnceDone OnceRunning OncePendingthreadWaitWriteSTMthreadWaitReadSTMthreadWaitWritethreadWaitReadrunInUnboundThreadrunInBoundThreadisCurrentThreadBoundforkOSrtsSupportsBoundThreadsControl.Concurrent.QSemN signalQSemN waitQSemNnewQSemNQSemNControl.Concurrent.QSem signalQSemwaitQSemnewQSemQSemControl.Concurrent.ChanwriteList2ChangetChanContents isEmptyChan unGetChandupChanreadChan writeChannewChanChan GHC.Conc.IO threadDelayControl.Concurrent.MVar mkWeakMVaraddMVarFinalizermodifyMVarMaskedmodifyMVarMasked_ modifyMVar modifyMVar_withMVarMaskedwithMVarswapMVarmkWeakThreadIdthreadCapabilityyield myThreadId killThreadforkOnWithUnmaskforkOnforkIOWithUnmaskforkIOThreadIdGHC.MVar isEmptyMVar tryReadMVar tryPutMVar tryTakeMVarputMVarreadMVartakeMVarnewMVar newEmptyMVarMVar System.IOreadFileGHC.IO.Encodingutf8GHC.IO.Handle.FDstdoutstderrGHC.IO.Handle.Types BufferMode GHC.IO.Handle hSetBufferingFilePathprintIOgetLineHandle(openBinaryTempFileWithDefaultPermissions"openTempFileWithDefaultPermissionsopenBinaryTempFile openTempFilefixIOwithBinaryFilewithFilehPrinthReadylocaleEncodingreadIOreadLn appendFile writeFileinteract getContentsgetCharputStrLnputStrputCharopenBinaryFileopenFileisEOFstdinhShowhSetNewlineModehSetBinaryModehIsTerminalDevicehGetEchohSetEcho hIsSeekable hGetBuffering hIsWritable hIsReadable hIsClosedhIsOpenhTellhSeekhSetPosnhGetPosn hGetEncoding hSetEncoding hLookAheadhIsEOF hSetFileSize hFileSizehClose HandlePosnGHC.IO.Handle.TexthGetBufNonBlocking hGetBufSomehGetBufhPutBufNonBlockinghPutBuf hPutStrLnhPutStrhPutChar hGetContentshGetLinehGetChar hWaitForInputmkTextEncodingchar8utf32beutf32leutf32utf16beutf16leutf16utf8_bomlatin1 GHC.IO.IOModeReadMode WriteMode AppendMode ReadWriteModeIOModehFlushnoNewlineTranslationnativeNewlineModeuniversalNewlineMode nativeNewline NoBuffering LineBufferingBlockBufferingLFCRLFNewlineoutputNLinputNL NewlineMode GHC.IO.Device AbsoluteSeek RelativeSeek SeekFromEndSeekModeGHC.IO.Encoding.Types TextEncodingprocess-1.2.0.0System.ProcesssystemExitCode ExitSuccess rawSystemrunInteractiveProcessrunInteractiveCommand runProcess runCommandinterruptProcessGroupOfterminateProcessgetProcessExitCodewaitForProcessshowCommandForUserreadProcessWithExitCode readProcess callCommand callProcess spawnCommand spawnProcess createProcessshellprocSystem.Process.Internals ProcessHandle delegate_ctlc create_group close_fdsstd_errstd_outstd_inenvcwdcmdspec CreateProcess ShellCommand RawCommandCmdSpecInherit UseHandle CreatePipe StdStream