-- Hoogle documentation, generated by Haddock -- See Hoogle, http://www.haskell.org/hoogle/ -- | Compatibility with Haskell 98 -- -- This package provides compatibility with the modules of Haskell 98 and -- the FFI addendum, by means of wrappers around modules from the base -- package (which in many cases have additional features). However -- Prelude, Numeric and Foreign are provided directly by the base -- package. @package haskell98 @version 1.1.0.1 module MarshalUtils module MarshalError -- | An abstract type that contains a value for each variant of -- <a>IOError</a>. data IOErrorType :: * -- | Construct an <a>IOError</a> of the given type where the second -- argument describes the error location and the third and fourth -- argument contain the file handle and file path of the file involved in -- the error if applicable. mkIOError :: IOErrorType -> String -> Maybe Handle -> Maybe FilePath -> IOError -- | I/O error where the operation failed because one of its arguments -- already exists. alreadyExistsErrorType :: IOErrorType -- | I/O error where the operation failed because one of its arguments does -- not exist. doesNotExistErrorType :: IOErrorType -- | I/O error where the operation failed because one of its arguments is a -- single-use resource, which is already being used. alreadyInUseErrorType :: IOErrorType -- | I/O error where the operation failed because the device is full. fullErrorType :: IOErrorType -- | I/O error where the operation failed because the end of file has been -- reached. eofErrorType :: IOErrorType -- | I/O error where the operation is not possible. illegalOperationErrorType :: IOErrorType -- | I/O error where the operation failed because the user does not have -- sufficient operating system privilege to perform that operation. permissionErrorType :: IOErrorType -- | I/O error that is programmer-defined. userErrorType :: IOErrorType -- | Adds a location description and maybe a file path and file handle to -- an <a>IOError</a>. If any of the file handle or file path is not given -- the corresponding value in the <a>IOError</a> remains unaltered. annotateIOError :: IOError -> String -> Maybe Handle -> Maybe FilePath -> IOError module MarshalArray module MarshalAlloc module CTypes module CForeign module CError module Time -- | A representation of the internal clock time. Clock times may be -- compared, converted to strings, or converted to an external calendar -- time <a>CalendarTime</a> for I/O or other manipulations. data ClockTime :: * -- | A month of the year. data Month :: * January :: Month February :: Month March :: Month April :: Month May :: Month June :: Month July :: Month August :: Month September :: Month October :: Month November :: Month December :: Month -- | A day of the week. data Day :: * Sunday :: Day Monday :: Day Tuesday :: Day Wednesday :: Day Thursday :: Day Friday :: Day Saturday :: Day -- | <a>CalendarTime</a> is a user-readable and manipulable representation -- of the internal <a>ClockTime</a> type. data CalendarTime :: * CalendarTime :: Int -> Month -> Int -> Int -> Int -> Int -> Integer -> Day -> Int -> String -> Int -> Bool -> CalendarTime -- | Year (pre-Gregorian dates are inaccurate) ctYear :: CalendarTime -> Int -- | Month of the year ctMonth :: CalendarTime -> Month -- | Day of the month (1 to 31) ctDay :: CalendarTime -> Int -- | Hour of the day (0 to 23) ctHour :: CalendarTime -> Int -- | Minutes (0 to 59) ctMin :: CalendarTime -> Int -- | Seconds (0 to 61, allowing for up to two leap seconds) ctSec :: CalendarTime -> Int -- | Picoseconds ctPicosec :: CalendarTime -> Integer -- | Day of the week ctWDay :: CalendarTime -> Day -- | Day of the year (0 to 364, or 365 in leap years) ctYDay :: CalendarTime -> Int -- | Name of the time zone ctTZName :: CalendarTime -> String -- | Variation from UTC in seconds ctTZ :: CalendarTime -> Int -- | <a>True</a> if Daylight Savings Time would be in effect, and -- <a>False</a> otherwise ctIsDST :: CalendarTime -> Bool -- | records the difference between two clock times in a user-readable way. data TimeDiff :: * TimeDiff :: Int -> Int -> Int -> Int -> Int -> Int -> Integer -> TimeDiff tdYear :: TimeDiff -> Int tdMonth :: TimeDiff -> Int tdDay :: TimeDiff -> Int tdHour :: TimeDiff -> Int tdMin :: TimeDiff -> Int tdSec :: TimeDiff -> Int tdPicosec :: TimeDiff -> Integer getClockTime :: IO ClockTime -- | <tt><a>addToClockTime</a> d t</tt> adds a time difference <tt>d</tt> -- and a clock time <tt>t</tt> to yield a new clock time. The difference -- <tt>d</tt> may be either positive or negative. addToClockTime :: TimeDiff -> ClockTime -> ClockTime -- | <tt><a>diffClockTimes</a> t1 t2</tt> returns the difference between -- two clock times <tt>t1</tt> and <tt>t2</tt> as a <a>TimeDiff</a>. diffClockTimes :: ClockTime -> ClockTime -> TimeDiff -- | converts an internal clock time to a local time, modified by the -- timezone and daylight savings time settings in force at the time of -- conversion. Because of this dependence on the local environment, -- <a>toCalendarTime</a> is in the <a>IO</a> monad. toCalendarTime :: ClockTime -> IO CalendarTime -- | converts an internal clock time into a <a>CalendarTime</a> in standard -- UTC format. toUTCTime :: ClockTime -> CalendarTime -- | converts a <a>CalendarTime</a> into the corresponding internal -- <a>ClockTime</a>, ignoring the contents of the <a>ctWDay</a>, -- <a>ctYDay</a>, <a>ctTZName</a> and <a>ctIsDST</a> fields. toClockTime :: CalendarTime -> ClockTime -- | formats calendar times using local conventions. calendarTimeToString :: CalendarTime -> String -- | formats calendar times using local conventions and a formatting -- string. The formatting string is that understood by the ISO C -- <tt>strftime()</tt> function. formatCalendarTime :: TimeLocale -> String -> CalendarTime -> String module Locale data TimeLocale :: * TimeLocale :: [(String, String)] -> [(String, String)] -> [(String, String)] -> (String, String) -> String -> String -> String -> String -> TimeLocale defaultTimeLocale :: TimeLocale module List -- | The <a>elemIndex</a> function returns the index of the first element -- in the given list which is equal (by <a>==</a>) to the query element, -- or <a>Nothing</a> if there is no such element. elemIndex :: Eq a => a -> [a] -> Maybe Int -- | The <a>elemIndices</a> function extends <a>elemIndex</a>, by returning -- the indices of all elements equal to the query element, in ascending -- order. elemIndices :: Eq a => a -> [a] -> [Int] -- | The <a>find</a> function takes a predicate and a list and returns the -- first element in the list matching the predicate, or <a>Nothing</a> if -- there is no such element. find :: (a -> Bool) -> [a] -> Maybe a -- | The <a>findIndex</a> function takes a predicate and a list and returns -- the index of the first element in the list satisfying the predicate, -- or <a>Nothing</a> if there is no such element. findIndex :: (a -> Bool) -> [a] -> Maybe Int -- | The <a>findIndices</a> function extends <a>findIndex</a>, by returning -- the indices of all elements satisfying the predicate, in ascending -- order. findIndices :: (a -> Bool) -> [a] -> [Int] -- | <i>O(n^2)</i>. The <a>nub</a> function removes duplicate elements from -- a list. In particular, it keeps only the first occurrence of each -- element. (The name <a>nub</a> means `essence'.) It is a special case -- of <a>nubBy</a>, which allows the programmer to supply their own -- equality test. nub :: Eq a => [a] -> [a] -- | The <a>nubBy</a> function behaves just like <a>nub</a>, except it uses -- a user-supplied equality predicate instead of the overloaded <a>==</a> -- function. nubBy :: (a -> a -> Bool) -> [a] -> [a] -- | <a>delete</a> <tt>x</tt> removes the first occurrence of <tt>x</tt> -- from its list argument. For example, -- -- <pre> -- delete 'a' "banana" == "bnana" -- </pre> -- -- It is a special case of <a>deleteBy</a>, which allows the programmer -- to supply their own equality test. delete :: Eq a => a -> [a] -> [a] -- | The <a>deleteBy</a> function behaves like <a>delete</a>, but takes a -- user-supplied equality predicate. deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a] -- | The <a>\\</a> function is list difference ((non-associative). In the -- result of <tt>xs</tt> <a>\\</a> <tt>ys</tt>, the first occurrence of -- each element of <tt>ys</tt> in turn (if any) has been removed from -- <tt>xs</tt>. Thus -- -- <pre> -- (xs ++ ys) \\ xs == ys. -- </pre> -- -- It is a special case of <a>deleteFirstsBy</a>, which allows the -- programmer to supply their own equality test. (\\) :: Eq a => [a] -> [a] -> [a] -- | The <a>deleteFirstsBy</a> function takes a predicate and two lists and -- returns the first list with the first occurrence of each element of -- the second list removed. deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] -- | The <a>union</a> function returns the list union of the two lists. For -- example, -- -- <pre> -- "dog" `union` "cow" == "dogcw" -- </pre> -- -- 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. It is a special case of <a>unionBy</a>, which allows the -- programmer to supply their own equality test. union :: Eq a => [a] -> [a] -> [a] -- | The <a>unionBy</a> function is the non-overloaded version of -- <a>union</a>. unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] -- | The <a>intersect</a> function takes the list intersection of two -- lists. For example, -- -- <pre> -- [1,2,3,4] `intersect` [2,4,6,8] == [2,4] -- </pre> -- -- If the first list contains duplicates, so will the result. -- -- <pre> -- [1,2,2,3,4] `intersect` [6,4,4,2] == [2,2,4] -- </pre> -- -- It is a special case of <a>intersectBy</a>, which allows the -- programmer to supply their own equality test. intersect :: Eq a => [a] -> [a] -> [a] -- | The <a>intersectBy</a> function is the non-overloaded version of -- <a>intersect</a>. intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] -- | The <a>intersperse</a> function takes an element and a list and -- `intersperses' that element between the elements of the list. For -- example, -- -- <pre> -- intersperse ',' "abcde" == "a,b,c,d,e" -- </pre> intersperse :: a -> [a] -> [a] -- | The <a>transpose</a> function transposes the rows and columns of its -- argument. For example, -- -- <pre> -- transpose [[1,2,3],[4,5,6]] == [[1,4],[2,5],[3,6]] -- </pre> transpose :: [[a]] -> [[a]] -- | The <a>partition</a> function takes a predicate a list and returns the -- pair of lists of elements which do and do not satisfy the predicate, -- respectively; i.e., -- -- <pre> -- partition p xs == (filter p xs, filter (not . p) xs) -- </pre> partition :: (a -> Bool) -> [a] -> ([a], [a]) -- | The <a>group</a> function takes a list and returns a list of lists -- such that the concatenation of the result is equal to the argument. -- Moreover, each sublist in the result contains only equal elements. For -- example, -- -- <pre> -- group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"] -- </pre> -- -- It is a special case of <a>groupBy</a>, which allows the programmer to -- supply their own equality test. group :: Eq a => [a] -> [[a]] -- | The <a>groupBy</a> function is the non-overloaded version of -- <a>group</a>. groupBy :: (a -> a -> Bool) -> [a] -> [[a]] -- | The <a>inits</a> function returns all initial segments of the -- argument, shortest first. For example, -- -- <pre> -- inits "abc" == ["","a","ab","abc"] -- </pre> inits :: [a] -> [[a]] -- | The <a>tails</a> function returns all final segments of the argument, -- longest first. For example, -- -- <pre> -- tails "abc" == ["abc", "bc", "c",""] -- </pre> tails :: [a] -> [[a]] -- | The <a>isPrefixOf</a> function takes two lists and returns <a>True</a> -- iff the first list is a prefix of the second. isPrefixOf :: Eq a => [a] -> [a] -> Bool -- | The <a>isSuffixOf</a> function takes two lists and returns <a>True</a> -- iff the first list is a suffix of the second. Both lists must be -- finite. isSuffixOf :: Eq a => [a] -> [a] -> Bool -- | The <a>mapAccumL</a> function behaves like a combination of <a>map</a> -- and <a>foldl</a>; it applies a function to each element of a list, -- passing an accumulating parameter from left to right, and returning a -- final value of this accumulator together with the new list. mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y]) -- | The <a>mapAccumR</a> function behaves like a combination of <a>map</a> -- and <a>foldr</a>; it applies a function to each element of a list, -- passing an accumulating parameter from right to left, and returning a -- final value of this accumulator together with the new list. mapAccumR :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y]) -- | The <a>sort</a> function implements a stable sorting algorithm. It is -- a special case of <a>sortBy</a>, which allows the programmer to supply -- their own comparison function. sort :: Ord a => [a] -> [a] -- | The <a>sortBy</a> function is the non-overloaded version of -- <a>sort</a>. sortBy :: (a -> a -> Ordering) -> [a] -> [a] -- | The <a>insert</a> function takes an element and a list and inserts the -- element into the list at the last position where it is still less than -- or equal to the next element. In particular, if the list is sorted -- before the call, the result will also be sorted. It is a special case -- of <a>insertBy</a>, which allows the programmer to supply their own -- comparison function. insert :: Ord a => a -> [a] -> [a] -- | The non-overloaded version of <a>insert</a>. insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a] -- | The <a>maximumBy</a> function takes a comparison function and a list -- and returns the greatest element of the list by the comparison -- function. The list must be finite and non-empty. maximumBy :: (a -> a -> Ordering) -> [a] -> a -- | The <a>minimumBy</a> function takes a comparison function and a list -- and returns the least element of the list by the comparison function. -- The list must be finite and non-empty. minimumBy :: (a -> a -> Ordering) -> [a] -> a -- | The <a>genericLength</a> function is an overloaded version of -- <a>length</a>. In particular, instead of returning an <a>Int</a>, it -- returns any type which is an instance of <a>Num</a>. It is, however, -- less efficient than <a>length</a>. genericLength :: Num i => [b] -> i -- | The <a>genericTake</a> function is an overloaded version of -- <a>take</a>, which accepts any <a>Integral</a> value as the number of -- elements to take. genericTake :: Integral i => i -> [a] -> [a] -- | The <a>genericDrop</a> function is an overloaded version of -- <a>drop</a>, which accepts any <a>Integral</a> value as the number of -- elements to drop. genericDrop :: Integral i => i -> [a] -> [a] -- | The <a>genericSplitAt</a> function is an overloaded version of -- <a>splitAt</a>, which accepts any <a>Integral</a> value as the -- position at which to split. genericSplitAt :: Integral i => i -> [b] -> ([b], [b]) -- | The <a>genericIndex</a> function is an overloaded version of -- <a>!!</a>, which accepts any <a>Integral</a> value as the index. genericIndex :: Integral a => [b] -> a -> b -- | The <a>genericReplicate</a> function is an overloaded version of -- <a>replicate</a>, which accepts any <a>Integral</a> value as the -- number of repetitions to make. genericReplicate :: Integral i => i -> a -> [a] -- | The <a>zip4</a> function takes four lists and returns a list of -- quadruples, analogous to <a>zip</a>. zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)] -- | The <a>zip5</a> function takes five lists and returns a list of -- five-tuples, analogous to <a>zip</a>. zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)] -- | The <a>zip6</a> function takes six lists and returns a list of -- six-tuples, analogous to <a>zip</a>. zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)] -- | The <a>zip7</a> function takes seven lists and returns a list of -- seven-tuples, analogous to <a>zip</a>. zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)] -- | The <a>zipWith4</a> function takes a function which combines four -- elements, as well as four lists and returns a list of their point-wise -- combination, analogous to <a>zipWith</a>. zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e] -- | The <a>zipWith5</a> function takes a function which combines five -- elements, as well as five lists and returns a list of their point-wise -- combination, analogous to <a>zipWith</a>. zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -- | The <a>zipWith6</a> function takes a function which combines six -- elements, as well as six lists and returns a list of their point-wise -- combination, analogous to <a>zipWith</a>. zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -- | The <a>zipWith7</a> function takes a function which combines seven -- elements, as well as seven lists and returns a list of their -- point-wise combination, analogous to <a>zipWith</a>. zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h] -- | The <a>unzip4</a> function takes a list of quadruples and returns four -- lists, analogous to <a>unzip</a>. unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d]) -- | The <a>unzip5</a> function takes a list of five-tuples and returns -- five lists, analogous to <a>unzip</a>. unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e]) -- | The <a>unzip6</a> function takes a list of six-tuples and returns six -- lists, analogous to <a>unzip</a>. unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f]) -- | The <a>unzip7</a> function takes a list of seven-tuples and returns -- seven lists, analogous to <a>unzip</a>. unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g]) -- | The <a>unfoldr</a> function is a `dual' to <a>foldr</a>: while -- <a>foldr</a> reduces a list to a summary value, <a>unfoldr</a> builds -- a list from a seed value. The function takes the element and returns -- <a>Nothing</a> if it is done producing the list or returns <a>Just</a> -- <tt>(a,b)</tt>, in which case, <tt>a</tt> is a prepended to the list -- and <tt>b</tt> is used as the next element in a recursive call. For -- example, -- -- <pre> -- iterate f == unfoldr (\x -> Just (x, f x)) -- </pre> -- -- In some cases, <a>unfoldr</a> can undo a <a>foldr</a> operation: -- -- <pre> -- unfoldr f' (foldr f z xs) == xs -- </pre> -- -- if the following holds: -- -- <pre> -- f' (f x y) = Just (x,y) -- f' z = Nothing -- </pre> -- -- A simple use of unfoldr: -- -- <pre> -- unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10 -- [10,9,8,7,6,5,4,3,2,1] -- </pre> unfoldr :: (b -> Maybe (a, b)) -> b -> [a] -- | <a>map</a> <tt>f xs</tt> is the list obtained by applying <tt>f</tt> -- to each element of <tt>xs</tt>, i.e., -- -- <pre> -- map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn] -- map f [x1, x2, ...] == [f x1, f x2, ...] -- </pre> map :: (a -> b) -> [a] -> [b] -- | Append two lists, i.e., -- -- <pre> -- [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn] -- [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...] -- </pre> -- -- If the first list is not finite, the result is the first list. (++) :: [a] -> [a] -> [a] -- | Concatenate a list of lists. concat :: [[a]] -> [a] -- | <a>filter</a>, applied to a predicate and a list, returns the list of -- those elements that satisfy the predicate; i.e., -- -- <pre> -- filter p xs = [ x | x <- xs, p x] -- </pre> filter :: (a -> Bool) -> [a] -> [a] -- | Extract the first element of a list, which must be non-empty. head :: [a] -> a -- | Extract the last element of a list, which must be finite and -- non-empty. last :: [a] -> a -- | Extract the elements after the head of a list, which must be -- non-empty. tail :: [a] -> [a] -- | Return all the elements of a list except the last one. The list must -- be non-empty. init :: [a] -> [a] -- | Test whether a list is empty. null :: [a] -> Bool -- | <i>O(n)</i>. <a>length</a> returns the length of a finite list as an -- <a>Int</a>. It is an instance of the more general -- <tt>Data.List.genericLength</tt>, the result type of which may be any -- kind of number. length :: [a] -> Int -- | List index (subscript) operator, starting from 0. It is an instance of -- the more general <tt>Data.List.genericIndex</tt>, which takes an index -- of any integral type. (!!) :: [a] -> Int -> a -- | <a>foldl</a>, applied to a binary operator, a starting value -- (typically the left-identity of the operator), and a list, reduces the -- list using the binary operator, from left to right: -- -- <pre> -- foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn -- </pre> -- -- The list must be finite. foldl :: (a -> b -> a) -> a -> [b] -> a -- | <a>foldl1</a> is a variant of <a>foldl</a> that has no starting value -- argument, and thus must be applied to non-empty lists. foldl1 :: (a -> a -> a) -> [a] -> a -- | <a>scanl</a> is similar to <a>foldl</a>, but returns a list of -- successive reduced values from the left: -- -- <pre> -- scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...] -- </pre> -- -- Note that -- -- <pre> -- last (scanl f z xs) == foldl f z xs. -- </pre> scanl :: (a -> b -> a) -> a -> [b] -> [a] -- | <a>scanl1</a> is a variant of <a>scanl</a> that has no starting value -- argument: -- -- <pre> -- scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...] -- </pre> scanl1 :: (a -> a -> a) -> [a] -> [a] -- | <a>foldr</a>, applied to a binary operator, a starting value -- (typically the right-identity of the operator), and a list, reduces -- the list using the binary operator, from right to left: -- -- <pre> -- foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...) -- </pre> foldr :: (a -> b -> b) -> b -> [a] -> b -- | <a>foldr1</a> is a variant of <a>foldr</a> that has no starting value -- argument, and thus must be applied to non-empty lists. foldr1 :: (a -> a -> a) -> [a] -> a -- | <a>scanr</a> is the right-to-left dual of <a>scanl</a>. Note that -- -- <pre> -- head (scanr f z xs) == foldr f z xs. -- </pre> scanr :: (a -> b -> b) -> b -> [a] -> [b] -- | <a>scanr1</a> is a variant of <a>scanr</a> that has no starting value -- argument. scanr1 :: (a -> a -> a) -> [a] -> [a] -- | <a>iterate</a> <tt>f x</tt> returns an infinite list of repeated -- applications of <tt>f</tt> to <tt>x</tt>: -- -- <pre> -- iterate f x == [x, f x, f (f x), ...] -- </pre> iterate :: (a -> a) -> a -> [a] -- | <a>repeat</a> <tt>x</tt> is an infinite list, with <tt>x</tt> the -- value of every element. repeat :: a -> [a] -- | <a>replicate</a> <tt>n x</tt> is a list of length <tt>n</tt> with -- <tt>x</tt> the value of every element. It is an instance of the more -- general <tt>Data.List.genericReplicate</tt>, in which <tt>n</tt> may -- be of any integral type. replicate :: Int -> a -> [a] -- | <a>cycle</a> ties a finite list into a circular one, or equivalently, -- the infinite repetition of the original list. It is the identity on -- infinite lists. cycle :: [a] -> [a] -- | <a>take</a> <tt>n</tt>, applied to a list <tt>xs</tt>, returns the -- prefix of <tt>xs</tt> of length <tt>n</tt>, or <tt>xs</tt> itself if -- <tt>n > <a>length</a> xs</tt>: -- -- <pre> -- take 5 "Hello World!" == "Hello" -- take 3 [1,2,3,4,5] == [1,2,3] -- take 3 [1,2] == [1,2] -- take 3 [] == [] -- take (-1) [1,2] == [] -- take 0 [1,2] == [] -- </pre> -- -- It is an instance of the more general <tt>Data.List.genericTake</tt>, -- in which <tt>n</tt> may be of any integral type. take :: Int -> [a] -> [a] -- | <a>drop</a> <tt>n xs</tt> returns the suffix of <tt>xs</tt> after the -- first <tt>n</tt> elements, or <tt>[]</tt> if <tt>n > <a>length</a> -- xs</tt>: -- -- <pre> -- drop 6 "Hello World!" == "World!" -- drop 3 [1,2,3,4,5] == [4,5] -- drop 3 [1,2] == [] -- drop 3 [] == [] -- drop (-1) [1,2] == [1,2] -- drop 0 [1,2] == [1,2] -- </pre> -- -- It is an instance of the more general <tt>Data.List.genericDrop</tt>, -- in which <tt>n</tt> may be of any integral type. drop :: Int -> [a] -> [a] -- | <a>splitAt</a> <tt>n xs</tt> returns a tuple where first element is -- <tt>xs</tt> prefix of length <tt>n</tt> and second element is the -- remainder of the list: -- -- <pre> -- splitAt 6 "Hello World!" == ("Hello ","World!") -- splitAt 3 [1,2,3,4,5] == ([1,2,3],[4,5]) -- splitAt 1 [1,2,3] == ([1],[2,3]) -- splitAt 3 [1,2,3] == ([1,2,3],[]) -- splitAt 4 [1,2,3] == ([1,2,3],[]) -- splitAt 0 [1,2,3] == ([],[1,2,3]) -- splitAt (-1) [1,2,3] == ([],[1,2,3]) -- </pre> -- -- It is equivalent to <tt>(<a>take</a> n xs, <a>drop</a> n xs)</tt>. -- <a>splitAt</a> is an instance of the more general -- <tt>Data.List.genericSplitAt</tt>, in which <tt>n</tt> may be of any -- integral type. splitAt :: Int -> [a] -> ([a], [a]) -- | <a>takeWhile</a>, applied to a predicate <tt>p</tt> and a list -- <tt>xs</tt>, returns the longest prefix (possibly empty) of -- <tt>xs</tt> of elements that satisfy <tt>p</tt>: -- -- <pre> -- takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2] -- takeWhile (< 9) [1,2,3] == [1,2,3] -- takeWhile (< 0) [1,2,3] == [] -- </pre> takeWhile :: (a -> Bool) -> [a] -> [a] -- | <a>dropWhile</a> <tt>p xs</tt> returns the suffix remaining after -- <a>takeWhile</a> <tt>p xs</tt>: -- -- <pre> -- dropWhile (< 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3] -- dropWhile (< 9) [1,2,3] == [] -- dropWhile (< 0) [1,2,3] == [1,2,3] -- </pre> dropWhile :: (a -> Bool) -> [a] -> [a] -- | <a>span</a>, applied to a predicate <tt>p</tt> and a list <tt>xs</tt>, -- returns a tuple where first element is longest prefix (possibly empty) -- of <tt>xs</tt> of elements that satisfy <tt>p</tt> and second element -- is the remainder of the list: -- -- <pre> -- span (< 3) [1,2,3,4,1,2,3,4] == ([1,2],[3,4,1,2,3,4]) -- span (< 9) [1,2,3] == ([1,2,3],[]) -- span (< 0) [1,2,3] == ([],[1,2,3]) -- </pre> -- -- <a>span</a> <tt>p xs</tt> is equivalent to <tt>(<a>takeWhile</a> p xs, -- <a>dropWhile</a> p xs)</tt> span :: (a -> Bool) -> [a] -> ([a], [a]) -- | <a>break</a>, applied to a predicate <tt>p</tt> and a list -- <tt>xs</tt>, returns a tuple where first element is longest prefix -- (possibly empty) of <tt>xs</tt> of elements that <i>do not satisfy</i> -- <tt>p</tt> and second element is the remainder of the list: -- -- <pre> -- break (> 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4]) -- break (< 9) [1,2,3] == ([],[1,2,3]) -- break (> 9) [1,2,3] == ([1,2,3],[]) -- </pre> -- -- <a>break</a> <tt>p</tt> is equivalent to <tt><a>span</a> (<a>not</a> . -- p)</tt>. break :: (a -> Bool) -> [a] -> ([a], [a]) -- | <a>lines</a> breaks a string up into a list of strings at newline -- characters. The resulting strings do not contain newlines. lines :: String -> [String] -- | <a>words</a> breaks a string up into a list of words, which were -- delimited by white space. words :: String -> [String] -- | <a>unlines</a> is an inverse operation to <a>lines</a>. It joins -- lines, after appending a terminating newline to each. unlines :: [String] -> String -- | <a>unwords</a> is an inverse operation to <a>words</a>. It joins words -- with separating spaces. unwords :: [String] -> String -- | <a>reverse</a> <tt>xs</tt> returns the elements of <tt>xs</tt> in -- reverse order. <tt>xs</tt> must be finite. reverse :: [a] -> [a] -- | <a>and</a> returns the conjunction of a Boolean list. For the result -- to be <a>True</a>, the list must be finite; <a>False</a>, however, -- results from a <a>False</a> value at a finite index of a finite or -- infinite list. and :: [Bool] -> Bool -- | <a>or</a> returns the disjunction of a Boolean list. For the result to -- be <a>False</a>, the list must be finite; <a>True</a>, however, -- results from a <a>True</a> value at a finite index of a finite or -- infinite list. or :: [Bool] -> Bool -- | Applied to a predicate and a list, <a>any</a> determines if any -- element of the list satisfies the predicate. For the result to be -- <a>False</a>, the list must be finite; <a>True</a>, however, results -- from a <a>True</a> value for the predicate applied to an element at a -- finite index of a finite or infinite list. any :: (a -> Bool) -> [a] -> Bool -- | Applied to a predicate and a list, <a>all</a> determines if all -- elements of the list satisfy the predicate. For the result to be -- <a>True</a>, the list must be finite; <a>False</a>, however, results -- from a <a>False</a> value for the predicate applied to an element at a -- finite index of a finite or infinite list. all :: (a -> Bool) -> [a] -> Bool -- | <a>elem</a> is the list membership predicate, usually written in infix -- form, e.g., <tt>x `elem` xs</tt>. For the result to be <a>False</a>, -- the list must be finite; <a>True</a>, however, results from an element -- equal to <tt>x</tt> found at a finite index of a finite or infinite -- list. elem :: Eq a => a -> [a] -> Bool -- | <a>notElem</a> is the negation of <a>elem</a>. notElem :: Eq a => a -> [a] -> Bool -- | <a>lookup</a> <tt>key assocs</tt> looks up a key in an association -- list. lookup :: Eq a => a -> [(a, b)] -> Maybe b -- | The <a>sum</a> function computes the sum of a finite list of numbers. sum :: Num a => [a] -> a -- | The <a>product</a> function computes the product of a finite list of -- numbers. product :: Num a => [a] -> a -- | <a>maximum</a> returns the maximum value from a list, which must be -- non-empty, finite, and of an ordered type. It is a special case of -- <a>maximumBy</a>, which allows the programmer to supply their own -- comparison function. maximum :: Ord a => [a] -> a -- | <a>minimum</a> returns the minimum value from a list, which must be -- non-empty, finite, and of an ordered type. It is a special case of -- <a>minimumBy</a>, which allows the programmer to supply their own -- comparison function. minimum :: Ord a => [a] -> a -- | Map a function over a list and concatenate the results. concatMap :: (a -> [b]) -> [a] -> [b] -- | <a>zip</a> takes two lists and returns a list of corresponding pairs. -- If one input list is short, excess elements of the longer list are -- discarded. zip :: [a] -> [b] -> [(a, b)] -- | <a>zip3</a> takes three lists and returns a list of triples, analogous -- to <a>zip</a>. zip3 :: [a] -> [b] -> [c] -> [(a, b, c)] -- | <a>zipWith</a> generalises <a>zip</a> by zipping with the function -- given as the first argument, instead of a tupling function. For -- example, <tt><a>zipWith</a> (+)</tt> is applied to two lists to -- produce the list of corresponding sums. zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] -- | The <a>zipWith3</a> function takes a function which combines three -- elements, as well as three lists and returns a list of their -- point-wise combination, analogous to <a>zipWith</a>. zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] -- | <a>unzip</a> transforms a list of pairs into a list of first -- components and a list of second components. unzip :: [(a, b)] -> ([a], [b]) -- | The <a>unzip3</a> function takes a list of triples and returns three -- lists, analogous to <a>unzip</a>. unzip3 :: [(a, b, c)] -> ([a], [b], [c]) module System -- | Defines the exit codes that a program can return. data ExitCode :: * -- | indicates successful termination; ExitSuccess :: ExitCode -- | indicates program failure with an exit code. The exact interpretation -- of the code is operating-system dependent. In particular, some values -- may be prohibited (e.g. 0 on a POSIX-compliant system). ExitFailure :: Int -> ExitCode -- | Computation <a>getArgs</a> returns a list of the program's command -- line arguments (not including the program name). getArgs :: IO [String] -- | Computation <a>getProgName</a> returns the name of the program as it -- was invoked. -- -- However, this is hard-to-impossible to implement on some non-Unix -- OSes, so instead, for maximum portability, we just return the leafname -- of the program as invoked. Even then there are some differences -- between platforms: on Windows, for example, a program invoked as foo -- is probably really <tt>FOO.EXE</tt>, and that is what -- <a>getProgName</a> will return. getProgName :: IO String -- | Computation <a>getEnv</a> <tt>var</tt> returns the value of the -- environment variable <tt>var</tt>. -- -- This computation may fail with: -- -- <ul> -- <li><tt>System.IO.Error.isDoesNotExistError</tt> if the environment -- variable does not exist.</li> -- </ul> getEnv :: String -> IO String -- | Computation <tt>system cmd</tt> returns the exit code produced when -- the operating system runs the shell command <tt>cmd</tt>. -- -- This computation may fail with -- -- <ul> -- <li><tt>PermissionDenied</tt>: The process has insufficient privileges -- to perform the operation.</li> -- <li><tt>ResourceExhausted</tt>: Insufficient resources are available -- to perform the operation.</li> -- <li><tt>UnsupportedOperation</tt>: The implementation does not support -- system calls.</li> -- </ul> -- -- On Windows, <a>system</a> passes the command to the Windows command -- interpreter (<tt>CMD.EXE</tt> or <tt>COMMAND.COM</tt>), hence Unixy -- shell tricks will not work. system :: String -> IO ExitCode -- | Computation <a>exitWith</a> <tt>code</tt> throws <a>ExitCode</a> -- <tt>code</tt>. Normally this terminates the program, returning -- <tt>code</tt> to the program's caller. -- -- On program termination, the standard <tt>Handle</tt>s <tt>stdout</tt> -- and <tt>stderr</tt> are flushed automatically; any other buffered -- <tt>Handle</tt>s need to be flushed manually, otherwise the buffered -- data will be discarded. -- -- A program that fails in any other way is treated as if it had called -- <a>exitFailure</a>. A program that terminates successfully without -- calling <a>exitWith</a> explicitly is treated as it it had called -- <a>exitWith</a> <a>ExitSuccess</a>. -- -- As an <a>ExitCode</a> is not an <a>IOError</a>, <a>exitWith</a> -- bypasses the error handling in the <a>IO</a> monad and cannot be -- intercepted by <a>catch</a> from the <a>Prelude</a>. However it is a -- <tt>SomeException</tt>, and can be caught using the functions of -- <a>Control.Exception</a>. This means that cleanup computations added -- with <tt>Control.Exception.bracket</tt> (from -- <a>Control.Exception</a>) are also executed properly on -- <a>exitWith</a>. -- -- Note: in GHC, <a>exitWith</a> should be called from the main program -- thread in order to exit the process. When called from another thread, -- <a>exitWith</a> will throw an <tt>ExitException</tt> as normal, but -- the exception will not cause the process itself to exit. exitWith :: ExitCode -> IO a -- | The computation <a>exitFailure</a> is equivalent to <a>exitWith</a> -- <tt>(</tt><a>ExitFailure</a> <i>exitfail</i><tt>)</tt>, where -- <i>exitfail</i> is implementation-dependent. exitFailure :: IO a module CPUTime -- | Computation <a>getCPUTime</a> returns the number of picoseconds CPU -- time used by the current program. The precision of this result is -- implementation-dependent. getCPUTime :: IO Integer -- | The <a>cpuTimePrecision</a> constant is the smallest measurable -- difference in CPU time that the implementation can record, and is -- given as an integral number of picoseconds. cpuTimePrecision :: Integer module Complex -- | Complex numbers are an algebraic type. -- -- For a complex number <tt>z</tt>, <tt><a>abs</a> z</tt> is a number -- with the magnitude of <tt>z</tt>, but oriented in the positive real -- direction, whereas <tt><a>signum</a> z</tt> has the phase of -- <tt>z</tt>, but unit magnitude. data RealFloat a => Complex a :: * -> * -- | forms a complex number from its real and imaginary rectangular -- components. (:+) :: !a -> !a -> Complex a -- | Extracts the real part of a complex number. realPart :: RealFloat a => Complex a -> a -- | Extracts the imaginary part of a complex number. imagPart :: RealFloat a => Complex a -> a -- | The conjugate of a complex number. conjugate :: RealFloat a => Complex a -> Complex a -- | Form a complex number from polar components of magnitude and phase. mkPolar :: RealFloat a => a -> a -> Complex a -- | <tt><a>cis</a> t</tt> is a complex value with magnitude <tt>1</tt> and -- phase <tt>t</tt> (modulo <tt>2*<a>pi</a></tt>). cis :: RealFloat a => a -> Complex a -- | The function <a>polar</a> takes a complex number and returns a -- (magnitude, phase) pair in canonical form: the magnitude is -- nonnegative, and the phase in the range <tt>(-<a>pi</a>, -- <a>pi</a>]</tt>; if the magnitude is zero, then so is the phase. polar :: RealFloat a => Complex a -> (a, a) -- | The nonnegative magnitude of a complex number. magnitude :: RealFloat a => Complex a -> a -- | The phase of a complex number, in the range <tt>(-<a>pi</a>, -- <a>pi</a>]</tt>. If the magnitude is zero, then so is the phase. phase :: RealFloat a => Complex a -> a module CString module Storable module Directory data Permissions Permissions :: Bool -> Bool -> Bool -> Bool -> Permissions readable :: Permissions -> Bool writable :: Permissions -> Bool executable :: Permissions -> Bool searchable :: Permissions -> Bool -- | <tt><a>createDirectory</a> dir</tt> creates a new directory -- <tt>dir</tt> which is initially empty, or as near to empty as the -- operating system allows. -- -- The operation may fail with: -- -- <ul> -- <li><a>isPermissionError</a> / <a>PermissionDenied</a> The process has -- insufficient privileges to perform the operation. <tt>[EROFS, -- EACCES]</tt></li> -- <li><a>isAlreadyExistsError</a> / <a>AlreadyExists</a> The operand -- refers to a directory that already exists. <tt> [EEXIST]</tt></li> -- <li><a>HardwareFault</a> A physical I/O error has occurred. -- <tt>[EIO]</tt></li> -- <li><a>InvalidArgument</a> The operand is not a valid directory name. -- <tt>[ENAMETOOLONG, ELOOP]</tt></li> -- <li><a>NoSuchThing</a> There is no path to the directory. <tt>[ENOENT, -- ENOTDIR]</tt></li> -- <li><a>ResourceExhausted</a> Insufficient resources (virtual memory, -- process file descriptors, physical disk space, etc.) are available to -- perform the operation. <tt>[EDQUOT, ENOSPC, ENOMEM, EMLINK]</tt></li> -- <li><a>InappropriateType</a> The path refers to an existing -- non-directory object. <tt>[EEXIST]</tt></li> -- </ul> createDirectory :: FilePath -> IO () -- | <tt><a>removeDirectory</a> dir</tt> removes an existing directory -- <i>dir</i>. The implementation may specify additional constraints -- which must be satisfied before a directory can be removed (e.g. the -- directory has to be empty, or may not be in use by other processes). -- It is not legal for an implementation to partially remove a directory -- unless the entire directory is removed. A conformant implementation -- need not support directory removal in all situations (e.g. removal of -- the root directory). -- -- The operation may fail with: -- -- <ul> -- <li><a>HardwareFault</a> A physical I/O error has occurred. EIO</li> -- <li><a>InvalidArgument</a> The operand is not a valid directory name. -- [ENAMETOOLONG, ELOOP]</li> -- <li><a>isDoesNotExistError</a> / <a>NoSuchThing</a> The directory does -- not exist. <tt>[ENOENT, ENOTDIR]</tt></li> -- <li><a>isPermissionError</a> / <a>PermissionDenied</a> The process has -- insufficient privileges to perform the operation. <tt>[EROFS, EACCES, -- EPERM]</tt></li> -- <li><a>UnsatisfiedConstraints</a> Implementation-dependent constraints -- are not satisfied. <tt>[EBUSY, ENOTEMPTY, EEXIST]</tt></li> -- <li><a>UnsupportedOperation</a> The implementation does not support -- removal in this situation. <tt>[EINVAL]</tt></li> -- <li><a>InappropriateType</a> The operand refers to an existing -- non-directory object. <tt>[ENOTDIR]</tt></li> -- </ul> removeDirectory :: FilePath -> IO () -- | <a>removeFile</a> <i>file</i> removes the directory entry for an -- existing file <i>file</i>, where <i>file</i> is not itself a -- directory. The implementation may specify additional constraints which -- must be satisfied before a file can be removed (e.g. the file may not -- be in use by other processes). -- -- The operation may fail with: -- -- <ul> -- <li><a>HardwareFault</a> A physical I/O error has occurred. -- <tt>[EIO]</tt></li> -- <li><a>InvalidArgument</a> The operand is not a valid file name. -- <tt>[ENAMETOOLONG, ELOOP]</tt></li> -- <li><a>isDoesNotExistError</a> / <a>NoSuchThing</a> The file does not -- exist. <tt>[ENOENT, ENOTDIR]</tt></li> -- <li><a>isPermissionError</a> / <a>PermissionDenied</a> The process has -- insufficient privileges to perform the operation. <tt>[EROFS, EACCES, -- EPERM]</tt></li> -- <li><a>UnsatisfiedConstraints</a> Implementation-dependent constraints -- are not satisfied. <tt>[EBUSY]</tt></li> -- <li><a>InappropriateType</a> The operand refers to an existing -- directory. <tt>[EPERM, EINVAL]</tt></li> -- </ul> removeFile :: FilePath -> IO () -- | <tt><a>renameDirectory</a> old new</tt> changes the name of an -- existing directory from <i>old</i> to <i>new</i>. If the <i>new</i> -- directory already exists, it is atomically replaced by the <i>old</i> -- directory. If the <i>new</i> directory is neither the <i>old</i> -- directory nor an alias of the <i>old</i> directory, it is removed as -- if by <a>removeDirectory</a>. A conformant implementation need not -- support renaming directories in all situations (e.g. renaming to an -- existing directory, or across different physical devices), but the -- constraints must be documented. -- -- On Win32 platforms, <tt>renameDirectory</tt> fails if the <i>new</i> -- directory already exists. -- -- The operation may fail with: -- -- <ul> -- <li><a>HardwareFault</a> A physical I/O error has occurred. -- <tt>[EIO]</tt></li> -- <li><a>InvalidArgument</a> Either operand is not a valid directory -- name. <tt>[ENAMETOOLONG, ELOOP]</tt></li> -- <li><a>isDoesNotExistError</a> / <a>NoSuchThing</a> The original -- directory does not exist, or there is no path to the target. -- <tt>[ENOENT, ENOTDIR]</tt></li> -- <li><a>isPermissionError</a> / <a>PermissionDenied</a> The process has -- insufficient privileges to perform the operation. <tt>[EROFS, EACCES, -- EPERM]</tt></li> -- <li><a>ResourceExhausted</a> Insufficient resources are available to -- perform the operation. <tt>[EDQUOT, ENOSPC, ENOMEM, EMLINK]</tt></li> -- <li><a>UnsatisfiedConstraints</a> Implementation-dependent constraints -- are not satisfied. <tt>[EBUSY, ENOTEMPTY, EEXIST]</tt></li> -- <li><a>UnsupportedOperation</a> The implementation does not support -- renaming in this situation. <tt>[EINVAL, EXDEV]</tt></li> -- <li><a>InappropriateType</a> Either path refers to an existing -- non-directory object. <tt>[ENOTDIR, EISDIR]</tt></li> -- </ul> renameDirectory :: FilePath -> FilePath -> IO () -- | <tt><a>renameFile</a> old new</tt> changes the name of an existing -- file system object from <i>old</i> to <i>new</i>. If the <i>new</i> -- object already exists, it is atomically replaced by the <i>old</i> -- object. Neither path may refer to an existing directory. A conformant -- implementation need not support renaming files in all situations (e.g. -- renaming across different physical devices), but the constraints must -- be documented. -- -- The operation may fail with: -- -- <ul> -- <li><a>HardwareFault</a> A physical I/O error has occurred. -- <tt>[EIO]</tt></li> -- <li><a>InvalidArgument</a> Either operand is not a valid file name. -- <tt>[ENAMETOOLONG, ELOOP]</tt></li> -- <li><a>isDoesNotExistError</a> / <a>NoSuchThing</a> The original file -- does not exist, or there is no path to the target. <tt>[ENOENT, -- ENOTDIR]</tt></li> -- <li><a>isPermissionError</a> / <a>PermissionDenied</a> The process has -- insufficient privileges to perform the operation. <tt>[EROFS, EACCES, -- EPERM]</tt></li> -- <li><a>ResourceExhausted</a> Insufficient resources are available to -- perform the operation. <tt>[EDQUOT, ENOSPC, ENOMEM, EMLINK]</tt></li> -- <li><a>UnsatisfiedConstraints</a> Implementation-dependent constraints -- are not satisfied. <tt>[EBUSY]</tt></li> -- <li><a>UnsupportedOperation</a> The implementation does not support -- renaming in this situation. <tt>[EXDEV]</tt></li> -- <li><a>InappropriateType</a> Either path refers to an existing -- directory. <tt>[ENOTDIR, EISDIR, EINVAL, EEXIST, ENOTEMPTY]</tt></li> -- </ul> renameFile :: FilePath -> FilePath -> IO () -- | <tt><a>getDirectoryContents</a> dir</tt> returns a list of <i>all</i> -- entries in <i>dir</i>. -- -- The operation may fail with: -- -- <ul> -- <li><a>HardwareFault</a> A physical I/O error has occurred. -- <tt>[EIO]</tt></li> -- <li><a>InvalidArgument</a> The operand is not a valid directory name. -- <tt>[ENAMETOOLONG, ELOOP]</tt></li> -- <li><a>isDoesNotExistError</a> / <a>NoSuchThing</a> The directory does -- not exist. <tt>[ENOENT, ENOTDIR]</tt></li> -- <li><a>isPermissionError</a> / <a>PermissionDenied</a> The process has -- insufficient privileges to perform the operation. -- <tt>[EACCES]</tt></li> -- <li><a>ResourceExhausted</a> Insufficient resources are available to -- perform the operation. <tt>[EMFILE, ENFILE]</tt></li> -- <li><a>InappropriateType</a> The path refers to an existing -- non-directory object. <tt>[ENOTDIR]</tt></li> -- </ul> getDirectoryContents :: FilePath -> IO [FilePath] -- | If the operating system has a notion of current directories, -- <a>getCurrentDirectory</a> returns an absolute path to the current -- directory of the calling process. -- -- The operation may fail with: -- -- <ul> -- <li><a>HardwareFault</a> A physical I/O error has occurred. -- <tt>[EIO]</tt></li> -- <li><a>isDoesNotExistError</a> / <a>NoSuchThing</a> There is no path -- referring to the current directory. <tt>[EPERM, ENOENT, -- ESTALE...]</tt></li> -- <li><a>isPermissionError</a> / <a>PermissionDenied</a> The process has -- insufficient privileges to perform the operation. -- <tt>[EACCES]</tt></li> -- <li><a>ResourceExhausted</a> Insufficient resources are available to -- perform the operation.</li> -- <li><a>UnsupportedOperation</a> The operating system has no notion of -- current directory.</li> -- </ul> getCurrentDirectory :: IO FilePath -- | If the operating system has a notion of current directories, -- <tt><a>setCurrentDirectory</a> dir</tt> changes the current directory -- of the calling process to <i>dir</i>. -- -- The operation may fail with: -- -- <ul> -- <li><a>HardwareFault</a> A physical I/O error has occurred. -- <tt>[EIO]</tt></li> -- <li><a>InvalidArgument</a> The operand is not a valid directory name. -- <tt>[ENAMETOOLONG, ELOOP]</tt></li> -- <li><a>isDoesNotExistError</a> / <a>NoSuchThing</a> The directory does -- not exist. <tt>[ENOENT, ENOTDIR]</tt></li> -- <li><a>isPermissionError</a> / <a>PermissionDenied</a> The process has -- insufficient privileges to perform the operation. -- <tt>[EACCES]</tt></li> -- <li><a>UnsupportedOperation</a> The operating system has no notion of -- current directory, or the current directory cannot be dynamically -- changed.</li> -- <li><a>InappropriateType</a> The path refers to an existing -- non-directory object. <tt>[ENOTDIR]</tt></li> -- </ul> setCurrentDirectory :: FilePath -> IO () -- | The operation <a>doesFileExist</a> returns <a>True</a> if the argument -- file exists and is not a directory, and <a>False</a> otherwise. doesFileExist :: FilePath -> IO Bool -- | The operation <a>doesDirectoryExist</a> returns <a>True</a> if the -- argument file exists and is a directory, and <a>False</a> otherwise. doesDirectoryExist :: FilePath -> IO Bool getPermissions :: FilePath -> IO Permissions setPermissions :: FilePath -> Permissions -> IO () -- | The <a>getModificationTime</a> operation returns the clock time at -- which the file or directory was last modified. -- -- The operation may fail with: -- -- <ul> -- <li><a>isPermissionError</a> if the user is not permitted to access -- the modification time; or</li> -- <li><a>isDoesNotExistError</a> if the file or directory does not -- exist.</li> -- </ul> getModificationTime :: FilePath -> IO ClockTime instance Eq Permissions instance Ord Permissions instance Read Permissions instance Show Permissions module Bits module Maybe -- | The <a>isJust</a> function returns <a>True</a> iff its argument is of -- the form <tt>Just _</tt>. isJust :: Maybe a -> Bool -- | The <a>isNothing</a> function returns <a>True</a> iff its argument is -- <a>Nothing</a>. isNothing :: Maybe a -> Bool -- | The <a>fromJust</a> function extracts the element out of a <a>Just</a> -- and throws an error if its argument is <a>Nothing</a>. fromJust :: Maybe a -> a -- | The <a>fromMaybe</a> function takes a default value and and -- <a>Maybe</a> value. If the <a>Maybe</a> is <a>Nothing</a>, it returns -- the default values; otherwise, it returns the value contained in the -- <a>Maybe</a>. fromMaybe :: a -> Maybe a -> a -- | The <a>listToMaybe</a> function returns <a>Nothing</a> on an empty -- list or <tt><a>Just</a> a</tt> where <tt>a</tt> is the first element -- of the list. listToMaybe :: [a] -> Maybe a -- | The <a>maybeToList</a> function returns an empty list when given -- <a>Nothing</a> or a singleton list when not given <a>Nothing</a>. maybeToList :: Maybe a -> [a] -- | The <a>catMaybes</a> function takes a list of <a>Maybe</a>s and -- returns a list of all the <a>Just</a> values. catMaybes :: [Maybe a] -> [a] -- | The <a>mapMaybe</a> function is a version of <a>map</a> which can -- throw out elements. In particular, the functional argument returns -- something of type <tt><a>Maybe</a> b</tt>. If this is <a>Nothing</a>, -- no element is added on to the result list. If it just <tt><a>Just</a> -- b</tt>, then <tt>b</tt> is included in the result list. mapMaybe :: (a -> Maybe b) -> [a] -> [b] -- | The <a>Maybe</a> type encapsulates an optional value. A value of type -- <tt><a>Maybe</a> a</tt> either contains a value of type <tt>a</tt> -- (represented as <tt><a>Just</a> a</tt>), or it is empty (represented -- as <a>Nothing</a>). Using <a>Maybe</a> is a good way to deal with -- errors or exceptional cases without resorting to drastic measures such -- as <a>error</a>. -- -- The <a>Maybe</a> type is also a monad. It is a simple kind of error -- monad, where all errors are represented by <a>Nothing</a>. A richer -- error monad can be built using the <tt>Data.Either.Either</tt> type. data Maybe a :: * -> * Nothing :: Maybe a Just :: a -> Maybe a -- | The <a>maybe</a> function takes a default value, a function, and a -- <a>Maybe</a> value. If the <a>Maybe</a> value is <a>Nothing</a>, the -- function returns the default value. Otherwise, it applies the function -- to the value inside the <a>Just</a> and returns the result. maybe :: b -> (a -> b) -> Maybe a -> b module Random -- | The class <a>RandomGen</a> provides a common interface to random -- number generators. -- -- Minimal complete definition: <a>next</a> and <a>split</a>. class RandomGen g next :: RandomGen g => g -> (Int, g) split :: RandomGen g => g -> (g, g) genRange :: RandomGen g => g -> (Int, Int) -- | The <a>StdGen</a> instance of <a>RandomGen</a> has a <a>genRange</a> -- of at least 30 bits. -- -- The result of repeatedly using <a>next</a> should be at least as -- statistically robust as the <i>Minimal Standard Random Number -- Generator</i> described by [<a>System.Random#Park</a>, -- <a>System.Random#Carta</a>]. Until more is known about implementations -- of <a>split</a>, all we require is that <a>split</a> deliver -- generators that are (a) not identical and (b) independently robust in -- the sense just given. -- -- The <a>Show</a> and <a>Read</a> instances of <a>StdGen</a> provide a -- primitive way to save the state of a random number generator. It is -- required that <tt><a>read</a> (<a>show</a> g) == g</tt>. -- -- In addition, <a>reads</a> may be used to map an arbitrary string (not -- necessarily one produced by <a>show</a>) onto a value of type -- <a>StdGen</a>. In general, the <a>Read</a> instance of <a>StdGen</a> -- has the following properties: -- -- <ul> -- <li>It guarantees to succeed on any string.</li> -- <li>It guarantees to consume only a finite portion of the string.</li> -- <li>Different argument strings are likely to result in different -- results.</li> -- </ul> data StdGen :: * -- | The function <a>mkStdGen</a> provides an alternative way of producing -- an initial generator, by mapping an <a>Int</a> into a generator. -- Again, distinct arguments should be likely to produce distinct -- generators. mkStdGen :: Int -> StdGen -- | With a source of random number supply in hand, the <a>Random</a> class -- allows the programmer to extract random values of a variety of types. -- -- Minimal complete definition: <a>randomR</a> and <a>random</a>. class Random a randomR :: (Random a, RandomGen g) => (a, a) -> g -> (a, g) random :: (Random a, RandomGen g) => g -> (a, g) randomRs :: (Random a, RandomGen g) => (a, a) -> g -> [a] randoms :: (Random a, RandomGen g) => g -> [a] randomRIO :: Random a => (a, a) -> IO a randomIO :: Random a => IO a -- | Uses the supplied function to get a value from the current global -- random generator, and updates the global generator with the new -- generator returned by the function. For example, <tt>rollDice</tt> -- gets a random integer between 1 and 6: -- -- <pre> -- rollDice :: IO Int -- rollDice = getStdRandom (randomR (1,6)) -- </pre> getStdRandom :: (StdGen -> (a, StdGen)) -> IO a -- | Gets the global random number generator. getStdGen :: IO StdGen -- | Sets the global random number generator. setStdGen :: StdGen -> IO () -- | Applies <a>split</a> to the current global random generator, updates -- it with one of the results, and returns the other. newStdGen :: IO StdGen module Word module Ptr module StablePtr module Monad -- | Monads that also support choice and failure. class Monad m => MonadPlus m :: (* -> *) mzero :: MonadPlus m => m a mplus :: MonadPlus m => m a -> m a -> m a -- | The <a>join</a> function is the conventional monad join operator. It -- is used to remove one level of monadic structure, projecting its bound -- argument into the outer level. join :: Monad m => m (m a) -> m a -- | <tt><a>guard</a> b</tt> is <tt><a>return</a> ()</tt> if <tt>b</tt> is -- <a>True</a>, and <a>mzero</a> if <tt>b</tt> is <a>False</a>. guard :: MonadPlus m => Bool -> m () -- | Conditional execution of monadic expressions. For example, -- -- <pre> -- when debug (putStr "Debugging\n") -- </pre> -- -- will output the string <tt>Debugging\n</tt> if the Boolean value -- <tt>debug</tt> is <a>True</a>, and otherwise do nothing. when :: Monad m => Bool -> m () -> m () -- | The reverse of <a>when</a>. unless :: Monad m => Bool -> m () -> m () -- | In many situations, the <a>liftM</a> operations can be replaced by -- uses of <a>ap</a>, which promotes function application. -- -- <pre> -- return f `ap` x1 `ap` ... `ap` xn -- </pre> -- -- is equivalent to -- -- <pre> -- liftMn f x1 x2 ... xn -- </pre> ap :: Monad m => m (a -> b) -> m a -> m b -- | This generalizes the list-based <a>concat</a> function. msum :: MonadPlus m => [m a] -> m a -- | This generalizes the list-based <a>filter</a> function. filterM :: Monad m => (a -> m Bool) -> [a] -> m [a] -- | The <a>mapAndUnzipM</a> function maps its first argument over a list, -- returning the result as a pair of lists. This function is mainly used -- with complicated data structures or a state-transforming monad. mapAndUnzipM :: Monad m => (a -> m (b, c)) -> [a] -> m ([b], [c]) -- | The <a>zipWithM</a> function generalizes <a>zipWith</a> to arbitrary -- monads. zipWithM :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m [c] -- | <a>zipWithM_</a> is the extension of <a>zipWithM</a> which ignores the -- final result. zipWithM_ :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m () -- | The <a>foldM</a> function is analogous to <a>foldl</a>, except that -- its result is encapsulated in a monad. Note that <a>foldM</a> works -- from left-to-right over the list arguments. This could be an issue -- where <tt>(<a>>></a>)</tt> and the `folded function' are not -- commutative. -- -- <pre> -- foldM f a1 [x1, x2, ..., xm] -- </pre> -- -- == -- -- <pre> -- do -- a2 <- f a1 x1 -- a3 <- f a2 x2 -- ... -- f am xm -- </pre> -- -- If right-to-left evaluation is required, the input list should be -- reversed. foldM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a -- | Promote a function to a monad. liftM :: Monad m => (a1 -> r) -> m a1 -> m r -- | Promote a function to a monad, scanning the monadic arguments from -- left to right. For example, -- -- <pre> -- liftM2 (+) [0,1] [0,2] = [0,2,1,3] -- liftM2 (+) (Just 1) Nothing = Nothing -- </pre> liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r -- | Promote a function to a monad, scanning the monadic arguments from -- left to right (cf. <a>liftM2</a>). liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r -- | Promote a function to a monad, scanning the monadic arguments from -- left to right (cf. <a>liftM2</a>). liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r -- | Promote a function to a monad, scanning the monadic arguments from -- left to right (cf. <a>liftM2</a>). liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r -- | The <a>Monad</a> class defines the basic operations over a -- <i>monad</i>, a concept from a branch of mathematics known as -- <i>category theory</i>. From the perspective of a Haskell programmer, -- however, it is best to think of a monad as an <i>abstract datatype</i> -- of actions. Haskell's <tt>do</tt> expressions provide a convenient -- syntax for writing monadic expressions. -- -- Minimal complete definition: <a>>>=</a> and <a>return</a>. -- -- Instances of <a>Monad</a> should satisfy the following laws: -- -- <pre> -- return a >>= k == k a -- m >>= return == m -- m >>= (\x -> k x >>= h) == (m >>= k) >>= h -- </pre> -- -- Instances of both <a>Monad</a> and <a>Functor</a> should additionally -- satisfy the law: -- -- <pre> -- fmap f xs == xs >>= return . f -- </pre> -- -- The instances of <a>Monad</a> for lists, <tt>Data.Maybe.Maybe</tt> and -- <tt>System.IO.IO</tt> defined in the <a>Prelude</a> satisfy these -- laws. class Monad m :: (* -> *) (>>=) :: Monad m => m a -> (a -> m b) -> m b (>>) :: Monad m => m a -> m b -> m b return :: Monad m => a -> m a fail :: Monad m => String -> m a -- | The <a>Functor</a> class is used for types that can be mapped over. -- Instances of <a>Functor</a> should satisfy the following laws: -- -- <pre> -- fmap id == id -- fmap (f . g) == fmap f . fmap g -- </pre> -- -- The instances of <a>Functor</a> for lists, <tt>Data.Maybe.Maybe</tt> -- and <tt>System.IO.IO</tt> satisfy these laws. class Functor f :: (* -> *) fmap :: Functor f => (a -> b) -> f a -> f b -- | <tt><a>mapM</a> f</tt> is equivalent to <tt><a>sequence</a> . -- <a>map</a> f</tt>. mapM :: Monad m => (a -> m b) -> [a] -> m [b] -- | <tt><a>mapM_</a> f</tt> is equivalent to <tt><a>sequence_</a> . -- <a>map</a> f</tt>. mapM_ :: Monad m => (a -> m b) -> [a] -> m () -- | Evaluate each action in the sequence from left to right, and collect -- the results. sequence :: Monad m => [m a] -> m [a] -- | Evaluate each action in the sequence from left to right, and ignore -- the results. sequence_ :: Monad m => [m a] -> m () -- | Same as <a>>>=</a>, but with the arguments interchanged. (=<<) :: Monad m => (a -> m b) -> m a -> m b module Ratio -- | Rational numbers, with numerator and denominator of some -- <a>Integral</a> type. data Integral a => Ratio a :: * -> * -- | Arbitrary-precision rational numbers, represented as a ratio of two -- <a>Integer</a> values. A rational number may be constructed using the -- <a>%</a> operator. type Rational = Ratio Integer -- | Forms the ratio of two integral numbers. (%) :: Integral a => a -> a -> Ratio a -- | Extract the numerator of the ratio in reduced form: the numerator and -- denominator have no common factor and the denominator is positive. numerator :: Integral a => Ratio a -> a -- | Extract the denominator of the ratio in reduced form: the numerator -- and denominator have no common factor and the denominator is positive. denominator :: Integral a => Ratio a -> a -- | <a>approxRational</a>, applied to two real fractional numbers -- <tt>x</tt> and <tt>epsilon</tt>, returns the simplest rational number -- within <tt>epsilon</tt> of <tt>x</tt>. A rational number <tt>y</tt> is -- said to be <i>simpler</i> than another <tt>y'</tt> if -- -- <ul> -- <li><tt><a>abs</a> (<a>numerator</a> y) <= <a>abs</a> -- (<a>numerator</a> y')</tt>, and</li> -- <li><tt><a>denominator</a> y <= <a>denominator</a> y'</tt>.</li> -- </ul> -- -- Any real interval contains a unique simplest rational; in particular, -- note that <tt>0/1</tt> is the simplest rational of all. approxRational :: RealFrac a => a -> a -> Rational module ForeignPtr module IO -- | Haskell defines operations to read and write characters from and to -- files, represented by values of type <tt>Handle</tt>. Each value of -- this type is a <i>handle</i>: a record used by the Haskell run-time -- system to <i>manage</i> I/O with file system objects. A handle has at -- least the following properties: -- -- <ul> -- <li>whether it manages input or output or both;</li> -- <li>whether it is <i>open</i>, <i>closed</i> or -- <i>semi-closed</i>;</li> -- <li>whether the object is seekable;</li> -- <li>whether buffering is disabled, or enabled on a line or block -- basis;</li> -- <li>a buffer (whose length may be zero).</li> -- </ul> -- -- Most handles will also have a current I/O position indicating where -- the next input or output operation will occur. A handle is -- <i>readable</i> if it manages only input or both input and output; -- likewise, it is <i>writable</i> if it manages only output or both -- input and output. A handle is <i>open</i> when first allocated. Once -- it is closed it can no longer be used for either input or output, -- though an implementation cannot re-use its storage while references -- remain to it. Handles are in the <a>Show</a> and <a>Eq</a> classes. -- The string produced by showing a handle is system dependent; it should -- include enough information to identify the handle for debugging. A -- handle is equal according to <a>==</a> only to itself; no attempt is -- made to compare the internal state of different handles for equality. data Handle :: * data HandlePosn :: * -- | See <tt>System.IO.openFile</tt> data IOMode :: * ReadMode :: IOMode WriteMode :: IOMode AppendMode :: IOMode ReadWriteMode :: IOMode -- | Three kinds of buffering are supported: line-buffering, -- block-buffering or no-buffering. These modes have the following -- effects. For output, items are written out, or <i>flushed</i>, from -- the internal buffer according to the buffer mode: -- -- <ul> -- <li><i>line-buffering</i>: the entire output buffer is flushed -- whenever a newline is output, the buffer overflows, a -- <tt>System.IO.hFlush</tt> is issued, or the handle is closed.</li> -- <li><i>block-buffering</i>: the entire buffer is written out whenever -- it overflows, a <tt>System.IO.hFlush</tt> is issued, or the handle is -- closed.</li> -- <li><i>no-buffering</i>: output is written immediately, and never -- stored in the buffer.</li> -- </ul> -- -- An implementation is free to flush the buffer more frequently, but not -- less frequently, than specified above. The output buffer is emptied as -- soon as it has been written out. -- -- Similarly, input occurs according to the buffer mode for the handle: -- -- <ul> -- <li><i>line-buffering</i>: when the buffer for the handle is not -- empty, the next item is obtained from the buffer; otherwise, when the -- buffer is empty, characters up to and including the next newline -- character are read into the buffer. No characters are available until -- the newline character is available or the buffer is full.</li> -- <li><i>block-buffering</i>: when the buffer for the handle becomes -- empty, the next block of data is read into the buffer.</li> -- <li><i>no-buffering</i>: the next input item is read and returned. The -- <tt>System.IO.hLookAhead</tt> operation implies that even a -- no-buffered handle may require a one-character buffer.</li> -- </ul> -- -- The default buffering mode when a handle is opened is -- implementation-dependent and may depend on the file system object -- which is attached to that handle. For most implementations, physical -- files will normally be block-buffered and terminals will normally be -- line-buffered. data BufferMode :: * -- | buffering is disabled if possible. NoBuffering :: BufferMode -- | line-buffering should be enabled if possible. LineBuffering :: BufferMode -- | block-buffering should be enabled if possible. The size of the buffer -- is <tt>n</tt> items if the argument is <a>Just</a> <tt>n</tt> and is -- otherwise implementation-dependent. BlockBuffering :: Maybe Int -> BufferMode -- | A mode that determines the effect of <tt>hSeek</tt> <tt>hdl mode -- i</tt>. data SeekMode :: * -- | the position of <tt>hdl</tt> is set to <tt>i</tt>. AbsoluteSeek :: SeekMode -- | the position of <tt>hdl</tt> is set to offset <tt>i</tt> from the -- current position. RelativeSeek :: SeekMode -- | the position of <tt>hdl</tt> is set to offset <tt>i</tt> from the end -- of the file. SeekFromEnd :: SeekMode -- | A handle managing input from the Haskell program's standard input -- channel. stdin :: Handle -- | A handle managing output to the Haskell program's standard output -- channel. stdout :: Handle -- | A handle managing output to the Haskell program's standard error -- channel. stderr :: Handle -- | Computation <a>openFile</a> <tt>file mode</tt> allocates and returns a -- new, open handle to manage the file <tt>file</tt>. It manages input if -- <tt>mode</tt> is <a>ReadMode</a>, output if <tt>mode</tt> is -- <a>WriteMode</a> or <a>AppendMode</a>, and both input and output if -- mode is <a>ReadWriteMode</a>. -- -- If the file does not exist and it is opened for output, it should be -- created as a new file. If <tt>mode</tt> is <a>WriteMode</a> and the -- file already exists, then it should be truncated to zero length. Some -- operating systems delete empty files, so there is no guarantee that -- the file will exist following an <a>openFile</a> with <tt>mode</tt> -- <a>WriteMode</a> unless it is subsequently written to successfully. -- The handle is positioned at the end of the file if <tt>mode</tt> is -- <a>AppendMode</a>, and otherwise at the beginning (in which case its -- internal position is 0). The initial buffer mode is -- implementation-dependent. -- -- This operation may fail with: -- -- <ul> -- <li><tt>isAlreadyInUseError</tt> if the file is already open and -- cannot be reopened;</li> -- <li><tt>isDoesNotExistError</tt> if the file does not exist; or</li> -- <li><tt>isPermissionError</tt> if the user does not have permission to -- open the file.</li> -- </ul> -- -- Note: if you will be working with files containing binary data, you'll -- want to be using <a>openBinaryFile</a>. openFile :: FilePath -> IOMode -> IO Handle -- | Computation <a>hClose</a> <tt>hdl</tt> makes handle <tt>hdl</tt> -- closed. Before the computation finishes, if <tt>hdl</tt> is writable -- its buffer is flushed as for <a>hFlush</a>. Performing <a>hClose</a> -- on a handle that has already been closed has no effect; doing so is -- not an error. All other operations on a closed handle will fail. If -- <a>hClose</a> fails for any reason, any further operations (apart from -- <a>hClose</a>) on the handle will still fail as if <tt>hdl</tt> had -- been successfully closed. hClose :: Handle -> IO () -- | For a handle <tt>hdl</tt> which attached to a physical file, -- <a>hFileSize</a> <tt>hdl</tt> returns the size of that file in 8-bit -- bytes. hFileSize :: Handle -> IO Integer -- | For a readable handle <tt>hdl</tt>, <a>hIsEOF</a> <tt>hdl</tt> returns -- <a>True</a> if no further input can be taken from <tt>hdl</tt> or for -- a physical file, if the current I/O position is equal to the length of -- the file. Otherwise, it returns <a>False</a>. -- -- NOTE: <a>hIsEOF</a> may block, because it has to attempt to read from -- the stream to determine whether there is any more data to be read. hIsEOF :: Handle -> IO Bool -- | The computation <a>isEOF</a> is identical to <a>hIsEOF</a>, except -- that it works only on <a>stdin</a>. isEOF :: IO Bool -- | Computation <a>hSetBuffering</a> <tt>hdl mode</tt> sets the mode of -- buffering for handle <tt>hdl</tt> on subsequent reads and writes. -- -- If the buffer mode is changed from <a>BlockBuffering</a> or -- <a>LineBuffering</a> to <a>NoBuffering</a>, then -- -- <ul> -- <li>if <tt>hdl</tt> is writable, the buffer is flushed as for -- <a>hFlush</a>;</li> -- <li>if <tt>hdl</tt> is not writable, the contents of the buffer is -- discarded.</li> -- </ul> -- -- This operation may fail with: -- -- <ul> -- <li><tt>isPermissionError</tt> if the handle has already been used for -- reading or writing and the implementation does not allow the buffering -- mode to be changed.</li> -- </ul> hSetBuffering :: Handle -> BufferMode -> IO () -- | Computation <a>hGetBuffering</a> <tt>hdl</tt> returns the current -- buffering mode for <tt>hdl</tt>. hGetBuffering :: Handle -> IO BufferMode -- | The action <a>hFlush</a> <tt>hdl</tt> causes any items buffered for -- output in handle <tt>hdl</tt> to be sent immediately to the operating -- system. -- -- This operation may fail with: -- -- <ul> -- <li><tt>isFullError</tt> if the device is full;</li> -- <li><tt>isPermissionError</tt> if a system resource limit would be -- exceeded. It is unspecified whether the characters in the buffer are -- discarded or retained under these circumstances.</li> -- </ul> hFlush :: Handle -> IO () -- | Computation <a>hGetPosn</a> <tt>hdl</tt> returns the current I/O -- position of <tt>hdl</tt> as a value of the abstract type -- <a>HandlePosn</a>. hGetPosn :: Handle -> IO HandlePosn -- | If a call to <a>hGetPosn</a> <tt>hdl</tt> returns a position -- <tt>p</tt>, then computation <a>hSetPosn</a> <tt>p</tt> sets the -- position of <tt>hdl</tt> to the position it held at the time of the -- call to <a>hGetPosn</a>. -- -- This operation may fail with: -- -- <ul> -- <li><tt>isPermissionError</tt> if a system resource limit would be -- exceeded.</li> -- </ul> hSetPosn :: HandlePosn -> IO () -- | Computation <a>hSeek</a> <tt>hdl mode i</tt> sets the position of -- handle <tt>hdl</tt> depending on <tt>mode</tt>. The offset <tt>i</tt> -- is given in terms of 8-bit bytes. -- -- If <tt>hdl</tt> is block- or line-buffered, then seeking to a position -- which is not in the current buffer will first cause any items in the -- output buffer to be written to the device, and then cause the input -- buffer to be discarded. Some handles may not be seekable (see -- <a>hIsSeekable</a>), or only support a subset of the possible -- positioning operations (for instance, it may only be possible to seek -- to the end of a tape, or to a positive offset from the beginning or -- current position). It is not possible to set a negative I/O position, -- or for a physical file, an I/O position beyond the current -- end-of-file. -- -- This operation may fail with: -- -- <ul> -- <li><tt>isIllegalOperationError</tt> if the Handle is not seekable, or -- does not support the requested seek mode.</li> -- <li><tt>isPermissionError</tt> if a system resource limit would be -- exceeded.</li> -- </ul> hSeek :: Handle -> SeekMode -> Integer -> IO () -- | Computation <a>hWaitForInput</a> <tt>hdl t</tt> waits until input is -- available on handle <tt>hdl</tt>. It returns <a>True</a> as soon as -- input is available on <tt>hdl</tt>, or <a>False</a> if no input is -- available within <tt>t</tt> milliseconds. Note that -- <a>hWaitForInput</a> waits until one or more full <i>characters</i> -- are available, which means that it needs to do decoding, and hence may -- fail with a decoding error. -- -- If <tt>t</tt> is less than zero, then <tt>hWaitForInput</tt> waits -- indefinitely. -- -- This operation may fail with: -- -- <ul> -- <li><a>isEOFError</a> if the end of file has been reached.</li> -- <li>a decoding error, if the input begins with an invalid byte -- sequence in this Handle's encoding.</li> -- </ul> -- -- NOTE for GHC users: unless you use the <tt>-threaded</tt> flag, -- <tt>hWaitForInput t</tt> where <tt>t >= 0</tt> will block all other -- Haskell threads for the duration of the call. It behaves like a -- <tt>safe</tt> foreign call in this respect. hWaitForInput :: Handle -> Int -> IO Bool -- | Computation <a>hReady</a> <tt>hdl</tt> indicates whether at least one -- item is available for input from handle <tt>hdl</tt>. -- -- This operation may fail with: -- -- <ul> -- <li><tt>System.IO.Error.isEOFError</tt> if the end of file has been -- reached.</li> -- </ul> hReady :: Handle -> IO Bool -- | Computation <a>hGetChar</a> <tt>hdl</tt> reads a character from the -- file or channel managed by <tt>hdl</tt>, blocking until a character is -- available. -- -- This operation may fail with: -- -- <ul> -- <li><a>isEOFError</a> if the end of file has been reached.</li> -- </ul> hGetChar :: Handle -> IO Char -- | Computation <a>hGetLine</a> <tt>hdl</tt> reads a line from the file or -- channel managed by <tt>hdl</tt>. -- -- This operation may fail with: -- -- <ul> -- <li><a>isEOFError</a> if the end of file is encountered when reading -- the <i>first</i> character of the line.</li> -- </ul> -- -- If <a>hGetLine</a> encounters end-of-file at any other point while -- reading in a line, it is treated as a line terminator and the -- (partial) line is returned. hGetLine :: Handle -> IO String -- | Computation <a>hLookAhead</a> returns the next character from the -- handle without removing it from the input buffer, blocking until a -- character is available. -- -- This operation may fail with: -- -- <ul> -- <li><tt>isEOFError</tt> if the end of file has been reached.</li> -- </ul> hLookAhead :: Handle -> IO Char -- | Computation <a>hGetContents</a> <tt>hdl</tt> returns the list of -- characters corresponding to the unread portion of the channel or file -- managed by <tt>hdl</tt>, which is put into an intermediate state, -- <i>semi-closed</i>. In this state, <tt>hdl</tt> is effectively closed, -- but items are read from <tt>hdl</tt> on demand and accumulated in a -- special list returned by <a>hGetContents</a> <tt>hdl</tt>. -- -- Any operation that fails because a handle is closed, also fails if a -- handle is semi-closed. The only exception is <tt>hClose</tt>. A -- semi-closed handle becomes closed: -- -- <ul> -- <li>if <tt>hClose</tt> is applied to it;</li> -- <li>if an I/O error occurs when reading an item from the handle;</li> -- <li>or once the entire contents of the handle has been read.</li> -- </ul> -- -- Once a semi-closed handle becomes closed, the contents of the -- associated list becomes fixed. The contents of this final list is only -- partially specified: it will contain at least all the items of the -- stream that were evaluated prior to the handle becoming closed. -- -- Any I/O errors encountered while a handle is semi-closed are simply -- discarded. -- -- This operation may fail with: -- -- <ul> -- <li><a>isEOFError</a> if the end of file has been reached.</li> -- </ul> hGetContents :: Handle -> IO String -- | Computation <a>hPutChar</a> <tt>hdl ch</tt> writes the character -- <tt>ch</tt> to the file or channel managed by <tt>hdl</tt>. Characters -- may be buffered if buffering is enabled for <tt>hdl</tt>. -- -- This operation may fail with: -- -- <ul> -- <li><a>isFullError</a> if the device is full; or</li> -- <li><a>isPermissionError</a> if another system resource limit would be -- exceeded.</li> -- </ul> hPutChar :: Handle -> Char -> IO () -- | Computation <a>hPutStr</a> <tt>hdl s</tt> writes the string <tt>s</tt> -- to the file or channel managed by <tt>hdl</tt>. -- -- This operation may fail with: -- -- <ul> -- <li><a>isFullError</a> if the device is full; or</li> -- <li><a>isPermissionError</a> if another system resource limit would be -- exceeded.</li> -- </ul> hPutStr :: Handle -> String -> IO () -- | The same as <a>hPutStr</a>, but adds a newline character. hPutStrLn :: Handle -> String -> IO () -- | Computation <a>hPrint</a> <tt>hdl t</tt> writes the string -- representation of <tt>t</tt> given by the <a>shows</a> function to the -- file or channel managed by <tt>hdl</tt> and appends a newline. -- -- This operation may fail with: -- -- <ul> -- <li><tt>System.IO.Error.isFullError</tt> if the device is full; -- or</li> -- <li><tt>System.IO.Error.isPermissionError</tt> if another system -- resource limit would be exceeded.</li> -- </ul> hPrint :: Show a => Handle -> a -> IO () hIsOpen :: Handle -> IO Bool hIsClosed :: Handle -> IO Bool hIsReadable :: Handle -> IO Bool hIsWritable :: Handle -> IO Bool hIsSeekable :: Handle -> IO Bool -- | An error indicating that an <a>IO</a> operation failed because one of -- its arguments already exists. isAlreadyExistsError :: IOError -> Bool -- | An error indicating that an <a>IO</a> operation failed because one of -- its arguments does not exist. isDoesNotExistError :: IOError -> Bool -- | An error indicating that an <a>IO</a> operation failed because one of -- its arguments is a single-use resource, which is already being used -- (for example, opening the same file twice for writing might give this -- error). isAlreadyInUseError :: IOError -> Bool -- | An error indicating that an <a>IO</a> operation failed because the -- device is full. isFullError :: IOError -> Bool -- | An error indicating that an <a>IO</a> operation failed because the end -- of file has been reached. isEOFError :: IOError -> Bool -- | An error indicating that an <a>IO</a> operation failed because the -- operation was not possible. Any computation which returns an <a>IO</a> -- result may fail with <a>isIllegalOperation</a>. In some cases, an -- implementation will not be able to distinguish between the possible -- error causes. In this case it should fail with -- <a>isIllegalOperation</a>. isIllegalOperation :: IOError -> Bool -- | An error indicating that an <a>IO</a> operation failed because the -- user does not have sufficient operating system privilege to perform -- that operation. isPermissionError :: IOError -> Bool -- | A programmer-defined error value constructed using <a>userError</a>. isUserError :: IOError -> Bool ioeGetErrorString :: IOError -> String ioeGetHandle :: IOError -> Maybe Handle ioeGetFileName :: IOError -> Maybe FilePath -- | The construct <a>try</a> <tt>comp</tt> exposes IO errors which occur -- within a computation, and which are not fully handled. -- -- Non-I/O exceptions are not caught by this variant; to catch all -- exceptions, use <tt>Control.Exception.try</tt> from -- <a>Control.Exception</a>. try :: IO a -> IO (Either IOError a) -- | The <a>bracket</a> function captures a common allocate, compute, -- deallocate idiom in which the deallocation step must occur even in the -- case of an error during computation. This is similar to -- try-catch-finally in Java. -- -- This version handles only IO errors, as defined by Haskell 98. The -- version of <tt>bracket</tt> in <a>Control.Exception</a> handles all -- exceptions, and should be used instead. bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c -- | A variant of <a>bracket</a> where the middle computation doesn't want -- <tt>x</tt>. -- -- This version handles only IO errors, as defined by Haskell 98. The -- version of <tt>bracket_</tt> in <a>Control.Exception</a> handles all -- exceptions, and should be used instead. bracket_ :: IO a -> (a -> IO b) -> IO c -> IO c data IO a :: * -> * -- | File and directory names are values of type <a>String</a>, whose -- precise meaning is operating system dependent. Files can be opened, -- yielding a handle which can then be used to operate on the contents of -- that file. type FilePath = String -- | The Haskell 98 type for exceptions in the <a>IO</a> monad. Any I/O -- operation may raise an <a>IOError</a> instead of returning a result. -- For a more general type of exception, including also those that arise -- in pure code, see <a>Control.Exception.Exception</a>. -- -- In Haskell 98, this is an opaque type. type IOError = IOException -- | Raise an <a>IOError</a> in the <a>IO</a> monad. ioError :: IOError -> IO a -- | Construct an <a>IOError</a> value with a string describing the error. -- The <a>fail</a> method of the <a>IO</a> instance of the <a>Monad</a> -- class raises a <a>userError</a>, thus: -- -- <pre> -- instance Monad IO where -- ... -- fail s = ioError (userError s) -- </pre> userError :: String -> IOError -- | The <a>catch</a> function establishes a handler that receives any -- <a>IOError</a> raised in the action protected by <a>catch</a>. An -- <a>IOError</a> is caught by the most recent handler established by -- <a>catch</a>. These handlers are not selective: all <a>IOError</a>s -- are caught. Exception propagation must be explicitly provided in a -- handler by re-raising any unwanted exceptions. For example, in -- -- <pre> -- f = catch g (\e -> if IO.isEOFError e then return [] else ioError e) -- </pre> -- -- the function <tt>f</tt> returns <tt>[]</tt> when an end-of-file -- exception (cf. <a>isEOFError</a>) occurs in <tt>g</tt>; otherwise, the -- exception is propagated to the next outer handler. -- -- When an exception propagates outside the main program, the Haskell -- system prints the associated <a>IOError</a> value and exits the -- program. -- -- Non-I/O exceptions are not caught by this variant; to catch all -- exceptions, use <tt>Control.Exception.catch</tt> from -- <a>Control.Exception</a>. catch :: IO a -> (IOError -> IO a) -> IO a -- | The <a>interact</a> function takes a function of type -- <tt>String->String</tt> as its argument. The entire input from the -- standard input device is passed to this function as its argument, and -- the resulting string is output on the standard output device. interact :: (String -> String) -> IO () -- | Write a character to the standard output device (same as -- <a>hPutChar</a> <a>stdout</a>). putChar :: Char -> IO () -- | Write a string to the standard output device (same as <a>hPutStr</a> -- <a>stdout</a>). putStr :: String -> IO () -- | The same as <a>putStr</a>, but adds a newline character. putStrLn :: String -> IO () -- | The <a>print</a> function outputs a value of any printable type to the -- standard output device. Printable types are those that are instances -- of class <a>Show</a>; <a>print</a> converts values to strings for -- output using the <a>show</a> operation and adds a newline. -- -- For example, a program to print the first 20 integers and their powers -- of 2 could be written as: -- -- <pre> -- main = print ([(n, 2^n) | n <- [0..19]]) -- </pre> print :: Show a => a -> IO () -- | Read a character from the standard input device (same as -- <a>hGetChar</a> <a>stdin</a>). getChar :: IO Char -- | Read a line from the standard input device (same as <a>hGetLine</a> -- <a>stdin</a>). getLine :: IO String -- | The <a>getContents</a> operation returns all user input as a single -- string, which is read lazily as it is needed (same as -- <a>hGetContents</a> <a>stdin</a>). getContents :: IO String -- | The <a>readFile</a> function reads a file and returns the contents of -- the file as a string. The file is read lazily, on demand, as with -- <a>getContents</a>. readFile :: FilePath -> IO String -- | The computation <a>writeFile</a> <tt>file str</tt> function writes the -- string <tt>str</tt>, to the file <tt>file</tt>. writeFile :: FilePath -> String -> IO () -- | The computation <a>appendFile</a> <tt>file str</tt> function appends -- the string <tt>str</tt>, to the file <tt>file</tt>. -- -- Note that <a>writeFile</a> and <a>appendFile</a> write a literal -- string to a file. To write a value of any printable type, as with -- <a>print</a>, use the <a>show</a> function to convert the value to a -- string first. -- -- <pre> -- main = appendFile "squares" (show [(x,x*x) | x <- [0,0.1..2]]) -- </pre> appendFile :: FilePath -> String -> IO () -- | The <a>readIO</a> function is similar to <a>read</a> except that it -- signals parse failure to the <a>IO</a> monad instead of terminating -- the program. readIO :: Read a => String -> IO a -- | The <a>readLn</a> function combines <a>getLine</a> and <a>readIO</a>. readLn :: Read a => IO a module Char -- | Selects the first 128 characters of the Unicode character set, -- corresponding to the ASCII character set. isAscii :: Char -> Bool -- | Selects the first 256 characters of the Unicode character set, -- corresponding to the ISO 8859-1 (Latin-1) character set. isLatin1 :: Char -> Bool -- | Selects control characters, which are the non-printing characters of -- the Latin-1 subset of Unicode. isControl :: Char -> Bool -- | Selects printable Unicode characters (letters, numbers, marks, -- punctuation, symbols and spaces). isPrint :: Char -> Bool -- | Returns <a>True</a> for any Unicode space character, and the control -- characters <tt>\t</tt>, <tt>\n</tt>, <tt>\r</tt>, <tt>\f</tt>, -- <tt>\v</tt>. isSpace :: Char -> Bool -- | Selects upper-case or title-case alphabetic Unicode characters -- (letters). Title case is used by a small number of letter ligatures -- like the single-character form of <i>Lj</i>. isUpper :: Char -> Bool -- | Selects lower-case alphabetic Unicode characters (letters). isLower :: Char -> Bool -- | Selects alphabetic Unicode characters (lower-case, upper-case and -- title-case letters, plus letters of caseless scripts and modifiers -- letters). This function is equivalent to <tt>Data.Char.isLetter</tt>. isAlpha :: Char -> Bool -- | Selects ASCII digits, i.e. <tt>'0'</tt>..<tt>'9'</tt>. isDigit :: Char -> Bool -- | Selects ASCII octal digits, i.e. <tt>'0'</tt>..<tt>'7'</tt>. isOctDigit :: Char -> Bool -- | Selects ASCII hexadecimal digits, i.e. <tt>'0'</tt>..<tt>'9'</tt>, -- <tt>'a'</tt>..<tt>'f'</tt>, <tt>'A'</tt>..<tt>'F'</tt>. isHexDigit :: Char -> Bool -- | Selects alphabetic or numeric digit Unicode characters. -- -- Note that numeric digits outside the ASCII range are selected by this -- function but not by <a>isDigit</a>. Such digits may be part of -- identifiers but are not used by the printer and reader to represent -- numbers. isAlphaNum :: Char -> Bool -- | Convert a single digit <a>Char</a> to the corresponding <a>Int</a>. -- This function fails unless its argument satisfies <a>isHexDigit</a>, -- but recognises both upper and lower-case hexadecimal digits (i.e. -- <tt>'0'</tt>..<tt>'9'</tt>, <tt>'a'</tt>..<tt>'f'</tt>, -- <tt>'A'</tt>..<tt>'F'</tt>). digitToInt :: Char -> Int -- | Convert an <a>Int</a> in the range <tt>0</tt>..<tt>15</tt> to the -- corresponding single digit <a>Char</a>. This function fails on other -- inputs, and generates lower-case hexadecimal digits. intToDigit :: Int -> Char -- | Convert a letter to the corresponding upper-case letter, if any. Any -- other character is returned unchanged. toUpper :: Char -> Char -- | Convert a letter to the corresponding lower-case letter, if any. Any -- other character is returned unchanged. toLower :: Char -> Char -- | The <tt>Prelude.fromEnum</tt> method restricted to the type -- <tt>Data.Char.Char</tt>. ord :: Char -> Int -- | The <tt>Prelude.toEnum</tt> method restricted to the type -- <tt>Data.Char.Char</tt>. chr :: Int -> Char -- | Read a string representation of a character, using Haskell -- source-language escape conventions, and convert it to the character -- that it encodes. For example: -- -- <pre> -- readLitChar "\\nHello" = [('\n', "Hello")] -- </pre> readLitChar :: ReadS Char -- | Convert a character to a string using only printable characters, using -- Haskell source-language escape conventions. For example: -- -- <pre> -- showLitChar '\n' s = "\\n" ++ s -- </pre> showLitChar :: Char -> ShowS -- | Read a string representation of a character, using Haskell -- source-language escape conventions. For example: -- -- <pre> -- lexLitChar "\\nHello" = [("\\n", "Hello")] -- </pre> lexLitChar :: ReadS String data Char :: * -- | A <a>String</a> is a list of characters. String constants in Haskell -- are values of type <a>String</a>. type String = [Char] module Int module Ix -- | The <a>Ix</a> class is used to map a contiguous subrange of values in -- a type onto integers. It is used primarily for array indexing (see the -- array package). -- -- The first argument <tt>(l,u)</tt> of each of these operations is a -- pair specifying the lower and upper bounds of a contiguous subrange of -- values. -- -- An implementation is entitled to assume the following laws about these -- operations: -- -- <ul> -- <li><tt><a>inRange</a> (l,u) i == <a>elem</a> i (<a>range</a> -- (l,u))</tt> <tt> </tt></li> -- <li><tt><a>range</a> (l,u) <a>!!</a> <a>index</a> (l,u) i == i</tt>, -- when <tt><a>inRange</a> (l,u) i</tt></li> -- <li><tt><a>map</a> (<a>index</a> (l,u)) (<a>range</a> (l,u))) == -- [0..<a>rangeSize</a> (l,u)-1]</tt> <tt> </tt></li> -- <li><tt><a>rangeSize</a> (l,u) == <a>length</a> (<a>range</a> -- (l,u))</tt> <tt> </tt></li> -- </ul> -- -- Minimal complete instance: <a>range</a>, <a>index</a> and -- <a>inRange</a>. class Ord a => Ix a range :: Ix a => (a, a) -> [a] index :: Ix a => (a, a) -> a -> Int inRange :: Ix a => (a, a) -> a -> Bool rangeSize :: Ix a => (a, a) -> Int -- | The size of the subrange defined by a bounding pair. rangeSize :: Ix a => (a, a) -> Int module Array -- | The type of immutable non-strict (boxed) arrays with indices in -- <tt>i</tt> and elements in <tt>e</tt>. data Ix i => Array i e :: * -> * -> * -- | Construct an array with the specified bounds and containing values for -- given indices within these bounds. -- -- The array is undefined (i.e. bottom) if any index in the list is out -- of bounds. The Haskell 98 Report further specifies that if any two -- associations in the list have the same index, the value at that index -- is undefined (i.e. bottom). However in GHC's implementation, the value -- at such an index is the value part of the last association with that -- index in the list. -- -- Because the indices must be checked for these errors, <a>array</a> is -- strict in the bounds argument and in the indices of the association -- list, but non-strict in the values. Thus, recurrences such as the -- following are possible: -- -- <pre> -- a = array (1,100) ((1,1) : [(i, i * a!(i-1)) | i <- [2..100]]) -- </pre> -- -- Not every index within the bounds of the array need appear in the -- association list, but the values associated with indices that do not -- appear will be undefined (i.e. bottom). -- -- If, in any dimension, the lower bound is greater than the upper bound, -- then the array is legal, but empty. Indexing an empty array always -- gives an array-bounds error, but <a>bounds</a> still yields the bounds -- with which the array was constructed. array :: Ix i => (i, i) -> [(i, e)] -> Array i e -- | Construct an array from a pair of bounds and a list of values in index -- order. listArray :: Ix i => (i, i) -> [e] -> Array i e -- | The value at the given index in an array. (!) :: Ix i => Array i e -> i -> e -- | The bounds with which an array was constructed. bounds :: Ix i => Array i e -> (i, i) -- | The list of indices of an array in ascending order. indices :: Ix i => Array i e -> [i] -- | The list of elements of an array in index order. elems :: Ix i => Array i e -> [e] -- | The list of associations of an array in index order. assocs :: Ix i => Array i e -> [(i, e)] -- | The <a>accumArray</a> function deals with repeated indices in the -- association list using an <i>accumulating function</i> which combines -- the values of associations with the same index. For example, given a -- list of values of some index type, <tt>hist</tt> produces a histogram -- of the number of occurrences of each index within a specified range: -- -- <pre> -- hist :: (Ix a, Num b) => (a,a) -> [a] -> Array a b -- hist bnds is = accumArray (+) 0 bnds [(i, 1) | i<-is, inRange bnds i] -- </pre> -- -- If the accumulating function is strict, then <a>accumArray</a> is -- strict in the values, as well as the indices, in the association list. -- Thus, unlike ordinary arrays built with <a>array</a>, accumulated -- arrays should not in general be recursive. accumArray :: Ix i => (e -> a -> e) -> e -> (i, i) -> [(i, a)] -> Array i e -- | Constructs an array identical to the first argument except that it has -- been updated by the associations in the right argument. For example, -- if <tt>m</tt> is a 1-origin, <tt>n</tt> by <tt>n</tt> matrix, then -- -- <pre> -- m//[((i,i), 0) | i <- [1..n]] -- </pre> -- -- is the same matrix, except with the diagonal zeroed. -- -- Repeated indices in the association list are handled as for -- <a>array</a>: Haskell 98 specifies that the resulting array is -- undefined (i.e. bottom), but GHC's implementation uses the last -- association for each index. (//) :: Ix i => Array i e -> [(i, e)] -> Array i e -- | <tt><a>accum</a> f</tt> takes an array and an association list and -- accumulates pairs from the list into the array with the accumulating -- function <tt>f</tt>. Thus <a>accumArray</a> can be defined using -- <a>accum</a>: -- -- <pre> -- accumArray f z b = accum f (array b [(i, z) | i <- range b]) -- </pre> accum :: Ix i => (e -> a -> e) -> Array i e -> [(i, a)] -> Array i e -- | <a>ixmap</a> allows for transformations on array indices. It may be -- thought of as providing function composition on the right with the -- mapping that the original array embodies. -- -- A similar transformation of array values may be achieved using -- <a>fmap</a> from the <a>Array</a> instance of the <a>Functor</a> -- class. ixmap :: (Ix i, Ix j) => (i, i) -> (i -> j) -> Array j e -> Array i e