Safe Haskell | None |
---|---|
Language | Haskell2010 |
Agda.Utils.IArray
Description
Array utilities.
Documentation
Instances
Ix AllowedReduction Source # | |
Defined in Agda.TypeChecking.Monad.Base Methods range :: (AllowedReduction, AllowedReduction) -> [AllowedReduction] # index :: (AllowedReduction, AllowedReduction) -> AllowedReduction -> Int # unsafeIndex :: (AllowedReduction, AllowedReduction) -> AllowedReduction -> Int inRange :: (AllowedReduction, AllowedReduction) -> AllowedReduction -> Bool # rangeSize :: (AllowedReduction, AllowedReduction) -> Int # unsafeRangeSize :: (AllowedReduction, AllowedReduction) -> Int | |
Ix FunctionFlag Source # | |
Defined in Agda.TypeChecking.Monad.Base Methods range :: (FunctionFlag, FunctionFlag) -> [FunctionFlag] # index :: (FunctionFlag, FunctionFlag) -> FunctionFlag -> Int # unsafeIndex :: (FunctionFlag, FunctionFlag) -> FunctionFlag -> Int inRange :: (FunctionFlag, FunctionFlag) -> FunctionFlag -> Bool # rangeSize :: (FunctionFlag, FunctionFlag) -> Int # unsafeRangeSize :: (FunctionFlag, FunctionFlag) -> Int | |
Ix BlinkSpeed | |
Defined in System.Console.ANSI.Types Methods range :: (BlinkSpeed, BlinkSpeed) -> [BlinkSpeed] # index :: (BlinkSpeed, BlinkSpeed) -> BlinkSpeed -> Int # unsafeIndex :: (BlinkSpeed, BlinkSpeed) -> BlinkSpeed -> Int inRange :: (BlinkSpeed, BlinkSpeed) -> BlinkSpeed -> Bool # rangeSize :: (BlinkSpeed, BlinkSpeed) -> Int # unsafeRangeSize :: (BlinkSpeed, BlinkSpeed) -> Int | |
Ix Color | |
Defined in System.Console.ANSI.Types Methods range :: (Color, Color) -> [Color] # index :: (Color, Color) -> Color -> Int # unsafeIndex :: (Color, Color) -> Color -> Int inRange :: (Color, Color) -> Color -> Bool # rangeSize :: (Color, Color) -> Int # unsafeRangeSize :: (Color, Color) -> Int | |
Ix ColorIntensity | |
Defined in System.Console.ANSI.Types Methods range :: (ColorIntensity, ColorIntensity) -> [ColorIntensity] # index :: (ColorIntensity, ColorIntensity) -> ColorIntensity -> Int # unsafeIndex :: (ColorIntensity, ColorIntensity) -> ColorIntensity -> Int inRange :: (ColorIntensity, ColorIntensity) -> ColorIntensity -> Bool # rangeSize :: (ColorIntensity, ColorIntensity) -> Int # unsafeRangeSize :: (ColorIntensity, ColorIntensity) -> Int | |
Ix ConsoleIntensity | |
Defined in System.Console.ANSI.Types Methods range :: (ConsoleIntensity, ConsoleIntensity) -> [ConsoleIntensity] # index :: (ConsoleIntensity, ConsoleIntensity) -> ConsoleIntensity -> Int # unsafeIndex :: (ConsoleIntensity, ConsoleIntensity) -> ConsoleIntensity -> Int inRange :: (ConsoleIntensity, ConsoleIntensity) -> ConsoleIntensity -> Bool # rangeSize :: (ConsoleIntensity, ConsoleIntensity) -> Int # unsafeRangeSize :: (ConsoleIntensity, ConsoleIntensity) -> Int | |
Ix ConsoleLayer | |
Defined in System.Console.ANSI.Types Methods range :: (ConsoleLayer, ConsoleLayer) -> [ConsoleLayer] # index :: (ConsoleLayer, ConsoleLayer) -> ConsoleLayer -> Int # unsafeIndex :: (ConsoleLayer, ConsoleLayer) -> ConsoleLayer -> Int inRange :: (ConsoleLayer, ConsoleLayer) -> ConsoleLayer -> Bool # rangeSize :: (ConsoleLayer, ConsoleLayer) -> Int # unsafeRangeSize :: (ConsoleLayer, ConsoleLayer) -> Int | |
Ix Underlining | |
Defined in System.Console.ANSI.Types Methods range :: (Underlining, Underlining) -> [Underlining] # index :: (Underlining, Underlining) -> Underlining -> Int # unsafeIndex :: (Underlining, Underlining) -> Underlining -> Int inRange :: (Underlining, Underlining) -> Underlining -> Bool # rangeSize :: (Underlining, Underlining) -> Int # unsafeRangeSize :: (Underlining, Underlining) -> Int | |
Ix CBool | |
Defined in 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 Void | |
Ix Associativity | |
Defined in GHC.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 | |
Defined in GHC.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 | |
Defined in GHC.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 | |
Defined in GHC.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 | |
Defined in GHC.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 | |
Defined in GHC.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 | |
Ix Int32 | |
Ix Int64 | |
Ix Int8 | |
Ix GeneralCategory | |
Defined in GHC.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 | |
Ix Word32 | |
Ix Word64 | |
Ix Word8 | |
Ix CBlkCnt | |
Defined in 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 System.Posix.Types Methods index :: (Fd, Fd) -> Fd -> Int # unsafeIndex :: (Fd, Fd) -> Fd -> Int inRange :: (Fd, Fd) -> Fd -> Bool # rangeSize :: (Fd, Fd) -> Int # unsafeRangeSize :: (Fd, Fd) -> Int | |
Ix Ordering | |
Defined in GHC.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 Peano | |
Ix Day | |
Defined in Data.Time.Calendar.Days Methods range :: (Day, Day) -> [Day] # index :: (Day, Day) -> Day -> Int # unsafeIndex :: (Day, Day) -> Day -> Int inRange :: (Day, Day) -> Day -> Bool # rangeSize :: (Day, Day) -> Int # unsafeRangeSize :: (Day, Day) -> Int | |
Ix Month | |
Defined in Data.Time.Calendar.Month Methods range :: (Month, Month) -> [Month] # index :: (Month, Month) -> Month -> Int # unsafeIndex :: (Month, Month) -> Month -> Int inRange :: (Month, Month) -> Month -> Bool # rangeSize :: (Month, Month) -> Int # unsafeRangeSize :: (Month, Month) -> Int | |
Ix Quarter | |
Defined in Data.Time.Calendar.Quarter Methods range :: (Quarter, Quarter) -> [Quarter] # index :: (Quarter, Quarter) -> Quarter -> Int # unsafeIndex :: (Quarter, Quarter) -> Quarter -> Int inRange :: (Quarter, Quarter) -> Quarter -> Bool # rangeSize :: (Quarter, Quarter) -> Int # unsafeRangeSize :: (Quarter, Quarter) -> Int | |
Ix QuarterOfYear | |
Defined in Data.Time.Calendar.Quarter Methods range :: (QuarterOfYear, QuarterOfYear) -> [QuarterOfYear] # index :: (QuarterOfYear, QuarterOfYear) -> QuarterOfYear -> Int # unsafeIndex :: (QuarterOfYear, QuarterOfYear) -> QuarterOfYear -> Int inRange :: (QuarterOfYear, QuarterOfYear) -> QuarterOfYear -> Bool # rangeSize :: (QuarterOfYear, QuarterOfYear) -> Int # unsafeRangeSize :: (QuarterOfYear, QuarterOfYear) -> Int | |
Ix Integer | |
Ix Natural | |
Ix () | |
Ix Bool | |
Ix Char | |
Ix Int | |
Ix Word | |
Ix i => Ix (MIx i) Source # | |
Ix a => Ix (Identity a) | |
Defined in 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) | |
Ix a => Ix (Solo a) | |
Ix (Proxy s) | |
Defined in 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 (Pair a b) | |
Defined in Data.Strict.Tuple Methods range :: (Pair a b, Pair a b) -> [Pair a b] # index :: (Pair a b, Pair a b) -> Pair a b -> Int # unsafeIndex :: (Pair a b, Pair a b) -> Pair a b -> Int inRange :: (Pair a b, Pair a b) -> Pair a b -> Bool # rangeSize :: (Pair a b, Pair a b) -> Int # unsafeRangeSize :: (Pair a b, Pair a b) -> Int | |
(Ix a, Ix b) => Ix (a, b) | |
Ix a => Ix (Const a b) | |
Defined in 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 b => Ix (Tagged s b) | |
Defined in Data.Tagged Methods range :: (Tagged s b, Tagged s b) -> [Tagged s b] # index :: (Tagged s b, Tagged s b) -> Tagged s b -> Int # unsafeIndex :: (Tagged s b, Tagged s b) -> Tagged s b -> Int inRange :: (Tagged s b, Tagged s b) -> Tagged s b -> Bool # rangeSize :: (Tagged s b, Tagged s b) -> Int # unsafeRangeSize :: (Tagged s b, Tagged s b) -> Int | |
(Ix a1, Ix a2, Ix a3) => Ix (a1, a2, a3) | |
Defined in GHC.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) | |
Defined in GHC.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) | |
Defined in GHC.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) | |
Defined in GHC.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) | |
Defined in GHC.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) | |
Defined in GHC.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) | |
Defined in GHC.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) | |
Defined in GHC.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) | |
Defined in GHC.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) | |
Defined in GHC.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) | |
Defined in GHC.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) | |
Defined in GHC.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) | |
Defined in GHC.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 |
Instances
NFData2 Array | |
Defined in Control.DeepSeq | |
IArray Array e | |
Defined in Data.Array.Base Methods bounds :: Ix i => Array i e -> (i, i) # numElements :: Ix i => Array i e -> Int unsafeArray :: Ix i => (i, i) -> [(Int, e)] -> Array i e unsafeAt :: Ix i => Array i e -> Int -> e unsafeReplace :: Ix i => Array i e -> [(Int, e)] -> Array i e unsafeAccum :: Ix i => (e -> e' -> e) -> Array i e -> [(Int, e')] -> Array i e unsafeAccumArray :: Ix i => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> Array i e | |
Foldable (Array i) | |
Defined in Data.Foldable Methods fold :: Monoid m => Array i m -> m foldMap :: Monoid m => (a -> m) -> Array i a -> m foldMap' :: Monoid m => (a -> m) -> Array i a -> m foldr :: (a -> b -> b) -> b -> Array i a -> b foldr' :: (a -> b -> b) -> b -> Array i a -> b foldl :: (b -> a -> b) -> b -> Array i a -> b foldl' :: (b -> a -> b) -> b -> Array i a -> b foldr1 :: (a -> a -> a) -> Array i a -> a # foldl1 :: (a -> a -> a) -> Array i a -> a # elem :: Eq a => a -> Array i a -> Bool maximum :: Ord a => Array i a -> a minimum :: Ord a => Array i a -> a | |
Ix i => Traversable (Array i) | |
Functor (Array i) | |
NFData a => NFData1 (Array a) | |
Defined in Control.DeepSeq | |
(Data a, Data b, Ix a) => Data (Array a b) | |
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Array a b -> c (Array a b) gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Array a b) toConstr :: Array a b -> Constr dataTypeOf :: Array a b -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Array a b)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array a b)) gmapT :: (forall b0. Data b0 => b0 -> b0) -> Array a b -> Array a b gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Array a b -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Array a b -> r gmapQ :: (forall d. Data d => d -> u) -> Array a b -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Array a b -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) | |
(Ix a, Read a, Read b) => Read (Array a b) | |
(Ix a, Show a, Show b) => Show (Array a b) | |
(Binary i, Ix i, Binary e) => Binary (Array i e) | |
(NFData a, NFData b) => NFData (Array a b) | |
Defined in Control.DeepSeq | |
(Ix i, Eq e) => Eq (Array i e) | |
(Ix i, Ord e) => Ord (Array i e) | |
Defined in GHC.Arr | |
type Item (Array i e) | |
Defined in Data.ListLike.Instances |
class IArray (a :: Type -> Type -> Type) e where #
Minimal complete definition
bounds, numElements, unsafeArray, unsafeAt
Instances
IArray UArray Int16 | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Int16 -> (i, i) # numElements :: Ix i => UArray i Int16 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Int16)] -> UArray i Int16 unsafeAt :: Ix i => UArray i Int16 -> Int -> Int16 unsafeReplace :: Ix i => UArray i Int16 -> [(Int, Int16)] -> UArray i Int16 unsafeAccum :: Ix i => (Int16 -> e' -> Int16) -> UArray i Int16 -> [(Int, e')] -> UArray i Int16 unsafeAccumArray :: Ix i => (Int16 -> e' -> Int16) -> Int16 -> (i, i) -> [(Int, e')] -> UArray i Int16 | |
IArray UArray Int32 | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Int32 -> (i, i) # numElements :: Ix i => UArray i Int32 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Int32)] -> UArray i Int32 unsafeAt :: Ix i => UArray i Int32 -> Int -> Int32 unsafeReplace :: Ix i => UArray i Int32 -> [(Int, Int32)] -> UArray i Int32 unsafeAccum :: Ix i => (Int32 -> e' -> Int32) -> UArray i Int32 -> [(Int, e')] -> UArray i Int32 unsafeAccumArray :: Ix i => (Int32 -> e' -> Int32) -> Int32 -> (i, i) -> [(Int, e')] -> UArray i Int32 | |
IArray UArray Int64 | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Int64 -> (i, i) # numElements :: Ix i => UArray i Int64 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Int64)] -> UArray i Int64 unsafeAt :: Ix i => UArray i Int64 -> Int -> Int64 unsafeReplace :: Ix i => UArray i Int64 -> [(Int, Int64)] -> UArray i Int64 unsafeAccum :: Ix i => (Int64 -> e' -> Int64) -> UArray i Int64 -> [(Int, e')] -> UArray i Int64 unsafeAccumArray :: Ix i => (Int64 -> e' -> Int64) -> Int64 -> (i, i) -> [(Int, e')] -> UArray i Int64 | |
IArray UArray Int8 | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Int8 -> (i, i) # numElements :: Ix i => UArray i Int8 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Int8)] -> UArray i Int8 unsafeAt :: Ix i => UArray i Int8 -> Int -> Int8 unsafeReplace :: Ix i => UArray i Int8 -> [(Int, Int8)] -> UArray i Int8 unsafeAccum :: Ix i => (Int8 -> e' -> Int8) -> UArray i Int8 -> [(Int, e')] -> UArray i Int8 unsafeAccumArray :: Ix i => (Int8 -> e' -> Int8) -> Int8 -> (i, i) -> [(Int, e')] -> UArray i Int8 | |
IArray UArray Word16 | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word16 -> (i, i) # numElements :: Ix i => UArray i Word16 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word16)] -> UArray i Word16 unsafeAt :: Ix i => UArray i Word16 -> Int -> Word16 unsafeReplace :: Ix i => UArray i Word16 -> [(Int, Word16)] -> UArray i Word16 unsafeAccum :: Ix i => (Word16 -> e' -> Word16) -> UArray i Word16 -> [(Int, e')] -> UArray i Word16 unsafeAccumArray :: Ix i => (Word16 -> e' -> Word16) -> Word16 -> (i, i) -> [(Int, e')] -> UArray i Word16 | |
IArray UArray Word32 | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word32 -> (i, i) # numElements :: Ix i => UArray i Word32 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word32)] -> UArray i Word32 unsafeAt :: Ix i => UArray i Word32 -> Int -> Word32 unsafeReplace :: Ix i => UArray i Word32 -> [(Int, Word32)] -> UArray i Word32 unsafeAccum :: Ix i => (Word32 -> e' -> Word32) -> UArray i Word32 -> [(Int, e')] -> UArray i Word32 unsafeAccumArray :: Ix i => (Word32 -> e' -> Word32) -> Word32 -> (i, i) -> [(Int, e')] -> UArray i Word32 | |
IArray UArray Word64 | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word64 -> (i, i) # numElements :: Ix i => UArray i Word64 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word64)] -> UArray i Word64 unsafeAt :: Ix i => UArray i Word64 -> Int -> Word64 unsafeReplace :: Ix i => UArray i Word64 -> [(Int, Word64)] -> UArray i Word64 unsafeAccum :: Ix i => (Word64 -> e' -> Word64) -> UArray i Word64 -> [(Int, e')] -> UArray i Word64 unsafeAccumArray :: Ix i => (Word64 -> e' -> Word64) -> Word64 -> (i, i) -> [(Int, e')] -> UArray i Word64 | |
IArray UArray Word8 | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word8 -> (i, i) # numElements :: Ix i => UArray i Word8 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word8)] -> UArray i Word8 unsafeAt :: Ix i => UArray i Word8 -> Int -> Word8 unsafeReplace :: Ix i => UArray i Word8 -> [(Int, Word8)] -> UArray i Word8 unsafeAccum :: Ix i => (Word8 -> e' -> Word8) -> UArray i Word8 -> [(Int, e')] -> UArray i Word8 unsafeAccumArray :: Ix i => (Word8 -> e' -> Word8) -> Word8 -> (i, i) -> [(Int, e')] -> UArray i Word8 | |
IArray UArray Bool | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Bool -> (i, i) # numElements :: Ix i => UArray i Bool -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Bool)] -> UArray i Bool unsafeAt :: Ix i => UArray i Bool -> Int -> Bool unsafeReplace :: Ix i => UArray i Bool -> [(Int, Bool)] -> UArray i Bool unsafeAccum :: Ix i => (Bool -> e' -> Bool) -> UArray i Bool -> [(Int, e')] -> UArray i Bool unsafeAccumArray :: Ix i => (Bool -> e' -> Bool) -> Bool -> (i, i) -> [(Int, e')] -> UArray i Bool | |
IArray UArray Char | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Char -> (i, i) # numElements :: Ix i => UArray i Char -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Char)] -> UArray i Char unsafeAt :: Ix i => UArray i Char -> Int -> Char unsafeReplace :: Ix i => UArray i Char -> [(Int, Char)] -> UArray i Char unsafeAccum :: Ix i => (Char -> e' -> Char) -> UArray i Char -> [(Int, e')] -> UArray i Char unsafeAccumArray :: Ix i => (Char -> e' -> Char) -> Char -> (i, i) -> [(Int, e')] -> UArray i Char | |
IArray UArray Double | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Double -> (i, i) # numElements :: Ix i => UArray i Double -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Double)] -> UArray i Double unsafeAt :: Ix i => UArray i Double -> Int -> Double unsafeReplace :: Ix i => UArray i Double -> [(Int, Double)] -> UArray i Double unsafeAccum :: Ix i => (Double -> e' -> Double) -> UArray i Double -> [(Int, e')] -> UArray i Double unsafeAccumArray :: Ix i => (Double -> e' -> Double) -> Double -> (i, i) -> [(Int, e')] -> UArray i Double | |
IArray UArray Float | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Float -> (i, i) # numElements :: Ix i => UArray i Float -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Float)] -> UArray i Float unsafeAt :: Ix i => UArray i Float -> Int -> Float unsafeReplace :: Ix i => UArray i Float -> [(Int, Float)] -> UArray i Float unsafeAccum :: Ix i => (Float -> e' -> Float) -> UArray i Float -> [(Int, e')] -> UArray i Float unsafeAccumArray :: Ix i => (Float -> e' -> Float) -> Float -> (i, i) -> [(Int, e')] -> UArray i Float | |
IArray UArray Int | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Int -> (i, i) # numElements :: Ix i => UArray i Int -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Int)] -> UArray i Int unsafeAt :: Ix i => UArray i Int -> Int -> Int unsafeReplace :: Ix i => UArray i Int -> [(Int, Int)] -> UArray i Int unsafeAccum :: Ix i => (Int -> e' -> Int) -> UArray i Int -> [(Int, e')] -> UArray i Int unsafeAccumArray :: Ix i => (Int -> e' -> Int) -> Int -> (i, i) -> [(Int, e')] -> UArray i Int | |
IArray UArray Word | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word -> (i, i) # numElements :: Ix i => UArray i Word -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word)] -> UArray i Word unsafeAt :: Ix i => UArray i Word -> Int -> Word unsafeReplace :: Ix i => UArray i Word -> [(Int, Word)] -> UArray i Word unsafeAccum :: Ix i => (Word -> e' -> Word) -> UArray i Word -> [(Int, e')] -> UArray i Word unsafeAccumArray :: Ix i => (Word -> e' -> Word) -> Word -> (i, i) -> [(Int, e')] -> UArray i Word | |
IArray Array e | |
Defined in Data.Array.Base Methods bounds :: Ix i => Array i e -> (i, i) # numElements :: Ix i => Array i e -> Int unsafeArray :: Ix i => (i, i) -> [(Int, e)] -> Array i e unsafeAt :: Ix i => Array i e -> Int -> e unsafeReplace :: Ix i => Array i e -> [(Int, e)] -> Array i e unsafeAccum :: Ix i => (e -> e' -> e) -> Array i e -> [(Int, e')] -> Array i e unsafeAccumArray :: Ix i => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> Array i e | |
IArray UArray (FunPtr a) | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i (FunPtr a) -> (i, i) # numElements :: Ix i => UArray i (FunPtr a) -> Int unsafeArray :: Ix i => (i, i) -> [(Int, FunPtr a)] -> UArray i (FunPtr a) unsafeAt :: Ix i => UArray i (FunPtr a) -> Int -> FunPtr a unsafeReplace :: Ix i => UArray i (FunPtr a) -> [(Int, FunPtr a)] -> UArray i (FunPtr a) unsafeAccum :: Ix i => (FunPtr a -> e' -> FunPtr a) -> UArray i (FunPtr a) -> [(Int, e')] -> UArray i (FunPtr a) unsafeAccumArray :: Ix i => (FunPtr a -> e' -> FunPtr a) -> FunPtr a -> (i, i) -> [(Int, e')] -> UArray i (FunPtr a) | |
IArray UArray (Ptr a) | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i (Ptr a) -> (i, i) # numElements :: Ix i => UArray i (Ptr a) -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Ptr a)] -> UArray i (Ptr a) unsafeAt :: Ix i => UArray i (Ptr a) -> Int -> Ptr a unsafeReplace :: Ix i => UArray i (Ptr a) -> [(Int, Ptr a)] -> UArray i (Ptr a) unsafeAccum :: Ix i => (Ptr a -> e' -> Ptr a) -> UArray i (Ptr a) -> [(Int, e')] -> UArray i (Ptr a) unsafeAccumArray :: Ix i => (Ptr a -> e' -> Ptr a) -> Ptr a -> (i, i) -> [(Int, e')] -> UArray i (Ptr a) | |
IArray UArray (StablePtr a) | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i (StablePtr a) -> (i, i) # numElements :: Ix i => UArray i (StablePtr a) -> Int unsafeArray :: Ix i => (i, i) -> [(Int, StablePtr a)] -> UArray i (StablePtr a) unsafeAt :: Ix i => UArray i (StablePtr a) -> Int -> StablePtr a unsafeReplace :: Ix i => UArray i (StablePtr a) -> [(Int, StablePtr a)] -> UArray i (StablePtr a) unsafeAccum :: Ix i => (StablePtr a -> e' -> StablePtr a) -> UArray i (StablePtr a) -> [(Int, e')] -> UArray i (StablePtr a) unsafeAccumArray :: Ix i => (StablePtr a -> e' -> StablePtr a) -> StablePtr a -> (i, i) -> [(Int, e')] -> UArray i (StablePtr a) |
accumArray :: (IArray a e, Ix i) => (e -> e' -> e) -> e -> (i, i) -> [(i, e')] -> a i e #
foldlArray :: (IArray a e, Ix i) => (b -> e -> b) -> b -> a i e -> b #
foldlArray' :: (IArray a e, Ix i) => (b -> e -> b) -> b -> a i e -> b #
foldlArrayM' :: (IArray a e, Ix i, Monad m) => (b -> e -> m b) -> b -> a i e -> m b #
foldrArray :: (IArray a e, Ix i) => (e -> b -> b) -> b -> a i e -> b #
foldrArray' :: (IArray a e, Ix i) => (e -> b -> b) -> b -> a i e -> b #
foldrArrayM' :: (IArray a e, Ix i, Monad m) => (e -> b -> m b) -> b -> a i e -> m b #
traverseArray_ :: (IArray a e, Ix i, Applicative f) => (e -> f b) -> a i e -> f () #