enum-types-0.1.0.0: small enum types
Data.Enum.Types
data A Source #
Constructors
Defined in Data.Enum.Types
Methods
minBound :: A #
maxBound :: A #
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] #
(==) :: A -> A -> Bool #
(/=) :: A -> A -> Bool #
compare :: A -> A -> Ordering #
(<) :: A -> A -> Bool #
(<=) :: A -> A -> Bool #
(>) :: A -> A -> Bool #
(>=) :: A -> A -> Bool #
max :: A -> A -> A #
min :: A -> A -> A #
readsPrec :: Int -> ReadS A #
readList :: ReadS [A] #
readPrec :: ReadPrec A #
readListPrec :: ReadPrec [A] #
showsPrec :: Int -> A -> ShowS #
show :: A -> String #
showList :: [A] -> ShowS #
data B Source #
minBound :: B #
maxBound :: B #
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] #
(==) :: B -> B -> Bool #
(/=) :: B -> B -> Bool #
compare :: B -> B -> Ordering #
(<) :: B -> B -> Bool #
(<=) :: B -> B -> Bool #
(>) :: B -> B -> Bool #
(>=) :: B -> B -> Bool #
max :: B -> B -> B #
min :: B -> B -> B #
readsPrec :: Int -> ReadS B #
readList :: ReadS [B] #
readPrec :: ReadPrec B #
readListPrec :: ReadPrec [B] #
showsPrec :: Int -> B -> ShowS #
show :: B -> String #
showList :: [B] -> ShowS #
data C Source #
minBound :: C #
maxBound :: C #
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] #
(==) :: C -> C -> Bool #
(/=) :: C -> C -> Bool #
compare :: C -> C -> Ordering #
(<) :: C -> C -> Bool #
(<=) :: C -> C -> Bool #
(>) :: C -> C -> Bool #
(>=) :: C -> C -> Bool #
max :: C -> C -> C #
min :: C -> C -> C #
readsPrec :: Int -> ReadS C #
readList :: ReadS [C] #
readPrec :: ReadPrec C #
readListPrec :: ReadPrec [C] #
showsPrec :: Int -> C -> ShowS #
show :: C -> String #
showList :: [C] -> ShowS #
data D Source #
minBound :: D #
maxBound :: D #
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] #
(==) :: D -> D -> Bool #
(/=) :: D -> D -> Bool #
compare :: D -> D -> Ordering #
(<) :: D -> D -> Bool #
(<=) :: D -> D -> Bool #
(>) :: D -> D -> Bool #
(>=) :: D -> D -> Bool #
max :: D -> D -> D #
min :: D -> D -> D #
readsPrec :: Int -> ReadS D #
readList :: ReadS [D] #
readPrec :: ReadPrec D #
readListPrec :: ReadPrec [D] #
showsPrec :: Int -> D -> ShowS #
show :: D -> String #
showList :: [D] -> ShowS #
data E Source #
minBound :: E #
maxBound :: E #
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] #
(==) :: E -> E -> Bool #
(/=) :: E -> E -> Bool #
compare :: E -> E -> Ordering #
(<) :: E -> E -> Bool #
(<=) :: E -> E -> Bool #
(>) :: E -> E -> Bool #
(>=) :: E -> E -> Bool #
max :: E -> E -> E #
min :: E -> E -> E #
readsPrec :: Int -> ReadS E #
readList :: ReadS [E] #
readPrec :: ReadPrec E #
readListPrec :: ReadPrec [E] #
showsPrec :: Int -> E -> ShowS #
show :: E -> String #
showList :: [E] -> ShowS #
data F Source #
minBound :: F #
maxBound :: F #
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] #
(==) :: F -> F -> Bool #
(/=) :: F -> F -> Bool #
compare :: F -> F -> Ordering #
(<) :: F -> F -> Bool #
(<=) :: F -> F -> Bool #
(>) :: F -> F -> Bool #
(>=) :: F -> F -> Bool #
max :: F -> F -> F #
min :: F -> F -> F #
readsPrec :: Int -> ReadS F #
readList :: ReadS [F] #
readPrec :: ReadPrec F #
readListPrec :: ReadPrec [F] #
showsPrec :: Int -> F -> ShowS #
show :: F -> String #
showList :: [F] -> ShowS #
data G Source #
minBound :: G #
maxBound :: G #
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] #
(==) :: G -> G -> Bool #
(/=) :: G -> G -> Bool #
compare :: G -> G -> Ordering #
(<) :: G -> G -> Bool #
(<=) :: G -> G -> Bool #
(>) :: G -> G -> Bool #
(>=) :: G -> G -> Bool #
max :: G -> G -> G #
min :: G -> G -> G #
readsPrec :: Int -> ReadS G #
readList :: ReadS [G] #
readPrec :: ReadPrec G #
readListPrec :: ReadPrec [G] #
showsPrec :: Int -> G -> ShowS #
show :: G -> String #
showList :: [G] -> ShowS #
data H Source #
minBound :: H #
maxBound :: H #
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] #
(==) :: H -> H -> Bool #
(/=) :: H -> H -> Bool #
compare :: H -> H -> Ordering #
(<) :: H -> H -> Bool #
(<=) :: H -> H -> Bool #
(>) :: H -> H -> Bool #
(>=) :: H -> H -> Bool #
max :: H -> H -> H #
min :: H -> H -> H #
readsPrec :: Int -> ReadS H #
readList :: ReadS [H] #
readPrec :: ReadPrec H #
readListPrec :: ReadPrec [H] #
showsPrec :: Int -> H -> ShowS #
show :: H -> String #
showList :: [H] -> ShowS #
data I Source #
minBound :: I #
maxBound :: I #
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] #
(==) :: I -> I -> Bool #
(/=) :: I -> I -> Bool #
compare :: I -> I -> Ordering #
(<) :: I -> I -> Bool #
(<=) :: I -> I -> Bool #
(>) :: I -> I -> Bool #
(>=) :: I -> I -> Bool #
max :: I -> I -> I #
min :: I -> I -> I #
readsPrec :: Int -> ReadS I #
readList :: ReadS [I] #
readPrec :: ReadPrec I #
readListPrec :: ReadPrec [I] #
showsPrec :: Int -> I -> ShowS #
show :: I -> String #
showList :: [I] -> ShowS #
data J Source #
minBound :: J #
maxBound :: J #
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] #
(==) :: J -> J -> Bool #
(/=) :: J -> J -> Bool #
compare :: J -> J -> Ordering #
(<) :: J -> J -> Bool #
(<=) :: J -> J -> Bool #
(>) :: J -> J -> Bool #
(>=) :: J -> J -> Bool #
max :: J -> J -> J #
min :: J -> J -> J #
readsPrec :: Int -> ReadS J #
readList :: ReadS [J] #
readPrec :: ReadPrec J #
readListPrec :: ReadPrec [J] #
showsPrec :: Int -> J -> ShowS #
show :: J -> String #
showList :: [J] -> ShowS #
data K Source #
minBound :: K #
maxBound :: K #
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] #
(==) :: K -> K -> Bool #
(/=) :: K -> K -> Bool #
compare :: K -> K -> Ordering #
(<) :: K -> K -> Bool #
(<=) :: K -> K -> Bool #
(>) :: K -> K -> Bool #
(>=) :: K -> K -> Bool #
max :: K -> K -> K #
min :: K -> K -> K #
readsPrec :: Int -> ReadS K #
readList :: ReadS [K] #
readPrec :: ReadPrec K #
readListPrec :: ReadPrec [K] #
showsPrec :: Int -> K -> ShowS #
show :: K -> String #
showList :: [K] -> ShowS #