Generics.Deriving.Enum

generic-deriving-1.11.1: Generic programming library for generalised deriving.

Safe Haskell | Trustworthy
Language | Haskell2010

Generics.Deriving.Enum

Contents

- Generic enum class
- Default definitions for GEnum
- Internal enum class
- Generic Ix class
- Default definitions for GIx

Synopsis

- class GEnum a where
- 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
- class Enum' f where
- class Ord a => GIx a where
- 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

# 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 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 Natural # |
Methods genum :: [Natural] #
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 Fd # |
Methods genum :: [Fd] #
GEnum ExitCode # |
Methods genum :: [ExitCode] #
GEnum WordPtr # |
Methods genum :: [WordPtr] #
GEnum IntPtr # |
Methods genum :: [IntPtr] #
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 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 All # |
Methods genum :: [All] #
GEnum Any # |
Methods genum :: [Any] #
GEnum Fixity # |
Methods genum :: [Fixity] #
GEnum Associativity # |
Methods genum :: [Associativity] #
GEnum a => GEnum [a] # |
Methods genum :: [[a]] #
GEnum a => GEnum (Maybe a) # |
Methods genum :: [Maybe a] #
GEnum (U1 p) # |
Methods genum :: [U1 p] #
GEnum p => GEnum (Par1 p) # |
Methods genum :: [Par1 p] #
GEnum a => GEnum (Identity a) # |
Methods genum :: [Identity 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 (Complex a) # |
Methods genum :: [Complex a] #
GEnum a => GEnum (ZipList a) # |
Methods genum :: [ZipList 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 (f p) => GEnum (Rec1 f p) # |
Methods genum :: [Rec1 f 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 c => GEnum (K1 i c p) # |
Methods genum :: [K1 i c p] #
(GEnum (f p), GEnum (g p)) => GEnum ((:+:) f g p) # |
Methods genum :: [(f :+: g) p] #
(GEnum (f p), GEnum (g p)) => GEnum ((:*:) f g p) # |
Methods genum :: [(f :*: g) p] #
GEnum (f (g p)) => GEnum ((:.:) f g p) # |
Methods genum :: [(f :.: g) 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 (f p) => GEnum (M1 i c f p) # |
Methods genum :: [M1 i c f p] #
(GEnum a, GEnum b, GEnum c, GEnum d) => GEnum (a, b, c, d) # |
Methods genum :: [(a, b, c, d)] #
(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' * U1 # |
Methods enum' :: [f a] #
GEnum c => Enum' * (K1 i c) # |
Methods enum' :: [f a] #
(Enum' * f, Enum' * g) => Enum' * ((:+:) f g) # |
Methods enum' :: [f a] #
(Enum' * f, Enum' * g) => Enum' * ((:*:) f g) # |
Methods enum' :: [f a] #
Enum' * f => Enum' * (M1 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 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 Natural # |
Methods range :: (Natural, Natural) -> [Natural] # index :: (Natural, Natural) -> Natural -> Int # inRange :: (Natural, Natural) -> Natural -> 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 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 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 #
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 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 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 #
(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 (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 (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 (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 #