Num -package:base-prelude -package:stack -package:yesod-paginator package:linear-base
Class
Enum defines operations on sequentially ordered types.
The
enumFrom... methods are used in Haskell's translation of
arithmetic sequences.
Instances of
Enum may be derived for any enumeration type
(types whose constructors have no fields). The nullary constructors
are assumed to be numbered left-to-right by
fromEnum from
0 through
n-1. See Chapter 10 of the
Haskell
Report for more details.
For any type that is an instance of class
Bounded as well as
Enum, the following should hold:
enumFrom x = enumFromTo x maxBound
enumFromThen x y = enumFromThenTo x y bound
where
bound | fromEnum y >= fromEnum x = maxBound
| otherwise = minBound
Used in Haskell's translation of
[n..] with
[n..] =
enumFrom n, a possible implementation being
enumFrom n = n :
enumFrom (succ n). For example:
enumFrom 4 :: [Integer] = [4,5,6,7,...]
enumFrom 6 :: [Int] = [6,7,8,9,...,maxBound ::
Int]
Used in Haskell's translation of
[n,n'..] with
[n,n'..] =
enumFromThen n n', a possible implementation being
enumFromThen n n' = n : n' : worker (f x) (f x n'),
worker s v = v : worker s (s v),
x = fromEnum n' -
fromEnum n and
f n y | n > 0 = f (n - 1) (succ y) | n <
0 = f (n + 1) (pred y) | otherwise = y For example:
enumFromThen 4 6 :: [Integer] = [4,6,8,10...]
enumFromThen 6 2 :: [Int] = [6,2,-2,-6,...,minBound ::
Int]
Used in Haskell's translation of
[n,n'..m] with
[n,n'..m]
= enumFromThenTo n n' m, a possible implementation being
enumFromThenTo n n' m = worker (f x) (c x) n m,
x =
fromEnum n' - fromEnum n,
c x = bool (>=) ((x
0) f n y | n > 0 = f (n - 1) (succ y) | n < 0 = f (n +
1) (pred y) | otherwise = y and
worker s c v m | c v m = v :
worker s c (s v) m | otherwise = [] For example:
enumFromThenTo 4 2 -6 :: [Integer] =
[4,2,0,-2,-4,-6]
enumFromThenTo 6 8 2 :: [Int] = []
Used in Haskell's translation of
[n..m] with
[n..m] =
enumFromTo n m, a possible implementation being
enumFromTo n
m | n <= m = n : enumFromTo (succ n) m | otherwise = []. For
example:
enumFromTo 6 10 :: [Int] = [6,7,8,9,10]
enumFromTo 42 1 :: [Integer] = []
Convert to an
Int. It is implementation-dependent what
fromEnum returns when applied to a value that is too large to
fit in an
Int.
Like
enumFromThenN but where the next element in the
enumeration is just the successor
succ n for a given enum
n.
An finite sequence of enumerable values at a fixed distance,
determined by the first and second values.
>>> S.print $ S.enumFromThenN 3 100 200
100
200
300
A finite sequence of enumerable values at a fixed distance determined
by the first and second values. The length is limited by zipping with
a given finite stream, i.e., the first argument.
Like
enumFromThenZip but where the next element in the
enumeration is just the successor
succ n for a given enum
n.