Data.Orphans

Exports orphan instances that mimic instances available in later versions of base. To use them, simply import Data.Orphans ().

Orphan instances

Ix CDev

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 CIno

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 CMode

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 COff

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

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 CSsize

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 CGid

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 CNlink

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 CUid

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 CCc

Methods

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

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

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

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

rangeSize :: (CCc, CCc) -> Int

unsafeRangeSize :: (CCc, CCc) -> Int

Ix CSpeed

Methods

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

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

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

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

rangeSize :: (CSpeed, CSpeed) -> Int

unsafeRangeSize :: (CSpeed, CSpeed) -> Int

Ix CTcflag

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 CRLim

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 CBlkSize

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 CBlkCnt

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 CClockId

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 CFsBlkCnt

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

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 CId

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 CKey

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 CSocklen

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 CNfds

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 Fd

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 CChar

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 CSChar

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 CUChar

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 CShort

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 CUShort

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 CInt

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 CUInt

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 CLong

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 CULong

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 CLLong

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 CULLong

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 CBool

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 CPtrdiff

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 CSize

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 CWchar

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 CSigAtomic

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 CIntPtr

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 CUIntPtr

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 CIntMax

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 CUIntMax

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 WordPtr

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 IntPtr

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

MonadFix Complex

Methods

mfix :: (a -> Complex a) -> Complex a

Eq1 Complex

Methods

liftEq :: (a -> b -> Bool) -> Complex a -> Complex b -> Bool

Read1 Complex

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Complex a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Complex a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Complex a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Complex a]

Show1 Complex

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Complex a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Complex a] -> ShowS

MonadZip Complex

Methods

mzip :: Complex a -> Complex b -> Complex (a, b)

mzipWith :: (a -> b -> c) -> Complex a -> Complex b -> Complex c

munzip :: Complex (a, b) -> (Complex a, Complex b)

Eq a => Eq2 ((,,) a)

Methods

liftEq2 :: (a0 -> b -> Bool) -> (c -> d -> Bool) -> (a, a0, c) -> (a, b, d) -> Bool

Ord a => Ord2 ((,,) a)

Methods

liftCompare2 :: (a0 -> b -> Ordering) -> (c -> d -> Ordering) -> (a, a0, c) -> (a, b, d) -> Ordering

Read a => Read2 ((,,) a)

Methods

liftReadsPrec2 :: (Int -> ReadS a0) -> ReadS [a0] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (a, a0, b)

liftReadList2 :: (Int -> ReadS a0) -> ReadS [a0] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [(a, a0, b)]

liftReadPrec2 :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (a, a0, b)

liftReadListPrec2 :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [(a, a0, b)]

Show a => Show2 ((,,) a)

Methods

liftShowsPrec2 :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> (a, a0, b) -> ShowS

liftShowList2 :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [(a, a0, b)] -> ShowS

(Eq a, Eq b) => Eq1 ((,,) a b)

Methods

liftEq :: (a0 -> b0 -> Bool) -> (a, b, a0) -> (a, b, b0) -> Bool

(Ord a, Ord b) => Ord1 ((,,) a b)

Methods

liftCompare :: (a0 -> b0 -> Ordering) -> (a, b, a0) -> (a, b, b0) -> Ordering

(Read a, Read b) => Read1 ((,,) a b)

Methods

liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (a, b, a0)

liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [(a, b, a0)]

liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (a, b, a0)

liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [(a, b, a0)]

(Show a, Show b) => Show1 ((,,) a b)

Methods

liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> (a, b, a0) -> ShowS

liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [(a, b, a0)] -> ShowS

(Eq a, Eq b) => Eq2 ((,,,) a b)

Methods

liftEq2 :: (a0 -> b0 -> Bool) -> (c -> d -> Bool) -> (a, b, a0, c) -> (a, b, b0, d) -> Bool

(Ord a, Ord b) => Ord2 ((,,,) a b)

Methods

liftCompare2 :: (a0 -> b0 -> Ordering) -> (c -> d -> Ordering) -> (a, b, a0, c) -> (a, b, b0, d) -> Ordering

(Read a, Read b) => Read2 ((,,,) a b)

Methods

liftReadsPrec2 :: (Int -> ReadS a0) -> ReadS [a0] -> (Int -> ReadS b0) -> ReadS [b0] -> Int -> ReadS (a, b, a0, b0)

liftReadList2 :: (Int -> ReadS a0) -> ReadS [a0] -> (Int -> ReadS b0) -> ReadS [b0] -> ReadS [(a, b, a0, b0)]

liftReadPrec2 :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec b0 -> ReadPrec [b0] -> ReadPrec (a, b, a0, b0)

liftReadListPrec2 :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec b0 -> ReadPrec [b0] -> ReadPrec [(a, b, a0, b0)]

(Show a, Show b) => Show2 ((,,,) a b)

Methods

liftShowsPrec2 :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> (Int -> b0 -> ShowS) -> ([b0] -> ShowS) -> Int -> (a, b, a0, b0) -> ShowS

liftShowList2 :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> (Int -> b0 -> ShowS) -> ([b0] -> ShowS) -> [(a, b, a0, b0)] -> ShowS

(Eq a, Eq b, Eq c) => Eq1 ((,,,) a b c)

Methods

liftEq :: (a0 -> b0 -> Bool) -> (a, b, c, a0) -> (a, b, c, b0) -> Bool

(Ord a, Ord b, Ord c) => Ord1 ((,,,) a b c)

Methods

liftCompare :: (a0 -> b0 -> Ordering) -> (a, b, c, a0) -> (a, b, c, b0) -> Ordering

(Read a, Read b, Read c) => Read1 ((,,,) a b c)

Methods

liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (a, b, c, a0)

liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [(a, b, c, a0)]

liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (a, b, c, a0)

liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [(a, b, c, a0)]

(Show a, Show b, Show c) => Show1 ((,,,) a b c)

Methods

liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> (a, b, c, a0) -> ShowS

liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [(a, b, c, a0)] -> ShowS

(Semigroup (f a), Semigroup (g a)) => Semigroup (Product f g a)

Methods

(<>) :: Product f g a -> Product f g a -> Product f g a

sconcat :: NonEmpty (Product f g a) -> Product f g a

stimes :: Integral b => b -> Product f g a -> Product f g a

(Monoid (f a), Monoid (g a)) => Monoid (Product f g a)

Methods

mempty :: Product f g a

mappend :: Product f g a -> Product f g a -> Product f g a

mconcat :: [Product f g a] -> Product f g a

Semigroup (f (g a)) => Semigroup (Compose f g a)

Methods

(<>) :: Compose f g a -> Compose f g a -> Compose f g a

sconcat :: NonEmpty (Compose f g a) -> Compose f g a

stimes :: Integral b => b -> Compose f g a -> Compose f g a

Monoid (f (g a)) => Monoid (Compose f g a)

Methods

mempty :: Compose f g a

mappend :: Compose f g a -> Compose f g a -> Compose f g a

mconcat :: [Compose f g a] -> Compose f g a

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

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)

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)

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)

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)

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)

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)

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)

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)

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)

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