Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

more tests, support UTF-8

  • Loading branch information...
commit d3b750e8fa8615e8c7cf0002d832baa4d38a4332 1 parent b93cb57
@JPMoresmau JPMoresmau authored
View
347 data/base-unicode-symbols.txt
@@ -0,0 +1,347 @@
+-- Hoogle documentation, generated by Haddock
+-- See Hoogle, http://www.haskell.org/hoogle/
+
+
+-- | Unicode alternatives for common functions and operators
+--
+-- This package defines new symbols for a number of functions and
+-- operators in the base package.
+--
+-- All symbols are documented with their actual definition and
+-- information regarding their Unicode code point. They should be
+-- completely interchangeable with their definitions.
+--
+-- For further Unicode goodness you can enable the <tt>UnicodeSyntax</tt>
+-- language extension [1]. This extension enables Unicode characters to
+-- be used to stand for certain ASCII character sequences, i.e. → instead
+-- of <tt>-&gt;</tt>, ∀ instead of <tt>forall</tt> and many others.
+--
+-- Original idea by Péter Diviánszky.
+--
+-- [1]
+-- <a>http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#unicode-syntax</a>
+@package base-unicode-symbols
+@version 0.2.1.5
+
+
+module Data.Ord.Unicode
+
+-- | (≤) = (<a>&lt;=</a>)
+--
+-- U+2264, LESS-THAN OR EQUAL TO
+(≤) :: Ord α => α -> α -> Bool
+
+-- | (≥) = (<a>&gt;=</a>)
+--
+-- U+2265, GREATER-THAN OR EQUAL TO
+(≥) :: Ord α => α -> α -> Bool
+
+-- | (≮) = (<a>&gt;=</a>)
+--
+-- U+226E, NOT LESS-THAN
+(≮) :: Ord α => α -> α -> Bool
+
+-- | (≯) = (<a>&lt;=</a>)
+--
+-- U+226F, NOT GREATER-THAN
+(≯) :: Ord α => α -> α -> Bool
+
+
+module Data.Monoid.Unicode
+
+-- | (∅) = <a>mempty</a>
+--
+-- U+2205, EMPTY SET
+(∅) :: Monoid α => α
+
+-- | (⊕) = <a>mappend</a>
+--
+-- U+2295, CIRCLED PLUS
+(⊕) :: Monoid α => α -> α -> α
+
+
+module Data.List.Unicode
+
+-- | (⧺) = (<a>++</a>)
+--
+-- U+29FA, DOUBLE PLUS
+(⧺) :: [α] -> [α] -> [α]
+
+-- | (∈) = <a>elem</a>
+--
+-- U+2208, ELEMENT OF
+(∈) :: Eq α => α -> [α] -> Bool
+
+-- | (∋) = <a>flip</a> (∈)
+--
+-- U+220B, CONTAINS AS MEMBER
+(∋) :: Eq α => [α] -> α -> Bool
+
+-- | (∉) = <a>notElem</a>
+--
+-- U+2209, NOT AN ELEMENT OF
+(∉) :: Eq α => α -> [α] -> Bool
+
+-- | (∌) = <a>flip</a> (∉)
+--
+-- U+220C, DOES NOT CONTAIN AS MEMBER
+(∌) :: Eq α => [α] -> α -> Bool
+
+-- | (∪) = <a>union</a>
+--
+-- U+222A, UNION
+(∪) :: Eq α => [α] -> [α] -> [α]
+
+-- | (∖) = (<a>\\</a>)
+--
+-- U+2216, SET MINUS
+(∖) :: Eq α => [α] -> [α] -> [α]
+
+-- | Symmetric difference
+--
+-- a ∆ b = (a ∖ b) ∪ (b ∖ a)
+--
+-- U+2206, INCREMENT
+(∆) :: Eq α => [α] -> [α] -> [α]
+
+-- | (∩) = <a>intersect</a>
+--
+-- U+2229, INTERSECTION
+(∩) :: Eq α => [α] -> [α] -> [α]
+
+
+module Data.Function.Unicode
+
+-- | (∘) = (<a>.</a>)
+--
+-- U+2218, RING OPERATOR
+(∘) :: (β -> γ) -> (α -> β) -> (α -> γ)
+
+
+module Data.Foldable.Unicode
+
+-- | (∈) = <a>elem</a>
+--
+-- U+2208, ELEMENT OF
+(∈) :: (Foldable t, Eq α) => α -> t α -> Bool
+
+-- | (∋) = <a>flip</a> (∈)
+--
+-- U+220B, CONTAINS AS MEMBER
+(∋) :: (Foldable t, Eq α) => t α -> α -> Bool
+
+-- | (∉) = <a>notElem</a>
+--
+-- U+2209, NOT AN ELEMENT OF
+(∉) :: (Foldable t, Eq α) => α -> t α -> Bool
+
+-- | (∌) = <a>flip</a> (∉)
+--
+-- U+220C, DOES NOT CONTAIN AS MEMBER
+(∌) :: (Foldable t, Eq α) => t α -> α -> Bool
+
+
+module Data.Eq.Unicode
+
+-- | (≡) = (<a>==</a>)
+--
+-- U+2261, IDENTICAL TO
+(≡) :: Eq α => α -> α -> Bool
+
+-- | (≢) = (<a>/=</a>)
+--
+-- U+2262, NOT IDENTICAL TO
+(≢) :: Eq α => α -> α -> Bool
+
+-- | (≠) = (<a>/=</a>)
+--
+-- U+2260, NOT EQUAL TO
+(≠) :: Eq α => α -> α -> Bool
+
+
+module Data.Bool.Unicode
+
+-- | (∧) = (<a>&amp;&amp;</a>)
+--
+-- U+2227, LOGICAL AND
+(∧) :: Bool -> Bool -> Bool
+
+-- | (∨) = (<a>||</a>)
+--
+-- U+2228, LOGICAL OR
+(∨) :: Bool -> Bool -> Bool
+
+-- | (¬) = <a>not</a>
+--
+-- U+00AC, NOT SIGN
+(¬) :: Bool -> Bool
+
+
+module Prelude.Unicode
+
+-- | (¬) = <a>not</a>
+--
+-- U+00AC, NOT SIGN
+(¬) :: Bool -> Bool
+
+-- | (∧) = (<a>&amp;&amp;</a>)
+--
+-- U+2227, LOGICAL AND
+(∧) :: Bool -> Bool -> Bool
+
+-- | (∨) = (<a>||</a>)
+--
+-- U+2228, LOGICAL OR
+(∨) :: Bool -> Bool -> Bool
+
+-- | (≡) = (<a>==</a>)
+--
+-- U+2261, IDENTICAL TO
+(≡) :: Eq α => α -> α -> Bool
+
+-- | (≢) = (<a>/=</a>)
+--
+-- U+2262, NOT IDENTICAL TO
+(≢) :: Eq α => α -> α -> Bool
+
+-- | (≠) = (<a>/=</a>)
+--
+-- U+2260, NOT EQUAL TO
+(≠) :: Eq α => α -> α -> Bool
+
+-- | (≤) = (<a>&lt;=</a>)
+--
+-- U+2264, LESS-THAN OR EQUAL TO
+(≤) :: Ord α => α -> α -> Bool
+
+-- | (≥) = (<a>&gt;=</a>)
+--
+-- U+2265, GREATER-THAN OR EQUAL TO
+(≥) :: Ord α => α -> α -> Bool
+
+-- | (≮) = (<a>&gt;=</a>)
+--
+-- U+226E, NOT LESS-THAN
+(≮) :: Ord α => α -> α -> Bool
+
+-- | (≯) = (<a>&lt;=</a>)
+--
+-- U+226F, NOT GREATER-THAN
+(≯) :: Ord α => α -> α -> Bool
+
+-- | π = <a>pi</a>
+--
+-- U+03C0, GREEK SMALL LETTER PI
+π :: Floating α => α
+
+-- | (÷) = (<a>/</a>)
+--
+-- U+00F7, DIVISION SIGN
+(÷) :: Fractional α => α -> α -> α
+
+-- | (⋅) = (<a>*</a>)
+--
+-- U+22C5, DOT OPERATOR
+(⋅) :: Num α => α -> α -> α
+
+-- | (∘) = (<a>.</a>)
+--
+-- U+2218, RING OPERATOR
+(∘) :: (β -> γ) -> (α -> β) -> (α -> γ)
+
+-- | (⧺) = (<a>++</a>)
+--
+-- U+29FA, DOUBLE PLUS
+(⧺) :: [α] -> [α] -> [α]
+
+-- | (∈) = <a>elem</a>
+--
+-- U+2208, ELEMENT OF
+(∈) :: Eq α => α -> [α] -> Bool
+
+-- | (∉) = <a>notElem</a>
+--
+-- U+2209, NOT AN ELEMENT OF
+(∉) :: Eq α => α -> [α] -> Bool
+
+-- | (⊥) = <a>undefined</a>
+--
+-- U+22A5, UP TACK
+(⊥) :: α
+
+
+module Control.Monad.Unicode
+
+-- | (≫=) = (<a>&gt;&gt;=</a>)
+--
+-- (U+226B, MUCH GREATER-THAN) + (U+3D, EQUALS SIGN)
+(≫=) :: Monad m => m α -> (α -> m β) -> m β
+
+-- | (≫) = (<a>&gt;&gt;</a>)
+--
+-- U+226B, MUCH GREATER-THAN
+(≫) :: Monad m => m α -> m β -> m β
+
+-- | (=≪) = (<a>=&lt;&lt;</a>)
+--
+-- (U+3D, EQUALS SIGN) + (U+226A, MUCH LESS-THAN)
+(=≪) :: Monad m => (α -> m β) -> m α -> m β
+
+
+module Control.Applicative.Unicode
+
+-- | (⊛) = <a>&lt;*&gt;</a>
+--
+-- U+229B, CIRCLED ASTERISK OPERATOR
+(⊛) :: Applicative f => f (α -> β) -> f α -> f β
+
+-- | (∅) = <a>empty</a>
+--
+-- U+2205, EMPTY SET
+(∅) :: Alternative f => f α
+
+
+module Control.Category.Unicode
+
+-- | (∘) = (<a>.</a>)
+--
+-- U+2218, RING OPERATOR
+(∘) :: Category ⇝ => (β ⇝ γ) -> (α ⇝ β) -> (α ⇝ γ)
+
+-- | (⋙) = (<a>&gt;&gt;&gt;</a>)
+--
+-- U+22D9, VERY MUCH GREATER-THAN
+(⋙) :: Category ⇝ => (α ⇝ β) -> (β ⇝ γ) -> (α ⇝ γ)
+
+-- | (⋘) = (<a>&lt;&lt;&lt;</a>)
+--
+-- U+22D8, VERY MUCH LESS-THAN
+(⋘) :: Category ⇝ => (β ⇝ γ) -> (α ⇝ β) -> (α ⇝ γ)
+
+
+module Control.Arrow.Unicode
+
+-- | (⋙) = (<a>&gt;&gt;&gt;</a>)
+--
+-- U+22D9, VERY MUCH GREATER-THAN
+(⋙) :: Category ⇝ => (α ⇝ β) -> (β ⇝ γ) -> (α ⇝ γ)
+
+-- | (⋘) = (<a>&lt;&lt;&lt;</a>)
+--
+-- U+22D8, VERY MUCH LESS-THAN
+(⋘) :: Category ⇝ => (β ⇝ γ) -> (α ⇝ β) -> (α ⇝ γ)
+
+-- | (⁂) = (<a>***</a>)
+--
+-- U+2042, ASTERISM
+(⁂) :: Arrow ⇝ => (α ⇝ β) -> (α' ⇝ β') -> (α, α') ⇝ (β, β')
+
+-- | (⧻) = (<a>+++</a>)
+--
+-- U+29FB, TRIPLE PLUS
+(⧻) :: ArrowChoice ⇝ => (α ⇝ β) -> (α' ⇝ β') -> (Either α α' ⇝ Either β β')
+
+-- | (⫴) = (<a>|||</a>)
+--
+-- U+2AF4, TRIPLE VERTICAL BAR BINARY RELATION
+(⫴) :: ArrowChoice ⇝ => (α ⇝ δ) -> (β ⇝ δ) -> (Either α β ⇝ δ)
View
2,909 data/containers.txt
2,909 additions, 0 deletions not shown
View
1,158 data/ghc-prim.txt
@@ -0,0 +1,1158 @@
+-- Hoogle documentation, generated by Haddock
+-- See Hoogle, http://www.haskell.org/hoogle/
+
+
+-- | GHC primitives
+--
+-- GHC primitives.
+@package ghc-prim
+
+
+-- | GHC magic. Use GHC.Exts from the base package instead of importing
+-- this module directly.
+module GHC.Magic
+
+-- | The call '(inline f)' reduces to <tt>f</tt>, but <a>inline</a> has a
+-- BuiltInRule that tries to inline <tt>f</tt> (if it has an unfolding)
+-- unconditionally The <tt>NOINLINE</tt> pragma arranges that inline only
+-- gets inlined (and hence eliminated) late in compilation, after the
+-- rule has had a good chance to fire.
+inline :: a -> a
+
+module GHC.Generics
+data Unit
+Unit :: Unit
+data (:+:) a b
+Inl :: a -> :+: a b
+Inr :: b -> :+: a b
+data (:*:) a b
+(:*:) :: a -> b -> :*: a b
+
+
+-- | GHC type definitions. Use GHC.Exts from the base package instead of
+-- importing this module directly.
+module GHC.Types
+
+-- | 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
+C# :: Char# -> Char
+
+-- | A fixed-precision integer type with at least the range <tt>[-2^29 ..
+-- 2^29-1]</tt>. The exact range for a given implementation can be
+-- determined by using <tt>Prelude.minBound</tt> and
+-- <tt>Prelude.maxBound</tt> from the <tt>Prelude.Bounded</tt> class.
+data Int
+I# :: Int# -> Int
+
+-- | Single-precision floating point numbers. It is desirable that this
+-- type be at least equal in range and precision to the IEEE
+-- single-precision type.
+data Float
+F# :: Float# -> Float
+
+-- | Double-precision floating point numbers. It is desirable that this
+-- type be at least equal in range and precision to the IEEE
+-- double-precision type.
+data Double
+D# :: Double# -> Double
+
+-- | 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.
+newtype IO a
+IO :: (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
+
+module GHC.Unit
+
+-- | The unit datatype <tt>()</tt> has one non-undefined member, the
+-- nullary constructor <tt>()</tt>.
+data ()
+() :: ()
+
+module GHC.Debug
+debugLn :: [Char] -> IO ()
+debugErrLn :: [Char] -> IO ()
+
+module GHC.Ordering
+data Ordering
+LT :: Ordering
+EQ :: Ordering
+GT :: Ordering
+
+
+-- | The tuple data types
+module GHC.Tuple
+data (,) a b
+(,) :: a -> b -> (,) a b
+data (,,) a b c
+(,,) :: a -> b -> c -> (,,) a b c
+data (,,,) a b c d
+(,,,) :: a -> b -> c -> d -> (,,,) a b c d
+data (,,,,) a b c d e
+(,,,,) :: a -> b -> c -> d -> e -> (,,,,) a b c d e
+data (,,,,,) a b c d e f
+(,,,,,) :: a -> b -> c -> d -> e -> f -> (,,,,,) a b c d e f
+data (,,,,,,) a b c d e f g
+(,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> (,,,,,,) a b c d e f g
+data (,,,,,,,) a b c d e f g h
+(,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> (,,,,,,,) a b c d e f g h
+data (,,,,,,,,) a b c d e f g h i
+(,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> (,,,,,,,,) a b c d e f g h i
+data (,,,,,,,,,) a b c d e f g h i j
+(,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> (,,,,,,,,,) a b c d e f g h i j
+data (,,,,,,,,,,) a b c d e f g h i j k
+(,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> (,,,,,,,,,,) a b c d e f g h i j k
+data (,,,,,,,,,,,) a b c d e f g h i j k l
+(,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> (,,,,,,,,,,,) a b c d e f g h i j k l
+data (,,,,,,,,,,,,) a b c d e f g h i j k l m
+(,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> (,,,,,,,,,,,,) a b c d e f g h i j k l m
+data (,,,,,,,,,,,,,) a b c d e f g h i j k l m n
+(,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> (,,,,,,,,,,,,,) a b c d e f g h i j k l m n
+data (,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o
+(,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> (,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o
+data (,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p
+(,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> (,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p
+data (,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q
+(,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> (,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q
+data (,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r
+(,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> (,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r
+data (,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s
+(,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> (,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s
+data (,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t
+(,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> (,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t
+data (,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u
+(,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> (,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u
+data (,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v
+(,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> (,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v
+data (,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w
+(,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> (,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w
+data (,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x
+(,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> (,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x
+data (,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y
+(,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> (,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y
+data (,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z
+(,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> (,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> f__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> f__ -> g__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> f__ -> g__ -> h__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> f__ -> g__ -> h__ -> i__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__
+data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__
+(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> f__ -> g__ -> h__ -> i__ -> j__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__
+
+module GHC.Bool
+data Bool
+False :: Bool
+True :: Bool
+
+
+-- | GHC's primitive types and operations. Use GHC.Exts from the base
+-- package instead of importing this module directly.
+module GHC.Prim
+data Char#
+gtChar# :: Char# -> Char# -> Bool
+geChar# :: Char# -> Char# -> Bool
+eqChar# :: Char# -> Char# -> Bool
+neChar# :: Char# -> Char# -> Bool
+ltChar# :: Char# -> Char# -> Bool
+leChar# :: Char# -> Char# -> Bool
+ord# :: Char# -> Int#
+data Int#
+(+#) :: Int# -> Int# -> Int#
+(-#) :: Int# -> Int# -> Int#
+
+-- | Low word of signed integer multiply.
+(*#) :: Int# -> Int# -> Int#
+
+-- | Return non-zero if there is any possibility that the upper word of a
+-- signed integer multiply might contain useful information. Return zero
+-- only if you are completely sure that no overflow can occur. On a
+-- 32-bit platform, the recommmended implementation is to do a 32 x 32
+-- -&gt; 64 signed multiply, and subtract result[63:32] from (result[31]
+-- &gt;&gt;signed 31). If this is zero, meaning that the upper word is
+-- merely a sign extension of the lower one, no overflow can occur.
+--
+-- On a 64-bit platform it is not always possible to acquire the top 64
+-- bits of the result. Therefore, a recommended implementation is to take
+-- the absolute value of both operands, and return 0 iff bits[63:31] of
+-- them are zero, since that means that their magnitudes fit within 31
+-- bits, so the magnitude of the product must fit into 62 bits.
+--
+-- If in doubt, return non-zero, but do make an effort to create the
+-- correct answer for small args, since otherwise the performance of
+-- <tt>(*) :: Integer -&gt; Integer -&gt; Integer</tt> will be poor.
+mulIntMayOflo# :: Int# -> Int# -> Int#
+
+-- | Rounds towards zero.
+quotInt# :: Int# -> Int# -> Int#
+
+-- | Satisfies <tt>(quotInt# x y) *# y +# (remInt# x y) == x</tt>.
+remInt# :: Int# -> Int# -> Int#
+negateInt# :: Int# -> Int#
+
+-- | Add with carry. First member of result is (wrapped) sum; second member
+-- is 0 iff no overflow occured.
+addIntC# :: Int# -> Int# -> (# Int#, Int# #)
+
+-- | Subtract with carry. First member of result is (wrapped) difference;
+-- second member is 0 iff no overflow occured.
+subIntC# :: Int# -> Int# -> (# Int#, Int# #)
+(>#) :: Int# -> Int# -> Bool
+(>=#) :: Int# -> Int# -> Bool
+(==#) :: Int# -> Int# -> Bool
+(/=#) :: Int# -> Int# -> Bool
+(<#) :: Int# -> Int# -> Bool
+(<=#) :: Int# -> Int# -> Bool
+chr# :: Int# -> Char#
+int2Word# :: Int# -> Word#
+int2Float# :: Int# -> Float#
+int2Double# :: Int# -> Double#
+
+-- | Shift left. Result undefined if shift amount is not in the range 0 to
+-- word size - 1 inclusive.
+uncheckedIShiftL# :: Int# -> Int# -> Int#
+
+-- | Shift right arithmetic. Result undefined if shift amount is not in the
+-- range 0 to word size - 1 inclusive.
+uncheckedIShiftRA# :: Int# -> Int# -> Int#
+
+-- | Shift right logical. Result undefined if shift amount is not in the
+-- range 0 to word size - 1 inclusive.
+uncheckedIShiftRL# :: Int# -> Int# -> Int#
+data Word#
+plusWord# :: Word# -> Word# -> Word#
+minusWord# :: Word# -> Word# -> Word#
+timesWord# :: Word# -> Word# -> Word#
+quotWord# :: Word# -> Word# -> Word#
+remWord# :: Word# -> Word# -> Word#
+and# :: Word# -> Word# -> Word#
+or# :: Word# -> Word# -> Word#
+xor# :: Word# -> Word# -> Word#
+not# :: Word# -> Word#
+
+-- | Shift left logical. Result undefined if shift amount is not in the
+-- range 0 to word size - 1 inclusive.
+uncheckedShiftL# :: Word# -> Int# -> Word#
+
+-- | Shift right logical. Result undefined if shift amount is not in the
+-- range 0 to word size - 1 inclusive.
+uncheckedShiftRL# :: Word# -> Int# -> Word#
+word2Int# :: Word# -> Int#
+gtWord# :: Word# -> Word# -> Bool
+geWord# :: Word# -> Word# -> Bool
+eqWord# :: Word# -> Word# -> Bool
+neWord# :: Word# -> Word# -> Bool
+ltWord# :: Word# -> Word# -> Bool
+leWord# :: Word# -> Word# -> Bool
+narrow8Int# :: Int# -> Int#
+narrow16Int# :: Int# -> Int#
+narrow32Int# :: Int# -> Int#
+narrow8Word# :: Word# -> Word#
+narrow16Word# :: Word# -> Word#
+narrow32Word# :: Word# -> Word#
+data Double#
+(>##) :: Double# -> Double# -> Bool
+(>=##) :: Double# -> Double# -> Bool
+(==##) :: Double# -> Double# -> Bool
+(/=##) :: Double# -> Double# -> Bool
+(<##) :: Double# -> Double# -> Bool
+(<=##) :: Double# -> Double# -> Bool
+(+##) :: Double# -> Double# -> Double#
+(-##) :: Double# -> Double# -> Double#
+(*##) :: Double# -> Double# -> Double#
+(/##) :: Double# -> Double# -> Double#
+negateDouble# :: Double# -> Double#
+
+-- | Truncates a <tt>Double</tt>. Results are undefined if the truncation
+-- if truncation yields a value outside the range of <tt>Int#</tt>.
+double2Int# :: Double# -> Int#
+double2Float# :: Double# -> Float#
+expDouble# :: Double# -> Double#
+logDouble# :: Double# -> Double#
+sqrtDouble# :: Double# -> Double#
+sinDouble# :: Double# -> Double#
+cosDouble# :: Double# -> Double#
+tanDouble# :: Double# -> Double#
+asinDouble# :: Double# -> Double#
+acosDouble# :: Double# -> Double#
+atanDouble# :: Double# -> Double#
+sinhDouble# :: Double# -> Double#
+coshDouble# :: Double# -> Double#
+tanhDouble# :: Double# -> Double#
+
+-- | Exponentiation.
+(**##) :: Double# -> Double# -> Double#
+
+-- | Convert to integer. First component of the result is -1 or 1,
+-- indicating the sign of the mantissa. The next two are the high and low
+-- 32 bits of the mantissa respectively, and the last is the exponent.
+decodeDouble_2Int# :: Double# -> (# Int#, Word#, Word#, Int# #)
+data Float#
+gtFloat# :: Float# -> Float# -> Bool
+geFloat# :: Float# -> Float# -> Bool
+eqFloat# :: Float# -> Float# -> Bool
+neFloat# :: Float# -> Float# -> Bool
+ltFloat# :: Float# -> Float# -> Bool
+leFloat# :: Float# -> Float# -> Bool
+plusFloat# :: Float# -> Float# -> Float#
+minusFloat# :: Float# -> Float# -> Float#
+timesFloat# :: Float# -> Float# -> Float#
+divideFloat# :: Float# -> Float# -> Float#
+negateFloat# :: Float# -> Float#
+
+-- | Truncates a <tt>Float</tt>. Results are undefined if the truncation if
+-- truncation yields a value outside the range of <tt>Int#</tt>.
+float2Int# :: Float# -> Int#
+expFloat# :: Float# -> Float#
+logFloat# :: Float# -> Float#
+sqrtFloat# :: Float# -> Float#
+sinFloat# :: Float# -> Float#
+cosFloat# :: Float# -> Float#
+tanFloat# :: Float# -> Float#
+asinFloat# :: Float# -> Float#
+acosFloat# :: Float# -> Float#
+atanFloat# :: Float# -> Float#
+sinhFloat# :: Float# -> Float#
+coshFloat# :: Float# -> Float#
+tanhFloat# :: Float# -> Float#
+powerFloat# :: Float# -> Float# -> Float#
+float2Double# :: Float# -> Double#
+
+-- | Convert to integers. First <tt>Int#</tt> in result is the mantissa;
+-- second is the exponent.
+decodeFloat_Int# :: Float# -> (# Int#, Int# #)
+data Array# a
+data MutableArray# s a
+
+-- | Create a new mutable array with the specified number of elements, in
+-- the specified state thread, with each element containing the specified
+-- initial value.
+newArray# :: Int# -> a -> State# s -> (# State# s, MutableArray# s a #)
+sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Bool
+
+-- | Read from specified index of mutable array. Result is not yet
+-- evaluated.
+readArray# :: MutableArray# s a -> Int# -> State# s -> (# State# s, a #)
+
+-- | Write to specified index of mutable array.
+writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s
+
+-- | Read from specified index of immutable array. Result is packaged into
+-- an unboxed singleton; the result itself is not yet evaluated.
+indexArray# :: Array# a -> Int# -> (# a #)
+
+-- | Make a mutable array immutable, without copying.
+unsafeFreezeArray# :: MutableArray# s a -> State# s -> (# State# s, Array# a #)
+
+-- | Make an immutable array mutable, without copying.
+unsafeThawArray# :: Array# a -> State# s -> (# State# s, MutableArray# s a #)
+data ByteArray#
+data MutableByteArray# s
+
+-- | Create a new mutable byte array of specified size (in bytes), in the
+-- specified state thread.
+newByteArray# :: Int# -> State# s -> (# State# s, MutableByteArray# s #)
+
+-- | Create a mutable byte array that the GC guarantees not to move.
+newPinnedByteArray# :: Int# -> State# s -> (# State# s, MutableByteArray# s #)
+
+-- | Create a mutable byte array, aligned by the specified amount, that the
+-- GC guarantees not to move.
+newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (# State# s, MutableByteArray# s #)
+
+-- | Intended for use with pinned arrays; otherwise very unsafe!
+byteArrayContents# :: ByteArray# -> Addr#
+sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Bool
+
+-- | Make a mutable byte array immutable, without copying.
+unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s, ByteArray# #)
+
+-- | Return the size of the array in bytes.
+sizeofByteArray# :: ByteArray# -> Int#
+
+-- | Return the size of the array in bytes.
+sizeofMutableByteArray# :: MutableByteArray# s -> Int#
+
+-- | Read 8-bit character; offset in bytes.
+indexCharArray# :: ByteArray# -> Int# -> Char#
+
+-- | Read 31-bit character; offset in 4-byte words.
+indexWideCharArray# :: ByteArray# -> Int# -> Char#
+indexIntArray# :: ByteArray# -> Int# -> Int#
+indexWordArray# :: ByteArray# -> Int# -> Word#
+indexAddrArray# :: ByteArray# -> Int# -> Addr#
+indexFloatArray# :: ByteArray# -> Int# -> Float#
+indexDoubleArray# :: ByteArray# -> Int# -> Double#
+indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a
+indexInt8Array# :: ByteArray# -> Int# -> Int#
+indexInt16Array# :: ByteArray# -> Int# -> Int#
+indexInt32Array# :: ByteArray# -> Int# -> Int#
+indexInt64Array# :: ByteArray# -> Int# -> Int#
+indexWord8Array# :: ByteArray# -> Int# -> Word#
+indexWord16Array# :: ByteArray# -> Int# -> Word#
+indexWord32Array# :: ByteArray# -> Int# -> Word#
+indexWord64Array# :: ByteArray# -> Int# -> Word#
+
+-- | Read 8-bit character; offset in bytes.
+readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Char# #)
+
+-- | Read 31-bit character; offset in 4-byte words.
+readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Char# #)
+readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
+readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
+readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Addr# #)
+readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Float# #)
+readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Double# #)
+readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, StablePtr# a #)
+readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
+readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
+readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
+readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
+readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
+readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
+readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
+readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
+
+-- | Write 8-bit character; offset in bytes.
+writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
+
+-- | Write 31-bit character; offset in 4-byte words.
+writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
+writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
+writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s
+writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
+writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s
+writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s
+writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+writeInt16Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+writeInt32Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+writeInt64Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+writeWord8Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
+writeWord16Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
+writeWord32Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
+writeWord64Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
+
+-- | An arbitrary machine address assumed to point outside the
+-- garbage-collected heap.
+data Addr#
+
+-- | The null address.
+nullAddr# :: Addr#
+plusAddr# :: Addr# -> Int# -> Addr#
+
+-- | Result is meaningless if two <tt>Addr#</tt>s are so far apart that
+-- their difference doesn't fit in an <tt>Int#</tt>.
+minusAddr# :: Addr# -> Addr# -> Int#
+
+-- | Return the remainder when the <tt>Addr#</tt> arg, treated like an
+-- <tt>Int#</tt>, is divided by the <tt>Int#</tt> arg.
+remAddr# :: Addr# -> Int# -> Int#
+
+-- | Coerce directly from address to int. Strongly deprecated.
+addr2Int# :: Addr# -> Int#
+
+-- | Coerce directly from int to address. Strongly deprecated.
+int2Addr# :: Int# -> Addr#
+gtAddr# :: Addr# -> Addr# -> Bool
+geAddr# :: Addr# -> Addr# -> Bool
+eqAddr# :: Addr# -> Addr# -> Bool
+neAddr# :: Addr# -> Addr# -> Bool
+ltAddr# :: Addr# -> Addr# -> Bool
+leAddr# :: Addr# -> Addr# -> Bool
+
+-- | Reads 8-bit character; offset in bytes.
+indexCharOffAddr# :: Addr# -> Int# -> Char#
+
+-- | Reads 31-bit character; offset in 4-byte words.
+indexWideCharOffAddr# :: Addr# -> Int# -> Char#
+indexIntOffAddr# :: Addr# -> Int# -> Int#
+indexWordOffAddr# :: Addr# -> Int# -> Word#
+indexAddrOffAddr# :: Addr# -> Int# -> Addr#
+indexFloatOffAddr# :: Addr# -> Int# -> Float#
+indexDoubleOffAddr# :: Addr# -> Int# -> Double#
+indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a
+indexInt8OffAddr# :: Addr# -> Int# -> Int#
+indexInt16OffAddr# :: Addr# -> Int# -> Int#
+indexInt32OffAddr# :: Addr# -> Int# -> Int#
+indexInt64OffAddr# :: Addr# -> Int# -> Int#
+indexWord8OffAddr# :: Addr# -> Int# -> Word#
+indexWord16OffAddr# :: Addr# -> Int# -> Word#
+indexWord32OffAddr# :: Addr# -> Int# -> Word#
+indexWord64OffAddr# :: Addr# -> Int# -> Word#
+
+-- | Reads 8-bit character; offset in bytes.
+readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Char# #)
+
+-- | Reads 31-bit character; offset in 4-byte words.
+readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Char# #)
+readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int# #)
+readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word# #)
+readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Addr# #)
+readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Float# #)
+readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Double# #)
+readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, StablePtr# a #)
+readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int# #)
+readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int# #)
+readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int# #)
+readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int# #)
+readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word# #)
+readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word# #)
+readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word# #)
+readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word# #)
+writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s
+writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s
+writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
+writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
+writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s
+writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s
+writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s
+writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s
+writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
+writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
+writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
+writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
+writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
+writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
+writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
+writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
+
+-- | A <tt>MutVar#</tt> behaves like a single-element mutable array.
+data MutVar# s a
+
+-- | Create <tt>MutVar#</tt> with specified initial value in specified
+-- state thread.
+newMutVar# :: a -> State# s -> (# State# s, MutVar# s a #)
+
+-- | Read contents of <tt>MutVar#</tt>. Result is not yet evaluated.
+readMutVar# :: MutVar# s a -> State# s -> (# State# s, a #)
+
+-- | Write contents of <tt>MutVar#</tt>.
+writeMutVar# :: MutVar# s a -> a -> State# s -> State# s
+sameMutVar# :: MutVar# s a -> MutVar# s a -> Bool
+atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s, c #)
+catch# :: (State# (RealWorld) -> (# State# (RealWorld), a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld), a #)) -> State# (RealWorld) -> (# State# (RealWorld), a #)
+raise# :: a -> b
+raiseIO# :: a -> State# (RealWorld) -> (# State# (RealWorld), b #)
+maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld), a #)) -> State# (RealWorld) -> (# State# (RealWorld), a #)
+maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld), a #)) -> State# (RealWorld) -> (# State# (RealWorld), a #)
+unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld), a #)) -> State# (RealWorld) -> (# State# (RealWorld), a #)
+getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld), Int# #)
+data TVar# s a
+atomically# :: (State# (RealWorld) -> (# State# (RealWorld), a #)) -> State# (RealWorld) -> (# State# (RealWorld), a #)
+retry# :: State# (RealWorld) -> (# State# (RealWorld), a #)
+catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld), a #)) -> (State# (RealWorld) -> (# State# (RealWorld), a #)) -> State# (RealWorld) -> (# State# (RealWorld), a #)
+catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld), a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld), a #)) -> State# (RealWorld) -> (# State# (RealWorld), a #)
+check# :: (State# (RealWorld) -> (# State# (RealWorld), a #)) -> State# (RealWorld) -> (# State# (RealWorld), () #)
+
+-- | Create a new <tt>TVar#</tt> holding a specified initial value.
+newTVar# :: a -> State# s -> (# State# s, TVar# s a #)
+
+-- | Read contents of <tt>TVar#</tt>. Result is not yet evaluated.
+readTVar# :: TVar# s a -> State# s -> (# State# s, a #)
+
+-- | Read contents of <tt>TVar#</tt> outside an STM transaction
+readTVarIO# :: TVar# s a -> State# s -> (# State# s, a #)
+
+-- | Write contents of <tt>TVar#</tt>.
+writeTVar# :: TVar# s a -> a -> State# s -> State# s
+sameTVar# :: TVar# s a -> TVar# s a -> Bool
+
+-- | A shared mutable variable (<i>not</i> the same as a
+-- <tt>MutVar#</tt>!). (Note: in a non-concurrent implementation,
+-- <tt>(MVar# a)</tt> can be represented by <tt>(MutVar# (Maybe
+-- a))</tt>.)
+data MVar# s a
+
+-- | Create new <tt>MVar#</tt>; initially empty.
+newMVar# :: State# s -> (# State# s, MVar# s a #)
+
+-- | If <tt>MVar#</tt> is empty, block until it becomes full. Then remove
+-- and return its contents, and set it empty.
+takeMVar# :: MVar# s a -> State# s -> (# State# s, a #)
+
+-- | If <tt>MVar#</tt> is empty, immediately return with integer 0 and
+-- value undefined. Otherwise, return with integer 1 and contents of
+-- <tt>MVar#</tt>, and set <tt>MVar#</tt> empty.
+tryTakeMVar# :: MVar# s a -> State# s -> (# State# s, Int#, a #)
+
+-- | If <tt>MVar#</tt> is full, block until it becomes empty. Then store
+-- value arg as its new contents.
+putMVar# :: MVar# s a -> a -> State# s -> State# s
+
+-- | If <tt>MVar#</tt> is full, immediately return with integer 0.
+-- Otherwise, store value arg as <tt>MVar#</tt>'s new contents, and
+-- return with integer 1.
+tryPutMVar# :: MVar# s a -> a -> State# s -> (# State# s, Int# #)
+sameMVar# :: MVar# s a -> MVar# s a -> Bool
+
+-- | Return 1 if <tt>MVar#</tt> is empty; 0 otherwise.
+isEmptyMVar# :: MVar# s a -> State# s -> (# State# s, Int# #)
+
+-- | Sleep specified number of microseconds.
+delay# :: Int# -> State# s -> State# s
+
+-- | Block until input is available on specified file descriptor.
+waitRead# :: Int# -> State# s -> State# s
+
+-- | Block until output is possible on specified file descriptor.
+waitWrite# :: Int# -> State# s -> State# s
+
+-- | <tt>State#</tt> is the primitive, unlifted type of states. It has one
+-- type parameter, thus <tt>State# RealWorld</tt>, or <tt>State# s</tt>,
+-- where s is a type variable. The only purpose of the type parameter is
+-- to keep different state threads separate. It is represented by nothing
+-- at all.
+data State# s
+
+-- | <tt>RealWorld</tt> is deeply magical. It is <i>primitive</i>, but it
+-- is not <i>unlifted</i> (hence <tt>ptrArg</tt>). We never manipulate
+-- values of type <tt>RealWorld</tt>; it's only used in the type system,
+-- to parameterise <tt>State#</tt>.
+data RealWorld
+
+-- | (In a non-concurrent implementation, this can be a singleton type,
+-- whose (unique) value is returned by <tt>myThreadId#</tt>. The other
+-- operations can be omitted.)
+data ThreadId#
+fork# :: a -> State# (RealWorld) -> (# State# (RealWorld), ThreadId# #)
+forkOn# :: Int# -> a -> State# (RealWorld) -> (# State# (RealWorld), ThreadId# #)
+killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld)
+yield# :: State# (RealWorld) -> State# (RealWorld)
+myThreadId# :: State# (RealWorld) -> (# State# (RealWorld), ThreadId# #)
+labelThread# :: ThreadId# -> Addr# -> State# (RealWorld) -> State# (RealWorld)
+isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld), Int# #)
+noDuplicate# :: State# (RealWorld) -> State# (RealWorld)
+threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld), Int# #)
+data Weak# b
+mkWeak# :: o -> b -> c -> State# (RealWorld) -> (# State# (RealWorld), Weak# b #)
+mkWeakForeignEnv# :: o -> b -> Addr# -> Addr# -> Int# -> Addr# -> State# (RealWorld) -> (# State# (RealWorld), Weak# b #)
+deRefWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld), Int#, a #)
+finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld), Int#, State# (RealWorld) -> (# State# (RealWorld), () #) #)
+touch# :: o -> State# (RealWorld) -> State# (RealWorld)
+data StablePtr# a
+data StableName# a
+makeStablePtr# :: a -> State# (RealWorld) -> (# State# (RealWorld), StablePtr# a #)
+deRefStablePtr# :: StablePtr# a -> State# (RealWorld) -> (# State# (RealWorld), a #)
+eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int#
+makeStableName# :: a -> State# (RealWorld) -> (# State# (RealWorld), StableName# a #)
+eqStableName# :: StableName# a -> StableName# a -> Int#
+stableNameToInt# :: StableName# a -> Int#
+reallyUnsafePtrEquality# :: a -> a -> Int#
+par# :: a -> Int#
+getSpark# :: State# s -> (# State# s, Int#, a #)
+
+-- | Returns the number of sparks in the local spark pool.
+numSparks# :: State# s -> (# State# s, Int# #)
+parGlobal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int#
+parLocal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int#
+parAt# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#
+parAtAbs# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#
+parAtRel# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#
+parAtForNow# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#
+dataToTag# :: a -> Int#
+tagToEnum# :: Int# -> a
+
+-- | Primitive bytecode type.
+data BCO#
+
+-- | Convert an <tt>Addr#</tt> to a followable type.
+addrToHValue# :: Addr# -> (# a #)
+mkApUpd0# :: BCO# -> (# a #)
+newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s, BCO# #)
+unpackClosure# :: a -> (# Addr#, Array# b, ByteArray# #)
+getApStackVal# :: a -> Int# -> (# Int#, b #)
+traceCcs# :: a -> b -> b
+
+-- | Evaluates its first argument to head normal form, and then returns its
+-- second argument as the result.
+seq :: a -> b -> b
+
+-- | The call <tt>(inline f)</tt> arranges that f is inlined, regardless of
+-- its size. More precisely, the call <tt>(inline f)</tt> rewrites to the
+-- right-hand side of <tt>f</tt>'s definition. This allows the programmer
+-- to control inlining from a particular call site rather than the
+-- definition site of the function (c.f. <tt>INLINE</tt> pragmas in
+-- User's Guide, Section 7.10.3, "INLINE and NOINLINE pragmas").
+--
+-- This inlining occurs regardless of the argument to the call or the
+-- size of <tt>f</tt>'s definition; it is unconditional. The main caveat
+-- is that <tt>f</tt>'s definition must be visible to the compiler. That
+-- is, <tt>f</tt> must be <tt>let</tt>-bound in the current scope. If no
+-- inlining takes place, the <tt>inline</tt> function expands to the
+-- identity function in Phase zero; so its use imposes no overhead.
+--
+-- It is good practice to mark the function with an INLINABLE pragma at
+-- its definition, (a) so that GHC guarantees to expose its unfolding
+-- regardless of size, and (b) so that you have control over exactly what
+-- is inlined.
+inline :: a -> a
+
+-- | The <tt>lazy</tt> function restrains strictness analysis a little. The
+-- call <tt>(lazy e)</tt> means the same as <tt>e</tt>, but <tt>lazy</tt>
+-- has a magical property so far as strictness analysis is concerned: it
+-- is lazy in its first argument, even though its semantics is strict.
+-- After strictness analysis has run, calls to <tt>lazy</tt> are inlined
+-- to be the identity function.
+--
+-- This behaviour is occasionally useful when controlling evaluation
+-- order. Notably, <tt>lazy</tt> is used in the library definition of
+-- <tt>Control.Parallel.par</tt>:
+--
+-- <pre>
+-- par :: a -&gt; b -&gt; b
+-- </pre>
+--
+-- <pre>
+-- par x y = case (par# x) of _ -&gt; lazy y
+-- </pre>
+--
+-- If <tt>lazy</tt> were not lazy, <tt>par</tt> would look strict in
+-- <tt>y</tt> which would defeat the whole purpose of <tt>par</tt>.
+--
+-- Like <tt>seq</tt>, the argument of <tt>lazy</tt> can have an unboxed
+-- type.
+lazy :: a -> a
+
+-- | The type constructor <tt>Any</tt> is type to which you can unsafely
+-- coerce any lifted type, and back.
+--
+-- <ul>
+-- <li>It is lifted, and hence represented by a pointer</li>
+-- <li>It does not claim to be a <i>data</i> type, and that's important
+-- for the code generator, because the code gen may <i>enter</i> a data
+-- value but never enters a function value.</li>
+-- </ul>
+--
+-- It's also used to instantiate un-constrained type variables after type
+-- checking. For example
+--
+-- <pre>
+-- length Any []
+-- </pre>
+--
+-- Annoyingly, we sometimes need <tt>Any</tt>s of other kinds, such as
+-- <tt>(* -&gt; *)</tt> etc. This is a bit like tuples. We define a
+-- couple of useful ones here, and make others up on the fly. If any of
+-- these others end up being exported into interface files, we'll get a
+-- crash; at least until we add interface-file syntax to support them.
+data Any a
+
+-- | The function <tt>unsafeCoerce#</tt> allows you to side-step the
+-- typechecker entirely. That is, it allows you to coerce any type into
+-- any other type. If you use this function, you had better get it right,
+-- otherwise segmentation faults await. It is generally used when you
+-- want to write a program that you know is well-typed, but where
+-- Haskell's type system is not expressive enough to prove that it is
+-- well typed.
+--
+-- The following uses of <tt>unsafeCoerce#</tt> are supposed to work
+-- (i.e. not lead to spurious compile-time or run-time crashes):
+--
+-- <ul>
+-- <li>Casting any lifted type to <tt>Any</tt></li>
+-- <li>Casting <tt>Any</tt> back to the real type</li>
+-- <li>Casting an unboxed type to another unboxed type of the same size
+-- (but not coercions between floating-point and integral types)</li>
+-- <li>Casting between two types that have the same runtime
+-- representation. One case is when the two types differ only in
+-- "phantom" type parameters, for example <tt>Ptr Int</tt> to <tt>Ptr
+-- Float</tt>, or <tt>[Int]</tt> to <tt>[Float]</tt> when the list is
+-- known to be empty. Also, a <tt>newtype</tt> of a type <tt>T</tt> has
+-- the same representation at runtime as <tt>T</tt>.</li>
+-- </ul>
+--
+-- Other uses of <tt>unsafeCoerce#</tt> are undefined. In particular, you
+-- should not use <tt>unsafeCoerce#</tt> to cast a T to an algebraic data
+-- type D, unless T is also an algebraic data type. For example, do not
+-- cast <tt>Int-&gt;Int</tt> to <tt>Bool</tt>, even if you later cast
+-- that <tt>Bool</tt> back to <tt>Int-&gt;Int</tt> before applying it.
+-- The reasons have to do with GHC's internal representation details (for
+-- the congnoscenti, data values can be entered but function closures
+-- cannot). If you want a safe type to cast things to, use <tt>Any</tt>,
+-- which is not an algebraic data type.
+unsafeCoerce# :: a -> b
+
+-- | Emits an event via the RTS tracing framework. The contents of the
+-- event is the zero-terminated byte string passed as the first argument.
+-- The event will be emitted either to the .eventlog file, or to stderr,
+-- depending on the runtime RTS flags.
+traceEvent# :: Addr# -> State# s -> State# s
+
+module GHC.PrimopWrappers
+gtChar# :: Char# -> Char# -> Bool
+geChar# :: Char# -> Char# -> Bool
+eqChar# :: Char# -> Char# -> Bool
+neChar# :: Char# -> Char# -> Bool
+ltChar# :: Char# -> Char# -> Bool
+leChar# :: Char# -> Char# -> Bool
+ord# :: Char# -> Int#
+(+#) :: Int# -> Int# -> Int#
+(-#) :: Int# -> Int# -> Int#
+(*#) :: Int# -> Int# -> Int#
+mulIntMayOflo# :: Int# -> Int# -> Int#
+quotInt# :: Int# -> Int# -> Int#
+remInt# :: Int# -> Int# -> Int#
+negateInt# :: Int# -> Int#
+addIntC# :: Int# -> Int# -> (# Int#, Int# #)
+subIntC# :: Int# -> Int# -> (# Int#, Int# #)
+(>#) :: Int# -> Int# -> Bool
+(>=#) :: Int# -> Int# -> Bool
+(==#) :: Int# -> Int# -> Bool
+(/=#) :: Int# -> Int# -> Bool
+(<#) :: Int# -> Int# -> Bool
+(<=#) :: Int# -> Int# -> Bool
+chr# :: Int# -> Char#
+int2Word# :: Int# -> Word#
+int2Float# :: Int# -> Float#
+int2Double# :: Int# -> Double#
+uncheckedIShiftL# :: Int# -> Int# -> Int#
+uncheckedIShiftRA# :: Int# -> Int# -> Int#
+uncheckedIShiftRL# :: Int# -> Int# -> Int#
+plusWord# :: Word# -> Word# -> Word#
+minusWord# :: Word# -> Word# -> Word#
+timesWord# :: Word# -> Word# -> Word#
+quotWord# :: Word# -> Word# -> Word#
+remWord# :: Word# -> Word# -> Word#
+and# :: Word# -> Word# -> Word#
+or# :: Word# -> Word# -> Word#
+xor# :: Word# -> Word# -> Word#
+not# :: Word# -> Word#
+uncheckedShiftL# :: Word# -> Int# -> Word#
+uncheckedShiftRL# :: Word# -> Int# -> Word#
+word2Int# :: Word# -> Int#
+gtWord# :: Word# -> Word# -> Bool
+geWord# :: Word# -> Word# -> Bool
+eqWord# :: Word# -> Word# -> Bool
+neWord# :: Word# -> Word# -> Bool
+ltWord# :: Word# -> Word# -> Bool
+leWord# :: Word# -> Word# -> Bool
+narrow8Int# :: Int# -> Int#
+narrow16Int# :: Int# -> Int#
+narrow32Int# :: Int# -> Int#
+narrow8Word# :: Word# -> Word#
+narrow16Word# :: Word# -> Word#
+narrow32Word# :: Word# -> Word#
+(>##) :: Double# -> Double# -> Bool
+(>=##) :: Double# -> Double# -> Bool
+(==##) :: Double# -> Double# -> Bool
+(/=##) :: Double# -> Double# -> Bool
+(<##) :: Double# -> Double# -> Bool
+(<=##) :: Double# -> Double# -> Bool
+(+##) :: Double# -> Double# -> Double#
+(-##) :: Double# -> Double# -> Double#
+(*##) :: Double# -> Double# -> Double#
+(/##) :: Double# -> Double# -> Double#
+negateDouble# :: Double# -> Double#
+double2Int# :: Double# -> Int#
+double2Float# :: Double# -> Float#
+expDouble# :: Double# -> Double#
+logDouble# :: Double# -> Double#
+sqrtDouble# :: Double# -> Double#
+sinDouble# :: Double# -> Double#
+cosDouble# :: Double# -> Double#
+tanDouble# :: Double# -> Double#
+asinDouble# :: Double# -> Double#
+acosDouble# :: Double# -> Double#
+atanDouble# :: Double# -> Double#
+sinhDouble# :: Double# -> Double#
+coshDouble# :: Double# -> Double#
+tanhDouble# :: Double# -> Double#
+(**##) :: Double# -> Double# -> Double#
+decodeDouble_2Int# :: Double# -> (# Int#, Word#, Word#, Int# #)
+gtFloat# :: Float# -> Float# -> Bool
+geFloat# :: Float# -> Float# -> Bool
+eqFloat# :: Float# -> Float# -> Bool
+neFloat# :: Float# -> Float# -> Bool
+ltFloat# :: Float# -> Float# -> Bool
+leFloat# :: Float# -> Float# -> Bool
+plusFloat# :: Float# -> Float# -> Float#
+minusFloat# :: Float# -> Float# -> Float#
+timesFloat# :: Float# -> Float# -> Float#
+divideFloat# :: Float# -> Float# -> Float#
+negateFloat# :: Float# -> Float#
+float2Int# :: Float# -> Int#
+expFloat# :: Float# -> Float#
+logFloat# :: Float# -> Float#
+sqrtFloat# :: Float# -> Float#
+sinFloat# :: Float# -> Float#
+cosFloat# :: Float# -> Float#
+tanFloat# :: Float# -> Float#
+asinFloat# :: Float# -> Float#
+acosFloat# :: Float# -> Float#
+atanFloat# :: Float# -> Float#
+sinhFloat# :: Float# -> Float#
+coshFloat# :: Float# -> Float#
+tanhFloat# :: Float# -> Float#
+powerFloat# :: Float# -> Float# -> Float#
+float2Double# :: Float# -> Double#
+decodeFloat_Int# :: Float# -> (# Int#, Int# #)
+newArray# :: Int# -> a -> State# s -> (# State# s, MutableArray# s a #)
+sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Bool
+readArray# :: MutableArray# s a -> Int# -> State# s -> (# State# s, a #)
+writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s
+indexArray# :: Array# a -> Int# -> (# a #)
+unsafeFreezeArray# :: MutableArray# s a -> State# s -> (# State# s, Array# a #)
+unsafeThawArray# :: Array# a -> State# s -> (# State# s, MutableArray# s a #)
+newByteArray# :: Int# -> State# s -> (# State# s, MutableByteArray# s #)
+newPinnedByteArray# :: Int# -> State# s -> (# State# s, MutableByteArray# s #)
+newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (# State# s, MutableByteArray# s #)
+byteArrayContents# :: ByteArray# -> Addr#
+sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Bool
+unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s, ByteArray# #)
+sizeofByteArray# :: ByteArray# -> Int#
+sizeofMutableByteArray# :: MutableByteArray# s -> Int#
+indexCharArray# :: ByteArray# -> Int# -> Char#
+indexWideCharArray# :: ByteArray# -> Int# -> Char#
+indexIntArray# :: ByteArray# -> Int# -> Int#
+indexWordArray# :: ByteArray# -> Int# -> Word#
+indexAddrArray# :: ByteArray# -> Int# -> Addr#
+indexFloatArray# :: ByteArray# -> Int# -> Float#
+indexDoubleArray# :: ByteArray# -> Int# -> Double#
+indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a
+indexInt8Array# :: ByteArray# -> Int# -> Int#
+indexInt16Array# :: ByteArray# -> Int# -> Int#
+indexInt32Array# :: ByteArray# -> Int# -> Int#
+indexInt64Array# :: ByteArray# -> Int# -> Int#
+indexWord8Array# :: ByteArray# -> Int# -> Word#
+indexWord16Array# :: ByteArray# -> Int# -> Word#
+indexWord32Array# :: ByteArray# -> Int# -> Word#
+indexWord64Array# :: ByteArray# -> Int# -> Word#
+readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Char# #)
+readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Char# #)
+readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
+readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
+readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Addr# #)
+readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Float# #)
+readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Double# #)
+readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, StablePtr# a #)
+readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
+readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
+readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
+readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
+readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
+readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
+readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
+readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
+writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
+writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
+writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
+writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s
+writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
+writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s
+writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s
+writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+writeInt16Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+writeInt32Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+writeInt64Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+writeWord8Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
+writeWord16Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
+writeWord32Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
+writeWord64Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
+plusAddr# :: Addr# -> Int# -> Addr#
+minusAddr# :: Addr# -> Addr# -> Int#
+remAddr# :: Addr# -> Int# -> Int#
+addr2Int# :: Addr# -> Int#
+int2Addr# :: Int# -> Addr#
+gtAddr# :: Addr# -> Addr# -> Bool
+geAddr# :: Addr# -> Addr# -> Bool
+eqAddr# :: Addr# -> Addr# -> Bool
+neAddr# :: Addr# -> Addr# -> Bool
+ltAddr# :: Addr# -> Addr# -> Bool
+leAddr# :: Addr# -> Addr# -> Bool
+indexCharOffAddr# :: Addr# -> Int# -> Char#
+indexWideCharOffAddr# :: Addr# -> Int# -> Char#
+indexIntOffAddr# :: Addr# -> Int# -> Int#
+indexWordOffAddr# :: Addr# -> Int# -> Word#
+indexAddrOffAddr# :: Addr# -> Int# -> Addr#
+indexFloatOffAddr# :: Addr# -> Int# -> Float#
+indexDoubleOffAddr# :: Addr# -> Int# -> Double#
+indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a
+indexInt8OffAddr# :: Addr# -> Int# -> Int#
+indexInt16OffAddr# :: Addr# -> Int# -> Int#
+indexInt32OffAddr# :: Addr# -> Int# -> Int#
+indexInt64OffAddr# :: Addr# -> Int# -> Int#
+indexWord8OffAddr# :: Addr# -> Int# -> Word#
+indexWord16OffAddr# :: Addr# -> Int# -> Word#
+indexWord32OffAddr# :: Addr# -> Int# -> Word#
+indexWord64OffAddr# :: Addr# -> Int# -> Word#
+readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Char# #)
+readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Char# #)
+readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int# #)
+readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word# #)
+readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Addr# #)
+readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Float# #)
+readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Double# #)
+readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, StablePtr# a #)
+readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int# #)
+readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int# #)
+readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int# #)
+readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int# #)
+readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word# #)
+readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word# #)
+readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word# #)
+readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word# #)
+writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s
+writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s
+writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
+writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
+writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s
+writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s
+writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s
+writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s
+writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
+writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
+writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
+writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
+writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
+writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
+writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
+writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
+newMutVar# :: a -> State# s -> (# State# s, MutVar# s a #)
+readMutVar# :: MutVar# s a -> State# s -> (# State# s, a #)
+writeMutVar# :: MutVar# s a -> a -> State# s -> State# s
+sameMutVar# :: MutVar# s a -> MutVar# s a -> Bool
+atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s, c #)
+catch# :: (State# (RealWorld) -> (# State# (RealWorld), a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld), a #)) -> State# (RealWorld) -> (# State# (RealWorld), a #)
+raise# :: a -> b
+raiseIO# :: a -> State# (RealWorld) -> (# State# (RealWorld), b #)
+maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld), a #)) -> State# (RealWorld) -> (# State# (RealWorld), a #)
+maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld), a #)) -> State# (RealWorld) -> (# State# (RealWorld), a #)
+unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld), a #)) -> State# (RealWorld) -> (# State# (RealWorld), a #)
+getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld), Int# #)
+atomically# :: (State# (RealWorld) -> (# State# (RealWorld), a #)) -> State# (RealWorld) -> (# State# (RealWorld), a #)
+retry# :: State# (RealWorld) -> (# State# (RealWorld), a #)
+catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld), a #)) -> (State# (RealWorld) -> (# State# (RealWorld), a #)) -> State# (RealWorld) -> (# State# (RealWorld), a #)
+catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld), a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld), a #)) -> State# (RealWorld) -> (# State# (RealWorld), a #)
+check# :: (State# (RealWorld) -> (# State# (RealWorld), a #)) -> State# (RealWorld) -> (# State# (RealWorld), () #)
+newTVar# :: a -> State# s -> (# State# s, TVar# s a #)
+readTVar# :: TVar# s a -> State# s -> (# State# s, a #)
+readTVarIO# :: TVar# s a -> State# s -> (# State# s, a #)
+writeTVar# :: TVar# s a -> a -> State# s -> State# s
+sameTVar# :: TVar# s a -> TVar# s a -> Bool
+newMVar# :: State# s -> (# State# s, MVar# s a #)
+takeMVar# :: MVar# s a -> State# s -> (# State# s, a #)
+tryTakeMVar# :: MVar# s a -> State# s -> (# State# s, Int#, a #)
+putMVar# :: MVar# s a -> a -> State# s -> State# s
+tryPutMVar# :: MVar# s a -> a -> State# s -> (# State# s, Int# #)
+sameMVar# :: MVar# s a -> MVar# s a -> Bool
+isEmptyMVar# :: MVar# s a -> State# s -> (# State# s, Int# #)
+delay# :: Int# -> State# s -> State# s
+waitRead# :: Int# -> State# s -> State# s
+waitWrite# :: Int# -> State# s -> State# s
+fork# :: a -> State# (RealWorld) -> (# State# (RealWorld), ThreadId# #)
+forkOn# :: Int# -> a -> State# (RealWorld) -> (# State# (RealWorld), ThreadId# #)
+killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld)
+yield# :: State# (RealWorld) -> State# (RealWorld)
+myThreadId# :: State# (RealWorld) -> (# State# (RealWorld), ThreadId# #)
+labelThread# :: ThreadId# -> Addr# -> State# (RealWorld) -> State# (RealWorld)
+isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld), Int# #)
+noDuplicate# :: State# (RealWorld) -> State# (RealWorld)
+threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld), Int# #)
+mkWeak# :: o -> b -> c -> State# (RealWorld) -> (# State# (RealWorld), Weak# b #)
+mkWeakForeignEnv# :: o -> b -> Addr# -> Addr# -> Int# -> Addr# -> State# (RealWorld) -> (# State# (RealWorld), Weak# b #)
+deRefWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld), Int#, a #)
+finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld), Int#, State# (RealWorld) -> (# State# (RealWorld), () #) #)
+touch# :: o -> State# (RealWorld) -> State# (RealWorld)
+makeStablePtr# :: a -> State# (RealWorld) -> (# State# (RealWorld), StablePtr# a #)
+deRefStablePtr# :: StablePtr# a -> State# (RealWorld) -> (# State# (RealWorld), a #)
+eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int#
+makeStableName# :: a -> State# (RealWorld) -> (# State# (RealWorld), StableName# a #)
+eqStableName# :: StableName# a -> StableName# a -> Int#
+stableNameToInt# :: StableName# a -> Int#
+reallyUnsafePtrEquality# :: a -> a -> Int#
+getSpark# :: State# s -> (# State# s, Int#, a #)
+numSparks# :: State# s -> (# State# s, Int# #)
+dataToTag# :: a -> Int#
+addrToHValue# :: Addr# -> (# a #)
+mkApUpd0# :: BCO# -> (# a #)
+newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s, BCO# #)
+unpackClosure# :: a -> (# Addr#, Array# b, ByteArray# #)
+getApStackVal# :: a -> Int# -> (# Int#, b #)
+traceCcs# :: a -> b -> b
+traceEvent# :: Addr# -> State# s -> State# s
View
4,715 data/haskell2010.txt
4,715 additions, 0 deletions not shown
View
2,532 data/haskell98.txt
@@ -0,0 +1,2532 @@
+-- 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>.
+--