relude-1.2.2.0: Safe, performant, user-friendly and lightweight Haskell Standard Library

Copyright | (c) 2021-2023 Kowainik
License | MIT
Maintainer | Kowainik <xrom.xkov@gmail.com>
Stability | Stable
Portability | Portable
Safe Haskell | Safe
Language | Haskell2010

Relude.Enum

Contents

- Useful combinators for Enums
- Base reexports

Description

Reexports `Enum` related typeclasses and functions. Also introduces a few useful helpers to work with Enums.

Note: `universe`, `universeNonEmpty` and `inverseMap` were previously in the extra modules, but due to their benefit in different use cases. If you imported `Relude.Extra.Enum` module, you can remove it now, as these functions are reexported in the main Relude module.

Since: 1.0.0.0

Synopsis

- universe :: (Bounded a, Enum a) => [a]
- universeNonEmpty :: (Bounded a, Enum a) => NonEmpty a
- inverseMap :: (Bounded a, Enum a, Ord k) => (a -> k) -> k -> Maybe a
- class Enum a where
  - 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]
- class Bounded a where
  - minBound :: a
  - maxBound :: a
- boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
- boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]

# Useful combinators for Enums

universe :: (Bounded a, Enum a) => [a] #

Returns all values of some `Bounded` `Enum` in ascending order.

    >>> universe :: [Bool]
    [False,True]

    >>> universe @Ordering
    [LT,EQ,GT]

    >>> data TrafficLight = Red | Blue | Green deriving (Show, Enum, Bounded)
    >>> universe :: [TrafficLight]
    [Red,Blue,Green]

    >>> data Singleton = Singleton deriving (Show, Enum, Bounded)
    >>> universe @Singleton
    [Singleton]

Since: 0.1.0

universeNonEmpty :: (Bounded a, Enum a) => NonEmpty a #

Like `universe`, but returns `NonEmpty` list of some enumeration

    >>> universeNonEmpty :: NonEmpty Bool
    False :| [True]

    >>> universeNonEmpty @Ordering
    LT :| [EQ,GT]

    >>> data TrafficLight = Red | Blue | Green deriving (Show, Eq, Enum, Bounded)
    >>> universeNonEmpty :: NonEmpty TrafficLight
    Red :| [Blue,Green]

    >>> data Singleton = Singleton deriving (Show, Eq, Enum, Bounded)
    >>> universeNonEmpty @Singleton
    Singleton :| []

Since: 0.7.0.0

inverseMap :: (Bounded a, Enum a, Ord k) => (a -> k) -> k -> Maybe a #

`inverseMap f` creates a function that is the inverse of a given function `f`. It does so by constructing `Map` internally for each value `f a`. The implementation makes sure that the `Map` is constructed only once and then shared for every call.

Memory usage note: don't inverse functions that have types like `Int` as their input. In this case the created `Map` will have huge size.

The complexity of reversed mapping is \(\mathcal{O}(\log n)\).

Performance note: make sure to specialize monomorphic type of your functions that use `inverseMap` to avoid `Map` reconstruction.

One of the common `inverseMap` use-case is inverting the `show` or a `show`-like function.

    >>> data Color = Red | Green | Blue deriving (Show, Enum, Bounded)
    >>> parse = inverseMap show :: String -> Maybe Color
    >>> parse "Red"
    Just Red
    >>> parse "Black"
    Nothing

Correctness note: `inverseMap` expects injective function as its argument, i.e. the function must map distinct arguments to distinct values.

Typical usage of this function looks like this:

    data GhcVer
        = Ghc802
        | Ghc822
        | Ghc844
        | Ghc865
        | Ghc881
        deriving (Eq, Ord, Show, Enum, Bounded)

    showGhcVer :: GhcVer -> Text
    showGhcVer = \case
        Ghc802 -> "8.0.2"
        Ghc822 -> "8.2.2"
        Ghc844 -> "8.4.4"
        Ghc865 -> "8.6.5"
        Ghc881 -> "8.8.1"

    parseGhcVer :: Text -> Maybe GhcVer
    parseGhcVer = inverseMap showGhcVer

Since: 0.1.1

# Base reexports

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 #

Successor of a value. For numeric types, `succ` adds 1.

pred :: a -> a #

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)`.

#### Examples

Expand

-     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

#### Examples

Expand

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

#### Examples

Expand

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

#### Examples

Expand

-     enumFromThenTo 4 2 -6 :: [Integer] = [4,2,0,-2,-4,-6]

-     enumFromThenTo 6 8 2 :: [Int] = []

#### Instances

Instances details

Enum Extension |
Instance details Defined in GHC.LanguageExtensions.Type Methods succ :: Extension -> Extension # pred :: Extension -> Extension # toEnum :: Int -> Extension # fromEnum :: Extension -> Int # enumFrom :: Extension -> [Extension] # enumFromThen :: Extension -> Extension -> [Extension] # enumFromTo :: Extension -> Extension -> [Extension] # enumFromThenTo :: Extension -> Extension -> Extension -> [Extension] #
Enum Associativity | @since base-4.9.0.0
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.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 IOMode | @since base-4.2.0.0
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.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 Word16 | @since base-2.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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 Ordering | @since base-2.01
Instance details Defined in GHC.Internal.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 Undefined # |
Instance details Defined in Relude.Debug Methods succ :: Undefined -> Undefined # pred :: Undefined -> Undefined # toEnum :: Int -> Undefined # fromEnum :: Undefined -> Int # enumFrom :: Undefined -> [Undefined] # enumFromThen :: Undefined -> Undefined -> [Undefined] # enumFromTo :: Undefined -> Undefined -> [Undefined] # enumFromThenTo :: Undefined -> Undefined -> Undefined -> [Undefined] #
Enum I8 |
Instance details Defined in Data.Text.Foreign Methods succ :: I8 -> I8 # pred :: I8 -> I8 # toEnum :: Int -> I8 # fromEnum :: I8 -> Int # enumFrom :: I8 -> [I8] # enumFromThen :: I8 -> I8 -> [I8] # enumFromTo :: I8 -> I8 -> [I8] # enumFromThenTo :: I8 -> I8 -> I8 -> [I8] #
Enum FPFormat |
Instance details Defined in Data.Text.Lazy.Builder.RealFloat Methods succ :: FPFormat -> FPFormat # pred :: FPFormat -> FPFormat # toEnum :: Int -> FPFormat # fromEnum :: FPFormat -> Int # enumFrom :: FPFormat -> [FPFormat] # enumFromThen :: FPFormat -> FPFormat -> [FPFormat] # enumFromTo :: FPFormat -> FPFormat -> [FPFormat] # enumFromThenTo :: FPFormat -> FPFormat -> FPFormat -> [FPFormat] #
Enum Integer | @since base-2.01
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.Enum Methods succ :: () -> () # pred :: () -> () # toEnum :: Int -> () # fromEnum :: () -> Int # enumFrom :: () -> [()] # enumFromThen :: () -> () -> [()] # enumFromTo :: () -> () -> [()] # enumFromThenTo :: () -> () -> () -> [()] #
Enum Bool | @since base-2.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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 Int | @since base-2.01
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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 (First a) | Since: base-4.9.0.0
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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] #
Enum a => Enum (Identity a) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.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] #
Integral a => Enum (Ratio a) | @since base-2.0.1
Instance details Defined in GHC.Internal.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 (Solo a) |
Instance details Defined in GHC.Internal.Enum Methods succ :: Solo a -> Solo a # pred :: Solo a -> Solo a # toEnum :: Int -> Solo a # fromEnum :: Solo a -> Int # enumFrom :: Solo a -> [Solo a] # enumFromThen :: Solo a -> Solo a -> [Solo a] # enumFromTo :: Solo a -> Solo a -> [Solo a] # enumFromThenTo :: Solo a -> Solo a -> Solo a -> [Solo 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
Instance details 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
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.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] #
Enum (f (g a)) => Enum (Compose f g a) | Since: base-4.19.0.0
Instance details Defined in Data.Functor.Compose Methods succ :: Compose f g a -> Compose f g a # pred :: Compose f g a -> Compose f g a # toEnum :: Int -> Compose f g a # fromEnum :: Compose f g a -> Int # enumFrom :: Compose f g a -> [Compose f g a] # enumFromThen :: Compose f g a -> Compose f g a -> [Compose f g a] # enumFromTo :: Compose f g a -> Compose f g a -> [Compose f g a] # enumFromThenTo :: Compose f g a -> Compose f g a -> Compose f g a -> [Compose f g a] #

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

Instances details

Bounded Extension |
Instance details Defined in GHC.LanguageExtensions.Type Methods minBound :: Extension # maxBound :: Extension #
Bounded All | @since base-2.01
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods minBound :: All # maxBound :: All #
Bounded Any | @since base-2.01
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods minBound :: Any # maxBound :: Any #
Bounded Associativity | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods minBound :: Associativity # maxBound :: Associativity #
Bounded DecidedStrictness | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods minBound :: DecidedStrictness # maxBound :: DecidedStrictness #
Bounded SourceStrictness | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods minBound :: SourceStrictness # maxBound :: SourceStrictness #
Bounded SourceUnpackedness | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods minBound :: SourceUnpackedness # maxBound :: SourceUnpackedness #
Bounded Int16 | @since base-2.01
Instance details Defined in GHC.Internal.Int Methods minBound :: Int16 # maxBound :: Int16 #
Bounded Int32 | @since base-2.01
Instance details Defined in GHC.Internal.Int Methods minBound :: Int32 # maxBound :: Int32 #
Bounded Int64 | @since base-2.01
Instance details Defined in GHC.Internal.Int Methods minBound :: Int64 # maxBound :: Int64 #
Bounded Int8 | @since base-2.01
Instance details Defined in GHC.Internal.Int Methods minBound :: Int8 # maxBound :: Int8 #
Bounded Word16 | @since base-2.01
Instance details Defined in GHC.Internal.Word Methods minBound :: Word16 # maxBound :: Word16 #
Bounded Word32 | @since base-2.01
Instance details Defined in GHC.Internal.Word Methods minBound :: Word32 # maxBound :: Word32 #
Bounded Word64 | @since base-2.01
Instance details Defined in GHC.Internal.Word Methods minBound :: Word64 # maxBound :: Word64 #
Bounded Word8 | @since base-2.01
Instance details Defined in GHC.Internal.Word Methods minBound :: Word8 # maxBound :: Word8 #
Bounded Ordering | @since base-2.01
Instance details Defined in GHC.Internal.Enum Methods minBound :: Ordering # maxBound :: Ordering #
Bounded Undefined # |
Instance details Defined in Relude.Debug Methods minBound :: Undefined # maxBound :: Undefined #
Bounded I8 |
Instance details Defined in Data.Text.Foreign Methods minBound :: I8 # maxBound :: I8 #
Bounded FPFormat |
Instance details Defined in Data.Text.Lazy.Builder.RealFloat Methods minBound :: FPFormat # maxBound :: FPFormat #
Bounded () | @since base-2.01
Instance details Defined in GHC.Internal.Enum Methods minBound :: () # maxBound :: () #
Bounded Bool | @since base-2.01
Instance details Defined in GHC.Internal.Enum Methods minBound :: Bool # maxBound :: Bool #
Bounded Char | @since base-2.01
Instance details Defined in GHC.Internal.Enum Methods minBound :: Char # maxBound :: Char #
Bounded Int | @since base-2.01
Instance details Defined in GHC.Internal.Enum Methods minBound :: Int # maxBound :: Int #
Bounded Levity | @since base-4.16.0.0
Instance details Defined in GHC.Internal.Enum Methods minBound :: Levity # maxBound :: Levity #
Bounded VecCount | @since base-4.10.0.0
Instance details Defined in GHC.Internal.Enum Methods minBound :: VecCount # maxBound :: VecCount #
Bounded VecElem | @since base-4.10.0.0
Instance details Defined in GHC.Internal.Enum Methods minBound :: VecElem # maxBound :: VecElem #
Bounded Word | @since base-2.01
Instance details Defined in GHC.Internal.Enum Methods minBound :: Word # maxBound :: Word #
Bounded a => Bounded (First a) | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: First a # maxBound :: First a #
Bounded a => Bounded (Last a) | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: Last a # maxBound :: Last a #
Bounded a => Bounded (Max a) | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: Max a # maxBound :: Max a #
Bounded a => Bounded (Min a) | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: Min a # maxBound :: Min a #
Bounded m => Bounded (WrappedMonoid m) | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: WrappedMonoid m # maxBound :: WrappedMonoid m #
Bounded a => Bounded (Identity a) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.Data.Ord Methods minBound :: Down a # maxBound :: Down a #
Bounded a => Bounded (Dual a) | @since base-2.01
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods minBound :: Dual a # maxBound :: Dual a #
Bounded a => Bounded (Product a) | @since base-2.01
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods minBound :: Product a # maxBound :: Product a #
Bounded a => Bounded (Sum a) | @since base-2.01
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods minBound :: Sum a # maxBound :: Sum a #
Bounded a => Bounded (Solo a) |
Instance details Defined in GHC.Internal.Enum Methods minBound :: Solo a # maxBound :: Solo a #
Bounded (Proxy t) | @since base-4.7.0.0
Instance details Defined in GHC.Internal.Data.Proxy Methods minBound :: Proxy t # maxBound :: Proxy t #
(Bounded a, Bounded b) => Bounded (a, b) | @since base-2.01
Instance details Defined in GHC.Internal.Enum Methods minBound :: (a, b) # maxBound :: (a, b) #
Bounded a => Bounded (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.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
Instance details Defined in GHC.Internal.Data.Monoid Methods minBound :: Ap f a # maxBound :: Ap f a #
(Bounded a, Bounded b, Bounded c) => Bounded (a, b, c) | @since base-2.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.Enum Methods minBound :: (a, b, c, d) # maxBound :: (a, b, c, d) #
Bounded (f (g a)) => Bounded (Compose f g a) | Since: base-4.19.0.0
Instance details Defined in Data.Functor.Compose Methods minBound :: Compose f g a # maxBound :: Compose f g a #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a, b, c, d, e) | @since base-2.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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) #

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

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