Permalink
Fetching contributors…
Cannot retrieve contributors at this time
2532 lines (2180 sloc) 96.3 KB
-- 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>
--
-- Note that <a>inits</a> has the following strictness property:
-- <tt>inits _|_ = [] : _|_</tt>
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>
--
-- Note that <a>tails</a> has the following strictness property:
-- <tt>tails _|_ = _|_ : _|_</tt>
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 -&gt; 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 -&gt; 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 &lt;- 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 &gt; <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 &gt; <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> when
-- <tt>n</tt> is not <tt>_|_</tt> (<tt>splitAt _|_ 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 (&lt; 3) [1,2,3,4,1,2,3,4] == [1,2]
-- takeWhile (&lt; 9) [1,2,3] == [1,2,3]
-- takeWhile (&lt; 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 (&lt; 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3]
-- dropWhile (&lt; 9) [1,2,3] == []
-- dropWhile (&lt; 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 (&lt; 3) [1,2,3,4,1,2,3,4] == ([1,2],[3,4,1,2,3,4])
-- span (&lt; 9) [1,2,3] == ([1,2,3],[])
-- span (&lt; 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 (&gt; 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4])
-- break (&lt; 9) [1,2,3] == ([],[1,2,3])
-- break (&gt; 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 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>
--
-- Note that in a concurrent program, the current directory is global
-- state shared between all threads of the process. When using filesystem
-- operations from multiple threads, it is therefore highly recommended
-- to use absolute rather than relative <a>FilePath</a>s.
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>
--
-- Note that in a concurrent program, the current directory is global
-- state shared between all threads of the process. When using filesystem
-- operations from multiple threads, it is therefore highly recommended
-- to use absolute rather than relative <a>FilePath</a>s.
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>&gt;&gt;</a>)</tt> and the `folded function' are not
-- commutative.
--
-- <pre>
-- foldM f a1 [x1, x2, ..., xm]
-- </pre>
--
-- ==
--
-- <pre>
-- do
-- a2 &lt;- f a1 x1
-- a3 &lt;- 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>&gt;&gt;=</a> and <a>return</a>.
--
-- Instances of <a>Monad</a> should satisfy the following laws:
--
-- <pre>
-- return a &gt;&gt;= k == k a
-- m &gt;&gt;= return == m
-- m &gt;&gt;= (\x -&gt; k x &gt;&gt;= h) == (m &gt;&gt;= k) &gt;&gt;= h
-- </pre>
--
-- Instances of both <a>Monad</a> and <a>Functor</a> should additionally
-- satisfy the law:
--
-- <pre>
-- fmap f xs == xs &gt;&gt;= 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>&gt;&gt;=</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 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) &lt;= <a>abs</a>
-- (<a>numerator</a> y')</tt>, and</li>
-- <li><tt><a>denominator</a> y &lt;= <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 &gt;= 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 <a>try</a> function is deprecated. Please use the new exceptions
-- variant, <tt>Control.Exception.try</tt> from <a>Control.Exception</a>,
-- instead.
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
-- | A value of type <tt><a>IO</a> a</tt> is a computation which, when
-- performed, does some I/O before returning a value of type <tt>a</tt>.
--
-- There is really only one way to "perform" an I/O action: bind it to
-- <tt>Main.main</tt> in your program. When your program is run, the I/O
-- will be performed. It isn't possible to perform I/O from an arbitrary
-- function, unless that function is itself in the <a>IO</a> monad and
-- called at some point, directly or indirectly, from <tt>Main.main</tt>.
--
-- <a>IO</a> is a monad, so <a>IO</a> actions can be combined using
-- either the do-notation or the <tt>&gt;&gt;</tt> and <tt>&gt;&gt;=</tt>
-- operations from the <tt>Monad</tt> class.
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 is deprecated. Please use the new exceptions
-- variant, <tt>Control.Exception.catch</tt> from
-- <a>Control.Exception</a>, instead.
catch :: IO a -> (IOError -> IO a) -> IO a
-- | The <a>interact</a> function takes a function of type
-- <tt>String-&gt;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 &lt;- [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 &lt;- [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
-- | The character type <a>Char</a> is an enumeration whose values
-- represent Unicode (or equivalently ISO/IEC 10646) characters (see
-- <a>http://www.unicode.org/</a> for details). This set extends the ISO
-- 8859-1 (Latin-1) character set (the first 256 charachers), which is
-- itself an extension of the ASCII character set (the first 128
-- characters). A character literal in Haskell has type <a>Char</a>.
--
-- To convert a <a>Char</a> to or from the corresponding <a>Int</a> value
-- defined by Unicode, use <tt>Prelude.toEnum</tt> and
-- <tt>Prelude.fromEnum</tt> from the <tt>Prelude.Enum</tt> class
-- respectively (or equivalently <tt>ord</tt> and <tt>chr</tt>).
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 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 &lt;- [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) =&gt; (a,a) -&gt; [a] -&gt; Array a b
-- hist bnds is = accumArray (+) 0 bnds [(i, 1) | i&lt;-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 &lt;- [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 &lt;- 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