IHaskellPrelude

Documentation

type LText = Text

type LByteString = ByteString

headMay :: [a] -> Maybe a

tailMay :: [a] -> Maybe [a]

lastMay :: [a] -> Maybe a

initMay :: [a] -> Maybe [a]

maximumMay :: Ord a => [a] -> Maybe a

minimumMay :: Ord a => [a] -> Maybe a

wrapEmpty :: ([a] -> b) -> [a] -> Maybe b

maximumByMay :: (a -> a -> Ordering) -> [a] -> Maybe a

minimumByMay :: (a -> a -> Ordering) -> [a] -> Maybe a

readMay :: Read a => String -> Maybe a

putStrLn :: MonadIO m => String -> m ()

putStr :: MonadIO m => String -> m ()

putChar :: MonadIO m => Char -> m ()

print :: (MonadIO m, Show a) => a -> m ()

nonEmptyToList :: NonEmpty a -> [a]

augment :: (forall b. (a -> b -> b) -> b -> b) -> [a] -> [a]

A list producer that can be fused with foldr. This function is merely

   augment g xs = g (:) xs

but GHC's simplifier will transform an expression of the form foldr k z (augment g xs), which may arise after inlining, to g k (foldr k z xs), which avoids producing an intermediate list.

(++) :: [a] -> [a] -> [a] infixr 5

Append two lists, i.e.,

[x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
[x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]

If the first list is not finite, the result is the first list.

build :: (forall b. (a -> b -> b) -> b -> b) -> [a]

A list producer that can be fused with foldr. This function is merely

   build g = g (:) []

but GHC's simplifier will transform an expression of the form foldr k z (build g), which may arise after inlining, to g k z, which avoids producing an intermediate list.

seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b infixr 0

The value of seq a b is bottom if a is bottom, and otherwise equal to b. In other words, it evaluates the first argument a to weak head normal form (WHNF). seq is usually introduced to improve performance by avoiding unneeded laziness.

A note on evaluation order: the expression seq a b does not guarantee that a will be evaluated before b. The only guarantee given by seq is that the both a and b will be evaluated before seq returns a value. In particular, this means that b may be evaluated before a. If you need to guarantee a specific order of evaluation, you must use the function pseq from the "parallel" package.

eqString :: String -> String -> Bool

This String equality predicate is used when desugaring pattern-matches against strings.

realWorld# :: State# RealWorld

The token used in the implementation of the IO monad as a state monad. It does not pass any information at runtime. See also GHC.Magic.runRW#.

unpackCStringUtf8# :: Addr# -> [Char]

unpackFoldrCString# :: Addr# -> (Char -> a -> a) -> a -> a

unpackCString# :: Addr# -> [Char]

unpackFoldrCStringUtf8# :: Addr# -> (Char -> a -> a) -> a -> a

void# :: (# #)

This is an alias for the unboxed unit tuple constructor. In earlier versions of GHC, void# was a value of the primitive type Void#, which is now defined to be (# #).

divInt# :: Int# -> Int# -> Int#

modInt# :: Int# -> Int# -> Int#

cstringLength# :: Addr# -> Int#

Compute the length of a NUL-terminated string. This address must refer to immutable memory. GHC includes a built-in rule for constant folding when the argument is a statically-known literal. That is, a core-to-core pass reduces the expression cstringLength# "hello"# to the constant 5#.

filter :: (a -> Bool) -> [a] -> [a]

\(\mathcal{O}(n)\). filter, applied to a predicate and a list, returns the list of those elements that satisfy the predicate; i.e.,

filter p xs = [ x | x <- xs, p x]

>>> filter odd [1, 2, 3]
[1,3]

zip :: [a] -> [b] -> [(a, b)]

\(\mathcal{O}(\min(m,n))\). zip takes two lists and returns a list of corresponding pairs.

>>> zip [1, 2] ['a', 'b']
[(1,'a'),(2,'b')]

If one input list is shorter than the other, excess elements of the longer list are discarded, even if one of the lists is infinite:

>>> zip [1] ['a', 'b']
[(1,'a')]
>>> zip [1, 2] ['a']
[(1,'a')]
>>> zip [] [1..]
[]
>>> zip [1..] []
[]

zip is right-lazy:

>>> zip [] undefined
[]
>>> zip undefined []
*** Exception: Prelude.undefined
...

zip is capable of list fusion, but it is restricted to its first list argument and its resulting list.

bindIO :: IO a -> (a -> IO b) -> IO b

returnIO :: a -> IO a

nullAddr# :: Addr#

The null address.

fst :: (a, b) -> a

Extract the first component of a pair.

snd :: (a, b) -> b

Extract the second component of a pair.

otherwise :: Bool

otherwise is defined as the value True. It helps to make guards more readable. eg.

 f x | x < 0     = ...
     | otherwise = ...

assert :: Bool -> a -> a

If the first argument evaluates to True, then the result is the second argument. Otherwise an AssertionFailed exception is raised, containing a String with the source file and line number of the call to assert.

Assertions can normally be turned on or off with a compiler flag (for GHC, assertions are normally on unless optimisation is turned on with -O or the -fignore-asserts option is given). When assertions are turned off, the first argument to assert is ignored, and the second argument is returned as the result.

leftSection :: forall {q :: RuntimeRep} {r :: RuntimeRep} {n :: Multiplicity} (a :: TYPE q) (b :: TYPE r). (a %n -> b) -> a %n -> b

rightSection :: forall {q :: RuntimeRep} {r :: RuntimeRep} {s :: RuntimeRep} {n :: Multiplicity} {o :: Multiplicity} (a :: TYPE q) (b :: TYPE r) (c :: TYPE s). (a %n -> b %o -> c) -> b %o -> a %n -> c

thenIO :: IO a -> IO b -> IO b

lazy :: a -> a

The lazy function restrains strictness analysis a little. The call lazy e means the same as e, but lazy has a magical property so far as strictness analysis is concerned: it is lazy in its first argument, even though its semantics is strict. After strictness analysis has run, calls to lazy are inlined to be the identity function.

This behaviour is occasionally useful when controlling evaluation order. Notably, lazy is used in the library definition of par:

par :: a -> b -> b
par x y = case (par# x) of _ -> lazy y

If lazy were not lazy, par would look strict in y which would defeat the whole purpose of par.

oneShot :: forall {q :: RuntimeRep} {r :: RuntimeRep} (a :: TYPE q) (b :: TYPE r). (a -> b) -> a -> b

The oneShot function can be used to give a hint to the compiler that its argument will be called at most once, which may (or may not) enable certain optimizations. It can be useful to improve the performance of code in continuation passing style.

If oneShot is used wrongly, then it may be that computations whose result that would otherwise be shared are re-evaluated every time they are used. Otherwise, the use of oneShot is safe.

oneShot is representation polymorphic: the type variables may refer to lifted or unlifted types.

runRW# :: forall (r :: RuntimeRep) (o :: TYPE r). (State# RealWorld -> o) -> o

Apply a function to a State# RealWorld token. When manually applying a function to realWorld#, it is necessary to use NOINLINE to prevent semantically undesirable floating. runRW# is inlined, but only very late in compilation after all floating is complete.

breakpoint :: a -> a

breakpointCond :: Bool -> a -> a

inline :: a -> a

The call inline f arranges that f is inlined, regardless of its size. More precisely, the call inline f rewrites to the right-hand side of f's definition. This allows the programmer to control inlining from a particular call site rather than the definition site of the function (c.f. INLINE pragmas).

This inlining occurs regardless of the argument to the call or the size of f's definition; it is unconditional. The main caveat is that f's definition must be visible to the compiler; it is therefore recommended to mark the function with an INLINABLE pragma at its definition so that GHC guarantees to record its unfolding regardless of size.

If no inlining takes place, the inline function expands to the identity function in Phase zero, so its use imposes no overhead.

map :: (a -> b) -> [a] -> [b]

\(\mathcal{O}(n)\). map f xs is the list obtained by applying f to each element of xs, i.e.,

map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
map f [x1, x2, ...] == [f x1, f x2, ...]

>>> map (+1) [1, 2, 3]
[2,3,4]

($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b infixr 0

Application operator. This operator is redundant, since ordinary application (f x) means the same as (f $ x). However, $ has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example:

f $ g $ h x  =  f (g (h x))

It is also useful in higher-order situations, such as map ($ 0) xs, or zipWith ($) fs xs.

Note that ($) is levity-polymorphic in its result type, so that foo $ True where foo :: Bool -> Int# is well-typed.

noinline :: a -> a

The call noinline f arranges that f will not be inlined. It is removed during CorePrep so that its use imposes no overhead (besides the fact that it blocks inlining.)

magicDict :: a

magicDict is a special-purpose placeholder value. It is used internally by modules such as GHC.TypeNats to cast a typeclass dictionary with a single method. It is eliminated by a rule during compilation. For the details, see Note [magicDictId magic] in GHC.

coerce :: forall {k :: RuntimeRep} (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b

The function coerce allows you to safely convert between values of types that have the same representation with no run-time overhead. In the simplest case you can use it instead of a newtype constructor, to go from the newtype's concrete type to the abstract type. But it also works in more complicated settings, e.g. converting a list of newtypes to a list of concrete types.

This function is runtime-representation polymorphic, but the RuntimeRep type argument is marked as Inferred, meaning that it is not available for visible type application. This means the typechecker will accept coerce @Int @Age 42.

fromIntegral :: (Integral a, Num b) => a -> b

general coercion from integral types

realToFrac :: (Real a, Fractional b) => a -> b

general coercion to fractional types

guard :: Alternative f => Bool -> f ()

Conditional failure of Alternative computations. Defined by

guard True  = pure ()
guard False = empty

Examples

Common uses of guard include conditionally signaling an error in an error monad and conditionally rejecting the current choice in an Alternative-based parser.

As an example of signaling an error in the error monad Maybe, consider a safe division function safeDiv x y that returns Nothing when the denominator y is zero and Just (x `div` y) otherwise. For example:

>>> safeDiv 4 0
Nothing

>>> safeDiv 4 2
Just 2

A definition of safeDiv using guards, but not guard:

safeDiv :: Int -> Int -> Maybe Int
safeDiv x y | y /= 0    = Just (x `div` y)
            | otherwise = Nothing

A definition of safeDiv using guard and Monad do-notation:

safeDiv :: Int -> Int -> Maybe Int
safeDiv x y = do
  guard (y /= 0)
  return (x `div` y)

proxy# :: forall {k} (a :: k). Proxy# a

Witness for an unboxed Proxy# value, which has no runtime representation.

integerFromNatural :: Natural -> Integer

Convert a Natural into an Integer

integerToNaturalClamp :: Integer -> Natural

Convert an Integer into a Natural

Return 0 for negative Integers.

integerToNaturalThrow :: Integer -> Natural

Convert an Integer into a Natural

Throw an Underflow exception if input is negative.

integerToNatural :: Integer -> Natural

Convert an Integer into a Natural

Return absolute value

integerToWord# :: Integer -> Word#

Truncate an Integer into a Word

integerToInt# :: Integer -> Int#

Truncates Integer to least-significant Int#

integerAdd :: Integer -> Integer -> Integer

Add two Integers

integerMul :: Integer -> Integer -> Integer

Multiply two Integers

integerSub :: Integer -> Integer -> Integer

Subtract one Integer from another.

integerNegate :: Integer -> Integer

Negate Integer.

One edge-case issue to take into account is that Int's range is not symmetric around 0. I.e. minBound+maxBound = -1

IP is used iff n > maxBound::Int IN is used iff n < minBound::Int

integerEq# :: Integer -> Integer -> Bool#

Equal predicate.

integerNe# :: Integer -> Integer -> Bool#

Not-equal predicate.

integerLe# :: Integer -> Integer -> Bool#

Lower-or-equal predicate.

integerGt# :: Integer -> Integer -> Bool#

Greater predicate.

integerLt# :: Integer -> Integer -> Bool#

Lower predicate.

integerGe# :: Integer -> Integer -> Bool#

Greater-or-equal predicate.

integerAbs :: Integer -> Integer

Compute absolute value of an Integer

integerSignum :: Integer -> Integer

Return -1, 0, and 1 depending on whether argument is negative, zero, or positive, respectively

integerCompare :: Integer -> Integer -> Ordering

Compare two Integer

integerPopCount# :: Integer -> Int#

Count number of set bits. For negative arguments returns the negated population count of the absolute value.

integerQuot :: Integer -> Integer -> Integer

integerRem :: Integer -> Integer -> Integer

integerDiv :: Integer -> Integer -> Integer

integerMod :: Integer -> Integer -> Integer

integerDivMod# :: Integer -> Integer -> (# Integer, Integer #)

Simultaneous integerDiv and integerMod.

Divisor must be non-zero otherwise the GHC runtime will terminate with a division-by-zero fault.

integerQuotRem# :: Integer -> Integer -> (# Integer, Integer #)

Simultaneous integerQuot and integerRem.

Divisor must be non-zero otherwise the GHC runtime will terminate with a division-by-zero fault.

integerEncodeFloat# :: Integer -> Int# -> Float#

Encode (# Integer mantissa, Int# exponent #) into a Float#

TODO: Not sure if it's worth to write Float optimized versions here

integerEncodeDouble# :: Integer -> Int# -> Double#

Encode (# Integer mantissa, Int# exponent #) into a Double#

integerGcd :: Integer -> Integer -> Integer

Compute greatest common divisor.

integerLcm :: Integer -> Integer -> Integer

Compute least common multiple.

integerAnd :: Integer -> Integer -> Integer

Bitwise AND operation

Fake 2's complement for negative values (might be slow)

integerOr :: Integer -> Integer -> Integer

Bitwise OR operation

Fake 2's complement for negative values (might be slow)

integerXor :: Integer -> Integer -> Integer

Bitwise XOR operation

Fake 2's complement for negative values (might be slow)

integerComplement :: Integer -> Integer

Binary complement of the

integerBit# :: Word# -> Integer

Positive Integer for which only n-th bit is set

integerTestBit# :: Integer -> Word# -> Bool#

Test if n-th bit is set.

Fake 2's complement for negative values (might be slow)

integerShiftL# :: Integer -> Word# -> Integer

Shift-left operation

integerShiftR# :: Integer -> Word# -> Integer

Shift-right operation

Fake 2's complement for negative values (might be slow)

integerFromWord# :: Word# -> Integer

Convert a Word# into an Integer

integerFromInt64# :: Int# -> Integer

Convert an Int64# into an Integer on 64-bit architectures

naturalToWord# :: Natural -> Word#

Convert the lower bits of a Natural into a Word#

naturalToWordClamp# :: Natural -> Word#

Convert a Natural into a Word# clamping to (maxBound :: Word#).

naturalEq# :: Natural -> Natural -> Bool#

Equality test for Natural

naturalNe# :: Natural -> Natural -> Bool#

Inequality test for Natural

naturalGe# :: Natural -> Natural -> Bool#

Greater or equal test for Natural

naturalLe# :: Natural -> Natural -> Bool#

Lower or equal test for Natural

naturalGt# :: Natural -> Natural -> Bool#

Greater test for Natural

naturalLt# :: Natural -> Natural -> Bool#

Lower test for Natural

naturalCompare :: Natural -> Natural -> Ordering

Compare two Natural

naturalPopCount# :: Natural -> Word#

PopCount for Natural

naturalShiftR# :: Natural -> Word# -> Natural

Right shift for Natural

naturalShiftL# :: Natural -> Word# -> Natural

Left shift

naturalAdd :: Natural -> Natural -> Natural

Add two naturals

naturalSub :: Natural -> Natural -> (# (# #) | Natural #)

Sub two naturals

naturalSubThrow :: Natural -> Natural -> Natural

Sub two naturals

Throw an Underflow exception if x < y

naturalSubUnsafe :: Natural -> Natural -> Natural

Sub two naturals

Unsafe: don't check that x >= y Undefined results if it happens

naturalMul :: Natural -> Natural -> Natural

Multiplication

naturalSignum :: Natural -> Natural

Signum for Natural

naturalNegate :: Natural -> Natural

Negate for Natural

naturalQuotRem# :: Natural -> Natural -> (# Natural, Natural #)

Return division quotient and remainder

Division by zero is handled by BigNat

naturalQuot :: Natural -> Natural -> Natural

Return division quotient

naturalRem :: Natural -> Natural -> Natural

Return division remainder

naturalAnd :: Natural -> Natural -> Natural

naturalAndNot :: Natural -> Natural -> Natural

naturalOr :: Natural -> Natural -> Natural

naturalXor :: Natural -> Natural -> Natural

naturalTestBit# :: Natural -> Word# -> Bool#

naturalBit# :: Word# -> Natural

naturalGcd :: Natural -> Natural -> Natural

Compute greatest common divisor.

naturalLcm :: Natural -> Natural -> Natural

Compute least common multiple.

naturalLog2# :: Natural -> Word#

Base 2 logarithm

naturalLogBaseWord# :: Word# -> Natural -> Word#

Logarithm for an arbitrary base

naturalLogBase# :: Natural -> Natural -> Word#

Logarithm for an arbitrary base

naturalPowMod :: Natural -> Natural -> Natural -> Natural

"naturalPowMod b e m" computes base b raised to exponent e modulo m.

naturalSizeInBase# :: Word# -> Natural -> Word#

Compute the number of digits of the Natural in the given base.

base must be > 1

mkRationalBase2 :: Rational -> Integer -> Rational

mkRationalBase10 :: Rational -> Integer -> Rational

join :: Monad m => m (m a) -> m a

The join function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.

'join bss' can be understood as the do expression

do bs <- bss
   bs

Examples

A common use of join is to run an IO computation returned from an STM transaction, since STM transactions can't perform IO directly. Recall that

atomically :: STM a -> IO a

is used to run STM transactions atomically. So, by specializing the types of atomically and join to

atomically :: STM (IO b) -> IO (IO b)
join       :: IO (IO b)  -> IO b

we can compose them as

join . atomically :: STM (IO b) -> IO b

to run an STM transaction and the IO action it returns.

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 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 Encoding

Defined in Basement.String

Methods

minBound :: Encoding

maxBound :: Encoding

Bounded UTF32_Invalid

Defined in Basement.String.Encoding.UTF32

Methods

minBound :: UTF32_Invalid

maxBound :: UTF32_Invalid

Bounded TimeSpec

Defined in System.Clock

Methods

minBound :: TimeSpec

maxBound :: TimeSpec

Bounded HelpFormat

Defined in System.Console.CmdArgs.Explicit.Help

Methods

minBound :: HelpFormat

maxBound :: HelpFormat

Bounded FileType

Defined in System.Directory.Internal.Common

Methods

minBound :: FileType

maxBound :: FileType

Bounded XdgDirectory

Defined in System.Directory.Internal.Common

Methods

minBound :: XdgDirectory

maxBound :: XdgDirectory

Bounded XdgDirectoryList

Defined in System.Directory.Internal.Common

Methods

minBound :: XdgDirectoryList

maxBound :: XdgDirectoryList

Bounded Language

Defined in GHC.Driver.Flags

Methods

minBound :: Language

maxBound :: Language

Bounded Extension

Defined in GHC.LanguageExtensions.Type

Methods

minBound :: Extension

maxBound :: Extension

Bounded Extension

Defined in GHC.LanguageExtensions.Type

Methods

minBound :: Extension

maxBound :: Extension

Bounded Ordering

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Ordering

maxBound :: Ordering

Bounded Severity

Defined in Config.Type

Methods

minBound :: Severity

maxBound :: Severity

Bounded IPv4

Defined in Data.IP.Addr

Methods

minBound :: IPv4

maxBound :: IPv4

Bounded IPv6

Defined in Data.IP.Addr

Methods

minBound :: IPv6

maxBound :: IPv6

Bounded PortNumber

Defined in Network.Socket.Types

Methods

minBound :: PortNumber

maxBound :: PortNumber

Bounded CompressionStrategy

Defined in Codec.Compression.Zlib.Stream

Methods

minBound :: CompressionStrategy

maxBound :: CompressionStrategy

Bounded Format

Defined in Codec.Compression.Zlib.Stream

Methods

minBound :: Format

maxBound :: Format

Bounded Method

Defined in Codec.Compression.Zlib.Stream

Methods

minBound :: Method

maxBound :: Method

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 (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

SizeValid n => Bounded (Bits n)

Defined in Basement.Bits

Methods

minBound :: Bits n

maxBound :: Bits n

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 (Pair a b)

Defined in Data.Strict.Tuple

Methods

minBound :: Pair a b

maxBound :: Pair a b

(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

Bounded b => Bounded (Tagged s b)

Defined in Data.Tagged

Methods

minBound :: Tagged s b

maxBound :: Tagged s 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)

(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 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 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 ->