Documentation

Methods

minBound :: A #

maxBound :: A #

Methods

succ :: A -> A #

pred :: A -> A #

toEnum :: Int -> A #

fromEnum :: A -> Int #

enumFrom :: A -> [A] #

enumFromThen :: A -> A -> [A] #

enumFromTo :: A -> A -> [A] #

enumFromThenTo :: A -> A -> A -> [A] #

Methods

(==) :: A -> A -> Bool #

(/=) :: A -> A -> Bool #

Methods

compare :: A -> A -> Ordering #

(<) :: A -> A -> Bool #

(<=) :: A -> A -> Bool #

(>) :: A -> A -> Bool #

(>=) :: A -> A -> Bool #

max :: A -> A -> A #

min :: A -> A -> A #

Methods

readsPrec :: Int -> ReadS A #

readList :: ReadS [A] #

readPrec :: ReadPrec A #

readListPrec :: ReadPrec [A] #

Methods

showsPrec :: Int -> A -> ShowS #

show :: A -> String #

showList :: [A] -> ShowS #

Methods

minBound :: B #

maxBound :: B #

Methods

succ :: B -> B #

pred :: B -> B #

toEnum :: Int -> B #

fromEnum :: B -> Int #

enumFrom :: B -> [B] #

enumFromThen :: B -> B -> [B] #

enumFromTo :: B -> B -> [B] #

enumFromThenTo :: B -> B -> B -> [B] #

Methods

(==) :: B -> B -> Bool #

(/=) :: B -> B -> Bool #

Methods

compare :: B -> B -> Ordering #

(<) :: B -> B -> Bool #

(<=) :: B -> B -> Bool #

(>) :: B -> B -> Bool #

(>=) :: B -> B -> Bool #

max :: B -> B -> B #

min :: B -> B -> B #

Methods

readsPrec :: Int -> ReadS B #

readList :: ReadS [B] #

readPrec :: ReadPrec B #

readListPrec :: ReadPrec [B] #

Methods

showsPrec :: Int -> B -> ShowS #

show :: B -> String #

showList :: [B] -> ShowS #

Methods

minBound :: C #

maxBound :: C #

Methods

succ :: C -> C #

pred :: C -> C #

toEnum :: Int -> C #

fromEnum :: C -> Int #

enumFrom :: C -> [C] #

enumFromThen :: C -> C -> [C] #

enumFromTo :: C -> C -> [C] #

enumFromThenTo :: C -> C -> C -> [C] #

Methods

(==) :: C -> C -> Bool #

(/=) :: C -> C -> Bool #

Methods

compare :: C -> C -> Ordering #

(<) :: C -> C -> Bool #

(<=) :: C -> C -> Bool #

(>) :: C -> C -> Bool #

(>=) :: C -> C -> Bool #

max :: C -> C -> C #

min :: C -> C -> C #

Methods

readsPrec :: Int -> ReadS C #

readList :: ReadS [C] #

readPrec :: ReadPrec C #

readListPrec :: ReadPrec [C] #

Methods

showsPrec :: Int -> C -> ShowS #

show :: C -> String #

showList :: [C] -> ShowS #

Methods

minBound :: D #

maxBound :: D #

Methods

succ :: D -> D #

pred :: D -> D #

toEnum :: Int -> D #

fromEnum :: D -> Int #

enumFrom :: D -> [D] #

enumFromThen :: D -> D -> [D] #

enumFromTo :: D -> D -> [D] #

enumFromThenTo :: D -> D -> D -> [D] #

Methods

(==) :: D -> D -> Bool #

(/=) :: D -> D -> Bool #

Methods

compare :: D -> D -> Ordering #

(<) :: D -> D -> Bool #

(<=) :: D -> D -> Bool #

(>) :: D -> D -> Bool #

(>=) :: D -> D -> Bool #

max :: D -> D -> D #

min :: D -> D -> D #

Methods

readsPrec :: Int -> ReadS D #

readList :: ReadS [D] #

readPrec :: ReadPrec D #

readListPrec :: ReadPrec [D] #

Methods

showsPrec :: Int -> D -> ShowS #

show :: D -> String #

showList :: [D] -> ShowS #

Methods

minBound :: E #

maxBound :: E #

Methods

succ :: E -> E #

pred :: E -> E #

toEnum :: Int -> E #

fromEnum :: E -> Int #

enumFrom :: E -> [E] #

enumFromThen :: E -> E -> [E] #

enumFromTo :: E -> E -> [E] #

enumFromThenTo :: E -> E -> E -> [E] #

Methods

(==) :: E -> E -> Bool #

(/=) :: E -> E -> Bool #

Methods

compare :: E -> E -> Ordering #

(<) :: E -> E -> Bool #

(<=) :: E -> E -> Bool #

(>) :: E -> E -> Bool #

(>=) :: E -> E -> Bool #

max :: E -> E -> E #

min :: E -> E -> E #

Methods

readsPrec :: Int -> ReadS E #

readList :: ReadS [E] #

readPrec :: ReadPrec E #

readListPrec :: ReadPrec [E] #

Methods

showsPrec :: Int -> E -> ShowS #

show :: E -> String #

showList :: [E] -> ShowS #

Methods

minBound :: F #

maxBound :: F #

Methods

succ :: F -> F #

pred :: F -> F #

toEnum :: Int -> F #

fromEnum :: F -> Int #

enumFrom :: F -> [F] #

enumFromThen :: F -> F -> [F] #

enumFromTo :: F -> F -> [F] #

enumFromThenTo :: F -> F -> F -> [F] #

Methods

(==) :: F -> F -> Bool #

(/=) :: F -> F -> Bool #

Methods

compare :: F -> F -> Ordering #

(<) :: F -> F -> Bool #

(<=) :: F -> F -> Bool #

(>) :: F -> F -> Bool #

(>=) :: F -> F -> Bool #

max :: F -> F -> F #

min :: F -> F -> F #

Methods

readsPrec :: Int -> ReadS F #

readList :: ReadS [F] #

readPrec :: ReadPrec F #

readListPrec :: ReadPrec [F] #

Methods

showsPrec :: Int -> F -> ShowS #

show :: F -> String #

showList :: [F] -> ShowS #

Methods

minBound :: G #

maxBound :: G #

Methods

succ :: G -> G #

pred :: G -> G #

toEnum :: Int -> G #

fromEnum :: G -> Int #

enumFrom :: G -> [G] #

enumFromThen :: G -> G -> [G] #

enumFromTo :: G -> G -> [G] #

enumFromThenTo :: G -> G -> G -> [G] #

Methods

(==) :: G -> G -> Bool #

(/=) :: G -> G -> Bool #

Methods

compare :: G -> G -> Ordering #

(<) :: G -> G -> Bool #

(<=) :: G -> G -> Bool #

(>) :: G -> G -> Bool #

(>=) :: G -> G -> Bool #

max :: G -> G -> G #

min :: G -> G -> G #

Methods

readsPrec :: Int -> ReadS G #

readList :: ReadS [G] #

readPrec :: ReadPrec G #

readListPrec :: ReadPrec [G] #

Methods

showsPrec :: Int -> G -> ShowS #

show :: G -> String #

showList :: [G] -> ShowS #

Methods

minBound :: H #

maxBound :: H #

Methods

succ :: H -> H #

pred :: H -> H #

toEnum :: Int -> H #

fromEnum :: H -> Int #

enumFrom :: H -> [H] #

enumFromThen :: H -> H -> [H] #

enumFromTo :: H -> H -> [H] #

enumFromThenTo :: H -> H -> H -> [H] #

Methods

(==) :: H -> H -> Bool #

(/=) :: H -> H -> Bool #

Methods

compare :: H -> H -> Ordering #

(<) :: H -> H -> Bool #

(<=) :: H -> H -> Bool #

(>) :: H -> H -> Bool #

(>=) :: H -> H -> Bool #

max :: H -> H -> H #

min :: H -> H -> H #

Methods

readsPrec :: Int -> ReadS H #

readList :: ReadS [H] #

readPrec :: ReadPrec H #

readListPrec :: ReadPrec [H] #

Methods

showsPrec :: Int -> H -> ShowS #

show :: H -> String #

showList :: [H] -> ShowS #

Methods

minBound :: I #

maxBound :: I #

Methods

succ :: I -> I #

pred :: I -> I #

toEnum :: Int -> I #

fromEnum :: I -> Int #

enumFrom :: I -> [I] #

enumFromThen :: I -> I -> [I] #

enumFromTo :: I -> I -> [I] #

enumFromThenTo :: I -> I -> I -> [I] #

Methods

(==) :: I -> I -> Bool #

(/=) :: I -> I -> Bool #

Methods

compare :: I -> I -> Ordering #

(<) :: I -> I -> Bool #

(<=) :: I -> I -> Bool #

(>) :: I -> I -> Bool #

(>=) :: I -> I -> Bool #

max :: I -> I -> I #

min :: I -> I -> I #

Methods

readsPrec :: Int -> ReadS I #

readList :: ReadS [I] #

readPrec :: ReadPrec I #

readListPrec :: ReadPrec [I] #

Methods

showsPrec :: Int -> I -> ShowS #

show :: I -> String #

showList :: [I] -> ShowS #

Methods

minBound :: J #

maxBound :: J #

Methods

succ :: J -> J #

pred :: J -> J #

toEnum :: Int -> J #

fromEnum :: J -> Int #

enumFrom :: J -> [J] #

enumFromThen :: J -> J -> [J] #

enumFromTo :: J -> J -> [J] #

enumFromThenTo :: J -> J -> J -> [J] #

Methods

(==) :: J -> J -> Bool #

(/=) :: J -> J -> Bool #

Methods

compare :: J -> J -> Ordering #

(<) :: J -> J -> Bool #

(<=) :: J -> J -> Bool #

(>) :: J -> J -> Bool #

(>=) :: J -> J -> Bool #

max :: J -> J -> J #

min :: J -> J -> J #

Methods

readsPrec :: Int -> ReadS J #

readList :: ReadS [J] #

readPrec :: ReadPrec J #

readListPrec :: ReadPrec [J] #

Methods

showsPrec :: Int -> J -> ShowS #

show :: J -> String #

showList :: [J] -> ShowS #

Methods

minBound :: K #

maxBound :: K #

Methods

succ :: K -> K #

pred :: K -> K #

toEnum :: Int -> K #

fromEnum :: K -> Int #

enumFrom :: K -> [K] #

enumFromThen :: K -> K -> [K] #

enumFromTo :: K -> K -> [K] #

enumFromThenTo :: K -> K -> K -> [K] #

Methods

(==) :: K -> K -> Bool #

(/=) :: K -> K -> Bool #

Methods

compare :: K -> K -> Ordering #

(<) :: K -> K -> Bool #

(<=) :: K -> K -> Bool #

(>) :: K -> K -> Bool #

(>=) :: K -> K -> Bool #

max :: K -> K -> K #

min :: K -> K -> K #

Methods

readsPrec :: Int -> ReadS K #

readList :: ReadS [K] #

readPrec :: ReadPrec K #

readListPrec :: ReadPrec [K] #

Methods

showsPrec :: Int -> K -> ShowS #

show :: K -> String #

showList :: [K] -> ShowS #