relude-1.2.2.0: Safe, performant, user-friendly and lightweight Haskell Standard Library
Copyright(c) 2021-2023 Kowainik
LicenseMIT
MaintainerKowainik <xrom.xkov@gmail.com>
StabilityStable
PortabilityPortable
Safe HaskellSafe
LanguageHaskell2010

Relude.Enum

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

Useful combinators for Enums

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

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 Source #

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 Source #

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 #

Minimal complete definition

toEnum, fromEnum

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

Instances

Instances details
Enum CBool 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

Defined in GHC.IO.IOMode

Enum Int16 
Instance details

Defined in GHC.Int

Enum Int32 
Instance details

Defined in GHC.Int

Enum Int64 
Instance details

Defined in GHC.Int

Enum Int8 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

Defined in GHC.Word

Enum Word32 
Instance details

Defined in GHC.Word

Enum Word64 
Instance details

Defined in GHC.Word

Enum Word8 
Instance details

Defined in GHC.Word

Enum CBlkCnt 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 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 Ordering 
Instance details

Defined in GHC.Enum

Enum Undefined Source # 
Instance details

Defined in Relude.Debug

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 
Instance details

Defined in GHC.Enum

Enum Natural 
Instance details

Defined in GHC.Enum

Enum () 
Instance details

Defined in GHC.Enum

Methods

succ :: () -> () #

pred :: () -> () #

toEnum :: Int -> () #

fromEnum :: () -> Int #

enumFrom :: () -> [()] #

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

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

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

Enum Bool 
Instance details

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 
Instance details

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 Int 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

Defined in Data.Functor.Identity

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

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) 
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) 
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) 
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) 
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) 
Instance details

Defined in Data.Semigroup

Integral a => Enum (Ratio a) 
Instance details

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 (Solo a) 
Instance details

Defined in GHC.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) 
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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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

Enum (f (g a)) => Enum (Compose f g a) 
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 #

Methods

minBound :: a #

maxBound :: a #

Instances

Instances details
Bounded All 
Instance details

Defined in Data.Semigroup.Internal

Methods

minBound :: All #

maxBound :: All #

Bounded Any 
Instance details

Defined in Data.Semigroup.Internal

Methods

minBound :: Any #

maxBound :: Any #

Bounded CBool 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CBool #

maxBound :: CBool #

Bounded CChar 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CChar #

maxBound :: CChar #

Bounded CInt 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CInt #

maxBound :: CInt #

Bounded CIntMax 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CIntMax #

maxBound :: CIntMax #

Bounded CIntPtr 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CIntPtr #

maxBound :: CIntPtr #

Bounded CLLong 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CLLong #

maxBound :: CLLong #

Bounded CLong 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CLong #

maxBound :: CLong #

Bounded CPtrdiff 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CPtrdiff #

maxBound :: CPtrdiff #

Bounded CSChar 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CSChar #

maxBound :: CSChar #

Bounded CShort 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CShort #

maxBound :: CShort #

Bounded CSigAtomic 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CSigAtomic #

maxBound :: CSigAtomic #

Bounded CSize 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CSize #

maxBound :: CSize #

Bounded CUChar 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CUChar #

maxBound :: CUChar #

Bounded CUInt 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CUInt #

maxBound :: CUInt #

Bounded CUIntMax 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CUIntMax #

maxBound :: CUIntMax #

Bounded CUIntPtr 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CUIntPtr #

maxBound :: CUIntPtr #

Bounded CULLong 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CULLong #

maxBound :: CULLong #

Bounded CULong 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CULong #

maxBound :: CULong #

Bounded CUShort 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CUShort #

maxBound :: CUShort #

Bounded CWchar 
Instance details

Defined in Foreign.C.Types

Methods

minBound :: CWchar #

maxBound :: CWchar #

Bounded IntPtr 
Instance details

Defined in Foreign.Ptr

Methods

minBound :: IntPtr #

maxBound :: IntPtr #

Bounded WordPtr 
Instance details

Defined in Foreign.Ptr

Methods

minBound :: WordPtr #

maxBound :: WordPtr #

Bounded ByteOrder 
Instance details

Defined in GHC.ByteOrder

Methods

minBound :: ByteOrder #

maxBound :: ByteOrder #

Bounded Associativity 
Instance details

Defined in GHC.Generics

Methods

minBound :: Associativity #

maxBound :: Associativity #

Bounded DecidedStrictness 
Instance details

Defined in GHC.Generics

Methods

minBound :: DecidedStrictness #

maxBound :: DecidedStrictness #

Bounded SourceStrictness 
Instance details

Defined in GHC.Generics

Methods

minBound :: SourceStrictness #

maxBound :: SourceStrictness #

Bounded SourceUnpackedness 
Instance details

Defined in GHC.Generics

Methods

minBound :: SourceUnpackedness #

maxBound :: SourceUnpackedness #

Bounded Int16 
Instance details

Defined in GHC.Int

Bounded Int32 
Instance details

Defined in GHC.Int

Bounded Int64 
Instance details

Defined in GHC.Int

Bounded Int8 
Instance details

Defined in GHC.Int

Bounded GeneralCategory 
Instance details

Defined in GHC.Unicode

Methods

minBound :: GeneralCategory #

maxBound :: GeneralCategory #

Bounded Word16 
Instance details

Defined in GHC.Word

Bounded Word32 
Instance details

Defined in GHC.Word

Bounded Word64 
Instance details

Defined in GHC.Word

Bounded Word8 
Instance details

Defined in GHC.Word

Bounded CBlkCnt 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CBlkCnt #

maxBound :: CBlkCnt #

Bounded CBlkSize 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CBlkSize #

maxBound :: CBlkSize #

Bounded CClockId 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CClockId #

maxBound :: CClockId #

Bounded CDev 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CDev #

maxBound :: CDev #

Bounded CFsBlkCnt 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CFsBlkCnt #

maxBound :: CFsBlkCnt #

Bounded CFsFilCnt 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CFsFilCnt #

maxBound :: CFsFilCnt #

Bounded CGid 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CGid #

maxBound :: CGid #

Bounded CId 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CId #

maxBound :: CId #

Bounded CIno 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CIno #

maxBound :: CIno #

Bounded CKey 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CKey #

maxBound :: CKey #

Bounded CMode 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CMode #

maxBound :: CMode #

Bounded CNfds 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CNfds #

maxBound :: CNfds #

Bounded CNlink 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CNlink #

maxBound :: CNlink #

Bounded COff 
Instance details

Defined in System.Posix.Types

Methods

minBound :: COff #

maxBound :: COff #

Bounded CPid 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CPid #

maxBound :: CPid #

Bounded CRLim 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CRLim #

maxBound :: CRLim #

Bounded CSocklen 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CSocklen #

maxBound :: CSocklen #

Bounded CSsize 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CSsize #

maxBound :: CSsize #

Bounded CTcflag 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CTcflag #

maxBound :: CTcflag #

Bounded CUid 
Instance details

Defined in System.Posix.Types

Methods

minBound :: CUid #

maxBound :: CUid #

Bounded Fd 
Instance details

Defined in System.Posix.Types

Methods

minBound :: Fd #

maxBound :: Fd #

Bounded Extension 
Instance details

Defined in GHC.LanguageExtensions.Type

Methods

minBound :: Extension #

maxBound :: Extension #

Bounded Ordering 
Instance details

Defined in GHC.Enum

Bounded Undefined Source # 
Instance details

Defined in Relude.Debug

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 () 
Instance details

Defined in GHC.Enum

Methods

minBound :: () #

maxBound :: () #

Bounded Bool 
Instance details

Defined in GHC.Enum

Bounded Char 
Instance details

Defined in GHC.Enum

Bounded Int 
Instance details

Defined in GHC.Enum

Methods

minBound :: Int #

maxBound :: Int #

Bounded Levity 
Instance details

Defined in GHC.Enum

Methods

minBound :: Levity #

maxBound :: Levity #

Bounded VecCount 
Instance details

Defined in GHC.Enum

Methods

minBound :: VecCount #

maxBound :: VecCount #

Bounded VecElem 
Instance details

Defined in GHC.Enum

Methods

minBound :: VecElem #

maxBound :: VecElem #

Bounded Word 
Instance details

Defined in GHC.Enum

Bounded a => Bounded (And a) 
Instance details

Defined in Data.Bits

Methods

minBound :: And a #

maxBound :: And a #

Bounded a => Bounded (Iff a) 
Instance details

Defined in Data.Bits

Methods

minBound :: Iff a #

maxBound :: Iff a #

Bounded a => Bounded (Ior a) 
Instance details

Defined in Data.Bits

Methods

minBound :: Ior a #

maxBound :: Ior a #

Bounded a => Bounded (Xor a) 
Instance details

Defined in Data.Bits

Methods

minBound :: Xor a #

maxBound :: Xor a #

Bounded a => Bounded (Identity a) 
Instance details

Defined in Data.Functor.Identity

Bounded a => Bounded (Down a) 
Instance details

Defined in Data.Ord

Methods

minBound :: Down a #

maxBound :: Down a #

Bounded a => Bounded (First a) 
Instance details

Defined in Data.Semigroup

Methods

minBound :: First a #

maxBound :: First a #

Bounded a => Bounded (Last a) 
Instance details

Defined in Data.Semigroup

Methods

minBound :: Last a #

maxBound :: Last a #

Bounded a => Bounded (Max a) 
Instance details

Defined in Data.Semigroup

Methods

minBound :: Max a #

maxBound :: Max a #

Bounded a => Bounded (Min a) 
Instance details

Defined in Data.Semigroup

Methods

minBound :: Min a #

maxBound :: Min a #

Bounded m => Bounded (WrappedMonoid m) 
Instance details

Defined in Data.Semigroup

Bounded a => Bounded (Dual a) 
Instance details

Defined in Data.Semigroup.Internal

Methods

minBound :: Dual a #

maxBound :: Dual a #

Bounded a => Bounded (Product a) 
Instance details

Defined in Data.Semigroup.Internal

Bounded a => Bounded (Sum a) 
Instance details

Defined in Data.Semigroup.Internal

Methods

minBound :: Sum a #

maxBound :: Sum a #

Bounded a => Bounded (Solo a) 
Instance details

Defined in GHC.Enum

Methods

minBound :: Solo a #

maxBound :: Solo a #

Bounded (Proxy t) 
Instance details

Defined in Data.Proxy

Methods

minBound :: Proxy t #

maxBound :: Proxy t #

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

Defined in GHC.Enum

Methods

minBound :: (a, b) #

maxBound :: (a, b) #

Bounded a => Bounded (Const a b) 
Instance details

Defined in Data.Functor.Const

Methods

minBound :: Const a b #

maxBound :: Const a b #

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

Defined in Data.Monoid

Methods

minBound :: Ap f a #

maxBound :: Ap f a #

Coercible a b => Bounded (Coercion a b) 
Instance details

Defined in Data.Type.Coercion

Methods

minBound :: Coercion a b #

maxBound :: Coercion a b #

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

Defined in Data.Type.Equality

Methods

minBound :: a :~: b #

maxBound :: a :~: b #

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

Defined in GHC.Enum

Methods

minBound :: (a, b, c) #

maxBound :: (a, b, c) #

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

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) 
Instance details

Defined in GHC.Enum

Methods

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

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

Bounded (f (g a)) => Bounded (Compose f g a) 
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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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

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

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