Generics.Deriving.Enum

Generic enum class

class GEnum a where

Methods

genum :: [a]

genum :: (Generic a, Enum' (Rep a)) => [a]

Instances

GEnum Bool

Methods

genum :: [Bool]

GEnum Double

Methods

genum :: [Double]

GEnum Float

Methods

genum :: [Float]

GEnum Int

Methods

genum :: [Int]

GEnum Int8

Methods

genum :: [Int8]

GEnum Int16

Methods

genum :: [Int16]

GEnum Int32

Methods

genum :: [Int32]

GEnum Int64

Methods

genum :: [Int64]

GEnum Integer

Methods

genum :: [Integer]

GEnum Natural

Methods

genum :: [Natural]

GEnum Ordering

Methods

genum :: [Ordering]

GEnum Word

Methods

genum :: [Word]

GEnum Word8

Methods

genum :: [Word8]

GEnum Word16

Methods

genum :: [Word16]

GEnum Word32

Methods

genum :: [Word32]

GEnum Word64

Methods

genum :: [Word64]

GEnum ()

Methods

genum :: [()]

GEnum CDev

Methods

genum :: [CDev]

GEnum CIno

Methods

genum :: [CIno]

GEnum CMode

Methods

genum :: [CMode]

GEnum COff

Methods

genum :: [COff]

GEnum CPid

Methods

genum :: [CPid]

GEnum CSsize

Methods

genum :: [CSsize]

GEnum CGid

Methods

genum :: [CGid]

GEnum CNlink

Methods

genum :: [CNlink]

GEnum CUid

Methods

genum :: [CUid]

GEnum CCc

Methods

genum :: [CCc]

GEnum CSpeed

Methods

genum :: [CSpeed]

GEnum CTcflag

Methods

genum :: [CTcflag]

GEnum CRLim

Methods

genum :: [CRLim]

GEnum CBlkSize

Methods

genum :: [CBlkSize]

GEnum CBlkCnt

Methods

genum :: [CBlkCnt]

GEnum CClockId

Methods

genum :: [CClockId]

GEnum CFsBlkCnt

Methods

genum :: [CFsBlkCnt]

GEnum CFsFilCnt

Methods

genum :: [CFsFilCnt]

GEnum CId

Methods

genum :: [CId]

GEnum CKey

Methods

genum :: [CKey]

GEnum Fd

Methods

genum :: [Fd]

GEnum ExitCode

Methods

genum :: [ExitCode]

GEnum All

Methods

genum :: [All]

GEnum Any

Methods

genum :: [Any]

GEnum Fixity

Methods

genum :: [Fixity]

GEnum Associativity

Methods

genum :: [Associativity]

GEnum CChar

Methods

genum :: [CChar]

GEnum CSChar

Methods

genum :: [CSChar]

GEnum CUChar

Methods

genum :: [CUChar]

GEnum CShort

Methods

genum :: [CShort]

GEnum CUShort

Methods

genum :: [CUShort]

GEnum CInt

Methods

genum :: [CInt]

GEnum CUInt

Methods

genum :: [CUInt]

GEnum CLong

Methods

genum :: [CLong]

GEnum CULong

Methods

genum :: [CULong]

GEnum CLLong

Methods

genum :: [CLLong]

GEnum CULLong

Methods

genum :: [CULLong]

GEnum CBool

Methods

genum :: [CBool]

GEnum CFloat

Methods

genum :: [CFloat]

GEnum CDouble

Methods

genum :: [CDouble]

GEnum CPtrdiff

Methods

genum :: [CPtrdiff]

GEnum CSize

Methods

genum :: [CSize]

GEnum CWchar

Methods

genum :: [CWchar]

GEnum CSigAtomic

Methods

genum :: [CSigAtomic]

GEnum CClock

Methods

genum :: [CClock]

GEnum CTime

Methods

genum :: [CTime]

GEnum CUSeconds

Methods

genum :: [CUSeconds]

GEnum CSUSeconds

Methods

genum :: [CSUSeconds]

GEnum CIntPtr

Methods

genum :: [CIntPtr]

GEnum CUIntPtr

Methods

genum :: [CUIntPtr]

GEnum CIntMax

Methods

genum :: [CIntMax]

GEnum CUIntMax

Methods

genum :: [CUIntMax]

GEnum WordPtr

Methods

genum :: [WordPtr]

GEnum IntPtr

Methods

genum :: [IntPtr]

GEnum a => GEnum [a]

Methods

genum :: [[a]]

GEnum a => GEnum (Maybe a)

Methods

genum :: [Maybe a]

GEnum p => GEnum (Par1 p)

Methods

genum :: [Par1 p]

GEnum a => GEnum (Complex a)

Methods

genum :: [Complex a]

GEnum a => GEnum (Min a)

Methods

genum :: [Min a]

GEnum a => GEnum (Max a)

Methods

genum :: [Max a]

GEnum a => GEnum (First a)

Methods

genum :: [First a]

GEnum a => GEnum (Last a)

Methods

genum :: [Last a]

GEnum m => GEnum (WrappedMonoid m)

Methods

genum :: [WrappedMonoid m]

GEnum a => GEnum (Option a)

Methods

genum :: [Option a]

GEnum a => GEnum (NonEmpty a)

Methods

genum :: [NonEmpty a]

GEnum a => GEnum (ZipList a)

Methods

genum :: [ZipList a]

GEnum a => GEnum (Identity a)

Methods

genum :: [Identity a]

GEnum a => GEnum (Dual a)

Methods

genum :: [Dual a]

GEnum a => GEnum (Sum a)

Methods

genum :: [Sum a]

GEnum a => GEnum (Product a)

Methods

genum :: [Product a]

GEnum a => GEnum (First a)

Methods

genum :: [First a]

GEnum a => GEnum (Last a)

Methods

genum :: [Last a]

(GEnum a, GEnum b) => GEnum (Either a b)

Methods

genum :: [Either a b]

GEnum (U1 k p)

Methods

genum :: [U1 k p]

(GEnum a, GEnum b) => GEnum (a, b)

Methods

genum :: [(a, b)]

(GEnum a, GEnum b) => GEnum (Arg a b)

Methods

genum :: [Arg a b]

GEnum (Proxy k s)

Methods

genum :: [Proxy k s]

GEnum (f p) => GEnum (Rec1 k f p)

Methods

genum :: [Rec1 k f p]

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

Methods

genum :: [(a, b, c)]

GEnum a => GEnum (Const k a b)

Methods

genum :: [Const k a b]

GEnum (f a) => GEnum (Alt k f a)

Methods

genum :: [Alt k f a]

GEnum c => GEnum (K1 k i c p)

Methods

genum :: [K1 k i c p]

(GEnum (f p), GEnum (g p)) => GEnum ((:+:) k f g p)

Methods

genum :: [(k :+: f) g p]

(GEnum (f p), GEnum (g p)) => GEnum ((:*:) k f g p)

Methods

genum :: [(k :*: f) g p]

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

Methods

genum :: [(a, b, c, d)]

GEnum (f p) => GEnum (M1 k i c f p)

Methods

genum :: [M1 k i c f p]

GEnum (f (g p)) => GEnum ((:.:) k2 k1 f g p)

Methods

genum :: [(k2 :.: k1) f g p]

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

Methods

genum :: [(a, b, c, d, e)]

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

Methods

genum :: [(a, b, c, d, e, f)]

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

Methods

genum :: [(a, b, c, d, e, f, g)]

Default definitions for GEnum

genumDefault :: (Generic a, Enum' (Rep a)) => [a]

toEnumDefault :: (Generic a, Enum' (Rep a)) => Int -> a

fromEnumDefault :: (GEq a, Generic a, Enum' (Rep a)) => a -> Int

Internal enum class

class Enum' f where

Minimal complete definition

enum'

Methods

enum' :: [f a]

Instances

Enum' k (U1 k)

Methods

enum' :: [f a]

(Enum' k f, Enum' k g) => Enum' k ((:*:) k f g)

Methods

enum' :: [f a]

(Enum' k f, Enum' k g) => Enum' k ((:+:) k f g)

Methods

enum' :: [f a]

GEnum c => Enum' k (K1 k i c)

Methods

enum' :: [f a]

Enum' k f => Enum' k (M1 k i c f)

Methods

enum' :: [f a]

Generic Ix class

class Ord a => GIx a where

Methods

range :: (a, a) -> [a]

The list of values in the subrange defined by a bounding pair.

index :: (a, a) -> a -> Int

The position of a subscript in the subrange.

inRange :: (a, a) -> a -> Bool

Returns True the given subscript lies in the range defined the bounding pair.

range :: (GEq a, Generic a, Enum' (Rep a)) => (a, a) -> [a]

The list of values in the subrange defined by a bounding pair.

index :: (GEq a, Generic a, Enum' (Rep a)) => (a, a) -> a -> Int

The position of a subscript in the subrange.

inRange :: (GEq a, Generic a, Enum' (Rep a)) => (a, a) -> a -> Bool

Returns True the given subscript lies in the range defined the bounding pair.

Instances

GIx Bool

Methods

range :: (Bool, Bool) -> [Bool]

index :: (Bool, Bool) -> Bool -> Int

inRange :: (Bool, Bool) -> Bool -> Bool

GIx Int

Methods

range :: (Int, Int) -> [Int]

index :: (Int, Int) -> Int -> Int

inRange :: (Int, Int) -> Int -> Bool

GIx Int8

Methods

range :: (Int8, Int8) -> [Int8]

index :: (Int8, Int8) -> Int8 -> Int

inRange :: (Int8, Int8) -> Int8 -> Bool

GIx Int16

Methods

range :: (Int16, Int16) -> [Int16]

index :: (Int16, Int16) -> Int16 -> Int

inRange :: (Int16, Int16) -> Int16 -> Bool

GIx Int32

Methods

range :: (Int32, Int32) -> [Int32]

index :: (Int32, Int32) -> Int32 -> Int

inRange :: (Int32, Int32) -> Int32 -> Bool

GIx Int64

Methods

range :: (Int64, Int64) -> [Int64]

index :: (Int64, Int64) -> Int64 -> Int

inRange :: (Int64, Int64) -> Int64 -> Bool

GIx Integer

Methods

range :: (Integer, Integer) -> [Integer]

index :: (Integer, Integer) -> Integer -> Int

inRange :: (Integer, Integer) -> Integer -> Bool

GIx Natural

Methods

range :: (Natural, Natural) -> [Natural]

index :: (Natural, Natural) -> Natural -> Int

inRange :: (Natural, Natural) -> Natural -> Bool

GIx Ordering

Methods

range :: (Ordering, Ordering) -> [Ordering]

index :: (Ordering, Ordering) -> Ordering -> Int

inRange :: (Ordering, Ordering) -> Ordering -> Bool

GIx Word

Methods

range :: (Word, Word) -> [Word]

index :: (Word, Word) -> Word -> Int

inRange :: (Word, Word) -> Word -> Bool

GIx Word8

Methods

range :: (Word8, Word8) -> [Word8]

index :: (Word8, Word8) -> Word8 -> Int

inRange :: (Word8, Word8) -> Word8 -> Bool

GIx Word16

Methods

range :: (Word16, Word16) -> [Word16]

index :: (Word16, Word16) -> Word16 -> Int

inRange :: (Word16, Word16) -> Word16 -> Bool

GIx Word32

Methods

range :: (Word32, Word32) -> [Word32]

index :: (Word32, Word32) -> Word32 -> Int

inRange :: (Word32, Word32) -> Word32 -> Bool

GIx Word64

Methods

range :: (Word64, Word64) -> [Word64]

index :: (Word64, Word64) -> Word64 -> Int

inRange :: (Word64, Word64) -> Word64 -> Bool

GIx ()

Methods

range :: ((), ()) -> [()]

index :: ((), ()) -> () -> Int

inRange :: ((), ()) -> () -> Bool

GIx CIno

Methods

range :: (CIno, CIno) -> [CIno]

index :: (CIno, CIno) -> CIno -> Int

inRange :: (CIno, CIno) -> CIno -> Bool

GIx CMode

Methods

range :: (CMode, CMode) -> [CMode]

index :: (CMode, CMode) -> CMode -> Int

inRange :: (CMode, CMode) -> CMode -> Bool

GIx COff

Methods

range :: (COff, COff) -> [COff]

index :: (COff, COff) -> COff -> Int

inRange :: (COff, COff) -> COff -> Bool

GIx CPid

Methods

range :: (CPid, CPid) -> [CPid]

index :: (CPid, CPid) -> CPid -> Int

inRange :: (CPid, CPid) -> CPid -> Bool

GIx CSsize

Methods

range :: (CSsize, CSsize) -> [CSsize]

index :: (CSsize, CSsize) -> CSsize -> Int

inRange :: (CSsize, CSsize) -> CSsize -> Bool

GIx CGid

Methods

range :: (CGid, CGid) -> [CGid]

index :: (CGid, CGid) -> CGid -> Int

inRange :: (CGid, CGid) -> CGid -> Bool

GIx CNlink

Methods

range :: (CNlink, CNlink) -> [CNlink]

index :: (CNlink, CNlink) -> CNlink -> Int

inRange :: (CNlink, CNlink) -> CNlink -> Bool

GIx CUid

Methods

range :: (CUid, CUid) -> [CUid]

index :: (CUid, CUid) -> CUid -> Int

inRange :: (CUid, CUid) -> CUid -> Bool

GIx CTcflag

Methods

range :: (CTcflag, CTcflag) -> [CTcflag]

index :: (CTcflag, CTcflag) -> CTcflag -> Int

inRange :: (CTcflag, CTcflag) -> CTcflag -> Bool

GIx CRLim

Methods

range :: (CRLim, CRLim) -> [CRLim]

index :: (CRLim, CRLim) -> CRLim -> Int

inRange :: (CRLim, CRLim) -> CRLim -> Bool

GIx CBlkSize

Methods

range :: (CBlkSize, CBlkSize) -> [CBlkSize]

index :: (CBlkSize, CBlkSize) -> CBlkSize -> Int

inRange :: (CBlkSize, CBlkSize) -> CBlkSize -> Bool

GIx CBlkCnt

Methods

range :: (CBlkCnt, CBlkCnt) -> [CBlkCnt]

index :: (CBlkCnt, CBlkCnt) -> CBlkCnt -> Int

inRange :: (CBlkCnt, CBlkCnt) -> CBlkCnt -> Bool

GIx CClockId

Methods

range :: (CClockId, CClockId) -> [CClockId]

index :: (CClockId, CClockId) -> CClockId -> Int

inRange :: (CClockId, CClockId) -> CClockId -> Bool

GIx CFsBlkCnt

Methods

range :: (CFsBlkCnt, CFsBlkCnt) -> [CFsBlkCnt]

index :: (CFsBlkCnt, CFsBlkCnt) -> CFsBlkCnt -> Int

inRange :: (CFsBlkCnt, CFsBlkCnt) -> CFsBlkCnt -> Bool

GIx CFsFilCnt

Methods

range :: (CFsFilCnt, CFsFilCnt) -> [CFsFilCnt]

index :: (CFsFilCnt, CFsFilCnt) -> CFsFilCnt -> Int

inRange :: (CFsFilCnt, CFsFilCnt) -> CFsFilCnt -> Bool

GIx CId

Methods

range :: (CId, CId) -> [CId]

index :: (CId, CId) -> CId -> Int

inRange :: (CId, CId) -> CId -> Bool

GIx CKey

Methods

range :: (CKey, CKey) -> [CKey]

index :: (CKey, CKey) -> CKey -> Int

inRange :: (CKey, CKey) -> CKey -> Bool

GIx Fd

Methods

range :: (Fd, Fd) -> [Fd]

index :: (Fd, Fd) -> Fd -> Int

inRange :: (Fd, Fd) -> Fd -> Bool

GIx ExitCode

Methods

range :: (ExitCode, ExitCode) -> [ExitCode]

index :: (ExitCode, ExitCode) -> ExitCode -> Int

inRange :: (ExitCode, ExitCode) -> ExitCode -> Bool

GIx All

Methods

range :: (All, All) -> [All]

index :: (All, All) -> All -> Int

inRange :: (All, All) -> All -> Bool

GIx Any

Methods

range :: (Any, Any) -> [Any]

index :: (Any, Any) -> Any -> Int

inRange :: (Any, Any) -> Any -> Bool

GIx Fixity

Methods

range :: (Fixity, Fixity) -> [Fixity]

index :: (Fixity, Fixity) -> Fixity -> Int

inRange :: (Fixity, Fixity) -> Fixity -> Bool

GIx Associativity

Methods

range :: (Associativity, Associativity) -> [Associativity]

index :: (Associativity, Associativity) -> Associativity -> Int

inRange :: (Associativity, Associativity) -> Associativity -> Bool

GIx CChar

Methods

range :: (CChar, CChar) -> [CChar]

index :: (CChar, CChar) -> CChar -> Int

inRange :: (CChar, CChar) -> CChar -> Bool

GIx CSChar

Methods

range :: (CSChar, CSChar) -> [CSChar]

index :: (CSChar, CSChar) -> CSChar -> Int

inRange :: (CSChar, CSChar) -> CSChar -> Bool

GIx CUChar

Methods

range :: (CUChar, CUChar) -> [CUChar]

index :: (CUChar, CUChar) -> CUChar -> Int

inRange :: (CUChar, CUChar) -> CUChar -> Bool

GIx CShort

Methods

range :: (CShort, CShort) -> [CShort]

index :: (CShort, CShort) -> CShort -> Int

inRange :: (CShort, CShort) -> CShort -> Bool

GIx CUShort

Methods

range :: (CUShort, CUShort) -> [CUShort]

index :: (CUShort, CUShort) -> CUShort -> Int

inRange :: (CUShort, CUShort) -> CUShort -> Bool

GIx CInt

Methods

range :: (CInt, CInt) -> [CInt]

index :: (CInt, CInt) -> CInt -> Int

inRange :: (CInt, CInt) -> CInt -> Bool

GIx CUInt

Methods

range :: (CUInt, CUInt) -> [CUInt]

index :: (CUInt, CUInt) -> CUInt -> Int

inRange :: (CUInt, CUInt) -> CUInt -> Bool

GIx CLong

Methods

range :: (CLong, CLong) -> [CLong]

index :: (CLong, CLong) -> CLong -> Int

inRange :: (CLong, CLong) -> CLong -> Bool

GIx CULong

Methods

range :: (CULong, CULong) -> [CULong]

index :: (CULong, CULong) -> CULong -> Int

inRange :: (CULong, CULong) -> CULong -> Bool

GIx CLLong

Methods

range :: (CLLong, CLLong) -> [CLLong]

index :: (CLLong, CLLong) -> CLLong -> Int

inRange :: (CLLong, CLLong) -> CLLong -> Bool

GIx CULLong

Methods

range :: (CULLong, CULLong) -> [CULLong]

index :: (CULLong, CULLong) -> CULLong -> Int

inRange :: (CULLong, CULLong) -> CULLong -> Bool

GIx CBool

Methods

range :: (CBool, CBool) -> [CBool]

index :: (CBool, CBool) -> CBool -> Int

inRange :: (CBool, CBool) -> CBool -> Bool

GIx CPtrdiff

Methods

range :: (CPtrdiff, CPtrdiff) -> [CPtrdiff]

index :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> Int

inRange :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> Bool

GIx CSize

Methods

range :: (CSize, CSize) -> [CSize]

index :: (CSize, CSize) -> CSize -> Int

inRange :: (CSize, CSize) -> CSize -> Bool

GIx CWchar

Methods

range :: (CWchar, CWchar) -> [CWchar]

index :: (CWchar, CWchar) -> CWchar -> Int

inRange :: (CWchar, CWchar) -> CWchar -> Bool

GIx CSigAtomic

Methods

range :: (CSigAtomic, CSigAtomic) -> [CSigAtomic]

index :: (CSigAtomic, CSigAtomic) -> CSigAtomic -> Int

inRange :: (CSigAtomic, CSigAtomic) -> CSigAtomic -> Bool

GIx CIntPtr

Methods

range :: (CIntPtr, CIntPtr) -> [CIntPtr]

index :: (CIntPtr, CIntPtr) -> CIntPtr -> Int

inRange :: (CIntPtr, CIntPtr) -> CIntPtr -> Bool

GIx CUIntPtr

Methods

range :: (CUIntPtr, CUIntPtr) -> [CUIntPtr]

index :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Int

inRange :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Bool

GIx CIntMax

Methods

range :: (CIntMax, CIntMax) -> [CIntMax]

index :: (CIntMax, CIntMax) -> CIntMax -> Int

inRange :: (CIntMax, CIntMax) -> CIntMax -> Bool

GIx CUIntMax

Methods

range :: (CUIntMax, CUIntMax) -> [CUIntMax]

index :: (CUIntMax, CUIntMax) -> CUIntMax -> Int

inRange :: (CUIntMax, CUIntMax) -> CUIntMax -> Bool

GIx WordPtr

Methods

range :: (WordPtr, WordPtr) -> [WordPtr]

index :: (WordPtr, WordPtr) -> WordPtr -> Int

inRange :: (WordPtr, WordPtr) -> WordPtr -> Bool

GIx IntPtr

Methods

range :: (IntPtr, IntPtr) -> [IntPtr]

index :: (IntPtr, IntPtr) -> IntPtr -> Int

inRange :: (IntPtr, IntPtr) -> IntPtr -> Bool

(GEq a, GEnum a, GIx a) => GIx [a]

Methods

range :: ([a], [a]) -> [[a]]

index :: ([a], [a]) -> [a] -> Int

inRange :: ([a], [a]) -> [a] -> Bool

(GEq a, GEnum a, GIx a) => GIx (Maybe a)

Methods

range :: (Maybe a, Maybe a) -> [Maybe a]

index :: (Maybe a, Maybe a) -> Maybe a -> Int

inRange :: (Maybe a, Maybe a) -> Maybe a -> Bool

(GEq a, GEnum a, GIx a) => GIx (Min a)

Methods

range :: (Min a, Min a) -> [Min a]

index :: (Min a, Min a) -> Min a -> Int

inRange :: (Min a, Min a) -> Min a -> Bool

(GEq a, GEnum a, GIx a) => GIx (Max a)

Methods

range :: (Max a, Max a) -> [Max a]

index :: (Max a, Max a) -> Max a -> Int

inRange :: (Max a, Max a) -> Max a -> Bool

(GEq a, GEnum a, GIx a) => GIx (First a)

Methods

range :: (First a, First a) -> [First a]

index :: (First a, First a) -> First a -> Int

inRange :: (First a, First a) -> First a -> Bool

(GEq a, GEnum a, GIx a) => GIx (Last a)

Methods

range :: (Last a, Last a) -> [Last a]

index :: (Last a, Last a) -> Last a -> Int

inRange :: (Last a, Last a) -> Last a -> Bool

(GEq m, GEnum m, GIx m) => GIx (WrappedMonoid m)

Methods

range :: (WrappedMonoid m, WrappedMonoid m) -> [WrappedMonoid m]

index :: (WrappedMonoid m, WrappedMonoid m) -> WrappedMonoid m -> Int

inRange :: (WrappedMonoid m, WrappedMonoid m) -> WrappedMonoid m -> Bool

(GEq a, GEnum a, GIx a) => GIx (Option a)

Methods

range :: (Option a, Option a) -> [Option a]

index :: (Option a, Option a) -> Option a -> Int

inRange :: (Option a, Option a) -> Option a -> Bool

(GEq a, GEnum a, GIx a) => GIx (NonEmpty a)

Methods

range :: (NonEmpty a, NonEmpty a) -> [NonEmpty a]

index :: (NonEmpty a, NonEmpty a) -> NonEmpty a -> Int

inRange :: (NonEmpty a, NonEmpty a) -> NonEmpty a -> Bool

(GEq a, GEnum a, GIx a) => GIx (Identity a)

Methods

range :: (Identity a, Identity a) -> [Identity a]

index :: (Identity a, Identity a) -> Identity a -> Int

inRange :: (Identity a, Identity a) -> Identity a -> Bool

(GEq a, GEnum a, GIx a) => GIx (Dual a)

Methods

range :: (Dual a, Dual a) -> [Dual a]

index :: (Dual a, Dual a) -> Dual a -> Int

inRange :: (Dual a, Dual a) -> Dual a -> Bool

(GEq a, GEnum a, GIx a) => GIx (Sum a)

Methods

range :: (Sum a, Sum a) -> [Sum a]

index :: (Sum a, Sum a) -> Sum a -> Int

inRange :: (Sum a, Sum a) -> Sum a -> Bool

(GEq a, GEnum a, GIx a) => GIx (Product a)

Methods

range :: (Product a, Product a) -> [Product a]

index :: (Product a, Product a) -> Product a -> Int

inRange :: (Product a, Product a) -> Product a -> Bool

(GEq a, GEnum a, GIx a) => GIx (First a)

Methods

range :: (First a, First a) -> [First a]

index :: (First a, First a) -> First a -> Int

inRange :: (First a, First a) -> First a -> Bool

(GEq a, GEnum a, GIx a) => GIx (Last a)

Methods

range :: (Last a, Last a) -> [Last a]

index :: (Last a, Last a) -> Last a -> Int

inRange :: (Last a, Last a) -> Last a -> Bool

(GEq a, GEnum a, GIx a, GEq b, GEnum b, GIx b) => GIx (Either a b)

Methods

range :: (Either a b, Either a b) -> [Either a b]

index :: (Either a b, Either a b) -> Either a b -> Int

inRange :: (Either a b, Either a b) -> Either a b -> Bool

(GEq a, GEnum a, GIx a, GEq b, GEnum b, GIx b) => GIx (a, b)

Methods

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

index :: ((a, b), (a, b)) -> (a, b) -> Int

inRange :: ((a, b), (a, b)) -> (a, b) -> Bool

(GEq a, GEnum a, GIx a, GEnum b) => GIx (Arg a b)

Methods

range :: (Arg a b, Arg a b) -> [Arg a b]

index :: (Arg a b, Arg a b) -> Arg a b -> Int

inRange :: (Arg a b, Arg a b) -> Arg a b -> Bool

GIx (Proxy k s)

Methods

range :: (Proxy k s, Proxy k s) -> [Proxy k s]

index :: (Proxy k s, Proxy k s) -> Proxy k s -> Int

inRange :: (Proxy k s, Proxy k s) -> Proxy k s -> Bool

(GEq a, GEnum a, GIx a, GEq b, GEnum b, GIx b, GEq c, GEnum c, GIx c) => GIx (a, b, c)

Methods

range :: ((a, b, c), (a, b, c)) -> [(a, b, c)]

index :: ((a, b, c), (a, b, c)) -> (a, b, c) -> Int

inRange :: ((a, b, c), (a, b, c)) -> (a, b, c) -> Bool

(GEq (f a), GEnum (f a), GIx (f a)) => GIx (Alt k f a)

Methods

range :: (Alt k f a, Alt k f a) -> [Alt k f a]

index :: (Alt k f a, Alt k f a) -> Alt k f a -> Int

inRange :: (Alt k f a, Alt k f a) -> Alt k f a -> Bool

(GEq a, GEnum a, GIx a, GEq b, GEnum b, GIx b, GEq c, GEnum c, GIx c, GEq d, GEnum d, GIx d) => GIx (a, b, c, d)

Methods

range :: ((a, b, c, d), (a, b, c, d)) -> [(a, b, c, d)]

index :: ((a, b, c, d), (a, b, c, d)) -> (a, b, c, d) -> Int

inRange :: ((a, b, c, d), (a, b, c, d)) -> (a, b, c, d) -> Bool

(GEq a, GEnum a, GIx a, GEq b, GEnum b, GIx b, GEq c, GEnum c, GIx c, GEq d, GEnum d, GIx d, GEq e, GEnum e, GIx e) => GIx (a, b, c, d, e)

Methods

range :: ((a, b, c, d, e), (a, b, c, d, e)) -> [(a, b, c, d, e)]

index :: ((a, b, c, d, e), (a, b, c, d, e)) -> (a, b, c, d, e) -> Int

inRange :: ((a, b, c, d, e), (a, b, c, d, e)) -> (a, b, c, d, e) -> Bool

(GEq a, GEnum a, GIx a, GEq b, GEnum b, GIx b, GEq c, GEnum c, GIx c, GEq d, GEnum d, GIx d, GEq e, GEnum e, GIx e, GEq f, GEnum f, GIx f) => GIx (a, b, c, d, e, f)

Methods

range :: ((a, b, c, d, e, f), (a, b, c, d, e, f)) -> [(a, b, c, d, e, f)]

index :: ((a, b, c, d, e, f), (a, b, c, d, e, f)) -> (a, b, c, d, e, f) -> Int

inRange :: ((a, b, c, d, e, f), (a, b, c, d, e, f)) -> (a, b, c, d, e, f) -> Bool

(GEq a, GEnum a, GIx a, GEq b, GEnum b, GIx b, GEq c, GEnum c, GIx c, GEq d, GEnum d, GIx d, GEq e, GEnum e, GIx e, GEq f, GEnum f, GIx f, GEq g, GEnum g, GIx g) => GIx (a, b, c, d, e, f, g)

Methods

range :: ((a, b, c, d, e, f, g), (a, b, c, d, e, f, g)) -> [(a, b, c, d, e, f, g)]

index :: ((a, b, c, d, e, f, g), (a, b, c, d, e, f, g)) -> (a, b, c, d, e, f, g) -> Int

inRange :: ((a, b, c, d, e, f, g), (a, b, c, d, e, f, g)) -> (a, b, c, d, e, f, g) -> Bool

Default definitions for GIx

rangeDefault :: (GEq a, Generic a, Enum' (Rep a)) => (a, a) -> [a]

indexDefault :: (GEq a, Generic a, Enum' (Rep a)) => (a, a) -> a -> Int

inRangeDefault :: (GEq a, Generic a, Enum' (Rep a)) => (a, a) -> a -> Bool