Safe Haskell None

Bug3

Synopsis

foo :: Int :: Int

Safe Haskell None

Bug4

Synopsis

foo :: Int :: Int

Safe Haskell None

Bug6

data A = A Int A = A Int

data B = B B = B {

b :: Int b :: Int

}

data C = C C = C {

c1 :: Int c1 :: Int
c2 :: Int c2 :: Int

}

data D = D Int Int D = D Int Int

newtype E = E Int E = E Int

A Int Int

b :: Int :: Int

c1 :: Int :: Int

c2 :: Int :: Int

D Int Int Int Int E Int Int

Safe Haskell None

Bug7

data Foo = Foo Foo = Foo

class Bar Bar x y

Bar Foo Foo Bar Foo Foo

Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
Contents Contents
Index Index
Bar Foo Foo Bar Foo Foo
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
Contents Contents
Index Index
Safe Haskell None
Bug8
Type (String, [Typ (String, [Typ]) TFree (String, [String (String, [String])
Safe Haskell None

Bugs

A a (a -> Int a (a -> Int)

Safe Haskell	None

CrossPackageDocs

Synopsis

mapmap f xs

The MonadMonad class defines the basic operations over a monad

Minimal complete definition: >>=>>= and returnreturn.

Instances of MonadMonad should satisfy the following laws:

Instances of both MonadMonad and FunctorFunctor should additionally satisfy the law:

The instances of MonadMonad for lists, Data.Maybe.Maybe and System.IO.IO -defined in the PreludePrelude satisfy these laws.

Prelude

fail :: String :: String -> m a

PreludePrelude
Monad Monad []
Monad IO Monad IO
Monad Monad Q
Monad Maybe Monad Maybe
Monad Monad PprM
Monad ((->) r)
Monad (Either Monad (Either e)
Prelude
Runs a raw command, and returns HandleHandles that may be used to communicate with the process via its Prelude
The HandleHandles are initially in binary mode; if you need them to be in text mode then use hSetBinaryModehSetBinaryMode.
Prelude
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
ContentsContents
IndexIndex
:: FilePath:: FilePath
Prelude
-> [String-> [String]
Prelude
-> Maybe FilePath-> Maybe FilePath
Prelude
-> Maybe [(String, String-> Maybe [(String, String)]
Prelude
-> IO (Handle, Handle, Handle, ProcessHandle-> IO (Handle, Handle, Handle, ProcessHandle)
Safe Haskell None

Examples

Synopsis
fib :: Integer -> Integerfib :: Integer -> Integer

fib :: Integer -> Integer :: Integer -> Integer

Fibonacci number of given IntegerInteger.

Produced by Haddock version 2.9.2

Produced by Haddock version 2.9.4

Safe Haskell None

FunArgs

:: forall a . Ord a . Ord a => Int=> Int-> Bool-> Bool
-> ()-> ()

Produced by Haddock version 2.9.2

Produced by Haddock version 2.9.4

Safe Haskell None

GADTRecords

data  H1  H1 a b whereC1 ::  H1C1 ::  H1 a b  
C2 :: Ord a => [a] -> H1C2 :: Ord a => [a] -> H1 a a  
C3C3 ::  { field :: Intfield :: Int
 } -> H1 Int Int } -> H1 Int Int
C4C4 ::  { field2field2 :: a
 } -> H1 Int } -> H1 Int a

C1 ::  H1 ::  H1 a b C2 :: Ord a => [a] -> H1 :: Ord a => [a] -> H1 a a C3 ::  Int -> H1 Int Int ::  Int -> H1 Int Int field :: Int :: Int
C4 ::  a -> H1 Int ::  a -> H1 Int a

Produced by Haddock version 2.9.2

Produced by Haddock version 2.9.4

Safe Haskell None

Hash

Contents
The The HashTable type
 Operations on Operations on HashTables
 
The The Hash class
 
data  HashTable  HashTable key val
new :: (Eq key, Hash key) => Int -> IO (HashTablenew :: (Eq key, Hash key) => Int -> IO (HashTable key val)
insert :: (Eq key, Hash key) => key -> val -> IO ()insert :: (Eq key, Hash key) => key -> val -> IO ()
lookup :: Hash key => key -> IO (Maybelookup :: Hash key => key -> IO (Maybe val)
class  Hash  Hash a  wherehash :: a -> Inthash :: a -> Int
key should be an instance of EqEq.
 
new :: (Eq key, Hash key) => Int -> IO (HashTable :: (Eq key, Hash key) => Int -> IO (HashTable key val)
insert :: (Eq key, Hash key) => key -> val -> IO () :: (Eq key, Hash key) => key -> val -> IO ()
lookup :: Hash key => key -> IO (Maybe :: Hash key => key -> IO (Maybe val)
Looks up a key in the hash table, returns JustJust val if the key
  was found, or NothingNothing otherwise.
 
hash :: a -> Int :: a -> Int
hashes the value of type a into an IntInt
 
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
ContentsContents
IndexIndex
Hash FloatHash Float  
Hash IntHash Int  
(Hash a, Hash b) => Hash(Hash a, Hash b) => Hash (a, b)  
Safe Haskell None
NamedDoc
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
ContentsContents
IndexIndex
Safe Haskell None
NoLayout
Synopsis
g :: Intg :: Int
g :: Int :: Int
the function gg
 
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
ContentsContents
IndexIndex
Safe Haskell None
NonGreedy
Synopsis
ff ::  a
 ::  a
url1 url2url1 url2
 
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
ContentsContents
IndexIndex
Safe Haskell None
QuasiExpr
IntExpr Integer Integer AntiIntExpr String String BinopExpr BinOp Expr Expr BinOp Expr Expr AntiExpr String String Show ExprShow Expr  
eval :: Expr -> Integer :: Expr -> Integer
parseExprExp :: String :: String -> Q Exp
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
ContentsContents
IndexIndex
Show BinOpShow BinOp  
Safe Haskell None
QuasiQuote
val :: Integer :: Integer
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
ContentsContents
IndexIndex
Safe Haskell None
TH
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
ContentsContents
IndexIndex
Safe Haskell None
TH2
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
ContentsContents
IndexIndex
libraries@haskell.orgSafe HaskellNone
Test
Contents
Type declarations
+	  >Type declarations
 Data types
+	      >Data types
 
Records
+	      >Records
 
Class declarations
+	  >Class declarations
 
Function types
+	  >Function types
 
Auxiliary stuff
+	  >Auxiliary stuff
 
A hidden module
+	  >A hidden module
 
A visible module
+	  >A visible module
 
Existential / Universal types
+	  >Existential / Universal types
 
Type signatures with argument docs
+	  >Type signatures with argument docs
 
A section
+	  >A section
 A subsection 
+	      >A subsection 
 
This module illustrates & tests most of the features of Haddock.
  Testing references from the description: TT, ff, gg, visiblevisible.
 
data  T  T a b= A Int (Maybe Float= A Int (Maybe Float)  
| B (T a b, T Int Float| B (T a b, T Int Float)  
data  T2  T2 a b
data  T3  T3 a b= A1= A1 a  
| B1| B1 b  
data  T4  T4 a b= A2= A2 a  
| B2| B2 b  
data  T5  T5 a b= A3= A3 a  
| B3| B3 b  
data  T6  T6 = A4= A4  
| B4| B4  
| C4| C4  
newtype  N1 a = N1  N1 a = N1 a
newtype  N2 a b = N2  N2 a b = N2 {nn :: a b
}
newtype  N3 a b = N3  N3 a b = N3 {n3n3 :: a b
}
data  N4  N4 a b
newtype  N5 a b = N5  N5 a b = N5 {n5n5 :: a b
}
newtype  N6 a b = N6  N6 a b = N6 {n6n6 :: a b
}
newtype  N7 a b = N7  N7 a b = N7 {n7n7 :: a b
}
data  R  R = C1= C1 { p :: Intp :: Int
qq :: forall a.  a -> a
r :: Intr :: Int
s :: Ints :: Int
 }
| C2| C2 { t :: T1 -> T2 Int Int -> T3 Bool Bool -> T4 Float Float -> T5 () ()t :: T1 -> T2 Int Int -> T3 Bool Bool -> T4 Float Float -> T5 () ()
u :: Intu :: Int
v :: Intv :: Int
 }
data  R1  = C3  R1  = C3 {s1 :: Ints1 :: Int
s2 :: Ints2 :: Int
s3 :: Ints3 :: Int
}
class D a => C D a => C a  wherea :: IOa :: IO a
bb :: [a]
class  D  D a  whered ::  Td ::  T a b
ee :: (a, a)
class  E  E a 
class  F  F a  whereffff :: a
f :: C a => a -> Intf :: C a => a -> Int
g :: Int -> IOg :: Int -> IO CInt
hidden :: Int -> Inthidden :: Int -> Int
module Visiblemodule Visible
data  Ex  Ex a= forall b . C b => Ex1 b . C b => Ex1 b  
| forall b . Ex2 b . Ex2 b  
| forall b . C a => Ex3 b . C a => Ex3 b  
| Ex4| Ex4 (forall a.  a -> a)  
k :: T () () -> T2 Int Int -> (T3 Bool Bool -> T4 Float Float) -> T5 () () -> IO ()k :: T () () -> T2 Int Int -> (T3 Bool Bool -> T4 Float Float) -> T5 () () -> IO ()
l :: (Int, Int, Float) -> Intl :: (Int, Int, Float) -> Int
m :: R -> N1 () -> IO Intm :: R -> N1 () -> IO Int
o :: Float -> IO Floato :: Float -> IO Float
f' :: Intf' :: Int
A Int (Maybe Float Int (Maybe Float)This comment describes the AA constructor
 
B (T a b, T Int Float (T a b, T Int Float)This comment describes the BB constructor
 
documents A3A3
 
documents B3B3
 
This is the doc for A4A4
 
This is the doc for B4B4
 
This is the doc for C4C4
 
this is the n3n3 field 
 
The N7N7 constructor
 
This is the documentation for the RR record, which has four fields,
  pp, qq, rr, and ss.
 
This is the C1C1 record constructor, with the following fields:
 
p :: Int :: Int
This comment applies to the pp field
 
This comment applies to the qq field
 
r :: Int :: Int
This comment applies to both rr and ss
 
s :: Int :: Int
This comment applies to both rr and ss
 
This is the C2C2 record constructor, also with some fields:
 
t :: T1 -> T2 Int Int -> T3 Bool Bool -> T4 Float Float -> T5 () () :: T1 -> T2 Int Int -> T3 Bool Bool -> T4 Float Float -> T5 () ()
 
u :: Int :: Int
 
v :: Int :: Int
 
This is the C3C3 record constructor
 
s1 :: Int :: Int
The s1s1 record selector
 
s2 :: Int :: Int
The s2s2 record selector
 
s3 :: Int :: Int
The s3s3 record selector
 
class D D a => C a  This comment applies to the previous declaration (the CC class)
 
a :: IO :: IO a
this is a description of the aa method
 
this is a description of the bb method
 
d ::  T ::  T a b
f :: C a => a -> Int :: C a => a -> Int
In a comment string we can refer to identifiers in scope with
 single quotes like this: TT, and we can refer to modules by
-using double quotes: FooFoo.  We can add emphasis like this.
@@ -1485,7 +1717,8 @@ using double quotes: Foo
      This is a block of code, which can include other markup: RR
      formatting
@@ -1496,7 +1729,8 @@ using double quotes: Foo this is another block of code
 
We can also include URLs in documentation: http://www.haskell.org/We can also include URLs in documentation: http://www.haskell.org/.
 
Foog :: Int -> IO :: Int -> IO CInt
hidden :: Int -> Int :: Int -> Int
module Visiblemodule Visible
D FloatD Float  
D IntD Int   forall b . C b . C b => Ex1 b forall b . C b . C a => Ex3 b:: T () ():: T () () This argument has type TT
 
-> T2 Int Int-> T2 Int Int 
-> (T3 Bool Bool -> T4 Float Float-> (T3 Bool Bool -> T4 Float Float) 
-> T5 () ()-> T5 () () 
-> IO ()-> IO () :: (Int, Int, Float:: (Int, Int, Float) 
-> Int-> Int returns an IntInt
 
:: R:: R  
-> N1 ()-> N1 () 
-> IO Int-> IO Int :: Float:: Float 
-> IO Float-> IO Float 
f' :: Int :: Int
a function with a prime can be referred to as f'f' 
  but f' doesn't get link'd 'f\''
@@ -1960,8 +2234,9 @@ test2
       >
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
ContentsContents
IndexIndex
Safe Haskell None
Ticket112
Synopsis
ff ::  a
...given a raw Addr#Addr# to the string, and the length of the string.
 
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
ContentsContents
IndexIndex
Safe Haskell None
Ticket61
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
ContentsContents
IndexIndex
Safe Haskell None
Ticket75
data  a :- b = Q  a :- b = Q
f :: Intf :: Int
f :: Int :: Int
A reference to :-:-
 
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
ContentsContents
IndexIndex
Safe Haskell None
TypeFamilies
type family G G a :: *
class  A  A a  wheredata B B a :: * -> *
f :: B a Intf :: B a Int
type family F F a 
f :: B a Int :: B a Int
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
ContentsContents
IndexIndex
A IntA Int  
Safe Haskell None
TypeOperators
Contents
stuff
+	  >stuff
 
data  a :-:  a :-: b
data  (a :+:  (a :+: b) c
data  Op  Op a b
newtype  O g f a = O  O g f a = O {unOunO :: g (f a)
}
biO ::  (g `ObiO ::  (g `O` f) a
newtype  Flip (~>) b a = Flip  Flip (~>) b a = Flip {unFlipunFlip :: a ~> b
}
biO ::  (g `O ::  (g `O` f) a
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4
ContentsContents
IndexIndex
Safe Haskell None
Visible
visible :: Int -> Int :: Int -> Int
Produced by Haddock version 2.9.2
Produced by Haddock version 2.9.4

Monad Monad []
Monad IO Monad IO
Monad Monad Q
Monad Maybe Monad Maybe
Monad Monad PprM
Monad ((->) r)
Monad (Either Monad (Either e)

:: FilePath:: FilePath	Prelude
-> [String-> [String]	Prelude
-> Maybe FilePath-> Maybe FilePath	Prelude
-> Maybe [(String, String-> Maybe [(String, String)]	Prelude
-> IO (Handle, Handle, Handle, ProcessHandle-> IO (Handle, Handle, Handle, ProcessHandle)

Hash Float Hash Float
Hash Int Hash Int
(Hash a, Hash b) => Hash(Hash a, Hash b) => Hash (a, b)

D Float D Float
D Int D Int		forall b . C b . C b => Ex1 b	forall b . C b . C a => Ex3 b