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

Safe HaskellTrustworthy
LanguageHaskell2010

Generics.Deriving.Enum

Contents

Synopsis

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 # 
GIx Ordering # 
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 # 
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 # 
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 # 
GIx WordPtr # 
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 # 
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 # 
GIx CPtrdiff # 
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 # 
GIx CIntPtr # 
GIx CUIntPtr # 
GIx CIntMax # 
GIx CUIntMax # 
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 # 
(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) # 
(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 #