Data.Ix

The Ix class is used to map a contiguous subrange of values in type onto integers. It is used primarily for array indexing (see the array package). Ix uses row-major order.

The Ix class

class Ord a => Ix a where

The Ix class is used to map a contiguous subrange of values in a type onto integers. It is used primarily for array indexing (see the array package).

The first argument (l,u) of each of these operations is a pair specifying the lower and upper bounds of a contiguous subrange of values.

An implementation is entitled to assume the following laws about these operations:

• inRange (l,u) i == elem i (range (l,u))
• range (l,u) !! index (l,u) i == i, when inRange (l,u) i
• map (index (l,u)) (range (l,u))) == [0..rangeSize (l,u)-1]
• rangeSize (l,u) == length (range (l,u))

Minimal complete definition

range, (index | unsafeIndex), inRange

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.

rangeSize :: (a, a) -> Int

The size of the subrange defined by a bounding pair.

Instances

Ix Void

Since: base-4.8.0.0

Defined in GHC.Internal.Ix

Methods

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

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

unsafeIndex :: (Void, Void) -> Void -> Int

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

rangeSize :: (Void, Void) -> Int

unsafeRangeSize :: (Void, Void) -> Int

Ix CBool

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CBool, CBool) -> Int

unsafeRangeSize :: (CBool, CBool) -> Int

Ix CChar

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CChar, CChar) -> Int

unsafeRangeSize :: (CChar, CChar) -> Int

Ix CInt

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CInt, CInt) -> Int

unsafeRangeSize :: (CInt, CInt) -> Int

Ix CIntMax

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CIntMax, CIntMax) -> Int

unsafeRangeSize :: (CIntMax, CIntMax) -> Int

Ix CIntPtr

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CIntPtr, CIntPtr) -> Int

unsafeRangeSize :: (CIntPtr, CIntPtr) -> Int

Ix CLLong

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CLLong, CLLong) -> Int

unsafeRangeSize :: (CLLong, CLLong) -> Int

Ix CLong

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CLong, CLong) -> Int

unsafeRangeSize :: (CLong, CLong) -> Int

Ix CPtrdiff

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CPtrdiff, CPtrdiff) -> Int

unsafeRangeSize :: (CPtrdiff, CPtrdiff) -> Int

Ix CSChar

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CSChar, CSChar) -> Int

unsafeRangeSize :: (CSChar, CSChar) -> Int

Ix CShort

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CShort, CShort) -> Int

unsafeRangeSize :: (CShort, CShort) -> Int

Ix CSigAtomic

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CSigAtomic, CSigAtomic) -> Int

unsafeRangeSize :: (CSigAtomic, CSigAtomic) -> Int

Ix CSize

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CSize, CSize) -> Int

unsafeRangeSize :: (CSize, CSize) -> Int

Ix CUChar

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CUChar, CUChar) -> Int

unsafeRangeSize :: (CUChar, CUChar) -> Int

Ix CUInt

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CUInt, CUInt) -> Int

unsafeRangeSize :: (CUInt, CUInt) -> Int

Ix CUIntMax

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CUIntMax, CUIntMax) -> Int

unsafeRangeSize :: (CUIntMax, CUIntMax) -> Int

Ix CUIntPtr

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CUIntPtr, CUIntPtr) -> Int

unsafeRangeSize :: (CUIntPtr, CUIntPtr) -> Int

Ix CULLong

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CULLong, CULLong) -> Int

unsafeRangeSize :: (CULLong, CULLong) -> Int

Ix CULong

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CULong, CULong) -> Int

unsafeRangeSize :: (CULong, CULong) -> Int

Ix CUShort

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CUShort, CUShort) -> Int

unsafeRangeSize :: (CUShort, CUShort) -> Int

Ix CWchar

Defined in GHC.Internal.Foreign.C.Types

Methods

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

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

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

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

rangeSize :: (CWchar, CWchar) -> Int

unsafeRangeSize :: (CWchar, CWchar) -> Int

Ix IntPtr

Defined in GHC.Internal.Foreign.Ptr

Methods

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

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

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

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

rangeSize :: (IntPtr, IntPtr) -> Int

unsafeRangeSize :: (IntPtr, IntPtr) -> Int

Ix WordPtr

Defined in GHC.Internal.Foreign.Ptr

Methods

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

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

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

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

rangeSize :: (WordPtr, WordPtr) -> Int

unsafeRangeSize :: (WordPtr, WordPtr) -> Int

Ix Associativity

Since: base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

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

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

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

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

rangeSize :: (Associativity, Associativity) -> Int

unsafeRangeSize :: (Associativity, Associativity) -> Int

Ix DecidedStrictness

Since: base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

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

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

unsafeIndex :: (DecidedStrictness, DecidedStrictness) -> DecidedStrictness -> Int

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

rangeSize :: (DecidedStrictness, DecidedStrictness) -> Int

unsafeRangeSize :: (DecidedStrictness, DecidedStrictness) -> Int

Ix SourceStrictness

Since: base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

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

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

unsafeIndex :: (SourceStrictness, SourceStrictness) -> SourceStrictness -> Int

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

rangeSize :: (SourceStrictness, SourceStrictness) -> Int

unsafeRangeSize :: (SourceStrictness, SourceStrictness) -> Int

Ix SourceUnpackedness

Since: base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

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

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

unsafeIndex :: (SourceUnpackedness, SourceUnpackedness) -> SourceUnpackedness -> Int

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

rangeSize :: (SourceUnpackedness, SourceUnpackedness) -> Int

unsafeRangeSize :: (SourceUnpackedness, SourceUnpackedness) -> Int

Ix SeekMode

Since: base-4.2.0.0

Defined in GHC.Internal.IO.Device

Methods

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

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

unsafeIndex :: (SeekMode, SeekMode) -> SeekMode -> Int

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

rangeSize :: (SeekMode, SeekMode) -> Int

unsafeRangeSize :: (SeekMode, SeekMode) -> Int

Ix IOMode

Since: base-4.2.0.0

Defined in GHC.Internal.IO.IOMode

Methods

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

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

unsafeIndex :: (IOMode, IOMode) -> IOMode -> Int

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

rangeSize :: (IOMode, IOMode) -> Int

unsafeRangeSize :: (IOMode, IOMode) -> Int

Ix Int16

Since: base-2.1

Defined in GHC.Internal.Int

Methods

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

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

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

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

rangeSize :: (Int16, Int16) -> Int

unsafeRangeSize :: (Int16, Int16) -> Int

Ix Int32

Since: base-2.1

Defined in GHC.Internal.Int

Methods

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

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

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

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

rangeSize :: (Int32, Int32) -> Int

unsafeRangeSize :: (Int32, Int32) -> Int

Ix Int64

Since: base-2.1

Defined in GHC.Internal.Int

Methods

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

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

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

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

rangeSize :: (Int64, Int64) -> Int

unsafeRangeSize :: (Int64, Int64) -> Int

Ix Int8

Since: base-2.1

Defined in GHC.Internal.Int

Methods

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

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

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

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

rangeSize :: (Int8, Int8) -> Int

unsafeRangeSize :: (Int8, Int8) -> Int

Ix CBlkCnt

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (CBlkCnt, CBlkCnt) -> Int

unsafeRangeSize :: (CBlkCnt, CBlkCnt) -> Int

Ix CBlkSize

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (CBlkSize, CBlkSize) -> Int

unsafeRangeSize :: (CBlkSize, CBlkSize) -> Int

Ix CClockId

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (CClockId, CClockId) -> Int

unsafeRangeSize :: (CClockId, CClockId) -> Int

Ix CDev

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

unsafeIndex :: (CDev, CDev) -> CDev -> Int

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

rangeSize :: (CDev, CDev) -> Int

unsafeRangeSize :: (CDev, CDev) -> Int

Ix CFsBlkCnt

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (CFsBlkCnt, CFsBlkCnt) -> Int

unsafeRangeSize :: (CFsBlkCnt, CFsBlkCnt) -> Int

Ix CFsFilCnt

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (CFsFilCnt, CFsFilCnt) -> Int

unsafeRangeSize :: (CFsFilCnt, CFsFilCnt) -> Int

Ix CGid

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (CGid, CGid) -> Int

unsafeRangeSize :: (CGid, CGid) -> Int

Ix CId

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (CId, CId) -> Int

unsafeRangeSize :: (CId, CId) -> Int

Ix CIno

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (CIno, CIno) -> Int

unsafeRangeSize :: (CIno, CIno) -> Int

Ix CKey

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (CKey, CKey) -> Int

unsafeRangeSize :: (CKey, CKey) -> Int

Ix CMode

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (CMode, CMode) -> Int

unsafeRangeSize :: (CMode, CMode) -> Int

Ix CNfds

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

unsafeIndex :: (CNfds, CNfds) -> CNfds -> Int

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

rangeSize :: (CNfds, CNfds) -> Int

unsafeRangeSize :: (CNfds, CNfds) -> Int

Ix CNlink

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (CNlink, CNlink) -> Int

unsafeRangeSize :: (CNlink, CNlink) -> Int

Ix COff

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (COff, COff) -> Int

unsafeRangeSize :: (COff, COff) -> Int

Ix CPid

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (CPid, CPid) -> Int

unsafeRangeSize :: (CPid, CPid) -> Int

Ix CRLim

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (CRLim, CRLim) -> Int

unsafeRangeSize :: (CRLim, CRLim) -> Int

Ix CSocklen

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

unsafeIndex :: (CSocklen, CSocklen) -> CSocklen -> Int

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

rangeSize :: (CSocklen, CSocklen) -> Int

unsafeRangeSize :: (CSocklen, CSocklen) -> Int

Ix CSsize

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (CSsize, CSsize) -> Int

unsafeRangeSize :: (CSsize, CSsize) -> Int

Ix CTcflag

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (CTcflag, CTcflag) -> Int

unsafeRangeSize :: (CTcflag, CTcflag) -> Int

Ix CUid

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (CUid, CUid) -> Int

unsafeRangeSize :: (CUid, CUid) -> Int

Ix Fd

Defined in GHC.Internal.System.Posix.Types

Methods

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

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

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

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

rangeSize :: (Fd, Fd) -> Int

unsafeRangeSize :: (Fd, Fd) -> Int

Ix GeneralCategory

Since: base-2.1

Defined in GHC.Internal.Unicode

Methods

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

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

unsafeIndex :: (GeneralCategory, GeneralCategory) -> GeneralCategory -> Int

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

rangeSize :: (GeneralCategory, GeneralCategory) -> Int

unsafeRangeSize :: (GeneralCategory, GeneralCategory) -> Int

Ix Word16

Since: base-2.1

Defined in GHC.Internal.Word

Methods

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

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

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

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

rangeSize :: (Word16, Word16) -> Int

unsafeRangeSize :: (Word16, Word16) -> Int

Ix Word32

Since: base-2.1

Defined in GHC.Internal.Word

Methods

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

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

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

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

rangeSize :: (Word32, Word32) -> Int

unsafeRangeSize :: (Word32, Word32) -> Int

Ix Word64

Since: base-2.1

Defined in GHC.Internal.Word

Methods

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

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

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

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

rangeSize :: (Word64, Word64) -> Int

unsafeRangeSize :: (Word64, Word64) -> Int

Ix Word8

Since: base-2.1

Defined in GHC.Internal.Word

Methods

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

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

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

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

rangeSize :: (Word8, Word8) -> Int

unsafeRangeSize :: (Word8, Word8) -> Int

Ix Ordering

Since: base-2.1

Defined in GHC.Internal.Ix

Methods

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

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

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

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

rangeSize :: (Ordering, Ordering) -> Int

unsafeRangeSize :: (Ordering, Ordering) -> Int

Ix Integer

Since: base-2.1

Defined in GHC.Internal.Ix

Methods

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

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

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

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

rangeSize :: (Integer, Integer) -> Int

unsafeRangeSize :: (Integer, Integer) -> Int

Ix Natural

Since: base-4.8.0.0

Defined in GHC.Internal.Ix

Methods

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

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

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

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

rangeSize :: (Natural, Natural) -> Int

unsafeRangeSize :: (Natural, Natural) -> Int

Ix ()

Since: base-2.1

Defined in GHC.Internal.Ix

Methods

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

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

unsafeIndex :: ((), ()) -> () -> Int

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

rangeSize :: ((), ()) -> Int

unsafeRangeSize :: ((), ()) -> Int

Ix Bool

Since: base-2.1

Defined in GHC.Internal.Ix

Methods

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

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

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

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

rangeSize :: (Bool, Bool) -> Int

unsafeRangeSize :: (Bool, Bool) -> Int

Ix Char

Since: base-2.1

Defined in GHC.Internal.Ix

Methods

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

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

unsafeIndex :: (Char, Char) -> Char -> Int

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

rangeSize :: (Char, Char) -> Int

unsafeRangeSize :: (Char, Char) -> Int

Ix Int

Since: base-2.1

Defined in GHC.Internal.Ix

Methods

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

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

unsafeIndex :: (Int, Int) -> Int -> Int

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

rangeSize :: (Int, Int) -> Int

unsafeRangeSize :: (Int, Int) -> Int

Ix Word

Since: base-4.6.0.0

Defined in GHC.Internal.Ix

Methods

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

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

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

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

rangeSize :: (Word, Word) -> Int

unsafeRangeSize :: (Word, Word) -> Int

Ix a => Ix (Identity a)

Since: base-4.9.0.0

Defined in GHC.Internal.Data.Functor.Identity

Methods

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

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

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

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

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

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

Ix a => Ix (Down a)

Since: base-4.14.0.0

Defined in GHC.Internal.Data.Ord

Methods

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

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

unsafeIndex :: (Down a, Down a) -> Down a -> Int

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

rangeSize :: (Down a, Down a) -> Int

unsafeRangeSize :: (Down a, Down a) -> Int

Ix a => Ix (Solo a)

Defined in GHC.Internal.Ix

Methods

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

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

unsafeIndex :: (Solo a, Solo a) -> Solo a -> Int

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

rangeSize :: (Solo a, Solo a) -> Int

unsafeRangeSize :: (Solo a, Solo a) -> Int

Ix (Proxy s)

Since: base-4.7.0.0

Defined in GHC.Internal.Data.Proxy

Methods

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

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

unsafeIndex :: (Proxy s, Proxy s) -> Proxy s -> Int

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

rangeSize :: (Proxy s, Proxy s) -> Int

unsafeRangeSize :: (Proxy s, Proxy s) -> Int

(Ix a, Ix b) => Ix (a, b)

Since: base-2.1

Defined in GHC.Internal.Ix

Methods

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

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

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

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

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

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

Ix a => Ix (Const a b)

Since: base-4.9.0.0

Defined in GHC.Internal.Data.Functor.Const

Methods

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

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

unsafeIndex :: (Const a b, Const a b) -> Const a b -> Int

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

rangeSize :: (Const a b, Const a b) -> Int

unsafeRangeSize :: (Const a b, Const a b) -> Int

(Ix a1, Ix a2, Ix a3) => Ix (a1, a2, a3)

Since: base-2.1

Defined in GHC.Internal.Ix

Methods

range :: ((a1, a2, a3), (a1, a2, a3)) -> [(a1, a2, a3)]

index :: ((a1, a2, a3), (a1, a2, a3)) -> (a1, a2, a3) -> Int

unsafeIndex :: ((a1, a2, a3), (a1, a2, a3)) -> (a1, a2, a3) -> Int

inRange :: ((a1, a2, a3), (a1, a2, a3)) -> (a1, a2, a3) -> Bool

rangeSize :: ((a1, a2, a3), (a1, a2, a3)) -> Int

unsafeRangeSize :: ((a1, a2, a3), (a1, a2, a3)) -> Int

(Ix a1, Ix a2, Ix a3, Ix a4) => Ix (a1, a2, a3, a4)

Since: base-2.1

Defined in GHC.Internal.Ix

Methods

range :: ((a1, a2, a3, a4), (a1, a2, a3, a4)) -> [(a1, a2, a3, a4)]

index :: ((a1, a2, a3, a4), (a1, a2, a3, a4)) -> (a1, a2, a3, a4) -> Int

unsafeIndex :: ((a1, a2, a3, a4), (a1, a2, a3, a4)) -> (a1, a2, a3, a4) -> Int

inRange :: ((a1, a2, a3, a4), (a1, a2, a3, a4)) -> (a1, a2, a3, a4) -> Bool

rangeSize :: ((a1, a2, a3, a4), (a1, a2, a3, a4)) -> Int

unsafeRangeSize :: ((a1, a2, a3, a4), (a1, a2, a3, a4)) -> Int

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5) => Ix (a1, a2, a3, a4, a5)

Since: base-2.1

Defined in GHC.Internal.Ix

Methods

range :: ((a1, a2, a3, a4, a5), (a1, a2, a3, a4, a5)) -> [(a1, a2, a3, a4, a5)]

index :: ((a1, a2, a3, a4, a5), (a1, a2, a3, a4, a5)) -> (a1, a2, a3, a4, a5) -> Int

unsafeIndex :: ((a1, a2, a3, a4, a5), (a1, a2, a3, a4, a5)) -> (a1, a2, a3, a4, a5) -> Int

inRange :: ((a1, a2, a3, a4, a5), (a1, a2, a3, a4, a5)) -> (a1, a2, a3, a4, a5) -> Bool

rangeSize :: ((a1, a2, a3, a4, a5), (a1, a2, a3, a4, a5)) -> Int

unsafeRangeSize :: ((a1, a2, a3, a4, a5), (a1, a2, a3, a4, a5)) -> Int

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6) => Ix (a1, a2, a3, a4, a5, a6)

Since: base-4.15.0.0

Defined in GHC.Internal.Ix

Methods

range :: ((a1, a2, a3, a4, a5, a6), (a1, a2, a3, a4, a5, a6)) -> [(a1, a2, a3, a4, a5, a6)]

index :: ((a1, a2, a3, a4, a5, a6), (a1, a2, a3, a4, a5, a6)) -> (a1, a2, a3, a4, a5, a6) -> Int

unsafeIndex :: ((a1, a2, a3, a4, a5, a6), (a1, a2, a3, a4, a5, a6)) -> (a1, a2, a3, a4, a5, a6) -> Int

inRange :: ((a1, a2, a3, a4, a5, a6), (a1, a2, a3, a4, a5, a6)) -> (a1, a2, a3, a4, a5, a6) -> Bool

rangeSize :: ((a1, a2, a3, a4, a5, a6), (a1, a2, a3, a4, a5, a6)) -> Int

unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6), (a1, a2, a3, a4, a5, a6)) -> Int

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7) => Ix (a1, a2, a3, a4, a5, a6, a7)

Since: base-4.15.0.0

Defined in GHC.Internal.Ix

Methods

range :: ((a1, a2, a3, a4, a5, a6, a7), (a1, a2, a3, a4, a5, a6, a7)) -> [(a1, a2, a3, a4, a5, a6, a7)]

index :: ((a1, a2, a3, a4, a5, a6, a7), (a1, a2, a3, a4, a5, a6, a7)) -> (a1, a2, a3, a4, a5, a6, a7) -> Int

unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7), (a1, a2, a3, a4, a5, a6, a7)) -> (a1, a2, a3, a4, a5, a6, a7) -> Int

inRange :: ((a1, a2, a3, a4, a5, a6, a7), (a1, a2, a3, a4, a5, a6, a7)) -> (a1, a2, a3, a4, a5, a6, a7) -> Bool

rangeSize :: ((a1, a2, a3, a4, a5, a6, a7), (a1, a2, a3, a4, a5, a6, a7)) -> Int

unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7), (a1, a2, a3, a4, a5, a6, a7)) -> Int

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8) => Ix (a1, a2, a3, a4, a5, a6, a7, a8)

Since: base-4.15.0.0

Defined in GHC.Internal.Ix

Methods

range :: ((a1, a2, a3, a4, a5, a6, a7, a8), (a1, a2, a3, a4, a5, a6, a7, a8)) -> [(a1, a2, a3, a4, a5, a6, a7, a8)]

index :: ((a1, a2, a3, a4, a5, a6, a7, a8), (a1, a2, a3, a4, a5, a6, a7, a8)) -> (a1, a2, a3, a4, a5, a6, a7, a8) -> Int

unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8), (a1, a2, a3, a4, a5, a6, a7, a8)) -> (a1, a2, a3, a4, a5, a6, a7, a8) -> Int

inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8), (a1, a2, a3, a4, a5, a6, a7, a8)) -> (a1, a2, a3, a4, a5, a6, a7, a8) -> Bool

rangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8), (a1, a2, a3, a4, a5, a6, a7, a8)) -> Int

unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8), (a1, a2, a3, a4, a5, a6, a7, a8)) -> Int

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9) => Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9)

Since: base-4.15.0.0

Defined in GHC.Internal.Ix

Methods

range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9), (a1, a2, a3, a4, a5, a6, a7, a8, a9)) -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9)]

index :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9), (a1, a2, a3, a4, a5, a6, a7, a8, a9)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Int

unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9), (a1, a2, a3, a4, a5, a6, a7, a8, a9)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Int

inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9), (a1, a2, a3, a4, a5, a6, a7, a8, a9)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Bool

rangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9), (a1, a2, a3, a4, a5, a6, a7, a8, a9)) -> Int

unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9), (a1, a2, a3, a4, a5, a6, a7, a8, a9)) -> Int

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix aA) => Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA)

Since: base-4.15.0.0

Defined in GHC.Internal.Ix

Methods

range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA)) -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA)]

index :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA) -> Int

unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA) -> Int

inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA) -> Bool

rangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA)) -> Int

unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA)) -> Int

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix aA, Ix aB) => Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB)

Since: base-4.15.0.0

Defined in GHC.Internal.Ix

Methods

range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB)) -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB)]

index :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB) -> Int

unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB) -> Int

inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB) -> Bool

rangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB)) -> Int

unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB)) -> Int

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix aA, Ix aB, Ix aC) => Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC)

Since: base-4.15.0.0

Defined in GHC.Internal.Ix

Methods

range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC)) -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC)]

index :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC) -> Int

unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC) -> Int

inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC) -> Bool

rangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC)) -> Int

unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC)) -> Int

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix aA, Ix aB, Ix aC, Ix aD) => Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD)

Since: base-4.15.0.0

Defined in GHC.Internal.Ix

Methods

range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD)) -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD)]

index :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD) -> Int

unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD) -> Int

inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD) -> Bool

rangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD)) -> Int

unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD)) -> Int

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix aA, Ix aB, Ix aC, Ix aD, Ix aE) => Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE)

Since: base-4.15.0.0

Defined in GHC.Internal.Ix

Methods

range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE)) -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE)]

index :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE) -> Int

unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE) -> Int

inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE) -> Bool

rangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE)) -> Int

unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE)) -> Int

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix aA, Ix aB, Ix aC, Ix aD, Ix aE, Ix aF) => Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)

Since: base-4.15.0.0

Defined in GHC.Internal.Ix

Methods

range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)) -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)]

index :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF) -> Int

unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF) -> Int

inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF) -> Bool

rangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)) -> Int

unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)) -> Int

Deriving Instances of Ix

Derived instance declarations for the class Ix are only possible for enumerations (i.e. datatypes having only nullary constructors) and single-constructor datatypes, including arbitrarily large tuples, whose constituent types are instances of Ix.

• For an enumeration, the nullary constructors are assumed to be numbered left-to-right with the indices being 0 to n-1 inclusive. This is the same numbering defined by the Enum class. For example, given the datatype:

       data Colour = Red | Orange | Yellow | Green | Blue | Indigo | Violet

we would have:

       range   (Yellow,Blue)        ==  [Yellow,Green,Blue]
       index   (Yellow,Blue) Green  ==  1
       inRange (Yellow,Blue) Red    ==  False

• For single-constructor datatypes, the derived instance declarations are as shown for tuples in chapter 19, section 2 of the Haskell 2010 report: https://www.haskell.org/onlinereport/haskell2010/haskellch19.html.