GHC.Enum

The Enum and Bounded classes.

Documentation

class Bounded a where

The Bounded class is used to name the upper and lower limits of a type. Ord is not a superclass of Bounded since types that are not totally ordered may also have upper and lower bounds.

The Bounded class may be derived for any enumeration type; minBound is the first constructor listed in the data declaration and maxBound is the last. Bounded may also be derived for single-constructor datatypes whose constituent types are in Bounded.

Methods

minBound :: a

maxBound :: a

Instances

Bounded All

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

minBound :: All

maxBound :: All

Bounded Any

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

minBound :: Any

maxBound :: Any

Bounded CBool

Defined in Foreign.C.Types

Methods

minBound :: CBool

maxBound :: CBool

Bounded CChar

Defined in Foreign.C.Types

Methods

minBound :: CChar

maxBound :: CChar

Bounded CInt

Defined in Foreign.C.Types

Methods

minBound :: CInt

maxBound :: CInt

Bounded CIntMax

Defined in Foreign.C.Types

Methods

minBound :: CIntMax

maxBound :: CIntMax

Bounded CIntPtr

Defined in Foreign.C.Types

Methods

minBound :: CIntPtr

maxBound :: CIntPtr

Bounded CLLong

Defined in Foreign.C.Types

Methods

minBound :: CLLong

maxBound :: CLLong

Bounded CLong

Defined in Foreign.C.Types

Methods

minBound :: CLong

maxBound :: CLong

Bounded CPtrdiff

Defined in Foreign.C.Types

Methods

minBound :: CPtrdiff

maxBound :: CPtrdiff

Bounded CSChar

Defined in Foreign.C.Types

Methods

minBound :: CSChar

maxBound :: CSChar

Bounded CShort

Defined in Foreign.C.Types

Methods

minBound :: CShort

maxBound :: CShort

Bounded CSigAtomic

Defined in Foreign.C.Types

Methods

minBound :: CSigAtomic

maxBound :: CSigAtomic

Bounded CSize

Defined in Foreign.C.Types

Methods

minBound :: CSize

maxBound :: CSize

Bounded CUChar

Defined in Foreign.C.Types

Methods

minBound :: CUChar

maxBound :: CUChar

Bounded CUInt

Defined in Foreign.C.Types

Methods

minBound :: CUInt

maxBound :: CUInt

Bounded CUIntMax

Defined in Foreign.C.Types

Methods

minBound :: CUIntMax

maxBound :: CUIntMax

Bounded CUIntPtr

Defined in Foreign.C.Types

Methods

minBound :: CUIntPtr

maxBound :: CUIntPtr

Bounded CULLong

Defined in Foreign.C.Types

Methods

minBound :: CULLong

maxBound :: CULLong

Bounded CULong

Defined in Foreign.C.Types

Methods

minBound :: CULong

maxBound :: CULong

Bounded CUShort

Defined in Foreign.C.Types

Methods

minBound :: CUShort

maxBound :: CUShort

Bounded CWchar

Defined in Foreign.C.Types

Methods

minBound :: CWchar

maxBound :: CWchar

Bounded IntPtr

Defined in Foreign.Ptr

Methods

minBound :: IntPtr

maxBound :: IntPtr

Bounded WordPtr

Defined in Foreign.Ptr

Methods

minBound :: WordPtr

maxBound :: WordPtr

Bounded ByteOrder

Since: base-4.11.0.0

Defined in GHC.ByteOrder

Methods

minBound :: ByteOrder

maxBound :: ByteOrder

Bounded Associativity

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

minBound :: Associativity

maxBound :: Associativity

Bounded DecidedStrictness

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

minBound :: DecidedStrictness

maxBound :: DecidedStrictness

Bounded SourceStrictness

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

minBound :: SourceStrictness

maxBound :: SourceStrictness

Bounded SourceUnpackedness

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

minBound :: SourceUnpackedness

maxBound :: SourceUnpackedness

Bounded Int16

Since: base-2.1

Defined in GHC.Int

Methods

minBound :: Int16

maxBound :: Int16

Bounded Int32

Since: base-2.1

Defined in GHC.Int

Methods

minBound :: Int32

maxBound :: Int32

Bounded Int64

Since: base-2.1

Defined in GHC.Int

Methods

minBound :: Int64

maxBound :: Int64

Bounded Int8

Since: base-2.1

Defined in GHC.Int

Methods

minBound :: Int8

maxBound :: Int8

Bounded GeneralCategory

Since: base-2.1

Defined in GHC.Unicode

Methods

minBound :: GeneralCategory

maxBound :: GeneralCategory

Bounded Word16

Since: base-2.1

Defined in GHC.Word

Methods

minBound :: Word16

maxBound :: Word16

Bounded Word32

Since: base-2.1

Defined in GHC.Word

Methods

minBound :: Word32

maxBound :: Word32

Bounded Word64

Since: base-2.1

Defined in GHC.Word

Methods

minBound :: Word64

maxBound :: Word64

Bounded Word8

Since: base-2.1

Defined in GHC.Word

Methods

minBound :: Word8

maxBound :: Word8

Bounded CBlkCnt

Defined in System.Posix.Types

Methods

minBound :: CBlkCnt

maxBound :: CBlkCnt

Bounded CBlkSize

Defined in System.Posix.Types

Methods

minBound :: CBlkSize

maxBound :: CBlkSize

Bounded CClockId

Defined in System.Posix.Types

Methods

minBound :: CClockId

maxBound :: CClockId

Bounded CDev

Defined in System.Posix.Types

Methods

minBound :: CDev

maxBound :: CDev

Bounded CFsBlkCnt

Defined in System.Posix.Types

Methods

minBound :: CFsBlkCnt

maxBound :: CFsBlkCnt

Bounded CFsFilCnt

Defined in System.Posix.Types

Methods

minBound :: CFsFilCnt

maxBound :: CFsFilCnt

Bounded CGid

Defined in System.Posix.Types

Methods

minBound :: CGid

maxBound :: CGid

Bounded CId

Defined in System.Posix.Types

Methods

minBound :: CId

maxBound :: CId

Bounded CIno

Defined in System.Posix.Types

Methods

minBound :: CIno

maxBound :: CIno

Bounded CKey

Defined in System.Posix.Types

Methods

minBound :: CKey

maxBound :: CKey

Bounded CMode

Defined in System.Posix.Types

Methods

minBound :: CMode

maxBound :: CMode

Bounded CNfds

Defined in System.Posix.Types

Methods

minBound :: CNfds

maxBound :: CNfds

Bounded CNlink

Defined in System.Posix.Types

Methods

minBound :: CNlink

maxBound :: CNlink

Bounded COff

Defined in System.Posix.Types

Methods

minBound :: COff

maxBound :: COff

Bounded CPid

Defined in System.Posix.Types

Methods

minBound :: CPid

maxBound :: CPid

Bounded CRLim

Defined in System.Posix.Types

Methods

minBound :: CRLim

maxBound :: CRLim

Bounded CSocklen

Defined in System.Posix.Types

Methods

minBound :: CSocklen

maxBound :: CSocklen

Bounded CSsize

Defined in System.Posix.Types

Methods

minBound :: CSsize

maxBound :: CSsize

Bounded CTcflag

Defined in System.Posix.Types

Methods

minBound :: CTcflag

maxBound :: CTcflag

Bounded CUid

Defined in System.Posix.Types

Methods

minBound :: CUid

maxBound :: CUid

Bounded Fd

Defined in System.Posix.Types

Methods

minBound :: Fd

maxBound :: Fd

Bounded Ordering

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Ordering

maxBound :: Ordering

Bounded ()

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: ()

maxBound :: ()

Bounded Bool

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Bool

maxBound :: Bool

Bounded Char

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Char

maxBound :: Char

Bounded Int

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Int

maxBound :: Int

Bounded Levity

Since: base-4.16.0.0

Defined in GHC.Enum

Methods

minBound :: Levity

maxBound :: Levity

Bounded VecCount

Since: base-4.10.0.0

Defined in GHC.Enum

Methods

minBound :: VecCount

maxBound :: VecCount

Bounded VecElem

Since: base-4.10.0.0

Defined in GHC.Enum

Methods

minBound :: VecElem

maxBound :: VecElem

Bounded Word

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Word

maxBound :: Word

Bounded a => Bounded (And a)

Since: base-4.16

Defined in Data.Bits

Methods

minBound :: And a

maxBound :: And a

Bounded a => Bounded (Iff a)

Since: base-4.16

Defined in Data.Bits

Methods

minBound :: Iff a

maxBound :: Iff a

Bounded a => Bounded (Ior a)

Since: base-4.16

Defined in Data.Bits

Methods

minBound :: Ior a

maxBound :: Ior a

Bounded a => Bounded (Xor a)

Since: base-4.16

Defined in Data.Bits

Methods

minBound :: Xor a

maxBound :: Xor a

Bounded a => Bounded (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

minBound :: Identity a

maxBound :: Identity a

Bounded a => Bounded (Down a)

Swaps minBound and maxBound of the underlying type.

Since: base-4.14.0.0

Defined in Data.Ord

Methods

minBound :: Down a

maxBound :: Down a

Bounded a => Bounded (First a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

minBound :: First a

maxBound :: First a

Bounded a => Bounded (Last a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

minBound :: Last a

maxBound :: Last a

Bounded a => Bounded (Max a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

minBound :: Max a

maxBound :: Max a

Bounded a => Bounded (Min a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

minBound :: Min a

maxBound :: Min a

Bounded m => Bounded (WrappedMonoid m)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

minBound :: WrappedMonoid m

maxBound :: WrappedMonoid m

Bounded a => Bounded (Dual a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

minBound :: Dual a

maxBound :: Dual a

Bounded a => Bounded (Product a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

minBound :: Product a

maxBound :: Product a

Bounded a => Bounded (Sum a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

minBound :: Sum a

maxBound :: Sum a

Bounded a => Bounded (a)

Defined in GHC.Enum

Methods

minBound :: (a)

maxBound :: (a)

Bounded (Proxy t)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

minBound :: Proxy t

maxBound :: Proxy t

(Bounded a, Bounded b) => Bounded (a, b)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b)

maxBound :: (a, b)

Bounded a => Bounded (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

minBound :: Const a b

maxBound :: Const a b

(Applicative f, Bounded a) => Bounded (Ap f a)

Since: base-4.12.0.0

Defined in Data.Monoid

Methods

minBound :: Ap f a

maxBound :: Ap f a

Coercible a b => Bounded (Coercion a b)

Since: base-4.7.0.0

Defined in Data.Type.Coercion

Methods

minBound :: Coercion a b

maxBound :: Coercion a b

a ~ b => Bounded (a :~: b)

Since: base-4.7.0.0

Defined in Data.Type.Equality

Methods

minBound :: a :~: b

maxBound :: a :~: b

(Bounded a, Bounded b, Bounded c) => Bounded (a, b, c)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c)

maxBound :: (a, b, c)

a ~~ b => Bounded (a :~~: b)

Since: base-4.10.0.0

Defined in Data.Type.Equality

Methods

minBound :: a :~~: b

maxBound :: a :~~: b

(Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a, b, c, d)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d)

maxBound :: (a, b, c, d)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a, b, c, d, e)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e)

maxBound :: (a, b, c, d, e)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f) => Bounded (a, b, c, d, e, f)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f)

maxBound :: (a, b, c, d, e, f)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g) => Bounded (a, b, c, d, e, f, g)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g)

maxBound :: (a, b, c, d, e, f, g)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h) => Bounded (a, b, c, d, e, f, g, h)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g, h)

maxBound :: (a, b, c, d, e, f, g, h)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i) => Bounded (a, b, c, d, e, f, g, h, i)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g, h, i)

maxBound :: (a, b, c, d, e, f, g, h, i)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j) => Bounded (a, b, c, d, e, f, g, h, i, j)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j)

maxBound :: (a, b, c, d, e, f, g, h, i, j)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k) => Bounded (a, b, c, d, e, f, g, h, i, j, k)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j, k)

maxBound :: (a, b, c, d, e, f, g, h, i, j, k)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j, k, l)

maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m)

maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n, Bounded o) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

class Enum a where

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:

• The calls succ maxBound and pred minBound should result in a runtime error.
• fromEnum and toEnum should give a runtime error if the result value is not representable in the result type. For example, toEnum 7 :: Bool is an error.
• enumFrom and enumFromThen should be defined with an implicit bound, thus:

   enumFrom     x   = enumFromTo     x maxBound
   enumFromThen x y = enumFromThenTo x y bound
     where
       bound | fromEnum y >= fromEnum x = maxBound
             | otherwise                = minBound

Minimal complete definition

toEnum, fromEnum

Methods

succ :: a -> a

the successor of a value. For numeric types, succ adds 1.

pred :: a -> a

the predecessor of a value. For numeric types, pred subtracts 1.

toEnum :: Int -> a

Convert from an Int.

fromEnum :: a -> Int

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.

enumFrom :: a -> [a]

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]

enumFromThen :: a -> a -> [a]

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]

enumFromTo :: a -> a -> [a]

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] = []

enumFromThenTo :: a -> a -> a -> [a]

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] = []

Instances

Enum CBool

Defined in Foreign.C.Types

Methods

succ :: CBool -> CBool

pred :: CBool -> CBool

toEnum :: Int -> CBool

fromEnum :: CBool -> Int

enumFrom :: CBool -> [CBool]

enumFromThen :: CBool -> CBool -> [CBool]

enumFromTo :: CBool -> CBool -> [CBool]

enumFromThenTo :: CBool -> CBool -> CBool -> [CBool]

Enum CChar

Defined in Foreign.C.Types

Methods

succ :: CChar -> CChar

pred :: CChar -> CChar

toEnum :: Int -> CChar

fromEnum :: CChar -> Int

enumFrom :: CChar -> [CChar]

enumFromThen :: CChar -> CChar -> [CChar]

enumFromTo :: CChar -> CChar -> [CChar]

enumFromThenTo :: CChar -> CChar -> CChar -> [CChar]

Enum CClock

Defined in Foreign.C.Types

Methods

succ :: CClock -> CClock

pred :: CClock -> CClock

toEnum :: Int -> CClock

fromEnum :: CClock -> Int

enumFrom :: CClock -> [CClock]

enumFromThen :: CClock -> CClock -> [CClock]

enumFromTo :: CClock -> CClock -> [CClock]

enumFromThenTo :: CClock -> CClock -> CClock -> [CClock]

Enum CDouble

Defined in Foreign.C.Types

Methods

succ :: CDouble -> CDouble

pred :: CDouble -> CDouble

toEnum :: Int -> CDouble

fromEnum :: CDouble -> Int

enumFrom :: CDouble -> [CDouble]

enumFromThen :: CDouble -> CDouble -> [CDouble]

enumFromTo :: CDouble -> CDouble -> [CDouble]

enumFromThenTo :: CDouble -> CDouble -> CDouble -> [CDouble]

Enum CFloat

Defined in Foreign.C.Types

Methods

succ :: CFloat -> CFloat

pred :: CFloat -> CFloat

toEnum :: Int -> CFloat

fromEnum :: CFloat -> Int

enumFrom :: CFloat -> [CFloat]

enumFromThen :: CFloat -> CFloat -> [CFloat]

enumFromTo :: CFloat -> CFloat -> [CFloat]

enumFromThenTo :: CFloat -> CFloat -> CFloat -> [CFloat]

Enum CInt

Defined in Foreign.C.Types

Methods

succ :: CInt -> CInt

pred :: CInt -> CInt

toEnum :: Int -> CInt

fromEnum :: CInt -> Int

enumFrom :: CInt -> [CInt]

enumFromThen :: CInt -> CInt -> [CInt]

enumFromTo :: CInt -> CInt -> [CInt]

enumFromThenTo :: CInt -> CInt -> CInt -> [CInt]

Enum CIntMax

Defined in Foreign.C.Types

Methods

succ :: CIntMax -> CIntMax

pred :: CIntMax -> CIntMax

toEnum :: Int -> CIntMax

fromEnum :: CIntMax -> Int

enumFrom :: CIntMax -> [CIntMax]

enumFromThen :: CIntMax -> CIntMax -> [CIntMax]

enumFromTo :: CIntMax -> CIntMax -> [CIntMax]

enumFromThenTo :: CIntMax -> CIntMax -> CIntMax -> [CIntMax]

Enum CIntPtr

Defined in Foreign.C.Types

Methods

succ :: CIntPtr -> CIntPtr

pred :: CIntPtr -> CIntPtr

toEnum :: Int -> CIntPtr

fromEnum :: CIntPtr -> Int

enumFrom :: CIntPtr -> [CIntPtr]

enumFromThen :: CIntPtr -> CIntPtr -> [CIntPtr]

enumFromTo :: CIntPtr -> CIntPtr -> [CIntPtr]

enumFromThenTo :: CIntPtr -> CIntPtr -> CIntPtr -> [CIntPtr]

Enum CLLong

Defined in Foreign.C.Types

Methods

succ :: CLLong -> CLLong

pred :: CLLong -> CLLong

toEnum :: Int -> CLLong

fromEnum :: CLLong -> Int

enumFrom :: CLLong -> [CLLong]

enumFromThen :: CLLong -> CLLong -> [CLLong]

enumFromTo :: CLLong -> CLLong -> [CLLong]

enumFromThenTo :: CLLong -> CLLong -> CLLong -> [CLLong]

Enum CLong

Defined in Foreign.C.Types

Methods

succ :: CLong -> CLong

pred :: CLong -> CLong

toEnum :: Int -> CLong

fromEnum :: CLong -> Int

enumFrom :: CLong -> [CLong]

enumFromThen :: CLong -> CLong -> [CLong]

enumFromTo :: CLong -> CLong -> [CLong]

enumFromThenTo :: CLong -> CLong -> CLong -> [CLong]

Enum CPtrdiff

Defined in Foreign.C.Types

Methods

succ :: CPtrdiff -> CPtrdiff

pred :: CPtrdiff -> CPtrdiff

toEnum :: Int -> CPtrdiff

fromEnum :: CPtrdiff -> Int

enumFrom :: CPtrdiff -> [CPtrdiff]

enumFromThen :: CPtrdiff -> CPtrdiff -> [CPtrdiff]

enumFromTo :: CPtrdiff -> CPtrdiff -> [CPtrdiff]

enumFromThenTo :: CPtrdiff -> CPtrdiff -> CPtrdiff -> [CPtrdiff]

Enum CSChar

Defined in Foreign.C.Types

Methods

succ :: CSChar -> CSChar

pred :: CSChar -> CSChar

toEnum :: Int -> CSChar

fromEnum :: CSChar -> Int

enumFrom :: CSChar -> [CSChar]

enumFromThen :: CSChar -> CSChar -> [CSChar]

enumFromTo :: CSChar -> CSChar -> [CSChar]

enumFromThenTo :: CSChar -> CSChar -> CSChar -> [CSChar]

Enum CSUSeconds

Defined in Foreign.C.Types

Methods

succ :: CSUSeconds -> CSUSeconds

pred :: CSUSeconds -> CSUSeconds

toEnum :: Int -> CSUSeconds

fromEnum :: CSUSeconds -> Int

enumFrom :: CSUSeconds -> [CSUSeconds]

enumFromThen :: CSUSeconds -> CSUSeconds -> [CSUSeconds]

enumFromTo :: CSUSeconds -> CSUSeconds -> [CSUSeconds]

enumFromThenTo :: CSUSeconds -> CSUSeconds -> CSUSeconds -> [CSUSeconds]

Enum CShort

Defined in Foreign.C.Types

Methods

succ :: CShort -> CShort

pred :: CShort -> CShort

toEnum :: Int -> CShort

fromEnum :: CShort -> Int

enumFrom :: CShort -> [CShort]

enumFromThen :: CShort -> CShort -> [CShort]

enumFromTo :: CShort -> CShort -> [CShort]

enumFromThenTo :: CShort -> CShort -> CShort -> [CShort]

Enum CSigAtomic

Defined in Foreign.C.Types

Methods

succ :: CSigAtomic -> CSigAtomic

pred :: CSigAtomic -> CSigAtomic

toEnum :: Int -> CSigAtomic

fromEnum :: CSigAtomic -> Int

enumFrom :: CSigAtomic -> [CSigAtomic]

enumFromThen :: CSigAtomic -> CSigAtomic -> [CSigAtomic]

enumFromTo :: CSigAtomic -> CSigAtomic -> [CSigAtomic]

enumFromThenTo :: CSigAtomic -> CSigAtomic -> CSigAtomic -> [CSigAtomic]

Enum CSize

Defined in Foreign.C.Types

Methods

succ :: CSize -> CSize

pred :: CSize -> CSize

toEnum :: Int -> CSize

fromEnum :: CSize -> Int

enumFrom :: CSize -> [CSize]

enumFromThen :: CSize -> CSize -> [CSize]

enumFromTo :: CSize -> CSize -> [CSize]

enumFromThenTo :: CSize -> CSize -> CSize -> [CSize]

Enum CTime

Defined in Foreign.C.Types

Methods

succ :: CTime -> CTime

pred :: CTime -> CTime

toEnum :: Int -> CTime

fromEnum :: CTime -> Int

enumFrom :: CTime -> [CTime]

enumFromThen :: CTime -> CTime -> [CTime]

enumFromTo :: CTime -> CTime -> [CTime]

enumFromThenTo :: CTime -> CTime -> CTime -> [CTime]

Enum CUChar

Defined in Foreign.C.Types

Methods

succ :: CUChar -> CUChar

pred :: CUChar -> CUChar

toEnum :: Int -> CUChar

fromEnum :: CUChar -> Int

enumFrom :: CUChar -> [CUChar]

enumFromThen :: CUChar -> CUChar -> [CUChar]

enumFromTo :: CUChar -> CUChar -> [CUChar]

enumFromThenTo :: CUChar -> CUChar -> CUChar -> [CUChar]

Enum CUInt

Defined in Foreign.C.Types

Methods

succ :: CUInt -> CUInt

pred :: CUInt -> CUInt

toEnum :: Int -> CUInt

fromEnum :: CUInt -> Int

enumFrom :: CUInt -> [CUInt]

enumFromThen :: CUInt -> CUInt -> [CUInt]

enumFromTo :: CUInt -> CUInt -> [CUInt]

enumFromThenTo :: CUInt -> CUInt -> CUInt -> [CUInt]

Enum CUIntMax

Defined in Foreign.C.Types

Methods

succ :: CUIntMax -> CUIntMax

pred :: CUIntMax -> CUIntMax

toEnum :: Int -> CUIntMax

fromEnum :: CUIntMax -> Int

enumFrom :: CUIntMax -> [CUIntMax]

enumFromThen :: CUIntMax -> CUIntMax -> [CUIntMax]

enumFromTo :: CUIntMax -> CUIntMax -> [CUIntMax]

enumFromThenTo :: CUIntMax -> CUIntMax -> CUIntMax -> [CUIntMax]

Enum CUIntPtr

Defined in Foreign.C.Types

Methods

succ :: CUIntPtr -> CUIntPtr

pred :: CUIntPtr -> CUIntPtr

toEnum :: Int -> CUIntPtr

fromEnum :: CUIntPtr -> Int

enumFrom :: CUIntPtr -> [CUIntPtr]

enumFromThen :: CUIntPtr -> CUIntPtr -> [CUIntPtr]

enumFromTo :: CUIntPtr -> CUIntPtr -> [CUIntPtr]

enumFromThenTo :: CUIntPtr -> CUIntPtr -> CUIntPtr -> [CUIntPtr]

Enum CULLong

Defined in Foreign.C.Types

Methods

succ :: CULLong -> CULLong

pred :: CULLong -> CULLong

toEnum :: Int -> CULLong

fromEnum :: CULLong -> Int

enumFrom :: CULLong -> [CULLong]

enumFromThen :: CULLong -> CULLong -> [CULLong]

enumFromTo :: CULLong -> CULLong -> [CULLong]

enumFromThenTo :: CULLong -> CULLong -> CULLong -> [CULLong]

Enum CULong

Defined in Foreign.C.Types

Methods

succ :: CULong -> CULong

pred :: CULong -> CULong

toEnum :: Int -> CULong

fromEnum :: CULong -> Int

enumFrom :: CULong -> [CULong]

enumFromThen :: CULong -> CULong -> [CULong]

enumFromTo :: CULong -> CULong -> [CULong]

enumFromThenTo :: CULong -> CULong -> CULong -> [CULong]

Enum CUSeconds

Defined in Foreign.C.Types

Methods

succ :: CUSeconds -> CUSeconds

pred :: CUSeconds -> CUSeconds

toEnum :: Int -> CUSeconds

fromEnum :: CUSeconds -> Int

enumFrom :: CUSeconds -> [CUSeconds]

enumFromThen :: CUSeconds -> CUSeconds -> [CUSeconds]

enumFromTo :: CUSeconds -> CUSeconds -> [CUSeconds]

enumFromThenTo :: CUSeconds -> CUSeconds -> CUSeconds -> [CUSeconds]

Enum CUShort

Defined in Foreign.C.Types

Methods

succ :: CUShort -> CUShort

pred :: CUShort -> CUShort

toEnum :: Int -> CUShort

fromEnum :: CUShort -> Int

enumFrom :: CUShort -> [CUShort]

enumFromThen :: CUShort -> CUShort -> [CUShort]

enumFromTo :: CUShort -> CUShort -> [CUShort]

enumFromThenTo :: CUShort -> CUShort -> CUShort -> [CUShort]

Enum CWchar

Defined in Foreign.C.Types

Methods

succ :: CWchar -> CWchar

pred :: CWchar -> CWchar

toEnum :: Int -> CWchar

fromEnum :: CWchar -> Int

enumFrom :: CWchar -> [CWchar]

enumFromThen :: CWchar -> CWchar -> [CWchar]

enumFromTo :: CWchar -> CWchar -> [CWchar]

enumFromThenTo :: CWchar -> CWchar -> CWchar -> [CWchar]

Enum IntPtr

Defined in Foreign.Ptr

Methods

succ :: IntPtr -> IntPtr

pred :: IntPtr -> IntPtr

toEnum :: Int -> IntPtr

fromEnum :: IntPtr -> Int

enumFrom :: IntPtr -> [IntPtr]

enumFromThen :: IntPtr -> IntPtr -> [IntPtr]

enumFromTo :: IntPtr -> IntPtr -> [IntPtr]

enumFromThenTo :: IntPtr -> IntPtr -> IntPtr -> [IntPtr]

Enum WordPtr

Defined in Foreign.Ptr

Methods

succ :: WordPtr -> WordPtr

pred :: WordPtr -> WordPtr

toEnum :: Int -> WordPtr

fromEnum :: WordPtr -> Int

enumFrom :: WordPtr -> [WordPtr]

enumFromThen :: WordPtr -> WordPtr -> [WordPtr]

enumFromTo :: WordPtr -> WordPtr -> [WordPtr]

enumFromThenTo :: WordPtr -> WordPtr -> WordPtr -> [WordPtr]

Enum ByteOrder

Since: base-4.11.0.0

Defined in GHC.ByteOrder

Methods

succ :: ByteOrder -> ByteOrder

pred :: ByteOrder -> ByteOrder

toEnum :: Int -> ByteOrder

fromEnum :: ByteOrder -> Int

enumFrom :: ByteOrder -> [ByteOrder]

enumFromThen :: ByteOrder -> ByteOrder -> [ByteOrder]

enumFromTo :: ByteOrder -> ByteOrder -> [ByteOrder]

enumFromThenTo :: ByteOrder -> ByteOrder -> ByteOrder -> [ByteOrder]

Enum Associativity

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

succ :: Associativity -> Associativity

pred :: Associativity -> Associativity

toEnum :: Int -> Associativity

fromEnum :: Associativity -> Int

enumFrom :: Associativity -> [Associativity]

enumFromThen :: Associativity -> Associativity -> [Associativity]

enumFromTo :: Associativity -> Associativity -> [Associativity]

enumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity]

Enum DecidedStrictness

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

succ :: DecidedStrictness -> DecidedStrictness

pred :: DecidedStrictness -> DecidedStrictness

toEnum :: Int -> DecidedStrictness

fromEnum :: DecidedStrictness -> Int

enumFrom :: DecidedStrictness -> [DecidedStrictness]

enumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness]

enumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness]

enumFromThenTo :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness]

Enum SourceStrictness

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

succ :: SourceStrictness -> SourceStrictness

pred :: SourceStrictness -> SourceStrictness

toEnum :: Int -> SourceStrictness

fromEnum :: SourceStrictness -> Int

enumFrom :: SourceStrictness -> [SourceStrictness]

enumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness]

enumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness]

enumFromThenTo :: SourceStrictness -> SourceStrictness -> SourceStrictness -> [SourceStrictness]

Enum SourceUnpackedness

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

succ :: SourceUnpackedness -> SourceUnpackedness

pred :: SourceUnpackedness -> SourceUnpackedness

toEnum :: Int -> SourceUnpackedness

fromEnum :: SourceUnpackedness -> Int

enumFrom :: SourceUnpackedness -> [SourceUnpackedness]

enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness]

enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness]

enumFromThenTo :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness]

Enum SeekMode

Since: base-4.2.0.0

Defined in GHC.IO.Device

Methods

succ :: SeekMode -> SeekMode

pred :: SeekMode -> SeekMode

toEnum :: Int -> SeekMode

fromEnum :: SeekMode -> Int

enumFrom :: SeekMode -> [SeekMode]

enumFromThen :: SeekMode -> SeekMode -> [SeekMode]

enumFromTo :: SeekMode -> SeekMode -> [SeekMode]

enumFromThenTo :: SeekMode -> SeekMode -> SeekMode -> [SeekMode]

Enum IOMode

Since: base-4.2.0.0

Defined in GHC.IO.IOMode

Methods

succ :: IOMode -> IOMode

pred :: IOMode -> IOMode

toEnum :: Int -> IOMode

fromEnum :: IOMode -> Int

enumFrom :: IOMode -> [IOMode]

enumFromThen :: IOMode -> IOMode -> [IOMode]

enumFromTo :: IOMode -> IOMode -> [IOMode]

enumFromThenTo :: IOMode -> IOMode -> IOMode -> [IOMode]

Enum Int16

Since: base-2.1

Defined in GHC.Int

Methods

succ :: Int16 -> Int16

pred :: Int16 -> Int16

toEnum :: Int -> Int16

fromEnum :: Int16 -> Int

enumFrom :: Int16 -> [Int16]

enumFromThen :: Int16 -> Int16 -> [Int16]

enumFromTo :: Int16 -> Int16 -> [Int16]

enumFromThenTo :: Int16 -> Int16 -> Int16 -> [Int16]

Enum Int32

Since: base-2.1

Defined in GHC.Int

Methods

succ :: Int32 -> Int32

pred :: Int32 -> Int32

toEnum :: Int -> Int32

fromEnum :: Int32 -> Int

enumFrom :: Int32 -> [Int32]

enumFromThen :: Int32 -> Int32 -> [Int32]

enumFromTo :: Int32 -> Int32 -> [Int32]

enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32]

Enum Int64

Since: base-2.1

Defined in GHC.Int

Methods

succ :: Int64 -> Int64

pred :: Int64 -> Int64

toEnum :: Int -> Int64

fromEnum :: Int64 -> Int

enumFrom :: Int64 -> [Int64]

enumFromThen :: Int64 -> Int64 -> [Int64]

enumFromTo :: Int64 -> Int64 -> [Int64]

enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64]

Enum Int8

Since: base-2.1

Defined in GHC.Int

Methods

succ :: Int8 -> Int8

pred :: Int8 -> Int8

toEnum :: Int -> Int8

fromEnum :: Int8 -> Int

enumFrom :: Int8 -> [Int8]

enumFromThen :: Int8 -> Int8 -> [Int8]

enumFromTo :: Int8 -> Int8 -> [Int8]

enumFromThenTo :: Int8 -> Int8 -> Int8 -> [Int8]

Enum DoCostCentres

Since: base-4.8.0.0

Defined in GHC.RTS.Flags

Methods

succ :: DoCostCentres -> DoCostCentres

pred :: DoCostCentres -> DoCostCentres

toEnum :: Int -> DoCostCentres

fromEnum :: DoCostCentres -> Int

enumFrom :: DoCostCentres -> [DoCostCentres]

enumFromThen :: DoCostCentres -> DoCostCentres -> [DoCostCentres]

enumFromTo :: DoCostCentres -> DoCostCentres -> [DoCostCentres]

enumFromThenTo :: DoCostCentres -> DoCostCentres -> DoCostCentres -> [DoCostCentres]

Enum DoHeapProfile

Since: base-4.8.0.0

Defined in GHC.RTS.Flags

Methods

succ :: DoHeapProfile -> DoHeapProfile

pred :: DoHeapProfile -> DoHeapProfile

toEnum :: Int -> DoHeapProfile

fromEnum :: DoHeapProfile -> Int

enumFrom :: DoHeapProfile -> [DoHeapProfile]

enumFromThen :: DoHeapProfile -> DoHeapProfile -> [DoHeapProfile]

enumFromTo :: DoHeapProfile -> DoHeapProfile -> [DoHeapProfile]

enumFromThenTo :: DoHeapProfile -> DoHeapProfile -> DoHeapProfile -> [DoHeapProfile]

Enum DoTrace

Since: base-4.8.0.0

Defined in GHC.RTS.Flags

Methods

succ :: DoTrace -> DoTrace

pred :: DoTrace -> DoTrace

toEnum :: Int -> DoTrace

fromEnum :: DoTrace -> Int

enumFrom :: DoTrace -> [DoTrace]

enumFromThen :: DoTrace -> DoTrace -> [DoTrace]

enumFromTo :: DoTrace -> DoTrace -> [DoTrace]

enumFromThenTo :: DoTrace -> DoTrace -> DoTrace -> [DoTrace]

Enum GiveGCStats

Since: base-4.8.0.0

Defined in GHC.RTS.Flags

Methods

succ :: GiveGCStats -> GiveGCStats

pred :: GiveGCStats -> GiveGCStats

toEnum :: Int -> GiveGCStats

fromEnum :: GiveGCStats -> Int

enumFrom :: GiveGCStats -> [GiveGCStats]

enumFromThen :: GiveGCStats -> GiveGCStats -> [GiveGCStats]

enumFromTo :: GiveGCStats -> GiveGCStats -> [GiveGCStats]

enumFromThenTo :: GiveGCStats -> GiveGCStats -> GiveGCStats -> [GiveGCStats]

Enum IoSubSystem

Since: base-4.9.0.0

Defined in GHC.RTS.Flags

Methods

succ :: IoSubSystem -> IoSubSystem

pred :: IoSubSystem -> IoSubSystem

toEnum :: Int -> IoSubSystem

fromEnum :: IoSubSystem -> Int

enumFrom :: IoSubSystem -> [IoSubSystem]

enumFromThen :: IoSubSystem -> IoSubSystem -> [IoSubSystem]

enumFromTo :: IoSubSystem -> IoSubSystem -> [IoSubSystem]

enumFromThenTo :: IoSubSystem -> IoSubSystem -> IoSubSystem -> [IoSubSystem]

Enum GeneralCategory

Since: base-2.1

Defined in GHC.Unicode

Methods

succ :: GeneralCategory -> GeneralCategory

pred :: GeneralCategory -> GeneralCategory

toEnum :: Int -> GeneralCategory

fromEnum :: GeneralCategory -> Int

enumFrom :: GeneralCategory -> [GeneralCategory]

enumFromThen :: GeneralCategory -> GeneralCategory -> [GeneralCategory]

enumFromTo :: GeneralCategory -> GeneralCategory -> [GeneralCategory]

enumFromThenTo :: GeneralCategory -> GeneralCategory -> GeneralCategory -> [GeneralCategory]

Enum Word16

Since: base-2.1

Defined in GHC.Word

Methods

succ :: Word16 -> Word16

pred :: Word16 -> Word16

toEnum :: Int -> Word16

fromEnum :: Word16 -> Int

enumFrom :: Word16 -> [Word16]

enumFromThen :: Word16 -> Word16 -> [Word16]

enumFromTo :: Word16 -> Word16 -> [Word16]

enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16]

Enum Word32

Since: base-2.1

Defined in GHC.Word

Methods

succ :: Word32 -> Word32

pred :: Word32 -> Word32

toEnum :: Int -> Word32

fromEnum :: Word32 -> Int

enumFrom :: Word32 -> [Word32]

enumFromThen :: Word32 -> Word32 -> [Word32]

enumFromTo :: Word32 -> Word32 -> [Word32]

enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32]

Enum Word64

Since: base-2.1

Defined in GHC.Word

Methods

succ :: Word64 -> Word64

pred :: Word64 -> Word64

toEnum :: Int -> Word64

fromEnum :: Word64 -> Int

enumFrom :: Word64 -> [Word64]

enumFromThen :: Word64 -> Word64 -> [Word64]

enumFromTo :: Word64 -> Word64 -> [Word64]

enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64]

Enum Word8

Since: base-2.1

Defined in GHC.Word

Methods

succ :: Word8 -> Word8

pred :: Word8 -> Word8

toEnum :: Int -> Word8

fromEnum :: Word8 -> Int

enumFrom :: Word8 -> [Word8]

enumFromThen :: Word8 -> Word8 -> [Word8]

enumFromTo :: Word8 -> Word8 -> [Word8]

enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8]

Enum CBlkCnt

Defined in System.Posix.Types

Methods

succ :: CBlkCnt -> CBlkCnt

pred :: CBlkCnt -> CBlkCnt

toEnum :: Int -> CBlkCnt

fromEnum :: CBlkCnt -> Int

enumFrom :: CBlkCnt -> [CBlkCnt]

enumFromThen :: CBlkCnt -> CBlkCnt -> [CBlkCnt]

enumFromTo :: CBlkCnt -> CBlkCnt -> [CBlkCnt]

enumFromThenTo :: CBlkCnt -> CBlkCnt -> CBlkCnt -> [CBlkCnt]

Enum CBlkSize

Defined in System.Posix.Types

Methods

succ :: CBlkSize -> CBlkSize

pred :: CBlkSize -> CBlkSize

toEnum :: Int -> CBlkSize

fromEnum :: CBlkSize -> Int

enumFrom :: CBlkSize -> [CBlkSize]

enumFromThen :: CBlkSize -> CBlkSize -> [CBlkSize]

enumFromTo :: CBlkSize -> CBlkSize -> [CBlkSize]

enumFromThenTo :: CBlkSize -> CBlkSize -> CBlkSize -> [CBlkSize]

Enum CCc

Defined in System.Posix.Types

Methods

succ :: CCc -> CCc

pred :: CCc -> CCc

toEnum :: Int -> CCc

fromEnum :: CCc -> Int

enumFrom :: CCc -> [CCc]

enumFromThen :: CCc -> CCc -> [CCc]

enumFromTo :: CCc -> CCc -> [CCc]

enumFromThenTo :: CCc -> CCc -> CCc -> [CCc]

Enum CClockId

Defined in System.Posix.Types

Methods

succ :: CClockId -> CClockId

pred :: CClockId -> CClockId

toEnum :: Int -> CClockId

fromEnum :: CClockId -> Int

enumFrom :: CClockId -> [CClockId]

enumFromThen :: CClockId -> CClockId -> [CClockId]

enumFromTo :: CClockId -> CClockId -> [CClockId]

enumFromThenTo :: CClockId -> CClockId -> CClockId -> [CClockId]

Enum CDev

Defined in System.Posix.Types

Methods

succ :: CDev -> CDev

pred :: CDev -> CDev

toEnum :: Int -> CDev

fromEnum :: CDev -> Int

enumFrom :: CDev -> [CDev]

enumFromThen :: CDev -> CDev -> [CDev]

enumFromTo :: CDev -> CDev -> [CDev]

enumFromThenTo :: CDev -> CDev -> CDev -> [CDev]

Enum CFsBlkCnt

Defined in System.Posix.Types

Methods

succ :: CFsBlkCnt -> CFsBlkCnt

pred :: CFsBlkCnt -> CFsBlkCnt

toEnum :: Int -> CFsBlkCnt

fromEnum :: CFsBlkCnt -> Int

enumFrom :: CFsBlkCnt -> [CFsBlkCnt]

enumFromThen :: CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt]

enumFromTo :: CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt]

enumFromThenTo :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt]

Enum CFsFilCnt

Defined in System.Posix.Types

Methods

succ :: CFsFilCnt -> CFsFilCnt

pred :: CFsFilCnt -> CFsFilCnt

toEnum :: Int -> CFsFilCnt

fromEnum :: CFsFilCnt -> Int

enumFrom :: CFsFilCnt -> [CFsFilCnt]

enumFromThen :: CFsFilCnt -> CFsFilCnt -> [CFsFilCnt]

enumFromTo :: CFsFilCnt -> CFsFilCnt -> [CFsFilCnt]

enumFromThenTo :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt -> [CFsFilCnt]

Enum CGid

Defined in System.Posix.Types

Methods

succ :: CGid -> CGid

pred :: CGid -> CGid

toEnum :: Int -> CGid

fromEnum :: CGid -> Int

enumFrom :: CGid -> [CGid]

enumFromThen :: CGid -> CGid -> [CGid]

enumFromTo :: CGid -> CGid -> [CGid]

enumFromThenTo :: CGid -> CGid -> CGid -> [CGid]

Enum CId

Defined in System.Posix.Types

Methods

succ :: CId -> CId

pred :: CId -> CId

toEnum :: Int -> CId

fromEnum :: CId -> Int

enumFrom :: CId -> [CId]

enumFromThen :: CId -> CId -> [CId]

enumFromTo :: CId -> CId -> [CId]

enumFromThenTo :: CId -> CId -> CId -> [CId]

Enum CIno

Defined in System.Posix.Types

Methods

succ :: CIno -> CIno

pred :: CIno -> CIno

toEnum :: Int -> CIno

fromEnum :: CIno -> Int

enumFrom :: CIno -> [CIno]

enumFromThen :: CIno -> CIno -> [CIno]

enumFromTo :: CIno -> CIno -> [CIno]

enumFromThenTo :: CIno -> CIno -> CIno -> [CIno]

Enum CKey

Defined in System.Posix.Types

Methods

succ :: CKey -> CKey

pred :: CKey -> CKey

toEnum :: Int -> CKey

fromEnum :: CKey -> Int

enumFrom :: CKey -> [CKey]

enumFromThen :: CKey -> CKey -> [CKey]

enumFromTo :: CKey -> CKey -> [CKey]

enumFromThenTo :: CKey -> CKey -> CKey -> [CKey]

Enum CMode

Defined in System.Posix.Types

Methods

succ :: CMode -> CMode

pred :: CMode -> CMode

toEnum :: Int -> CMode

fromEnum :: CMode -> Int

enumFrom :: CMode -> [CMode]

enumFromThen :: CMode -> CMode -> [CMode]

enumFromTo :: CMode -> CMode -> [CMode]

enumFromThenTo :: CMode -> CMode -> CMode -> [CMode]

Enum CNfds

Defined in System.Posix.Types

Methods

succ :: CNfds -> CNfds

pred :: CNfds -> CNfds

toEnum :: Int -> CNfds

fromEnum :: CNfds -> Int

enumFrom :: CNfds -> [CNfds]

enumFromThen :: CNfds -> CNfds -> [CNfds]

enumFromTo :: CNfds -> CNfds -> [CNfds]

enumFromThenTo :: CNfds -> CNfds -> CNfds -> [CNfds]

Enum CNlink

Defined in System.Posix.Types

Methods

succ :: CNlink -> CNlink

pred :: CNlink -> CNlink

toEnum :: Int -> CNlink

fromEnum :: CNlink -> Int

enumFrom :: CNlink -> [CNlink]

enumFromThen :: CNlink -> CNlink -> [CNlink]

enumFromTo :: CNlink -> CNlink -> [CNlink]

enumFromThenTo :: CNlink -> CNlink -> CNlink -> [CNlink]

Enum COff

Defined in System.Posix.Types

Methods

succ :: COff -> COff

pred :: COff -> COff

toEnum :: Int -> COff

fromEnum :: COff -> Int

enumFrom :: COff -> [COff]

enumFromThen :: COff -> COff -> [COff]

enumFromTo :: COff -> COff -> [COff]

enumFromThenTo :: COff -> COff -> COff -> [COff]

Enum CPid

Defined in System.Posix.Types

Methods

succ :: CPid -> CPid

pred :: CPid -> CPid

toEnum :: Int -> CPid

fromEnum :: CPid -> Int

enumFrom :: CPid -> [CPid]

enumFromThen :: CPid -> CPid -> [CPid]

enumFromTo :: CPid -> CPid -> [CPid]

enumFromThenTo :: CPid -> CPid -> CPid -> [CPid]

Enum CRLim

Defined in System.Posix.Types

Methods

succ :: CRLim -> CRLim

pred :: CRLim -> CRLim

toEnum :: Int -> CRLim

fromEnum :: CRLim -> Int

enumFrom :: CRLim -> [CRLim]

enumFromThen :: CRLim -> CRLim -> [CRLim]

enumFromTo :: CRLim -> CRLim -> [CRLim]

enumFromThenTo :: CRLim -> CRLim -> CRLim -> [CRLim]

Enum CSocklen

Defined in System.Posix.Types

Methods

succ :: CSocklen -> CSocklen

pred :: CSocklen -> CSocklen

toEnum :: Int -> CSocklen

fromEnum :: CSocklen -> Int

enumFrom :: CSocklen -> [CSocklen]

enumFromThen :: CSocklen -> CSocklen -> [CSocklen]

enumFromTo :: CSocklen -> CSocklen -> [CSocklen]

enumFromThenTo :: CSocklen -> CSocklen -> CSocklen -> [CSocklen]

Enum CSpeed

Defined in System.Posix.Types

Methods

succ :: CSpeed -> CSpeed

pred :: CSpeed -> CSpeed

toEnum :: Int -> CSpeed

fromEnum :: CSpeed -> Int

enumFrom :: CSpeed -> [CSpeed]

enumFromThen :: CSpeed -> CSpeed -> [CSpeed]

enumFromTo :: CSpeed -> CSpeed -> [CSpeed]

enumFromThenTo :: CSpeed -> CSpeed -> CSpeed -> [CSpeed]

Enum CSsize

Defined in System.Posix.Types

Methods

succ :: CSsize -> CSsize

pred :: CSsize -> CSsize

toEnum :: Int -> CSsize

fromEnum :: CSsize -> Int

enumFrom :: CSsize -> [CSsize]

enumFromThen :: CSsize -> CSsize -> [CSsize]

enumFromTo :: CSsize -> CSsize -> [CSsize]

enumFromThenTo :: CSsize -> CSsize -> CSsize -> [CSsize]

Enum CTcflag

Defined in System.Posix.Types

Methods

succ :: CTcflag -> CTcflag

pred :: CTcflag -> CTcflag

toEnum :: Int -> CTcflag

fromEnum :: CTcflag -> Int

enumFrom :: CTcflag -> [CTcflag]

enumFromThen :: CTcflag -> CTcflag -> [CTcflag]

enumFromTo :: CTcflag -> CTcflag -> [CTcflag]

enumFromThenTo :: CTcflag -> CTcflag -> CTcflag -> [CTcflag]

Enum CUid

Defined in System.Posix.Types

Methods

succ :: CUid -> CUid

pred :: CUid -> CUid

toEnum :: Int -> CUid

fromEnum :: CUid -> Int

enumFrom :: CUid -> [CUid]

enumFromThen :: CUid -> CUid -> [CUid]

enumFromTo :: CUid -> CUid -> [CUid]

enumFromThenTo :: CUid -> CUid -> CUid -> [CUid]

Enum Fd

Defined in System.Posix.Types

Methods

succ :: Fd -> Fd

pred :: Fd -> Fd

toEnum :: Int -> Fd

fromEnum :: Fd -> Int

enumFrom :: Fd -> [Fd]

enumFromThen :: Fd -> Fd -> [Fd]

enumFromTo :: Fd -> Fd -> [Fd]

enumFromThenTo :: Fd -> Fd -> Fd -> [Fd]

Enum Ordering

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Ordering -> Ordering

pred :: Ordering -> Ordering

toEnum :: Int -> Ordering

fromEnum :: Ordering -> Int

enumFrom :: Ordering -> [Ordering]

enumFromThen :: Ordering -> Ordering -> [Ordering]

enumFromTo :: Ordering -> Ordering -> [Ordering]

enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering]

Enum Integer

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Integer -> Integer

pred :: Integer -> Integer

toEnum :: Int -> Integer

fromEnum :: Integer -> Int

enumFrom :: Integer -> [Integer]

enumFromThen :: Integer -> Integer -> [Integer]

enumFromTo :: Integer -> Integer -> [Integer]

enumFromThenTo :: Integer -> Integer -> Integer -> [Integer]

Enum Natural

Since: base-4.8.0.0

Defined in GHC.Enum

Methods

succ :: Natural -> Natural

pred :: Natural -> Natural

toEnum :: Int -> Natural

fromEnum :: Natural -> Int

enumFrom :: Natural -> [Natural]

enumFromThen :: Natural -> Natural -> [Natural]

enumFromTo :: Natural -> Natural -> [Natural]

enumFromThenTo :: Natural -> Natural -> Natural -> [Natural]

Enum ()

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: () -> ()

pred :: () -> ()

toEnum :: Int -> ()

fromEnum :: () -> Int

enumFrom :: () -> [()]

enumFromThen :: () -> () -> [()]

enumFromTo :: () -> () -> [()]

enumFromThenTo :: () -> () -> () -> [()]

Enum Bool

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Bool -> Bool

pred :: Bool -> Bool

toEnum :: Int -> Bool

fromEnum :: Bool -> Int

enumFrom :: Bool -> [Bool]

enumFromThen :: Bool -> Bool -> [Bool]

enumFromTo :: Bool -> Bool -> [Bool]

enumFromThenTo :: Bool -> Bool -> Bool -> [Bool]

Enum Char

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Char -> Char

pred :: Char -> Char

toEnum :: Int -> Char

fromEnum :: Char -> Int

enumFrom :: Char -> [Char]

enumFromThen :: Char -> Char -> [Char]

enumFromTo :: Char -> Char -> [Char]

enumFromThenTo :: Char -> Char -> Char -> [Char]

Enum Double

Since: base-2.1

Defined in GHC.Float

Methods

succ :: Double -> Double

pred :: Double -> Double

toEnum :: Int -> Double

fromEnum :: Double -> Int

enumFrom :: Double -> [Double]

enumFromThen :: Double -> Double -> [Double]

enumFromTo :: Double -> Double -> [Double]

enumFromThenTo :: Double -> Double -> Double -> [Double]

Enum Float

Since: base-2.1

Defined in GHC.Float

Methods

succ :: Float -> Float

pred :: Float -> Float

toEnum :: Int -> Float

fromEnum :: Float -> Int

enumFrom :: Float -> [Float]

enumFromThen :: Float -> Float -> [Float]

enumFromTo :: Float -> Float -> [Float]

enumFromThenTo :: Float -> Float -> Float -> [Float]

Enum Int

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Int -> Int

pred :: Int -> Int

toEnum :: Int -> Int

fromEnum :: Int -> Int

enumFrom :: Int -> [Int]

enumFromThen :: Int -> Int -> [Int]

enumFromTo :: Int -> Int -> [Int]

enumFromThenTo :: Int -> Int -> Int -> [Int]

Enum Levity

Since: base-4.16.0.0

Defined in GHC.Enum

Methods

succ :: Levity -> Levity

pred :: Levity -> Levity

toEnum :: Int -> Levity

fromEnum :: Levity -> Int

enumFrom :: Levity -> [Levity]

enumFromThen :: Levity -> Levity -> [Levity]

enumFromTo :: Levity -> Levity -> [Levity]

enumFromThenTo :: Levity -> Levity -> Levity -> [Levity]

Enum VecCount

Since: base-4.10.0.0

Defined in GHC.Enum

Methods

succ :: VecCount -> VecCount

pred :: VecCount -> VecCount

toEnum :: Int -> VecCount

fromEnum :: VecCount -> Int

enumFrom :: VecCount -> [VecCount]

enumFromThen :: VecCount -> VecCount -> [VecCount]

enumFromTo :: VecCount -> VecCount -> [VecCount]

enumFromThenTo :: VecCount -> VecCount -> VecCount -> [VecCount]

Enum VecElem

Since: base-4.10.0.0

Defined in GHC.Enum

Methods

succ :: VecElem -> VecElem

pred :: VecElem -> VecElem

toEnum :: Int -> VecElem

fromEnum :: VecElem -> Int

enumFrom :: VecElem -> [VecElem]

enumFromThen :: VecElem -> VecElem -> [VecElem]

enumFromTo :: VecElem -> VecElem -> [VecElem]

enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem]

Enum Word

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Word -> Word

pred :: Word -> Word

toEnum :: Int -> Word

fromEnum :: Word -> Int

enumFrom :: Word -> [Word]

enumFromThen :: Word -> Word -> [Word]

enumFromTo :: Word -> Word -> [Word]

enumFromThenTo :: Word -> Word -> Word -> [Word]

Enum a => Enum (And a)

Since: base-4.16

Defined in Data.Bits

Methods

succ :: And a -> And a

pred :: And a -> And a

toEnum :: Int -> And a

fromEnum :: And a -> Int

enumFrom :: And a -> [And a]

enumFromThen :: And a -> And a -> [And a]

enumFromTo :: And a -> And a -> [And a]

enumFromThenTo :: And a -> And a -> And a -> [And a]

Enum a => Enum (Iff a)

Since: base-4.16

Defined in Data.Bits

Methods

succ :: Iff a -> Iff a

pred :: Iff a -> Iff a

toEnum :: Int -> Iff a

fromEnum :: Iff a -> Int

enumFrom :: Iff a -> [Iff a]

enumFromThen :: Iff a -> Iff a -> [Iff a]

enumFromTo :: Iff a -> Iff a -> [Iff a]

enumFromThenTo :: Iff a -> Iff a -> Iff a -> [Iff a]

Enum a => Enum (Ior a)

Since: base-4.16

Defined in Data.Bits

Methods

succ :: Ior a -> Ior a

pred :: Ior a -> Ior a

toEnum :: Int -> Ior a

fromEnum :: Ior a -> Int

enumFrom :: Ior a -> [Ior a]

enumFromThen :: Ior a -> Ior a -> [Ior a]

enumFromTo :: Ior a -> Ior a -> [Ior a]

enumFromThenTo :: Ior a -> Ior a -> Ior a -> [Ior a]

Enum a => Enum (Xor a)

Since: base-4.16

Defined in Data.Bits

Methods

succ :: Xor a -> Xor a

pred :: Xor a -> Xor a

toEnum :: Int -> Xor a

fromEnum :: Xor a -> Int

enumFrom :: Xor a -> [Xor a]

enumFromThen :: Xor a -> Xor a -> [Xor a]

enumFromTo :: Xor a -> Xor a -> [Xor a]

enumFromThenTo :: Xor a -> Xor a -> Xor a -> [Xor a]

Enum a => Enum (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

succ :: Identity a -> Identity a

pred :: Identity a -> Identity a

toEnum :: Int -> Identity a

fromEnum :: Identity a -> Int

enumFrom :: Identity a -> [Identity a]

enumFromThen :: Identity a -> Identity a -> [Identity a]

enumFromTo :: Identity a -> Identity a -> [Identity a]

enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a]

(Enum a, Bounded a, Eq a) => Enum (Down a)

Swaps succ and pred of the underlying type.

Since: base-4.18.0.0

Defined in Data.Ord

Methods

succ :: Down a -> Down a

pred :: Down a -> Down a

toEnum :: Int -> Down a

fromEnum :: Down a -> Int

enumFrom :: Down a -> [Down a]

enumFromThen :: Down a -> Down a -> [Down a]

enumFromTo :: Down a -> Down a -> [Down a]

enumFromThenTo :: Down a -> Down a -> Down a -> [Down a]

Enum a => Enum (First a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

succ :: First a -> First a

pred :: First a -> First a

toEnum :: Int -> First a

fromEnum :: First a -> Int

enumFrom :: First a -> [First a]

enumFromThen :: First a -> First a -> [First a]

enumFromTo :: First a -> First a -> [First a]

enumFromThenTo :: First a -> First a -> First a -> [First a]

Enum a => Enum (Last a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

succ :: Last a -> Last a

pred :: Last a -> Last a

toEnum :: Int -> Last a

fromEnum :: Last a -> Int

enumFrom :: Last a -> [Last a]

enumFromThen :: Last a -> Last a -> [Last a]

enumFromTo :: Last a -> Last a -> [Last a]

enumFromThenTo :: Last a -> Last a -> Last a -> [Last a]

Enum a => Enum (Max a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

succ :: Max a -> Max a

pred :: Max a -> Max a

toEnum :: Int -> Max a

fromEnum :: Max a -> Int

enumFrom :: Max a -> [Max a]

enumFromThen :: Max a -> Max a -> [Max a]

enumFromTo :: Max a -> Max a -> [Max a]

enumFromThenTo :: Max a -> Max a -> Max a -> [Max a]

Enum a => Enum (Min a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

succ :: Min a -> Min a

pred :: Min a -> Min a

toEnum :: Int -> Min a

fromEnum :: Min a -> Int

enumFrom :: Min a -> [Min a]

enumFromThen :: Min a -> Min a -> [Min a]

enumFromTo :: Min a -> Min a -> [Min a]

enumFromThenTo :: Min a -> Min a -> Min a -> [Min a]

Enum a => Enum (WrappedMonoid a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

succ :: WrappedMonoid a -> WrappedMonoid a

pred :: WrappedMonoid a -> WrappedMonoid a

toEnum :: Int -> WrappedMonoid a

fromEnum :: WrappedMonoid a -> Int

enumFrom :: WrappedMonoid a -> [WrappedMonoid a]

enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a]

enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a]

enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a]

Integral a => Enum (Ratio a)

Since: base-2.0.1

Defined in GHC.Real

Methods

succ :: Ratio a -> Ratio a

pred :: Ratio a -> Ratio a

toEnum :: Int -> Ratio a

fromEnum :: Ratio a -> Int

enumFrom :: Ratio a -> [Ratio a]

enumFromThen :: Ratio a -> Ratio a -> [Ratio a]

enumFromTo :: Ratio a -> Ratio a -> [Ratio a]

enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a]

Enum a => Enum (a)

Defined in GHC.Enum

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)]

Enum (Fixed a)

Recall that, for numeric types, succ and pred typically add and subtract 1, respectively. This is not true in the case of Fixed, whose successor and predecessor functions intuitively return the "next" and "previous" values in the enumeration. The results of these functions thus depend on the resolution of the Fixed value. For example, when enumerating values of resolution 10^-3 of type Milli = Fixed E3,

  succ (0.000 :: Milli) == 0.001

and likewise

  pred (0.000 :: Milli) == -0.001

In other words, succ and pred increment and decrement a fixed-precision value by the least amount such that the value's resolution is unchanged. For example, 10^-12 is the smallest (positive) amount that can be added to a value of type Pico = Fixed E12 without changing its resolution, and so

  succ (0.000000000000 :: Pico) == 0.000000000001

and similarly

  pred (0.000000000000 :: Pico) == -0.000000000001

This is worth bearing in mind when defining Fixed arithmetic sequences. In particular, you may be forgiven for thinking the sequence

  [1..10] :: [Pico]

evaluates to [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] :: [Pico].

However, this is not true. On the contrary, similarly to the above implementations of succ and pred, enumFromTo :: Pico -> Pico -> [Pico] has a "step size" of 10^-12. Hence, the list [1..10] :: [Pico] has the form

  [1.000000000000, 1.00000000001, 1.00000000002, ..., 10.000000000000]

and contains 9 * 10^12 + 1 values.

Since: base-2.1

Defined in Data.Fixed

Methods

succ :: Fixed a -> Fixed a

pred :: Fixed a -> Fixed a

toEnum :: Int -> Fixed a

fromEnum :: Fixed a -> Int

enumFrom :: Fixed a -> [Fixed a]

enumFromThen :: Fixed a -> Fixed a -> [Fixed a]

enumFromTo :: Fixed a -> Fixed a -> [Fixed a]

enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a]

Enum (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

succ :: Proxy s -> Proxy s

pred :: Proxy s -> Proxy s

toEnum :: Int -> Proxy s

fromEnum :: Proxy s -> Int

enumFrom :: Proxy s -> [Proxy s]

enumFromThen :: Proxy s -> Proxy s -> [Proxy s]

enumFromTo :: Proxy s -> Proxy s -> [Proxy s]

enumFromThenTo :: Proxy s -> Proxy s -> Proxy s -> [Proxy s]

Enum a => Enum (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

succ :: Const a b -> Const a b

pred :: Const a b -> Const a b

toEnum :: Int -> Const a b

fromEnum :: Const a b -> Int

enumFrom :: Const a b -> [Const a b]

enumFromThen :: Const a b -> Const a b -> [Const a b]

enumFromTo :: Const a b -> Const a b -> [Const a b]

enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b]

Enum (f a) => Enum (Ap f a)

Since: base-4.12.0.0

Defined in Data.Monoid

Methods

succ :: Ap f a -> Ap f a

pred :: Ap f a -> Ap f a

toEnum :: Int -> Ap f a

fromEnum :: Ap f a -> Int

enumFrom :: Ap f a -> [Ap f a]

enumFromThen :: Ap f a -> Ap f a -> [Ap f a]

enumFromTo :: Ap f a -> Ap f a -> [Ap f a]

enumFromThenTo :: Ap f a -> Ap f a -> Ap f a -> [Ap f a]

Enum (f a) => Enum (Alt f a)

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

succ :: Alt f a -> Alt f a

pred :: Alt f a -> Alt f a

toEnum :: Int -> Alt f a

fromEnum :: Alt f a -> Int

enumFrom :: Alt f a -> [Alt f a]

enumFromThen :: Alt f a -> Alt f a -> [Alt f a]

enumFromTo :: Alt f a -> Alt f a -> [Alt f a]

enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [Alt f a]

Coercible a b => Enum (Coercion a b)

Since: base-4.7.0.0

Defined in Data.Type.Coercion

Methods

succ :: Coercion a b -> Coercion a b

pred :: Coercion a b -> Coercion a b

toEnum :: Int -> Coercion a b

fromEnum :: Coercion a b -> Int

enumFrom :: Coercion a b -> [Coercion a b]

enumFromThen :: Coercion a b -> Coercion a b -> [Coercion a b]

enumFromTo :: Coercion a b -> Coercion a b -> [Coercion a b]

enumFromThenTo :: Coercion a b -> Coercion a b -> Coercion a b -> [Coercion a b]

a ~ b => Enum (a :~: b)

Since: base-4.7.0.0

Defined in Data.Type.Equality

Methods

succ :: (a :~: b) -> a :~: b

pred :: (a :~: b) -> a :~: b

toEnum :: Int -> a :~: b

fromEnum :: (a :~: b) -> Int

enumFrom :: (a :~: b) -> [a :~: b]

enumFromThen :: (a :~: b) -> (a :~: b) -> [a :~: b]

enumFromTo :: (a :~: b) -> (a :~: b) -> [a :~: b]

enumFromThenTo :: (a :~: b) -> (a :~: b) -> (a :~: b) -> [a :~: b]

a ~~ b => Enum (a :~~: b)

Since: base-4.10.0.0

Defined in Data.Type.Equality

Methods

succ :: (a :~~: b) -> a :~~: b

pred :: (a :~~: b) -> a :~~: b

toEnum :: Int -> a :~~: b

fromEnum :: (a :~~: b) -> Int

enumFrom :: (a :~~: b) -> [a :~~: b]

enumFromThen :: (a :~~: b) -> (a :~~: b) -> [a :~~: b]

enumFromTo :: (a :~~: b) -> (a :~~: b) -> [a :~~: b]

enumFromThenTo :: (a :~~: b) -> (a :~~: b) -> (a :~~: b) -> [a :~~: b]

boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]

boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]

toEnumError :: Show a => String -> Int -> (a, a) -> b

fromEnumError :: Show a => String -> a -> b

succError :: String -> a

predError :: String -> a