License | BSD-style |
---|---|
Maintainer | Vincent Hanquez <vincent@snarc.org> |
Stability | experimental |
Portability | portable |
Safe Haskell | None |
Language | Haskell2010 |
Basement.Compat.Base
Description
internal re-export of all the good base bits
Synopsis
- ($) :: (a -> b) -> a -> b
- ($!) :: (a -> b) -> a -> b
- (&&) :: Bool -> Bool -> Bool
- (||) :: Bool -> Bool -> Bool
- (.) :: forall (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- not :: Bool -> Bool
- otherwise :: Bool
- fst :: (a, b) -> a
- snd :: (a, b) -> b
- id :: forall (a :: k). Category cat => cat a a
- maybe :: b -> (a -> b) -> Maybe a -> b
- either :: (a -> c) -> (b -> c) -> Either a b -> c
- flip :: (a -> b -> c) -> b -> a -> c
- const :: a -> b -> a
- error :: HasCallStack => [Char] -> a
- and :: Foldable t => t Bool -> Bool
- undefined :: HasCallStack => a
- seq :: a -> b -> b
- class Show a where
- class Eq a => Ord a where
- class Eq a where
- class Bounded a where
- class Enum a where
- succ :: a -> a
- pred :: a -> a
- toEnum :: Int -> a
- fromEnum :: a -> Int
- enumFrom :: a -> [a]
- enumFromThen :: a -> a -> [a]
- enumFromTo :: a -> a -> [a]
- enumFromThenTo :: a -> a -> a -> [a]
- class Functor (f :: Type -> Type) where
- class Functor f => Applicative (f :: Type -> Type) where
- class Applicative m => Monad (m :: Type -> Type) where
- when :: Applicative f => Bool -> f () -> f ()
- unless :: Applicative f => Bool -> f () -> f ()
- data Maybe a
- data Ordering
- data Bool
- data Int
- data Integer
- data Char
- class Integral a where
- fromInteger :: Integer -> a
- class Fractional a where
- fromRational :: Rational -> a
- class HasNegation a where
- negate :: a -> a
- data Int8
- data Int16
- data Int32
- data Int64
- data Word8
- data Word16
- data Word32
- data Word64
- data Word
- data Double
- data Float
- data IO a
- class IsList l where
- class IsString a where
- fromString :: String -> a
- class Generic a
- data Either a b
- class Typeable a => Data a where
- gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> a -> c a
- gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c a
- toConstr :: a -> Constr
- dataTypeOf :: a -> DataType
- dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c a)
- dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a)
- gmapT :: (forall b. Data b => b -> b) -> a -> a
- gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
- gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
- gmapQ :: (forall d. Data d => d -> u) -> a -> [u]
- gmapQi :: Int -> (forall d. Data d => d -> u) -> a -> u
- gmapM :: Monad m => (forall d. Data d => d -> m d) -> a -> m a
- gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
- gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
- mkNoRepType :: String -> DataType
- data DataType
- class Typeable (a :: k)
- class Semigroup a => Monoid a where
- (<>) :: Semigroup a => a -> a -> a
- class (Typeable e, Show e) => Exception e
- throw :: forall a e. (HasCallStack, Exception e) => e -> a
- throwIO :: (HasCallStack, Exception e) => e -> IO a
- data Ptr a = Ptr Addr#
- ifThenElse :: Bool -> a -> a -> a
- internalError :: [Char] -> a
Documentation
error :: HasCallStack => [Char] -> a #
undefined :: HasCallStack => a #
Instances
Show ByteArray | |
Show Timeout | |
Show Endianness Source # | |
Defined in Basement.Endianness Methods showsPrec :: Int -> Endianness -> ShowS # show :: Endianness -> String # showList :: [Endianness] -> ShowS # | |
Show InvalidRecast Source # | |
Defined in Basement.Exception Methods showsPrec :: Int -> InvalidRecast -> ShowS # show :: InvalidRecast -> String # showList :: [InvalidRecast] -> ShowS # | |
Show NonEmptyCollectionIsEmpty Source # | |
Defined in Basement.Exception Methods showsPrec :: Int -> NonEmptyCollectionIsEmpty -> ShowS # show :: NonEmptyCollectionIsEmpty -> String # showList :: [NonEmptyCollectionIsEmpty] -> ShowS # | |
Show OutOfBound Source # | |
Defined in Basement.Exception Methods showsPrec :: Int -> OutOfBound -> ShowS # show :: OutOfBound -> String # showList :: [OutOfBound] -> ShowS # | |
Show OutOfBoundOperation Source # | |
Defined in Basement.Exception Methods showsPrec :: Int -> OutOfBoundOperation -> ShowS # show :: OutOfBoundOperation -> String # showList :: [OutOfBoundOperation] -> ShowS # | |
Show RecastDestinationSize Source # | |
Defined in Basement.Exception Methods showsPrec :: Int -> RecastDestinationSize -> ShowS # show :: RecastDestinationSize -> String # showList :: [RecastDestinationSize] -> ShowS # | |
Show RecastSourceSize Source # | |
Defined in Basement.Exception Methods showsPrec :: Int -> RecastSourceSize -> ShowS # show :: RecastSourceSize -> String # showList :: [RecastSourceSize] -> ShowS # | |
Show Encoding Source # | |
Show AsciiString Source # | |
Defined in Basement.Types.AsciiString Methods showsPrec :: Int -> AsciiString -> ShowS # show :: AsciiString -> String # showList :: [AsciiString] -> ShowS # | |
Show Char7 Source # | |
Show FileSize Source # | |
Show Word128 Source # | |
Show Word256 Source # | |
Show String Source # | |
Show ValidationFailure Source # | |
Defined in Basement.UTF8.Types Methods showsPrec :: Int -> ValidationFailure -> ShowS # show :: ValidationFailure -> String # showList :: [ValidationFailure] -> ShowS # | |
Show Void | |
Show Constr | |
Show ConstrRep | |
Show DataRep | |
Show DataType | |
Show Fixity | |
Show All | |
Show Any | |
Show SomeTypeRep | |
Show Version | |
Show ErrorCall | |
Show ArithException | |
Show SomeException | |
Show CBool | |
Show CChar | |
Show CClock | |
Show CDouble | |
Show CFloat | |
Show CInt | |
Show CIntMax | |
Show CIntPtr | |
Show CLLong | |
Show CLong | |
Show CPtrdiff | |
Show CSChar | |
Show CSUSeconds | |
Defined in GHC.Internal.Foreign.C.Types Methods showsPrec :: Int -> CSUSeconds -> ShowS # show :: CSUSeconds -> String # showList :: [CSUSeconds] -> ShowS # | |
Show CShort | |
Show CSigAtomic | |
Defined in GHC.Internal.Foreign.C.Types Methods showsPrec :: Int -> CSigAtomic -> ShowS # show :: CSigAtomic -> String # showList :: [CSigAtomic] -> ShowS # | |
Show CSize | |
Show CTime | |
Show CUChar | |
Show CUInt | |
Show CUIntMax | |
Show CUIntPtr | |
Show CULLong | |
Show CULong | |
Show CUSeconds | |
Show CUShort | |
Show CWchar | |
Show IntPtr | |
Show WordPtr | |
Show Associativity | |
Show DecidedStrictness | |
Show Fixity | |
Show SourceStrictness | |
Show SourceUnpackedness | |
Show MaskingState | |
Show AllocationLimitExceeded | |
Show ArrayException | |
Show AssertionFailed | |
Show AsyncException | |
Show BlockedIndefinitelyOnMVar | |
Show BlockedIndefinitelyOnSTM | |
Show CompactionFailed | |
Show Deadlock | |
Show ExitCode | |
Show FixIOException | |
Show IOErrorType | |
Show IOException | |
Show SomeAsyncException | |
Show Int16 | |
Show Int32 | |
Show Int64 | |
Show Int8 | |
Show CCFlags | |
Show ConcFlags | |
Show DebugFlags | |
Show DoCostCentres | |
Show DoHeapProfile | |
Show DoTrace | |
Show GCFlags | |
Show GiveGCStats | |
Show HpcFlags | |
Show IoSubSystem | |
Show MiscFlags | |
Show ParFlags | |
Show ProfFlags | |
Show RTSFlags | |
Show TickyFlags | |
Show TraceFlags | |
Show FractionalExponentBase | |
Show CallStack | |
Show SrcLoc | |
Show CBlkCnt | |
Show CBlkSize | |
Show CCc | |
Show CClockId | |
Show CDev | |
Show CFsBlkCnt | |
Show CFsFilCnt | |
Show CGid | |
Show CId | |
Show CIno | |
Show CKey | |
Show CMode | |
Show CNfds | |
Show CNlink | |
Show COff | |
Show CPid | |
Show CRLim | |
Show CSocklen | |
Show CSpeed | |
Show CSsize | |
Show CTcflag | |
Show CTimer | |
Show CUid | |
Show Fd | |
Show SomeChar | |
Show SomeSymbol | |
Show SomeNat | |
Show GeneralCategory | |
Show Word16 | |
Show Word32 | |
Show Word64 | |
Show Word8 | |
Show KindRep | |
Show Module | |
Show Ordering | |
Show TrName | |
Show TyCon | |
Show TypeLitSort | |
Show Integer | |
Show Natural | |
Show () | |
Show Bool | |
Show Char | |
Show Int | |
Show Levity | |
Show RuntimeRep | |
Show VecCount | |
Show VecElem | |
Show Word | |
Show a => Show (Complex a) | |
Show a => Show (First a) | |
Show a => Show (Last a) | |
Show a => Show (Max a) | |
Show a => Show (Min a) | |
Show m => Show (WrappedMonoid m) | |
Show (Bits n) Source # | |
(PrimType ty, Show ty) => Show (Block ty) Source # | |
Show (Zn n) Source # | |
Show (Zn64 n) Source # | |
Show a => Show (Array a) Source # | |
Show a => Show (BE a) Source # | |
Show a => Show (LE a) Source # | |
Show (FinalPtr a) Source # | |
Show a => Show (NonEmpty a) Source # | |
Show (CountOf ty) Source # | |
Show (Offset ty) Source # | |
(PrimType ty, Show ty) => Show (UArray ty) Source # | |
Show a => Show (NonEmpty a) | |
Show a => Show (Identity a) | |
Show a => Show (First a) | |
Show a => Show (Last a) | |
Show a => Show (Dual a) | |
Show a => Show (Product a) | |
Show a => Show (Sum a) | |
Show a => Show (ExceptionWithContext a) | |
Show e => Show (NoBacktrace e) | |
Show (ForeignPtr a) | |
Show a => Show (ZipList a) | |
Show p => Show (Par1 p) | |
Show (FunPtr a) | |
Show (Ptr a) | |
Show a => Show (Ratio a) | |
Show (SChar c) | |
Show (SSymbol s) | |
Show (SNat n) | |
Show a => Show (Maybe a) | |
Show a => Show (Solo a) | |
Show a => Show [a] | |
HasResolution a => Show (Fixed a) | |
(Show a, Show b) => Show (Arg a b) | |
(PrimType a, Show a) => Show (BlockN n a) Source # | |
Show a => Show (ListN n a) Source # | |
(PrimType a, Show a) => Show (UVect n a) Source # | |
Show a => Show (Vect n a) Source # | |
(Show a, Show b) => Show (These a b) Source # | |
(Show a, Show b) => Show (Either a b) | |
Show (Proxy s) | |
Show (TypeRep a) | |
Show (U1 p) | |
Show (V1 p) | |
Show (ST s a) | |
(Show a, Show b) => Show (a, b) | |
Show a => Show (Const a b) | |
Show (f a) => Show (Ap f a) | |
Show (f a) => Show (Alt f a) | |
Show (OrderingI a b) | |
Show (f p) => Show (Rec1 f p) | |
Show (URec Char p) | |
Show (URec Double p) | |
Show (URec Float p) | |
Show (URec Int p) | |
Show (URec Word p) | |
(Show a, Show b, Show c) => Show (a, b, c) | |
(Show (f a), Show (g a)) => Show (Product f g a) | |
(Show (f a), Show (g a)) => Show (Sum f g a) | |
(Show (f p), Show (g p)) => Show ((f :*: g) p) | |
(Show (f p), Show (g p)) => Show ((f :+: g) p) | |
Show c => Show (K1 i c p) | |
(Show a, Show b, Show c, Show d) => Show (a, b, c, d) | |
Show (f (g a)) => Show (Compose f g a) | |
Show (f (g p)) => Show ((f :.: g) p) | |
Show (f p) => Show (M1 i c f p) | |
(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) | |
(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Instances
Ord ByteArray | |
Ord Encoding Source # | |
Defined in Basement.String | |
Ord AsciiString Source # | |
Defined in Basement.Types.AsciiString Methods compare :: AsciiString -> AsciiString -> Ordering # (<) :: AsciiString -> AsciiString -> Bool # (<=) :: AsciiString -> AsciiString -> Bool # (>) :: AsciiString -> AsciiString -> Bool # (>=) :: AsciiString -> AsciiString -> Bool # max :: AsciiString -> AsciiString -> AsciiString # min :: AsciiString -> AsciiString -> AsciiString # | |
Ord Char7 Source # | |
Ord FileSize Source # | |
Defined in Basement.Types.OffsetSize | |
Ord Addr Source # | |
Ord Word128 Source # | |
Defined in Basement.Types.Word128 | |
Ord Word256 Source # | |
Defined in Basement.Types.Word256 | |
Ord String Source # | |
Ord BigNat | |
Ord Void | |
Ord All | |
Ord Any | |
Ord SomeTypeRep | |
Defined in GHC.Internal.Data.Typeable.Internal | |
Ord Version | |
Defined in GHC.Internal.Data.Version | |
Ord ErrorCall | |
Ord ArithException | |
Defined in GHC.Internal.Exception.Type Methods compare :: ArithException -> ArithException -> Ordering # (<) :: ArithException -> ArithException -> Bool # (<=) :: ArithException -> ArithException -> Bool # (>) :: ArithException -> ArithException -> Bool # (>=) :: ArithException -> ArithException -> Bool # | |
Ord CBool | |
Ord CChar | |
Ord CClock | |
Ord CDouble | |
Defined in GHC.Internal.Foreign.C.Types | |
Ord CFloat | |
Ord CInt | |
Ord CIntMax | |
Defined in GHC.Internal.Foreign.C.Types | |
Ord CIntPtr | |
Defined in GHC.Internal.Foreign.C.Types | |
Ord CLLong | |
Ord CLong | |
Ord CPtrdiff | |
Defined in GHC.Internal.Foreign.C.Types | |
Ord CSChar | |
Ord CSUSeconds | |
Defined in GHC.Internal.Foreign.C.Types Methods compare :: CSUSeconds -> CSUSeconds -> Ordering # (<) :: CSUSeconds -> CSUSeconds -> Bool # (<=) :: CSUSeconds -> CSUSeconds -> Bool # (>) :: CSUSeconds -> CSUSeconds -> Bool # (>=) :: CSUSeconds -> CSUSeconds -> Bool # max :: CSUSeconds -> CSUSeconds -> CSUSeconds # min :: CSUSeconds -> CSUSeconds -> CSUSeconds # | |
Ord CShort | |
Ord CSigAtomic | |
Defined in GHC.Internal.Foreign.C.Types Methods compare :: CSigAtomic -> CSigAtomic -> Ordering # (<) :: CSigAtomic -> CSigAtomic -> Bool # (<=) :: CSigAtomic -> CSigAtomic -> Bool # (>) :: CSigAtomic -> CSigAtomic -> Bool # (>=) :: CSigAtomic -> CSigAtomic -> Bool # max :: CSigAtomic -> CSigAtomic -> CSigAtomic # min :: CSigAtomic -> CSigAtomic -> CSigAtomic # | |
Ord CSize | |
Ord CTime | |
Ord CUChar | |
Ord CUInt | |
Ord CUIntMax | |
Defined in GHC.Internal.Foreign.C.Types | |
Ord CUIntPtr | |
Defined in GHC.Internal.Foreign.C.Types | |
Ord CULLong | |
Defined in GHC.Internal.Foreign.C.Types | |
Ord CULong | |
Ord CUSeconds | |
Ord CUShort | |
Defined in GHC.Internal.Foreign.C.Types | |
Ord CWchar | |
Ord IntPtr | |
Ord WordPtr | |
Defined in GHC.Internal.Foreign.Ptr | |
Ord Associativity | |
Defined in GHC.Internal.Generics Methods compare :: Associativity -> Associativity -> Ordering # (<) :: Associativity -> Associativity -> Bool # (<=) :: Associativity -> Associativity -> Bool # (>) :: Associativity -> Associativity -> Bool # (>=) :: Associativity -> Associativity -> Bool # | |
Ord DecidedStrictness | |
Defined in GHC.Internal.Generics Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering # (<) :: DecidedStrictness -> DecidedStrictness -> Bool # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool # (>) :: DecidedStrictness -> DecidedStrictness -> Bool # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # | |
Ord Fixity | |
Ord SourceStrictness | |
Defined in GHC.Internal.Generics Methods compare :: SourceStrictness -> SourceStrictness -> Ordering # (<) :: SourceStrictness -> SourceStrictness -> Bool # (<=) :: SourceStrictness -> SourceStrictness -> Bool # (>) :: SourceStrictness -> SourceStrictness -> Bool # (>=) :: SourceStrictness -> SourceStrictness -> Bool # max :: SourceStrictness -> SourceStrictness -> SourceStrictness # min :: SourceStrictness -> SourceStrictness -> SourceStrictness # | |
Ord SourceUnpackedness | |
Defined in GHC.Internal.Generics Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # | |
Ord ArrayException | |
Defined in GHC.Internal.IO.Exception Methods compare :: ArrayException -> ArrayException -> Ordering # (<) :: ArrayException -> ArrayException -> Bool # (<=) :: ArrayException -> ArrayException -> Bool # (>) :: ArrayException -> ArrayException -> Bool # (>=) :: ArrayException -> ArrayException -> Bool # | |
Ord AsyncException | |
Defined in GHC.Internal.IO.Exception Methods compare :: AsyncException -> AsyncException -> Ordering # (<) :: AsyncException -> AsyncException -> Bool # (<=) :: AsyncException -> AsyncException -> Bool # (>) :: AsyncException -> AsyncException -> Bool # (>=) :: AsyncException -> AsyncException -> Bool # | |
Ord ExitCode | |
Defined in GHC.Internal.IO.Exception | |
Ord Int16 | |
Ord Int32 | |
Ord Int64 | |
Ord Int8 | |
Ord CBlkCnt | |
Defined in GHC.Internal.System.Posix.Types | |
Ord CBlkSize | |
Defined in GHC.Internal.System.Posix.Types | |
Ord CCc | |
Ord CClockId | |
Defined in GHC.Internal.System.Posix.Types | |
Ord CDev | |
Ord CFsBlkCnt | |
Ord CFsFilCnt | |
Ord CGid | |
Ord CId | |
Ord CIno | |
Ord CKey | |
Ord CMode | |
Ord CNfds | |
Ord CNlink | |
Ord COff | |
Ord CPid | |
Ord CRLim | |
Ord CSocklen | |
Defined in GHC.Internal.System.Posix.Types | |
Ord CSpeed | |
Ord CSsize | |
Ord CTcflag | |
Defined in GHC.Internal.System.Posix.Types | |
Ord CTimer | |
Ord CUid | |
Ord Fd | |
Ord SomeChar | |
Defined in GHC.Internal.TypeLits | |
Ord SomeSymbol | |
Defined in GHC.Internal.TypeLits | |
Ord SomeNat | |
Defined in GHC.Internal.TypeNats | |
Ord GeneralCategory | |
Defined in GHC.Internal.Unicode Methods compare :: GeneralCategory -> GeneralCategory -> Ordering # (<) :: GeneralCategory -> GeneralCategory -> Bool # (<=) :: GeneralCategory -> GeneralCategory -> Bool # (>) :: GeneralCategory -> GeneralCategory -> Bool # (>=) :: GeneralCategory -> GeneralCategory -> Bool # max :: GeneralCategory -> GeneralCategory -> GeneralCategory # min :: GeneralCategory -> GeneralCategory -> GeneralCategory # | |
Ord Word16 | |
Ord Word32 | |
Ord Word64 | |
Ord Word8 | |
Ord Ordering | |
Defined in GHC.Classes | |
Ord TyCon | |
Ord Integer | |
Ord Natural | |
Ord () | |
Ord Bool | |
Ord Char | |
Ord Double | |
Ord Float | |
Ord Int | |
Ord Word | |
Ord a => Ord (First a) | |
Ord a => Ord (Last a) | |
Ord a => Ord (Max a) | |
Ord a => Ord (Min a) | |
Ord m => Ord (WrappedMonoid m) | |
Defined in Data.Semigroup Methods compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering # (<) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # | |
Ord (Bits n) Source # | |
(PrimType ty, Ord ty) => Ord (Block ty) Source # | |
Defined in Basement.Block.Base | |
Ord (Zn n) Source # | |
Ord (Zn64 n) Source # | |
Ord a => Ord (Array a) Source # | |
(ByteSwap a, Ord a) => Ord (BE a) Source # | |
(ByteSwap a, Ord a) => Ord (LE a) Source # | |
Ord (FinalPtr a) Source # | |
Ord (CountOf ty) Source # | |
Defined in Basement.Types.OffsetSize | |
Ord (Offset ty) Source # | |
(PrimType ty, Ord ty) => Ord (UArray ty) Source # | |
Ord a => Ord (NonEmpty a) | |
Ord a => Ord (Identity a) | |
Defined in GHC.Internal.Data.Functor.Identity | |
Ord a => Ord (First a) | |
Defined in GHC.Internal.Data.Monoid | |
Ord a => Ord (Last a) | |
Ord a => Ord (Dual a) | |
Defined in GHC.Internal.Data.Semigroup.Internal | |
Ord a => Ord (Product a) | |
Defined in GHC.Internal.Data.Semigroup.Internal | |
Ord a => Ord (Sum a) | |
Ord (ForeignPtr a) | |
Defined in GHC.Internal.ForeignPtr | |
Ord a => Ord (ZipList a) | |
Ord p => Ord (Par1 p) | |
Ord (FunPtr a) | |
Defined in GHC.Internal.Ptr | |
Ord (Ptr a) | |
Integral a => Ord (Ratio a) | |
Ord (SChar c) | |
Defined in GHC.Internal.TypeLits | |
Ord (SSymbol s) | |
Ord (SNat n) | |
Ord a => Ord (Maybe a) | |
Ord a => Ord (Solo a) | |
Ord a => Ord [a] | |
Ord (Fixed a) | |
Ord a => Ord (Arg a b) | |
(PrimType a, Ord a) => Ord (BlockN n a) Source # | |
Defined in Basement.Sized.Block | |
Ord a => Ord (ListN n a) Source # | |
(Ord a, Ord b) => Ord (These a b) Source # | |
(Ord a, Ord b) => Ord (Either a b) | |
Defined in GHC.Internal.Data.Either | |
Ord (Proxy s) | |
Defined in GHC.Internal.Data.Proxy | |
Ord (TypeRep a) | |
Defined in GHC.Internal.Data.Typeable.Internal | |
Ord (U1 p) | |
Ord (V1 p) | |
(Ord a, Ord b) => Ord (a, b) | |
Ord a => Ord (Const a b) | |
Ord (f a) => Ord (Ap f a) | |
Ord (f a) => Ord (Alt f a) | |
Defined in GHC.Internal.Data.Semigroup.Internal | |
(Generic1 f, Ord (Rep1 f a)) => Ord (Generically1 f a) | |
Defined in GHC.Internal.Generics Methods compare :: Generically1 f a -> Generically1 f a -> Ordering # (<) :: Generically1 f a -> Generically1 f a -> Bool # (<=) :: Generically1 f a -> Generically1 f a -> Bool # (>) :: Generically1 f a -> Generically1 f a -> Bool # (>=) :: Generically1 f a -> Generically1 f a -> Bool # max :: Generically1 f a -> Generically1 f a -> Generically1 f a # min :: Generically1 f a -> Generically1 f a -> Generically1 f a # | |
Ord (f p) => Ord (Rec1 f p) | |
Defined in GHC.Internal.Generics | |
Ord (URec (Ptr ()) p) | |
Defined in GHC.Internal.Generics Methods compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering # (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # | |
Ord (URec Char p) | |
Defined in GHC.Internal.Generics | |
Ord (URec Double p) | |
Defined in GHC.Internal.Generics Methods compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # | |
Ord (URec Float p) | |
Defined in GHC.Internal.Generics | |
Ord (URec Int p) | |
Defined in GHC.Internal.Generics | |
Ord (URec Word p) | |
Defined in GHC.Internal.Generics | |
(Ord a, Ord b, Ord c) => Ord (a, b, c) | |
(Ord (f a), Ord (g a)) => Ord (Product f g a) | |
Defined in Data.Functor.Product Methods compare :: Product f g a -> Product f g a -> Ordering # (<) :: Product f g a -> Product f g a -> Bool # (<=) :: Product f g a -> Product f g a -> Bool # (>) :: Product f g a -> Product f g a -> Bool # (>=) :: Product f g a -> Product f g a -> Bool # | |
(Ord (f a), Ord (g a)) => Ord (Sum f g a) | |
(Ord (f p), Ord (g p)) => Ord ((f :*: g) p) | |
Defined in GHC.Internal.Generics | |
(Ord (f p), Ord (g p)) => Ord ((f :+: g) p) | |
Defined in GHC.Internal.Generics | |
Ord c => Ord (K1 i c p) | |
Defined in GHC.Internal.Generics | |
(Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) | |
Defined in GHC.Classes | |
Ord (f (g a)) => Ord (Compose f g a) | |
Defined in Data.Functor.Compose Methods compare :: Compose f g a -> Compose f g a -> Ordering # (<) :: Compose f g a -> Compose f g a -> Bool # (<=) :: Compose f g a -> Compose f g a -> Bool # (>) :: Compose f g a -> Compose f g a -> Bool # (>=) :: Compose f g a -> Compose f g a -> Bool # | |
Ord (f (g p)) => Ord ((f :.: g) p) | |
Defined in GHC.Internal.Generics | |
Ord (f p) => Ord (M1 i c f p) | |
Defined in GHC.Internal.Generics | |
(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e) -> (a, b, c, d, e) -> Ordering # (<) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (<=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (>=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # max :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # min :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Ordering # (<) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (<=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (>) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (>=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # max :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # min :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Ordering # (<) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (<=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (>) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (>=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # max :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # min :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Ordering # (<) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (<=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (>) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (>=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # max :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # min :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # max :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # min :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # min :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # min :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # min :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # |
Instances
Eq ByteArray | |
Eq Timeout | |
Eq PinnedStatus Source # | |
Defined in Basement.Compat.Primitive | |
Eq Endianness Source # | |
Defined in Basement.Endianness | |
Eq OutOfBoundOperation Source # | |
Defined in Basement.Exception Methods (==) :: OutOfBoundOperation -> OutOfBoundOperation -> Bool # (/=) :: OutOfBoundOperation -> OutOfBoundOperation -> Bool # | |
Eq RecastDestinationSize Source # | |
Defined in Basement.Exception Methods (==) :: RecastDestinationSize -> RecastDestinationSize -> Bool # (/=) :: RecastDestinationSize -> RecastDestinationSize -> Bool # | |
Eq RecastSourceSize Source # | |
Defined in Basement.Exception Methods (==) :: RecastSourceSize -> RecastSourceSize -> Bool # (/=) :: RecastSourceSize -> RecastSourceSize -> Bool # | |
Eq Encoding Source # | |
Eq AsciiString Source # | |
Defined in Basement.Types.AsciiString | |
Eq Char7 Source # | |
Eq FileSize Source # | |
Eq Addr Source # | |
Eq Word128 Source # | |
Eq Word256 Source # | |
Eq String Source # | |
Eq ValidationFailure Source # | |
Defined in Basement.UTF8.Types Methods (==) :: ValidationFailure -> ValidationFailure -> Bool # (/=) :: ValidationFailure -> ValidationFailure -> Bool # | |
Eq BigNat | |
Eq Void | |
Eq Constr | |
Eq ConstrRep | |
Eq DataRep | |
Eq Fixity | |
Eq All | |
Eq Any | |
Eq SomeTypeRep | |
Eq Version | |
Eq ErrorCall | |
Eq ArithException | |
Eq CBool | |
Eq CChar | |
Eq CClock | |
Eq CDouble | |
Eq CFloat | |
Eq CInt | |
Eq CIntMax | |
Eq CIntPtr | |
Eq CLLong | |
Eq CLong | |
Eq CPtrdiff | |
Eq CSChar | |
Eq CSUSeconds | |
Defined in GHC.Internal.Foreign.C.Types | |
Eq CShort | |
Eq CSigAtomic | |
Defined in GHC.Internal.Foreign.C.Types | |
Eq CSize | |
Eq CTime | |
Eq CUChar | |
Eq CUInt | |
Eq CUIntMax | |
Eq CUIntPtr | |
Eq CULLong | |
Eq CULong | |
Eq CUSeconds | |
Eq CUShort | |
Eq CWchar | |
Eq IntPtr | |
Eq WordPtr | |
Eq Associativity | |
Eq DecidedStrictness | |
Eq Fixity | |
Eq SourceStrictness | |
Eq SourceUnpackedness | |
Eq MaskingState | |
Eq ArrayException | |
Eq AsyncException | |
Eq ExitCode | |
Eq IOErrorType | |
Eq IOException | |
Eq Int16 | |
Eq Int32 | |
Eq Int64 | |
Eq Int8 | |
Eq IoSubSystem | |
Eq SrcLoc | |
Eq CBlkCnt | |
Eq CBlkSize | |
Eq CCc | |
Eq CClockId | |
Eq CDev | |
Eq CFsBlkCnt | |
Eq CFsFilCnt | |
Eq CGid | |
Eq CId | |
Eq CIno | |
Eq CKey | |
Eq CMode | |
Eq CNfds | |
Eq CNlink | |
Eq COff | |
Eq CPid | |
Eq CRLim | |
Eq CSocklen | |
Eq CSpeed | |
Eq CSsize | |
Eq CTcflag | |
Eq CTimer | |
Eq CUid | |
Eq Fd | |
Eq SomeChar | |
Eq SomeSymbol | |
Eq SomeNat | |
Eq GeneralCategory | |
Eq Word16 | |
Eq Word32 | |
Eq Word64 | |
Eq Word8 | |
Eq Module | |
Eq Ordering | |
Eq TrName | |
Eq TyCon | |
Eq Integer | |
Eq Natural | |
Eq () | |
Eq Bool | |
Eq Char | |
Eq Double | |
Eq Float | |
Eq Int | |
Eq Word | |
Eq (Chan a) | |
Eq (MutableByteArray s) | |
Eq a => Eq (Complex a) | |
Eq a => Eq (First a) | |
Eq a => Eq (Last a) | |
Eq a => Eq (Max a) | |
Eq a => Eq (Min a) | |
Eq m => Eq (WrappedMonoid m) | |
Eq (Bits n) Source # | |
(PrimType ty, Eq ty) => Eq (Block ty) Source # | |
Eq (Zn n) Source # | |
Eq (Zn64 n) Source # | |
Eq a => Eq (Array a) Source # | |
Eq a => Eq (BE a) Source # | |
Eq a => Eq (LE a) Source # | |
Eq (FinalPtr a) Source # | |
Eq a => Eq (NonEmpty a) Source # | |
Eq (CountOf ty) Source # | |
Eq (Offset ty) Source # | |
(PrimType ty, Eq ty) => Eq (UArray ty) Source # | |
Eq a => Eq (NonEmpty a) | |
Eq a => Eq (Identity a) | |
Eq a => Eq (First a) | |
Eq a => Eq (Last a) | |
Eq a => Eq (Dual a) | |
Eq a => Eq (Product a) | |
Eq a => Eq (Sum a) | |
Eq (ForeignPtr a) | |
Eq a => Eq (ZipList a) | |
Eq p => Eq (Par1 p) | |
Eq (IORef a) | |
Eq (FunPtr a) | |
Eq (Ptr a) | |
Eq a => Eq (Ratio a) | |
Eq (SChar c) | |
Eq (SSymbol s) | |
Eq (SNat n) | |
Eq a => Eq (Maybe a) | |
Eq a => Eq (Solo a) | |
Eq a => Eq [a] | |
Eq (Fixed a) | |
Eq a => Eq (Arg a b) | |
PrimType a => Eq (BlockN n a) Source # | |
Eq a => Eq (ListN n a) Source # | |
PrimType a => Eq (UVect n a) Source # | |
Eq a => Eq (Vect n a) Source # | |
(Eq a, Eq b) => Eq (These a b) Source # | |
(Eq a, Eq b) => Eq (Either a b) | |
Eq (Proxy s) | |
Eq (TypeRep a) | |
Eq (U1 p) | |
Eq (V1 p) | |
Eq (STRef s a) | |
(Eq a, Eq b) => Eq (a, b) | |
Eq a => Eq (Const a b) | |
Eq (f a) => Eq (Ap f a) | |
Eq (f a) => Eq (Alt f a) | |
Eq (OrderingI a b) | |
(Generic1 f, Eq (Rep1 f a)) => Eq (Generically1 f a) | |
Eq (f p) => Eq (Rec1 f p) | |
Eq (URec (Ptr ()) p) | |
Eq (URec Char p) | |
Eq (URec Double p) | |
Eq (URec Float p) | |
Eq (URec Int p) | |
Eq (URec Word p) | |
(Eq a, Eq b, Eq c) => Eq (a, b, c) | |
(Eq (f a), Eq (g a)) => Eq (Product f g a) | |
(Eq (f a), Eq (g a)) => Eq (Sum f g a) | |
(Eq (f p), Eq (g p)) => Eq ((f :*: g) p) | |
(Eq (f p), Eq (g p)) => Eq ((f :+: g) p) | |
Eq c => Eq (K1 i c p) | |
(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) | |
Eq (f (g a)) => Eq (Compose f g a) | |
Eq (f (g p)) => Eq ((f :.: g) p) | |
Eq (f p) => Eq (M1 i c f p) | |
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Instances
Methods
enumFromThen :: a -> a -> [a] #
enumFromTo :: a -> a -> [a] #
enumFromThenTo :: a -> a -> a -> [a] #
Instances
Enum Encoding Source # | |
Enum Word128 Source # | |
Enum Word256 Source # | |
Enum CBool | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum CChar | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum CClock | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum CDouble | |
Enum CFloat | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum CInt | |
Enum CIntMax | |
Enum CIntPtr | |
Enum CLLong | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum CLong | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum CPtrdiff | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum CSChar | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum CSUSeconds | |
Defined in GHC.Internal.Foreign.C.Types Methods succ :: CSUSeconds -> CSUSeconds # pred :: CSUSeconds -> CSUSeconds # toEnum :: Int -> CSUSeconds # fromEnum :: CSUSeconds -> Int # enumFrom :: CSUSeconds -> [CSUSeconds] # enumFromThen :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromTo :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromThenTo :: CSUSeconds -> CSUSeconds -> CSUSeconds -> [CSUSeconds] # | |
Enum CShort | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum CSigAtomic | |
Defined in GHC.Internal.Foreign.C.Types Methods succ :: CSigAtomic -> CSigAtomic # pred :: CSigAtomic -> CSigAtomic # toEnum :: Int -> CSigAtomic # fromEnum :: CSigAtomic -> Int # enumFrom :: CSigAtomic -> [CSigAtomic] # enumFromThen :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromTo :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromThenTo :: CSigAtomic -> CSigAtomic -> CSigAtomic -> [CSigAtomic] # | |
Enum CSize | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum CTime | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum CUChar | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum CUInt | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum CUIntMax | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum CUIntPtr | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum CULLong | |
Enum CULong | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum CUSeconds | |
Defined in GHC.Internal.Foreign.C.Types Methods succ :: CUSeconds -> CUSeconds # pred :: CUSeconds -> CUSeconds # fromEnum :: CUSeconds -> Int # enumFrom :: CUSeconds -> [CUSeconds] # enumFromThen :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromTo :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromThenTo :: CUSeconds -> CUSeconds -> CUSeconds -> [CUSeconds] # | |
Enum CUShort | |
Enum CWchar | |
Defined in GHC.Internal.Foreign.C.Types | |
Enum IntPtr | |
Defined in GHC.Internal.Foreign.Ptr | |
Enum WordPtr | |
Defined in GHC.Internal.Foreign.Ptr Methods enumFrom :: WordPtr -> [WordPtr] # enumFromThen :: WordPtr -> WordPtr -> [WordPtr] # enumFromTo :: WordPtr -> WordPtr -> [WordPtr] # enumFromThenTo :: WordPtr -> WordPtr -> WordPtr -> [WordPtr] # | |
Enum Associativity | |
Defined in GHC.Internal.Generics Methods succ :: Associativity -> Associativity # pred :: Associativity -> Associativity # toEnum :: Int -> Associativity # fromEnum :: Associativity -> Int # enumFrom :: Associativity -> [Associativity] # enumFromThen :: Associativity -> Associativity -> [Associativity] # enumFromTo :: Associativity -> Associativity -> [Associativity] # enumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity] # | |
Enum DecidedStrictness | |
Defined in GHC.Internal.Generics Methods succ :: DecidedStrictness -> DecidedStrictness # pred :: DecidedStrictness -> DecidedStrictness # toEnum :: Int -> DecidedStrictness # fromEnum :: DecidedStrictness -> Int # enumFrom :: DecidedStrictness -> [DecidedStrictness] # enumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromThenTo :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # | |
Enum SourceStrictness | |
Defined in GHC.Internal.Generics Methods succ :: SourceStrictness -> SourceStrictness # pred :: SourceStrictness -> SourceStrictness # toEnum :: Int -> SourceStrictness # fromEnum :: SourceStrictness -> Int # enumFrom :: SourceStrictness -> [SourceStrictness] # enumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromThenTo :: SourceStrictness -> SourceStrictness -> SourceStrictness -> [SourceStrictness] # | |
Enum SourceUnpackedness | |
Defined in GHC.Internal.Generics Methods succ :: SourceUnpackedness -> SourceUnpackedness # pred :: SourceUnpackedness -> SourceUnpackedness # toEnum :: Int -> SourceUnpackedness # fromEnum :: SourceUnpackedness -> Int # enumFrom :: SourceUnpackedness -> [SourceUnpackedness] # enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromThenTo :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # | |
Enum Int16 | |
Defined in GHC.Internal.Int | |
Enum Int32 | |
Defined in GHC.Internal.Int | |
Enum Int64 | |
Defined in GHC.Internal.Int | |
Enum Int8 | |
Enum DoCostCentres | |
Defined in GHC.Internal.RTS.Flags Methods succ :: DoCostCentres -> DoCostCentres # pred :: DoCostCentres -> DoCostCentres # toEnum :: Int -> DoCostCentres # fromEnum :: DoCostCentres -> Int # enumFrom :: DoCostCentres -> [DoCostCentres] # enumFromThen :: DoCostCentres -> DoCostCentres -> [DoCostCentres] # enumFromTo :: DoCostCentres -> DoCostCentres -> [DoCostCentres] # enumFromThenTo :: DoCostCentres -> DoCostCentres -> DoCostCentres -> [DoCostCentres] # | |
Enum DoHeapProfile | |
Defined in GHC.Internal.RTS.Flags Methods succ :: DoHeapProfile -> DoHeapProfile # pred :: DoHeapProfile -> DoHeapProfile # toEnum :: Int -> DoHeapProfile # fromEnum :: DoHeapProfile -> Int # enumFrom :: DoHeapProfile -> [DoHeapProfile] # enumFromThen :: DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] # enumFromTo :: DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] # enumFromThenTo :: DoHeapProfile -> DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] # | |
Enum DoTrace | |
Defined in GHC.Internal.RTS.Flags Methods enumFrom :: DoTrace -> [DoTrace] # enumFromThen :: DoTrace -> DoTrace -> [DoTrace] # enumFromTo :: DoTrace -> DoTrace -> [DoTrace] # enumFromThenTo :: DoTrace -> DoTrace -> DoTrace -> [DoTrace] # | |
Enum GiveGCStats | |
Defined in GHC.Internal.RTS.Flags Methods succ :: GiveGCStats -> GiveGCStats # pred :: GiveGCStats -> GiveGCStats # toEnum :: Int -> GiveGCStats # fromEnum :: GiveGCStats -> Int # enumFrom :: GiveGCStats -> [GiveGCStats] # enumFromThen :: GiveGCStats -> GiveGCStats -> [GiveGCStats] # enumFromTo :: GiveGCStats -> GiveGCStats -> [GiveGCStats] # enumFromThenTo :: GiveGCStats -> GiveGCStats -> GiveGCStats -> [GiveGCStats] # | |
Enum IoSubSystem | |
Defined in GHC.Internal.RTS.Flags Methods succ :: IoSubSystem -> IoSubSystem # pred :: IoSubSystem -> IoSubSystem # toEnum :: Int -> IoSubSystem # fromEnum :: IoSubSystem -> Int # enumFrom :: IoSubSystem -> [IoSubSystem] # enumFromThen :: IoSubSystem -> IoSubSystem -> [IoSubSystem] # enumFromTo :: IoSubSystem -> IoSubSystem -> [IoSubSystem] # enumFromThenTo :: IoSubSystem -> IoSubSystem -> IoSubSystem -> [IoSubSystem] # | |
Enum CBlkCnt | |
Defined in GHC.Internal.System.Posix.Types Methods enumFrom :: CBlkCnt -> [CBlkCnt] # enumFromThen :: CBlkCnt -> CBlkCnt -> [CBlkCnt] # enumFromTo :: CBlkCnt -> CBlkCnt -> [CBlkCnt] # enumFromThenTo :: CBlkCnt -> CBlkCnt -> CBlkCnt -> [CBlkCnt] # | |
Enum CBlkSize | |
Defined in GHC.Internal.System.Posix.Types Methods succ :: CBlkSize -> CBlkSize # pred :: CBlkSize -> CBlkSize # enumFrom :: CBlkSize -> [CBlkSize] # enumFromThen :: CBlkSize -> CBlkSize -> [CBlkSize] # enumFromTo :: CBlkSize -> CBlkSize -> [CBlkSize] # enumFromThenTo :: CBlkSize -> CBlkSize -> CBlkSize -> [CBlkSize] # | |
Enum CCc | |
Defined in GHC.Internal.System.Posix.Types | |
Enum CClockId | |
Defined in GHC.Internal.System.Posix.Types Methods succ :: CClockId -> CClockId # pred :: CClockId -> CClockId # enumFrom :: CClockId -> [CClockId] # enumFromThen :: CClockId -> CClockId -> [CClockId] # enumFromTo :: CClockId -> CClockId -> [CClockId] # enumFromThenTo :: CClockId -> CClockId -> CClockId -> [CClockId] # | |
Enum CDev | |
Defined in GHC.Internal.System.Posix.Types | |
Enum CFsBlkCnt | |
Defined in GHC.Internal.System.Posix.Types Methods succ :: CFsBlkCnt -> CFsBlkCnt # pred :: CFsBlkCnt -> CFsBlkCnt # fromEnum :: CFsBlkCnt -> Int # enumFrom :: CFsBlkCnt -> [CFsBlkCnt] # enumFromThen :: CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt] # enumFromTo :: CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt] # enumFromThenTo :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt] # | |
Enum CFsFilCnt | |
Defined in GHC.Internal.System.Posix.Types Methods succ :: CFsFilCnt -> CFsFilCnt # pred :: CFsFilCnt -> CFsFilCnt # fromEnum :: CFsFilCnt -> Int # enumFrom :: CFsFilCnt -> [CFsFilCnt] # enumFromThen :: CFsFilCnt -> CFsFilCnt -> [CFsFilCnt] # enumFromTo :: CFsFilCnt -> CFsFilCnt -> [CFsFilCnt] # enumFromThenTo :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt -> [CFsFilCnt] # | |
Enum CGid | |
Defined in GHC.Internal.System.Posix.Types | |
Enum CId | |
Defined in GHC.Internal.System.Posix.Types | |
Enum CIno | |
Defined in GHC.Internal.System.Posix.Types | |
Enum CKey | |
Defined in GHC.Internal.System.Posix.Types | |
Enum CMode | |
Defined in GHC.Internal.System.Posix.Types | |
Enum CNfds | |
Defined in GHC.Internal.System.Posix.Types | |
Enum CNlink | |
Defined in GHC.Internal.System.Posix.Types | |
Enum COff | |
Enum CPid | |
Defined in GHC.Internal.System.Posix.Types | |
Enum CRLim | |
Defined in GHC.Internal.System.Posix.Types | |
Enum CSocklen | |
Defined in GHC.Internal.System.Posix.Types Methods succ :: CSocklen -> CSocklen # pred :: CSocklen -> CSocklen # enumFrom :: CSocklen -> [CSocklen] # enumFromThen :: CSocklen -> CSocklen -> [CSocklen] # enumFromTo :: CSocklen -> CSocklen -> [CSocklen] # enumFromThenTo :: CSocklen -> CSocklen -> CSocklen -> [CSocklen] # | |
Enum CSpeed | |
Defined in GHC.Internal.System.Posix.Types | |
Enum CSsize | |
Defined in GHC.Internal.System.Posix.Types | |
Enum CTcflag | |
Defined in GHC.Internal.System.Posix.Types Methods enumFrom :: CTcflag -> [CTcflag] # enumFromThen :: CTcflag -> CTcflag -> [CTcflag] # enumFromTo :: CTcflag -> CTcflag -> [CTcflag] # enumFromThenTo :: CTcflag -> CTcflag -> CTcflag -> [CTcflag] # | |
Enum CUid | |
Defined in GHC.Internal.System.Posix.Types | |
Enum Fd | |
Defined in GHC.Internal.System.Posix.Types | |
Enum GeneralCategory | |
Defined in GHC.Internal.Unicode Methods succ :: GeneralCategory -> GeneralCategory # pred :: GeneralCategory -> GeneralCategory # toEnum :: Int -> GeneralCategory # fromEnum :: GeneralCategory -> Int # enumFrom :: GeneralCategory -> [GeneralCategory] # enumFromThen :: GeneralCategory -> GeneralCategory -> [GeneralCategory] # enumFromTo :: GeneralCategory -> GeneralCategory -> [GeneralCategory] # enumFromThenTo :: GeneralCategory -> GeneralCategory -> GeneralCategory -> [GeneralCategory] # | |
Enum Word16 | |
Defined in GHC.Internal.Word | |
Enum Word32 | |
Defined in GHC.Internal.Word | |
Enum Word64 | |
Defined in GHC.Internal.Word | |
Enum Word8 | |
Defined in GHC.Internal.Word | |
Enum Ordering | |
Defined in GHC.Internal.Enum | |
Enum Integer | |
Enum Natural | |
Enum () | |
Defined in GHC.Internal.Enum | |
Enum Bool | |
Enum Char | |
Enum Int | |
Enum Levity | |
Defined in GHC.Internal.Enum | |
Enum VecCount | |
Defined in GHC.Internal.Enum Methods succ :: VecCount -> VecCount # pred :: VecCount -> VecCount # enumFrom :: VecCount -> [VecCount] # enumFromThen :: VecCount -> VecCount -> [VecCount] # enumFromTo :: VecCount -> VecCount -> [VecCount] # enumFromThenTo :: VecCount -> VecCount -> VecCount -> [VecCount] # | |
Enum VecElem | |
Defined in GHC.Internal.Enum Methods enumFrom :: VecElem -> [VecElem] # enumFromThen :: VecElem -> VecElem -> [VecElem] # enumFromTo :: VecElem -> VecElem -> [VecElem] # enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem] # | |
Enum Word | |
Enum a => Enum (First a) | |
Defined in Data.Semigroup Methods enumFrom :: First a -> [First a] # enumFromThen :: First a -> First a -> [First a] # enumFromTo :: First a -> First a -> [First a] # enumFromThenTo :: First a -> First a -> First a -> [First a] # | |
Enum a => Enum (Last a) | |
Defined in Data.Semigroup | |
Enum a => Enum (Max a) | |
Defined in Data.Semigroup | |
Enum a => Enum (Min a) | |
Defined in Data.Semigroup | |
Enum a => Enum (WrappedMonoid a) | |
Defined in Data.Semigroup Methods succ :: WrappedMonoid a -> WrappedMonoid a # pred :: WrappedMonoid a -> WrappedMonoid a # toEnum :: Int -> WrappedMonoid a # fromEnum :: WrappedMonoid a -> Int # enumFrom :: WrappedMonoid a -> [WrappedMonoid a] # enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # | |
SizeValid n => Enum (Bits n) Source # | |
Defined in Basement.Bits | |
Enum (CountOf ty) Source # | |
Defined in Basement.Types.OffsetSize Methods succ :: CountOf ty -> CountOf ty # pred :: CountOf ty -> CountOf ty # fromEnum :: CountOf ty -> Int # enumFrom :: CountOf ty -> [CountOf ty] # enumFromThen :: CountOf ty -> CountOf ty -> [CountOf ty] # enumFromTo :: CountOf ty -> CountOf ty -> [CountOf ty] # enumFromThenTo :: CountOf ty -> CountOf ty -> CountOf ty -> [CountOf ty] # | |
Enum (Offset ty) Source # | |
Defined in Basement.Types.OffsetSize Methods succ :: Offset ty -> Offset ty # pred :: Offset ty -> Offset ty # fromEnum :: Offset ty -> Int # enumFrom :: Offset ty -> [Offset ty] # enumFromThen :: Offset ty -> Offset ty -> [Offset ty] # enumFromTo :: Offset ty -> Offset ty -> [Offset ty] # enumFromThenTo :: Offset ty -> Offset ty -> Offset ty -> [Offset ty] # | |
Enum a => Enum (Identity a) | |
Defined in GHC.Internal.Data.Functor.Identity Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] # | |
Integral a => Enum (Ratio a) | |
Defined in GHC.Internal.Real Methods enumFrom :: Ratio a -> [Ratio a] # enumFromThen :: Ratio a -> Ratio a -> [Ratio a] # enumFromTo :: Ratio a -> Ratio a -> [Ratio a] # enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a] # | |
Enum a => Enum (Solo a) | |
Defined in GHC.Internal.Enum | |
Enum (Fixed a) | |
Defined in Data.Fixed Methods enumFrom :: Fixed a -> [Fixed a] # enumFromThen :: Fixed a -> Fixed a -> [Fixed a] # enumFromTo :: Fixed a -> Fixed a -> [Fixed a] # enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a] # | |
Enum (Proxy s) | |
Defined in GHC.Internal.Data.Proxy Methods enumFrom :: Proxy s -> [Proxy s] # enumFromThen :: Proxy s -> Proxy s -> [Proxy s] # enumFromTo :: Proxy s -> Proxy s -> [Proxy s] # enumFromThenTo :: Proxy s -> Proxy s -> Proxy s -> [Proxy s] # | |
Enum a => Enum (Const a b) | |
Defined in GHC.Internal.Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> Const a b # fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] # | |
Enum (f a) => Enum (Ap f a) | |
Defined in GHC.Internal.Data.Monoid | |
Enum (f a) => Enum (Alt f a) | |
Defined in GHC.Internal.Data.Semigroup.Internal Methods enumFrom :: Alt f a -> [Alt f a] # enumFromThen :: Alt f a -> Alt f a -> [Alt f a] # enumFromTo :: Alt f a -> Alt f a -> [Alt f a] # enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [Alt f a] # | |
Enum (f (g a)) => Enum (Compose f g a) | |
Defined in Data.Functor.Compose Methods succ :: Compose f g a -> Compose f g a # pred :: Compose f g a -> Compose f g a # toEnum :: Int -> Compose f g a # fromEnum :: Compose f g a -> Int # enumFrom :: Compose f g a -> [Compose f g a] # enumFromThen :: Compose f g a -> Compose f g a -> [Compose f g a] # enumFromTo :: Compose f g a -> Compose f g a -> [Compose f g a] # enumFromThenTo :: Compose f g a -> Compose f g a -> Compose f g a -> [Compose f g a] # |
class Functor (f :: Type -> Type) where #
Minimal complete definition
Instances
class Functor f => Applicative (f :: Type -> Type) where #
Instances
Applicative Complex | |
Applicative First | |
Applicative Last | |
Applicative Max | |
Applicative Min | |
Applicative NonEmpty | |
Applicative Identity | |
Applicative First | |
Applicative Last | |
Applicative Dual | |
Applicative Product | |
Applicative Sum | |
Applicative ZipList | |
Applicative Par1 | |
Applicative IO | |
Applicative Maybe | |
Applicative Solo | |
Applicative [] | |
Monad m => Applicative (WrappedMonad m) | |
Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c # (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a # | |
Arrow a => Applicative (ArrowMonad a) | |
Defined in GHC.Internal.Control.Arrow Methods pure :: a0 -> ArrowMonad a a0 # (<*>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c # (*>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 # | |
Applicative (Either e) | |
Applicative (Proxy :: Type -> Type) | |
Applicative (U1 :: Type -> Type) | |
Applicative (ST s) | |
Monoid a => Applicative ((,) a) | |
Arrow a => Applicative (WrappedArrow a b) | |
Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c # (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # | |
Monad m => Applicative (Reader r m) Source # | |
Defined in Basement.Compat.MonadTrans | |
Monad m => Applicative (State s m) Source # | |
Defined in Basement.Compat.MonadTrans | |
Applicative m => Applicative (Kleisli m a) | |
Defined in GHC.Internal.Control.Arrow | |
Monoid m => Applicative (Const m :: Type -> Type) | |
Applicative f => Applicative (Ap f) | |
Applicative f => Applicative (Alt f) | |
(Generic1 f, Applicative (Rep1 f)) => Applicative (Generically1 f) | |
Defined in GHC.Internal.Generics Methods pure :: a -> Generically1 f a # (<*>) :: Generically1 f (a -> b) -> Generically1 f a -> Generically1 f b # liftA2 :: (a -> b -> c) -> Generically1 f a -> Generically1 f b -> Generically1 f c # (*>) :: Generically1 f a -> Generically1 f b -> Generically1 f b # (<*) :: Generically1 f a -> Generically1 f b -> Generically1 f a # | |
Applicative f => Applicative (Rec1 f) | |
(Monoid a, Monoid b) => Applicative ((,,) a b) | |
(Applicative f, Applicative g) => Applicative (Product f g) | |
Defined in Data.Functor.Product | |
(Applicative f, Applicative g) => Applicative (f :*: g) | |
Monoid c => Applicative (K1 i c :: Type -> Type) | |
(Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) | |
Defined in GHC.Internal.Base | |
Applicative ((->) r) | |
(Applicative f, Applicative g) => Applicative (Compose f g) | |
Defined in Data.Functor.Compose | |
(Applicative f, Applicative g) => Applicative (f :.: g) | |
Applicative f => Applicative (M1 i c f) | |
Monad state => Applicative (Builder collection mutCollection step state err) Source # | |
Defined in Basement.MutableBuilder Methods pure :: a -> Builder collection mutCollection step state err a # (<*>) :: Builder collection mutCollection step state err (a -> b) -> Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b # liftA2 :: (a -> b -> c) -> Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err c # (*>) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err b # (<*) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err a # |
class Applicative m => Monad (m :: Type -> Type) where #
Minimal complete definition
Instances
Monad Complex | |
Monad First | |
Monad Last | |
Monad Max | |
Monad Min | |
Monad NonEmpty | |
Monad Identity | |
Monad First | |
Monad Last | |
Monad Dual | |
Monad Product | |
Monad Sum | |
Monad Par1 | |
Monad IO | |
Monad Maybe | |
Monad Solo | |
Monad [] | |
Monad m => Monad (WrappedMonad m) | |
ArrowApply a => Monad (ArrowMonad a) | |
Monad (Either e) | |
Monad (Proxy :: Type -> Type) | |
Monad (U1 :: Type -> Type) | |
Monad (ST s) | |
Monoid a => Monad ((,) a) | |
Monad m => Monad (Reader r m) Source # | |
Monad m => Monad (State r m) Source # | |
Monad m => Monad (Kleisli m a) | |
Monad f => Monad (Ap f) | |
Monad f => Monad (Alt f) | |
Monad f => Monad (Rec1 f) | |
(Monoid a, Monoid b) => Monad ((,,) a b) | |
(Monad f, Monad g) => Monad (Product f g) | |
(Monad f, Monad g) => Monad (f :*: g) | |
(Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | |
Monad ((->) r) | |
Monad f => Monad (M1 i c f) | |
Monad state => Monad (Builder collection mutCollection step state err) Source # | |
Defined in Basement.MutableBuilder Methods (>>=) :: Builder collection mutCollection step state err a -> (a -> Builder collection mutCollection step state err b) -> Builder collection mutCollection step state err b # (>>) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err b # return :: a -> Builder collection mutCollection step state err a # |
when :: Applicative f => Bool -> f () -> f () #
unless :: Applicative f => Bool -> f () -> f () #
Instances
MonadZip Maybe | |||||
Eq1 Maybe | |||||
Ord1 Maybe | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering | |||||
Read1 Maybe | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Maybe a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Maybe a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Maybe a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Maybe a] | |||||
Show1 Maybe | |||||
Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Maybe a -> ShowS liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Maybe a] -> ShowS | |||||
MonadFailure Maybe Source # | |||||
Alternative Maybe | |||||
Applicative Maybe | |||||
Functor Maybe | |||||
Monad Maybe | |||||
MonadPlus Maybe | |||||
Foldable Maybe | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => Maybe m -> m foldMap :: Monoid m => (a -> m) -> Maybe a -> m foldMap' :: Monoid m => (a -> m) -> Maybe a -> m foldr :: (a -> b -> b) -> b -> Maybe a -> b foldr' :: (a -> b -> b) -> b -> Maybe a -> b foldl :: (b -> a -> b) -> b -> Maybe a -> b foldl' :: (b -> a -> b) -> b -> Maybe a -> b foldr1 :: (a -> a -> a) -> Maybe a -> a foldl1 :: (a -> a -> a) -> Maybe a -> a elem :: Eq a => a -> Maybe a -> Bool maximum :: Ord a => Maybe a -> a | |||||
Traversable Maybe | |||||
Generic1 Maybe | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
NormalForm a => NormalForm (Maybe a) Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Maybe a -> () Source # | |||||
Semigroup a => Monoid (Maybe a) | |||||
Semigroup a => Semigroup (Maybe a) | |||||
Data a => Data (Maybe a) | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) # toConstr :: Maybe a -> Constr # dataTypeOf :: Maybe a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) # gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r # gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # | |||||
Generic (Maybe a) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
SingKind a => SingKind (Maybe a) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Read a => Read (Maybe a) | |||||
Defined in GHC.Internal.Read | |||||
Show a => Show (Maybe a) | |||||
Eq a => Eq (Maybe a) | |||||
Ord a => Ord (Maybe a) | |||||
SingI ('Nothing :: Maybe a) | |||||
Defined in GHC.Internal.Generics | |||||
From (Maybe a) (Either () a) Source # | |||||
SingI a2 => SingI ('Just a2 :: Maybe a1) | |||||
Defined in GHC.Internal.Generics | |||||
type Failure Maybe Source # | |||||
Defined in Basement.Monad | |||||
type Rep1 Maybe | |||||
Defined in GHC.Internal.Generics | |||||
type DemoteRep (Maybe a) | |||||
Defined in GHC.Internal.Generics | |||||
type Rep (Maybe a) | |||||
Defined in GHC.Internal.Generics | |||||
data Sing (b :: Maybe a) | |||||
Instances
Monoid Ordering | |
Semigroup Ordering | |
Data Ordering | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering # toConstr :: Ordering -> Constr # dataTypeOf :: Ordering -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) # gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r # gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering # | |
Bounded Ordering | |
Enum Ordering | |
Defined in GHC.Internal.Enum | |
Generic Ordering | |
Defined in GHC.Internal.Generics | |
Read Ordering | |
Defined in GHC.Internal.Read | |
Show Ordering | |
Eq Ordering | |
Ord Ordering | |
Defined in GHC.Classes | |
type Rep Ordering | |
Instances
BitOps Bool Source # | |||||
Defined in Basement.Bits Methods (.&.) :: Bool -> Bool -> Bool Source # (.|.) :: Bool -> Bool -> Bool Source # (.^.) :: Bool -> Bool -> Bool Source # (.<<.) :: Bool -> CountOf Bool -> Bool Source # (.>>.) :: Bool -> CountOf Bool -> Bool Source # bit :: Offset Bool -> Bool Source # isBitSet :: Bool -> Offset Bool -> Bool Source # | |||||
FiniteBitsOps Bool Source # | |||||
NormalForm Bool Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Bool -> () Source # | |||||
Bits Bool | |||||
Defined in GHC.Internal.Bits | |||||
FiniteBits Bool | |||||
Defined in GHC.Internal.Bits Methods finiteBitSize :: Bool -> Int countLeadingZeros :: Bool -> Int countTrailingZeros :: Bool -> Int | |||||
Data Bool | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool # dataTypeOf :: Bool -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bool) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bool) # gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r # gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool # | |||||
Bounded Bool | |||||
Enum Bool | |||||
Storable Bool | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
Generic Bool | |||||
Defined in GHC.Internal.Generics | |||||
SingKind Bool | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Read Bool | |||||
Defined in GHC.Internal.Read | |||||
Show Bool | |||||
Eq Bool | |||||
Ord Bool | |||||
SingI 'False | |||||
Defined in GHC.Internal.Generics | |||||
SingI 'True | |||||
Defined in GHC.Internal.Generics | |||||
type DemoteRep Bool | |||||
Defined in GHC.Internal.Generics | |||||
type Rep Bool | |||||
data Sing (a :: Bool) | |||||
Instances
Instances
PrintfArg Integer | |||||
Defined in Text.Printf | |||||
Fractional Rational Source # | |||||
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> Rational Source # | |||||
HasNegation Integer Source # | |||||
Integral Integer Source # | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Integer Source # | |||||
NormalForm Integer Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Integer -> () Source # | |||||
Additive Rational Source # | |||||
Additive Integer Source # | |||||
Divisible Rational Source # | |||||
Defined in Basement.Numerical.Multiplicative | |||||
IDivisible Integer Source # | |||||
Multiplicative Rational Source # | |||||
Multiplicative Integer Source # | |||||
IsIntegral Integer Source # | |||||
Subtractive Integer Source # | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
Bits Integer | |||||
Defined in GHC.Internal.Bits Methods (.&.) :: Integer -> Integer -> Integer (.|.) :: Integer -> Integer -> Integer xor :: Integer -> Integer -> Integer complement :: Integer -> Integer shift :: Integer -> Int -> Integer rotate :: Integer -> Int -> Integer setBit :: Integer -> Int -> Integer clearBit :: Integer -> Int -> Integer complementBit :: Integer -> Int -> Integer testBit :: Integer -> Int -> Bool bitSizeMaybe :: Integer -> Maybe Int shiftL :: Integer -> Int -> Integer unsafeShiftL :: Integer -> Int -> Integer shiftR :: Integer -> Int -> Integer unsafeShiftR :: Integer -> Int -> Integer rotateL :: Integer -> Int -> Integer | |||||
Data Integer | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Integer -> c Integer # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Integer # toConstr :: Integer -> Constr # dataTypeOf :: Integer -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Integer) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Integer) # gmapT :: (forall b. Data b => b -> b) -> Integer -> Integer # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r # gmapQ :: (forall d. Data d => d -> u) -> Integer -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Integer -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Integer -> m Integer # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer # | |||||
Enum Integer | |||||
Num Integer | |||||
Read Integer | |||||
Defined in GHC.Internal.Read | |||||
Integral Integer | |||||
Defined in GHC.Internal.Real | |||||
Real Integer | |||||
Defined in GHC.Internal.Real Methods toRational :: Integer -> Rational | |||||
Show Integer | |||||
Eq Integer | |||||
Ord Integer | |||||
IsIntegral n => From n Integer Source # | |||||
Defined in Basement.From | |||||
IntegralDownsize Integer Int16 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Integer Int32 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Integer Int64 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Integer Int8 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Integer Word16 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Integer Word32 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Integer Word64 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Integer Word8 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Integer Natural Source # | |||||
Defined in Basement.IntegralConv | |||||
IsIntegral a => IntegralUpsize a Integer Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: a -> Integer Source # | |||||
type Difference Integer Source # | |||||
Defined in Basement.Numerical.Subtractive |
Instances
IsChar Char | |||||
PrintfArg Char | |||||
Defined in Text.Printf | |||||
NormalForm Char Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Char -> () Source # | |||||
Subtractive Char Source # | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
PrimMemoryComparable Char Source # | |||||
Defined in Basement.PrimType | |||||
PrimType Char Source # | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Char -> CountOf Word8 Source # primShiftToBytes :: Proxy Char -> Int Source # primBaUIndex :: ByteArray# -> Offset Char -> Char Source # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> prim Char Source # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> Char -> prim () Source # primAddrIndex :: Addr# -> Offset Char -> Char Source # primAddrRead :: PrimMonad prim => Addr# -> Offset Char -> prim Char Source # primAddrWrite :: PrimMonad prim => Addr# -> Offset Char -> Char -> prim () Source # | |||||
Data Char | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char # dataTypeOf :: Char -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) # gmapT :: (forall b. Data b => b -> b) -> Char -> Char # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r # gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char # | |||||
Bounded Char | |||||
Enum Char | |||||
Storable Char | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
Read Char | |||||
Defined in GHC.Internal.Read | |||||
Show Char | |||||
Eq Char | |||||
Ord Char | |||||
TestCoercion SChar | |||||
Defined in GHC.Internal.TypeLits Methods testCoercion :: forall (a :: Char) (b :: Char). SChar a -> SChar b -> Maybe (Coercion a b) | |||||
TestEquality SChar | |||||
Defined in GHC.Internal.TypeLits Methods testEquality :: forall (a :: Char) (b :: Char). SChar a -> SChar b -> Maybe (a :~: b) | |||||
Generic1 (URec Char :: k -> Type) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Foldable (UChar :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => UChar m -> m foldMap :: Monoid m => (a -> m) -> UChar a -> m foldMap' :: Monoid m => (a -> m) -> UChar a -> m foldr :: (a -> b -> b) -> b -> UChar a -> b foldr' :: (a -> b -> b) -> b -> UChar a -> b foldl :: (b -> a -> b) -> b -> UChar a -> b foldl' :: (b -> a -> b) -> b -> UChar a -> b foldr1 :: (a -> a -> a) -> UChar a -> a foldl1 :: (a -> a -> a) -> UChar a -> a toList :: UChar a -> [a] elem :: Eq a => a -> UChar a -> Bool maximum :: Ord a => UChar a -> a minimum :: Ord a => UChar a -> a sum :: Num a => UChar a -> a product :: Num a => UChar a -> a | |||||
Traversable (UChar :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UChar a -> f (UChar b) sequenceA :: Applicative f => UChar (f a) -> f (UChar a) | |||||
Functor (URec Char :: Type -> Type) | |||||
Generic (URec Char p) | |||||
Defined in GHC.Internal.Generics | |||||
Show (URec Char p) | |||||
Eq (URec Char p) | |||||
Ord (URec Char p) | |||||
Defined in GHC.Internal.Generics | |||||
type NatNumMaxBound Char Source # | |||||
Defined in Basement.Nat | |||||
type Difference Char Source # | |||||
Defined in Basement.Numerical.Subtractive | |||||
type PrimSize Char Source # | |||||
Defined in Basement.PrimType | |||||
data URec Char (p :: k) | |||||
Defined in GHC.Internal.Generics | |||||
type Compare (a :: Char) (b :: Char) | |||||
Defined in GHC.Internal.Data.Type.Ord | |||||
type Rep1 (URec Char :: k -> Type) | |||||
Defined in GHC.Internal.Generics | |||||
type Rep (URec Char p) | |||||
class Integral a where Source #
Integral Literal support
e.g. 123 :: Integer 123 :: Word8
Methods
fromInteger :: Integer -> a Source #
Instances
Integral Word128 Source # | |
Defined in Basement.Types.Word128 Methods fromInteger :: Integer -> Word128 Source # | |
Integral Word256 Source # | |
Defined in Basement.Types.Word256 Methods fromInteger :: Integer -> Word256 Source # | |
Integral CBool Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CBool Source # | |
Integral CChar Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CChar Source # | |
Integral CClock Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CClock Source # | |
Integral CDouble Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CDouble Source # | |
Integral CFloat Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CFloat Source # | |
Integral CInt Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CInt Source # | |
Integral CIntMax Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CIntMax Source # | |
Integral CIntPtr Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CIntPtr Source # | |
Integral CLLong Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CLLong Source # | |
Integral CLong Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CLong Source # | |
Integral CPtrdiff Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CPtrdiff Source # | |
Integral CSChar Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CSChar Source # | |
Integral CSUSeconds Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CSUSeconds Source # | |
Integral CShort Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CShort Source # | |
Integral CSigAtomic Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CSigAtomic Source # | |
Integral CSize Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CSize Source # | |
Integral CTime Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CTime Source # | |
Integral CUChar Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CUChar Source # | |
Integral CUInt Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CUInt Source # | |
Integral CUIntMax Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CUIntMax Source # | |
Integral CUIntPtr Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CUIntPtr Source # | |
Integral CULLong Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CULLong Source # | |
Integral CULong Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CULong Source # | |
Integral CUSeconds Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CUSeconds Source # | |
Integral CUShort Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CUShort Source # | |
Integral CWchar Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> CWchar Source # | |
Integral IntPtr Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> IntPtr Source # | |
Integral Int16 Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Int16 Source # | |
Integral Int32 Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Int32 Source # | |
Integral Int64 Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Int64 Source # | |
Integral Int8 Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Int8 Source # | |
Integral COff Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> COff Source # | |
Integral Word16 Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Word16 Source # | |
Integral Word32 Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Word32 Source # | |
Integral Word64 Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Word64 Source # | |
Integral Word8 Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Word8 Source # | |
Integral Integer Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Integer Source # | |
Integral Natural Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Natural Source # | |
Integral Double Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Double Source # | |
Integral Float Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Float Source # | |
Integral Int Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Int Source # | |
Integral Word Source # | |
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Word Source # | |
KnownNat n => Integral (Zn n) Source # | |
Defined in Basement.Bounded Methods fromInteger :: Integer -> Zn n Source # | |
(KnownNat n, NatWithinBound Word64 n) => Integral (Zn64 n) Source # | |
Defined in Basement.Bounded Methods fromInteger :: Integer -> Zn64 n Source # | |
Integral (CountOf ty) Source # | |
Defined in Basement.Types.OffsetSize Methods fromInteger :: Integer -> CountOf ty Source # | |
Integral (Offset ty) Source # | |
Defined in Basement.Types.OffsetSize Methods fromInteger :: Integer -> Offset ty Source # |
class Fractional a where Source #
Fractional Literal support
e.g. 1.2 :: Double 0.03 :: Float
Methods
fromRational :: Rational -> a Source #
Instances
Fractional CDouble Source # | |
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> CDouble Source # | |
Fractional CFloat Source # | |
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> CFloat Source # | |
Fractional Rational Source # | |
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> Rational Source # | |
Fractional Double Source # | |
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> Double Source # | |
Fractional Float Source # | |
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> Float Source # |
class HasNegation a where Source #
Negation support
e.g. -(f x)
Instances
HasNegation Word128 Source # | |
HasNegation Word256 Source # | |
HasNegation CChar Source # | |
HasNegation CDouble Source # | |
HasNegation CFloat Source # | |
HasNegation CInt Source # | |
HasNegation CIntMax Source # | |
HasNegation CLLong Source # | |
HasNegation CLong Source # | |
HasNegation CPtrdiff Source # | |
HasNegation CSChar Source # | |
HasNegation CShort Source # | |
HasNegation CWchar Source # | |
HasNegation Int16 Source # | |
HasNegation Int32 Source # | |
HasNegation Int64 Source # | |
HasNegation Int8 Source # | |
HasNegation Word16 Source # | |
HasNegation Word32 Source # | |
HasNegation Word64 Source # | |
HasNegation Word8 Source # | |
HasNegation Integer Source # | |
HasNegation Double Source # | |
HasNegation Float Source # | |
HasNegation Int Source # | |
HasNegation Word Source # | |
Instances
PrintfArg Int8 | |||||
Defined in Text.Printf | |||||
BitOps Int8 Source # | |||||
Defined in Basement.Bits Methods (.&.) :: Int8 -> Int8 -> Int8 Source # (.|.) :: Int8 -> Int8 -> Int8 Source # (.^.) :: Int8 -> Int8 -> Int8 Source # (.<<.) :: Int8 -> CountOf Bool -> Int8 Source # (.>>.) :: Int8 -> CountOf Bool -> Int8 Source # bit :: Offset Bool -> Int8 Source # isBitSet :: Int8 -> Offset Bool -> Bool Source # | |||||
FiniteBitsOps Int8 Source # | |||||
HasNegation Int8 Source # | |||||
Integral Int8 Source # | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Int8 Source # | |||||
NormalForm Int8 Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Int8 -> () Source # | |||||
Additive Int8 Source # | |||||
IDivisible Int8 Source # | |||||
Multiplicative Int8 Source # | |||||
IsIntegral Int8 Source # | |||||
Subtractive Int8 Source # | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
PrimMemoryComparable Int8 Source # | |||||
Defined in Basement.PrimType | |||||
PrimType Int8 Source # | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Int8 -> CountOf Word8 Source # primShiftToBytes :: Proxy Int8 -> Int Source # primBaUIndex :: ByteArray# -> Offset Int8 -> Int8 Source # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int8 -> prim Int8 Source # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int8 -> Int8 -> prim () Source # primAddrIndex :: Addr# -> Offset Int8 -> Int8 Source # primAddrRead :: PrimMonad prim => Addr# -> Offset Int8 -> prim Int8 Source # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int8 -> Int8 -> prim () Source # | |||||
Bits Int8 | |||||
Defined in GHC.Internal.Int | |||||
FiniteBits Int8 | |||||
Defined in GHC.Internal.Int Methods finiteBitSize :: Int8 -> Int countLeadingZeros :: Int8 -> Int countTrailingZeros :: Int8 -> Int | |||||
Data Int8 | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int8 -> c Int8 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int8 # dataTypeOf :: Int8 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int8) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int8) # gmapT :: (forall b. Data b => b -> b) -> Int8 -> Int8 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int8 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int8 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 # | |||||
Bounded Int8 | |||||
Enum Int8 | |||||
Storable Int8 | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
Ix Int8 | |||||
Num Int8 | |||||
Read Int8 | |||||
Defined in GHC.Internal.Int | |||||
Integral Int8 | |||||
Real Int8 | |||||
Defined in GHC.Internal.Int Methods toRational :: Int8 -> Rational | |||||
Show Int8 | |||||
Eq Int8 | |||||
Ord Int8 | |||||
Cast Int8 Word8 Source # | |||||
Cast Word8 Int8 Source # | |||||
From Int8 Int16 Source # | |||||
From Int8 Int32 Source # | |||||
From Int8 Int64 Source # | |||||
From Int8 Int Source # | |||||
IntegralDownsize Int64 Int8 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Integer Int8 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Int Int8 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralUpsize Int8 Int16 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int8 -> Int16 Source # | |||||
IntegralUpsize Int8 Int32 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int8 -> Int32 Source # | |||||
IntegralUpsize Int8 Int64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int8 -> Int64 Source # | |||||
IntegralUpsize Int8 Int Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int8 -> Int Source # | |||||
type NatNumMaxBound Int8 Source # | |||||
Defined in Basement.Nat | |||||
type Difference Int8 Source # | |||||
Defined in Basement.Numerical.Subtractive | |||||
type PrimSize Int8 Source # | |||||
Defined in Basement.PrimType |
Instances
PrintfArg Int16 | |||||
Defined in Text.Printf | |||||
BitOps Int16 Source # | |||||
Defined in Basement.Bits Methods (.&.) :: Int16 -> Int16 -> Int16 Source # (.|.) :: Int16 -> Int16 -> Int16 Source # (.^.) :: Int16 -> Int16 -> Int16 Source # (.<<.) :: Int16 -> CountOf Bool -> Int16 Source # (.>>.) :: Int16 -> CountOf Bool -> Int16 Source # bit :: Offset Bool -> Int16 Source # isBitSet :: Int16 -> Offset Bool -> Bool Source # | |||||
FiniteBitsOps Int16 Source # | |||||
Defined in Basement.Bits | |||||
HasNegation Int16 Source # | |||||
Integral Int16 Source # | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Int16 Source # | |||||
NormalForm Int16 Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Int16 -> () Source # | |||||
Additive Int16 Source # | |||||
IDivisible Int16 Source # | |||||
Multiplicative Int16 Source # | |||||
IsIntegral Int16 Source # | |||||
Subtractive Int16 Source # | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
PrimMemoryComparable Int16 Source # | |||||
Defined in Basement.PrimType | |||||
PrimType Int16 Source # | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Int16 -> CountOf Word8 Source # primShiftToBytes :: Proxy Int16 -> Int Source # primBaUIndex :: ByteArray# -> Offset Int16 -> Int16 Source # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int16 -> prim Int16 Source # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int16 -> Int16 -> prim () Source # primAddrIndex :: Addr# -> Offset Int16 -> Int16 Source # primAddrRead :: PrimMonad prim => Addr# -> Offset Int16 -> prim Int16 Source # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int16 -> Int16 -> prim () Source # | |||||
Bits Int16 | |||||
Defined in GHC.Internal.Int Methods (.&.) :: Int16 -> Int16 -> Int16 (.|.) :: Int16 -> Int16 -> Int16 xor :: Int16 -> Int16 -> Int16 complement :: Int16 -> Int16 shift :: Int16 -> Int -> Int16 rotate :: Int16 -> Int -> Int16 setBit :: Int16 -> Int -> Int16 clearBit :: Int16 -> Int -> Int16 complementBit :: Int16 -> Int -> Int16 testBit :: Int16 -> Int -> Bool bitSizeMaybe :: Int16 -> Maybe Int shiftL :: Int16 -> Int -> Int16 unsafeShiftL :: Int16 -> Int -> Int16 shiftR :: Int16 -> Int -> Int16 unsafeShiftR :: Int16 -> Int -> Int16 rotateL :: Int16 -> Int -> Int16 | |||||
FiniteBits Int16 | |||||
Defined in GHC.Internal.Int Methods finiteBitSize :: Int16 -> Int countLeadingZeros :: Int16 -> Int countTrailingZeros :: Int16 -> Int | |||||
Data Int16 | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int16 -> c Int16 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int16 # dataTypeOf :: Int16 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int16) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int16) # gmapT :: (forall b. Data b => b -> b) -> Int16 -> Int16 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int16 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int16 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 # | |||||
Bounded Int16 | |||||
Enum Int16 | |||||
Defined in GHC.Internal.Int | |||||
Storable Int16 | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
Ix Int16 | |||||
Num Int16 | |||||
Read Int16 | |||||
Defined in GHC.Internal.Int | |||||
Integral Int16 | |||||
Real Int16 | |||||
Defined in GHC.Internal.Int Methods toRational :: Int16 -> Rational | |||||
Show Int16 | |||||
Eq Int16 | |||||
Ord Int16 | |||||
Cast Int16 Word16 Source # | |||||
Cast Word16 Int16 Source # | |||||
From Int16 Int32 Source # | |||||
From Int16 Int64 Source # | |||||
From Int16 Int Source # | |||||
From Int8 Int16 Source # | |||||
From Word8 Int16 Source # | |||||
IntegralDownsize Int64 Int16 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Integer Int16 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Int Int16 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralUpsize Int16 Int32 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int16 -> Int32 Source # | |||||
IntegralUpsize Int16 Int64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int16 -> Int64 Source # | |||||
IntegralUpsize Int16 Int Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int16 -> Int Source # | |||||
IntegralUpsize Int8 Int16 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int8 -> Int16 Source # | |||||
IntegralUpsize Word8 Int16 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Int16 Source # | |||||
type NatNumMaxBound Int16 Source # | |||||
Defined in Basement.Nat | |||||
type Difference Int16 Source # | |||||
Defined in Basement.Numerical.Subtractive | |||||
type PrimSize Int16 Source # | |||||
Defined in Basement.PrimType |
Instances
PrintfArg Int32 | |||||
Defined in Text.Printf | |||||
BitOps Int32 Source # | |||||
Defined in Basement.Bits Methods (.&.) :: Int32 -> Int32 -> Int32 Source # (.|.) :: Int32 -> Int32 -> Int32 Source # (.^.) :: Int32 -> Int32 -> Int32 Source # (.<<.) :: Int32 -> CountOf Bool -> Int32 Source # (.>>.) :: Int32 -> CountOf Bool -> Int32 Source # bit :: Offset Bool -> Int32 Source # isBitSet :: Int32 -> Offset Bool -> Bool Source # | |||||
FiniteBitsOps Int32 Source # | |||||
Defined in Basement.Bits | |||||
HasNegation Int32 Source # | |||||
Integral Int32 Source # | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Int32 Source # | |||||
NormalForm Int32 Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Int32 -> () Source # | |||||
Additive Int32 Source # | |||||
IDivisible Int32 Source # | |||||
Multiplicative Int32 Source # | |||||
IsIntegral Int32 Source # | |||||
Subtractive Int32 Source # | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
PrimMemoryComparable Int32 Source # | |||||
Defined in Basement.PrimType | |||||
PrimType Int32 Source # | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Int32 -> CountOf Word8 Source # primShiftToBytes :: Proxy Int32 -> Int Source # primBaUIndex :: ByteArray# -> Offset Int32 -> Int32 Source # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int32 -> prim Int32 Source # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int32 -> Int32 -> prim () Source # primAddrIndex :: Addr# -> Offset Int32 -> Int32 Source # primAddrRead :: PrimMonad prim => Addr# -> Offset Int32 -> prim Int32 Source # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int32 -> Int32 -> prim () Source # | |||||
Bits Int32 | |||||
Defined in GHC.Internal.Int Methods (.&.) :: Int32 -> Int32 -> Int32 (.|.) :: Int32 -> Int32 -> Int32 xor :: Int32 -> Int32 -> Int32 complement :: Int32 -> Int32 shift :: Int32 -> Int -> Int32 rotate :: Int32 -> Int -> Int32 setBit :: Int32 -> Int -> Int32 clearBit :: Int32 -> Int -> Int32 complementBit :: Int32 -> Int -> Int32 testBit :: Int32 -> Int -> Bool bitSizeMaybe :: Int32 -> Maybe Int shiftL :: Int32 -> Int -> Int32 unsafeShiftL :: Int32 -> Int -> Int32 shiftR :: Int32 -> Int -> Int32 unsafeShiftR :: Int32 -> Int -> Int32 rotateL :: Int32 -> Int -> Int32 | |||||
FiniteBits Int32 | |||||
Defined in GHC.Internal.Int Methods finiteBitSize :: Int32 -> Int countLeadingZeros :: Int32 -> Int countTrailingZeros :: Int32 -> Int | |||||
Data Int32 | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int32 -> c Int32 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int32 # dataTypeOf :: Int32 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int32) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int32) # gmapT :: (forall b. Data b => b -> b) -> Int32 -> Int32 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int32 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int32 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 # | |||||
Bounded Int32 | |||||
Enum Int32 | |||||
Defined in GHC.Internal.Int | |||||
Storable Int32 | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
Ix Int32 | |||||
Num Int32 | |||||
Read Int32 | |||||
Defined in GHC.Internal.Int | |||||
Integral Int32 | |||||
Real Int32 | |||||
Defined in GHC.Internal.Int Methods toRational :: Int32 -> Rational | |||||
Show Int32 | |||||
Eq Int32 | |||||
Ord Int32 | |||||
Cast Int32 Word32 Source # | |||||
Cast Word32 Int32 Source # | |||||
From Int16 Int32 Source # | |||||
From Int32 Int64 Source # | |||||
From Int32 Int Source # | |||||
From Int8 Int32 Source # | |||||
From Word16 Int32 Source # | |||||
From Word8 Int32 Source # | |||||
IntegralDownsize Int64 Int32 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Integer Int32 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Int Int32 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralUpsize Int16 Int32 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int16 -> Int32 Source # | |||||
IntegralUpsize Int32 Int64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int32 -> Int64 Source # | |||||
IntegralUpsize Int32 Int Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int32 -> Int Source # | |||||
IntegralUpsize Int8 Int32 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int8 -> Int32 Source # | |||||
IntegralUpsize Word8 Int32 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Int32 Source # | |||||
type NatNumMaxBound Int32 Source # | |||||
Defined in Basement.Nat | |||||
type Difference Int32 Source # | |||||
Defined in Basement.Numerical.Subtractive | |||||
type PrimSize Int32 Source # | |||||
Defined in Basement.PrimType |
Instances
PrintfArg Int64 | |||||
Defined in Text.Printf | |||||
BitOps Int64 Source # | |||||
Defined in Basement.Bits Methods (.&.) :: Int64 -> Int64 -> Int64 Source # (.|.) :: Int64 -> Int64 -> Int64 Source # (.^.) :: Int64 -> Int64 -> Int64 Source # (.<<.) :: Int64 -> CountOf Bool -> Int64 Source # (.>>.) :: Int64 -> CountOf Bool -> Int64 Source # bit :: Offset Bool -> Int64 Source # isBitSet :: Int64 -> Offset Bool -> Bool Source # | |||||
FiniteBitsOps Int64 Source # | |||||
Defined in Basement.Bits | |||||
HasNegation Int64 Source # | |||||
Integral Int64 Source # | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Int64 Source # | |||||
NormalForm Int64 Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Int64 -> () Source # | |||||
Additive Int64 Source # | |||||
IDivisible Int64 Source # | |||||
Multiplicative Int64 Source # | |||||
IsIntegral Int64 Source # | |||||
Subtractive Int64 Source # | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
PrimMemoryComparable Int64 Source # | |||||
Defined in Basement.PrimType | |||||
PrimType Int64 Source # | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Int64 -> CountOf Word8 Source # primShiftToBytes :: Proxy Int64 -> Int Source # primBaUIndex :: ByteArray# -> Offset Int64 -> Int64 Source # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int64 -> prim Int64 Source # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int64 -> Int64 -> prim () Source # primAddrIndex :: Addr# -> Offset Int64 -> Int64 Source # primAddrRead :: PrimMonad prim => Addr# -> Offset Int64 -> prim Int64 Source # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int64 -> Int64 -> prim () Source # | |||||
Bits Int64 | |||||
Defined in GHC.Internal.Int Methods (.&.) :: Int64 -> Int64 -> Int64 (.|.) :: Int64 -> Int64 -> Int64 xor :: Int64 -> Int64 -> Int64 complement :: Int64 -> Int64 shift :: Int64 -> Int -> Int64 rotate :: Int64 -> Int -> Int64 setBit :: Int64 -> Int -> Int64 clearBit :: Int64 -> Int -> Int64 complementBit :: Int64 -> Int -> Int64 testBit :: Int64 -> Int -> Bool bitSizeMaybe :: Int64 -> Maybe Int shiftL :: Int64 -> Int -> Int64 unsafeShiftL :: Int64 -> Int -> Int64 shiftR :: Int64 -> Int -> Int64 unsafeShiftR :: Int64 -> Int -> Int64 rotateL :: Int64 -> Int -> Int64 | |||||
FiniteBits Int64 | |||||
Defined in GHC.Internal.Int Methods finiteBitSize :: Int64 -> Int countLeadingZeros :: Int64 -> Int countTrailingZeros :: Int64 -> Int | |||||
Data Int64 | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int64 -> c Int64 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int64 # dataTypeOf :: Int64 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int64) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int64) # gmapT :: (forall b. Data b => b -> b) -> Int64 -> Int64 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int64 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int64 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 # | |||||
Bounded Int64 | |||||
Enum Int64 | |||||
Defined in GHC.Internal.Int | |||||
Storable Int64 | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
Ix Int64 | |||||
Num Int64 | |||||
Read Int64 | |||||
Defined in GHC.Internal.Int | |||||
Integral Int64 | |||||
Real Int64 | |||||
Defined in GHC.Internal.Int Methods toRational :: Int64 -> Rational | |||||
Show Int64 | |||||
Eq Int64 | |||||
Ord Int64 | |||||
Cast Int64 Word64 Source # | |||||
Cast Int64 Int Source # | |||||
Cast Int64 Word Source # | |||||
Cast Word64 Int64 Source # | |||||
Cast Int Int64 Source # | |||||
Cast Word Int64 Source # | |||||
From Int16 Int64 Source # | |||||
From Int32 Int64 Source # | |||||
From Int8 Int64 Source # | |||||
From Word16 Int64 Source # | |||||
From Word32 Int64 Source # | |||||
From Word8 Int64 Source # | |||||
From Int Int64 Source # | |||||
IntegralDownsize Int64 Int16 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Int64 Int32 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Int64 Int8 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Int64 Int Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Integer Int64 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralUpsize Int16 Int64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int16 -> Int64 Source # | |||||
IntegralUpsize Int32 Int64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int32 -> Int64 Source # | |||||
IntegralUpsize Int8 Int64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int8 -> Int64 Source # | |||||
IntegralUpsize Word8 Int64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Int64 Source # | |||||
IntegralUpsize Int Int64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int -> Int64 Source # | |||||
type NatNumMaxBound Int64 Source # | |||||
Defined in Basement.Nat | |||||
type Difference Int64 Source # | |||||
Defined in Basement.Numerical.Subtractive | |||||
type PrimSize Int64 Source # | |||||
Defined in Basement.PrimType |
Instances
PrintfArg Word8 | |||||
Defined in Text.Printf | |||||
BitOps Word8 Source # | |||||
Defined in Basement.Bits Methods (.&.) :: Word8 -> Word8 -> Word8 Source # (.|.) :: Word8 -> Word8 -> Word8 Source # (.^.) :: Word8 -> Word8 -> Word8 Source # (.<<.) :: Word8 -> CountOf Bool -> Word8 Source # (.>>.) :: Word8 -> CountOf Bool -> Word8 Source # bit :: Offset Bool -> Word8 Source # isBitSet :: Word8 -> Offset Bool -> Bool Source # | |||||
FiniteBitsOps Word8 Source # | |||||
Defined in Basement.Bits | |||||
HasNegation Word8 Source # | |||||
Integral Word8 Source # | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Word8 Source # | |||||
NormalForm Word8 Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Word8 -> () Source # | |||||
Additive Word8 Source # | |||||
IDivisible Word8 Source # | |||||
Multiplicative Word8 Source # | |||||
IsIntegral Word8 Source # | |||||
IsNatural Word8 Source # | |||||
Subtractive Word8 Source # | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
PrimMemoryComparable Word8 Source # | |||||
Defined in Basement.PrimType | |||||
PrimType Word8 Source # | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word8 -> CountOf Word8 Source # primShiftToBytes :: Proxy Word8 -> Int Source # primBaUIndex :: ByteArray# -> Offset Word8 -> Word8 Source # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word8 -> prim Word8 Source # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word8 -> Word8 -> prim () Source # primAddrIndex :: Addr# -> Offset Word8 -> Word8 Source # primAddrRead :: PrimMonad prim => Addr# -> Offset Word8 -> prim Word8 Source # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word8 -> Word8 -> prim () Source # | |||||
Bits Word8 | |||||
Defined in GHC.Internal.Word Methods (.&.) :: Word8 -> Word8 -> Word8 (.|.) :: Word8 -> Word8 -> Word8 xor :: Word8 -> Word8 -> Word8 complement :: Word8 -> Word8 shift :: Word8 -> Int -> Word8 rotate :: Word8 -> Int -> Word8 setBit :: Word8 -> Int -> Word8 clearBit :: Word8 -> Int -> Word8 complementBit :: Word8 -> Int -> Word8 testBit :: Word8 -> Int -> Bool bitSizeMaybe :: Word8 -> Maybe Int shiftL :: Word8 -> Int -> Word8 unsafeShiftL :: Word8 -> Int -> Word8 shiftR :: Word8 -> Int -> Word8 unsafeShiftR :: Word8 -> Int -> Word8 rotateL :: Word8 -> Int -> Word8 | |||||
FiniteBits Word8 | |||||
Defined in GHC.Internal.Word Methods finiteBitSize :: Word8 -> Int countLeadingZeros :: Word8 -> Int countTrailingZeros :: Word8 -> Int | |||||
Data Word8 | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word8 -> c Word8 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word8 # dataTypeOf :: Word8 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word8) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word8) # gmapT :: (forall b. Data b => b -> b) -> Word8 -> Word8 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word8 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word8 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 # | |||||
Bounded Word8 | |||||
Enum Word8 | |||||
Defined in GHC.Internal.Word | |||||
Storable Word8 | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
Ix Word8 | |||||
Num Word8 | |||||
Read Word8 | |||||
Defined in GHC.Internal.Read | |||||
Integral Word8 | |||||
Real Word8 | |||||
Defined in GHC.Internal.Word Methods toRational :: Word8 -> Rational | |||||
Show Word8 | |||||
Eq Word8 | |||||
Ord Word8 | |||||
Cast Int8 Word8 Source # | |||||
Cast Word8 Int8 Source # | |||||
From Word8 Word128 Source # | |||||
From Word8 Word256 Source # | |||||
From Word8 Int16 Source # | |||||
From Word8 Int32 Source # | |||||
From Word8 Int64 Source # | |||||
From Word8 Word16 Source # | |||||
From Word8 Word32 Source # | |||||
From Word8 Word64 Source # | |||||
From Word8 Int Source # | |||||
From Word8 Word Source # | |||||
IntegralDownsize Word16 Word8 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Word32 Word8 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Word64 Word8 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Integer Word8 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Natural Word8 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Word Word8 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralUpsize Word8 Int16 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Int16 Source # | |||||
IntegralUpsize Word8 Int32 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Int32 Source # | |||||
IntegralUpsize Word8 Int64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Int64 Source # | |||||
IntegralUpsize Word8 Word16 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Word16 Source # | |||||
IntegralUpsize Word8 Word32 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Word32 Source # | |||||
IntegralUpsize Word8 Word64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Word64 Source # | |||||
IntegralUpsize Word8 Int Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Int Source # | |||||
IntegralUpsize Word8 Word Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Word Source # | |||||
From AsciiString (UArray Word8) Source # | |||||
Defined in Basement.From | |||||
From String (UArray Word8) Source # | |||||
(KnownNat n, NatWithinBound Word8 n) => From (Zn n) Word8 Source # | |||||
(KnownNat n, NatWithinBound Word8 n) => From (Zn64 n) Word8 Source # | |||||
TryFrom (UArray Word8) String Source # | |||||
Cast (Block a) (Block Word8) Source # | |||||
type NatNumMaxBound Word8 Source # | |||||
Defined in Basement.Nat | |||||
type Difference Word8 Source # | |||||
Defined in Basement.Numerical.Subtractive | |||||
type PrimSize Word8 Source # | |||||
Defined in Basement.PrimType |
Instances
PrintfArg Word16 | |||||
Defined in Text.Printf | |||||
BitOps Word16 Source # | |||||
Defined in Basement.Bits Methods (.&.) :: Word16 -> Word16 -> Word16 Source # (.|.) :: Word16 -> Word16 -> Word16 Source # (.^.) :: Word16 -> Word16 -> Word16 Source # (.<<.) :: Word16 -> CountOf Bool -> Word16 Source # (.>>.) :: Word16 -> CountOf Bool -> Word16 Source # bit :: Offset Bool -> Word16 Source # isBitSet :: Word16 -> Offset Bool -> Bool Source # | |||||
FiniteBitsOps Word16 Source # | |||||
Defined in Basement.Bits | |||||
HasNegation Word16 Source # | |||||
Integral Word16 Source # | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Word16 Source # | |||||
ByteSwap Word16 Source # | |||||
Defined in Basement.Endianness | |||||
NormalForm Word16 Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Word16 -> () Source # | |||||
Additive Word16 Source # | |||||
IDivisible Word16 Source # | |||||
Multiplicative Word16 Source # | |||||
IsIntegral Word16 Source # | |||||
IsNatural Word16 Source # | |||||
Subtractive Word16 Source # | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
PrimMemoryComparable Word16 Source # | |||||
Defined in Basement.PrimType | |||||
PrimType Word16 Source # | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word16 -> CountOf Word8 Source # primShiftToBytes :: Proxy Word16 -> Int Source # primBaUIndex :: ByteArray# -> Offset Word16 -> Word16 Source # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word16 -> prim Word16 Source # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word16 -> Word16 -> prim () Source # primAddrIndex :: Addr# -> Offset Word16 -> Word16 Source # primAddrRead :: PrimMonad prim => Addr# -> Offset Word16 -> prim Word16 Source # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word16 -> Word16 -> prim () Source # | |||||
Bits Word16 | |||||
Defined in GHC.Internal.Word Methods (.&.) :: Word16 -> Word16 -> Word16 (.|.) :: Word16 -> Word16 -> Word16 xor :: Word16 -> Word16 -> Word16 complement :: Word16 -> Word16 shift :: Word16 -> Int -> Word16 rotate :: Word16 -> Int -> Word16 setBit :: Word16 -> Int -> Word16 clearBit :: Word16 -> Int -> Word16 complementBit :: Word16 -> Int -> Word16 testBit :: Word16 -> Int -> Bool bitSizeMaybe :: Word16 -> Maybe Int shiftL :: Word16 -> Int -> Word16 unsafeShiftL :: Word16 -> Int -> Word16 shiftR :: Word16 -> Int -> Word16 unsafeShiftR :: Word16 -> Int -> Word16 rotateL :: Word16 -> Int -> Word16 | |||||
FiniteBits Word16 | |||||
Defined in GHC.Internal.Word Methods finiteBitSize :: Word16 -> Int countLeadingZeros :: Word16 -> Int countTrailingZeros :: Word16 -> Int | |||||
Data Word16 | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word16 -> c Word16 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word16 # toConstr :: Word16 -> Constr # dataTypeOf :: Word16 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word16) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word16) # gmapT :: (forall b. Data b => b -> b) -> Word16 -> Word16 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word16 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word16 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 # | |||||
Bounded Word16 | |||||
Enum Word16 | |||||
Defined in GHC.Internal.Word | |||||
Storable Word16 | |||||
Ix Word16 | |||||
Num Word16 | |||||
Read Word16 | |||||
Defined in GHC.Internal.Read | |||||
Integral Word16 | |||||
Real Word16 | |||||
Defined in GHC.Internal.Word Methods toRational :: Word16 -> Rational | |||||
Show Word16 | |||||
Eq Word16 | |||||
Ord Word16 | |||||
Cast Int16 Word16 Source # | |||||
Cast Word16 Int16 Source # | |||||
From Word16 Word128 Source # | |||||
From Word16 Word256 Source # | |||||
From Word16 Int32 Source # | |||||
From Word16 Int64 Source # | |||||
From Word16 Word32 Source # | |||||
From Word16 Word64 Source # | |||||
From Word16 Int Source # | |||||
From Word16 Word Source # | |||||
From Word8 Word16 Source # | |||||
IntegralDownsize Word16 Word8 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Word32 Word16 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Word64 Word16 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Integer Word16 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Natural Word16 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Word Word16 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralUpsize Word16 Word32 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word16 -> Word32 Source # | |||||
IntegralUpsize Word16 Word64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word16 -> Word64 Source # | |||||
IntegralUpsize Word16 Word Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word16 -> Word Source # | |||||
IntegralUpsize Word8 Word16 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Word16 Source # | |||||
(KnownNat n, NatWithinBound Word16 n) => From (Zn n) Word16 Source # | |||||
(KnownNat n, NatWithinBound Word16 n) => From (Zn64 n) Word16 Source # | |||||
type NatNumMaxBound Word16 Source # | |||||
Defined in Basement.Nat | |||||
type Difference Word16 Source # | |||||
Defined in Basement.Numerical.Subtractive | |||||
type PrimSize Word16 Source # | |||||
Defined in Basement.PrimType |
Instances
PrintfArg Word32 | |||||
Defined in Text.Printf | |||||
BitOps Word32 Source # | |||||
Defined in Basement.Bits Methods (.&.) :: Word32 -> Word32 -> Word32 Source # (.|.) :: Word32 -> Word32 -> Word32 Source # (.^.) :: Word32 -> Word32 -> Word32 Source # (.<<.) :: Word32 -> CountOf Bool -> Word32 Source # (.>>.) :: Word32 -> CountOf Bool -> Word32 Source # bit :: Offset Bool -> Word32 Source # isBitSet :: Word32 -> Offset Bool -> Bool Source # | |||||
FiniteBitsOps Word32 Source # | |||||
Defined in Basement.Bits | |||||
HasNegation Word32 Source # | |||||
Integral Word32 Source # | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Word32 Source # | |||||
ByteSwap Word32 Source # | |||||
Defined in Basement.Endianness | |||||
NormalForm Word32 Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Word32 -> () Source # | |||||
Additive Word32 Source # | |||||
IDivisible Word32 Source # | |||||
Multiplicative Word32 Source # | |||||
IsIntegral Word32 Source # | |||||
IsNatural Word32 Source # | |||||
Subtractive Word32 Source # | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
PrimMemoryComparable Word32 Source # | |||||
Defined in Basement.PrimType | |||||
PrimType Word32 Source # | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word32 -> CountOf Word8 Source # primShiftToBytes :: Proxy Word32 -> Int Source # primBaUIndex :: ByteArray# -> Offset Word32 -> Word32 Source # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word32 -> prim Word32 Source # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word32 -> Word32 -> prim () Source # primAddrIndex :: Addr# -> Offset Word32 -> Word32 Source # primAddrRead :: PrimMonad prim => Addr# -> Offset Word32 -> prim Word32 Source # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word32 -> Word32 -> prim () Source # | |||||
Bits Word32 | |||||
Defined in GHC.Internal.Word Methods (.&.) :: Word32 -> Word32 -> Word32 (.|.) :: Word32 -> Word32 -> Word32 xor :: Word32 -> Word32 -> Word32 complement :: Word32 -> Word32 shift :: Word32 -> Int -> Word32 rotate :: Word32 -> Int -> Word32 setBit :: Word32 -> Int -> Word32 clearBit :: Word32 -> Int -> Word32 complementBit :: Word32 -> Int -> Word32 testBit :: Word32 -> Int -> Bool bitSizeMaybe :: Word32 -> Maybe Int shiftL :: Word32 -> Int -> Word32 unsafeShiftL :: Word32 -> Int -> Word32 shiftR :: Word32 -> Int -> Word32 unsafeShiftR :: Word32 -> Int -> Word32 rotateL :: Word32 -> Int -> Word32 | |||||
FiniteBits Word32 | |||||
Defined in GHC.Internal.Word Methods finiteBitSize :: Word32 -> Int countLeadingZeros :: Word32 -> Int countTrailingZeros :: Word32 -> Int | |||||
Data Word32 | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word32 -> c Word32 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word32 # toConstr :: Word32 -> Constr # dataTypeOf :: Word32 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word32) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word32) # gmapT :: (forall b. Data b => b -> b) -> Word32 -> Word32 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word32 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word32 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 # | |||||
Bounded Word32 | |||||
Enum Word32 | |||||
Defined in GHC.Internal.Word | |||||
Storable Word32 | |||||
Ix Word32 | |||||
Num Word32 | |||||
Read Word32 | |||||
Defined in GHC.Internal.Read | |||||
Integral Word32 | |||||
Real Word32 | |||||
Defined in GHC.Internal.Word Methods toRational :: Word32 -> Rational | |||||
Show Word32 | |||||
Eq Word32 | |||||
Ord Word32 | |||||
Cast Int32 Word32 Source # | |||||
Cast Word32 Int32 Source # | |||||
From Word16 Word32 Source # | |||||
From Word32 Word128 Source # | |||||
From Word32 Word256 Source # | |||||
From Word32 Int64 Source # | |||||
From Word32 Word64 Source # | |||||
From Word32 Int Source # | |||||
From Word32 Word Source # | |||||
From Word8 Word32 Source # | |||||
IntegralDownsize Word32 Word16 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Word32 Word8 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Word64 Word32 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Integer Word32 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Natural Word32 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Word Word32 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralUpsize Word16 Word32 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word16 -> Word32 Source # | |||||
IntegralUpsize Word32 Word64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word32 -> Word64 Source # | |||||
IntegralUpsize Word32 Word Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word32 -> Word Source # | |||||
IntegralUpsize Word8 Word32 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Word32 Source # | |||||
(KnownNat n, NatWithinBound Word32 n) => From (Zn n) Word32 Source # | |||||
(KnownNat n, NatWithinBound Word32 n) => From (Zn64 n) Word32 Source # | |||||
type NatNumMaxBound Word32 Source # | |||||
Defined in Basement.Nat | |||||
type Difference Word32 Source # | |||||
Defined in Basement.Numerical.Subtractive | |||||
type PrimSize Word32 Source # | |||||
Defined in Basement.PrimType |
Instances
PrintfArg Word64 | |||||
Defined in Text.Printf | |||||
BitOps Word64 Source # | |||||
Defined in Basement.Bits Methods (.&.) :: Word64 -> Word64 -> Word64 Source # (.|.) :: Word64 -> Word64 -> Word64 Source # (.^.) :: Word64 -> Word64 -> Word64 Source # (.<<.) :: Word64 -> CountOf Bool -> Word64 Source # (.>>.) :: Word64 -> CountOf Bool -> Word64 Source # bit :: Offset Bool -> Word64 Source # isBitSet :: Word64 -> Offset Bool -> Bool Source # | |||||
FiniteBitsOps Word64 Source # | |||||
Defined in Basement.Bits | |||||
HasNegation Word64 Source # | |||||
Integral Word64 Source # | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Word64 Source # | |||||
ByteSwap Word64 Source # | |||||
Defined in Basement.Endianness | |||||
NormalForm Word64 Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Word64 -> () Source # | |||||
Additive Word64 Source # | |||||
IDivisible Word64 Source # | |||||
Multiplicative Word64 Source # | |||||
IsIntegral Word64 Source # | |||||
IsNatural Word64 Source # | |||||
Subtractive Word64 Source # | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
PrimMemoryComparable Word64 Source # | |||||
Defined in Basement.PrimType | |||||
PrimType Word64 Source # | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word64 -> CountOf Word8 Source # primShiftToBytes :: Proxy Word64 -> Int Source # primBaUIndex :: ByteArray# -> Offset Word64 -> Word64 Source # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word64 -> prim Word64 Source # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word64 -> Word64 -> prim () Source # primAddrIndex :: Addr# -> Offset Word64 -> Word64 Source # primAddrRead :: PrimMonad prim => Addr# -> Offset Word64 -> prim Word64 Source # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word64 -> Word64 -> prim () Source # | |||||
Bits Word64 | |||||
Defined in GHC.Internal.Word Methods (.&.) :: Word64 -> Word64 -> Word64 (.|.) :: Word64 -> Word64 -> Word64 xor :: Word64 -> Word64 -> Word64 complement :: Word64 -> Word64 shift :: Word64 -> Int -> Word64 rotate :: Word64 -> Int -> Word64 setBit :: Word64 -> Int -> Word64 clearBit :: Word64 -> Int -> Word64 complementBit :: Word64 -> Int -> Word64 testBit :: Word64 -> Int -> Bool bitSizeMaybe :: Word64 -> Maybe Int shiftL :: Word64 -> Int -> Word64 unsafeShiftL :: Word64 -> Int -> Word64 shiftR :: Word64 -> Int -> Word64 unsafeShiftR :: Word64 -> Int -> Word64 rotateL :: Word64 -> Int -> Word64 | |||||
FiniteBits Word64 | |||||
Defined in GHC.Internal.Word Methods finiteBitSize :: Word64 -> Int countLeadingZeros :: Word64 -> Int countTrailingZeros :: Word64 -> Int | |||||
Data Word64 | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word64 -> c Word64 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word64 # toConstr :: Word64 -> Constr # dataTypeOf :: Word64 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word64) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word64) # gmapT :: (forall b. Data b => b -> b) -> Word64 -> Word64 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word64 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word64 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 # | |||||
Bounded Word64 | |||||
Enum Word64 | |||||
Defined in GHC.Internal.Word | |||||
Storable Word64 | |||||
Ix Word64 | |||||
Num Word64 | |||||
Read Word64 | |||||
Defined in GHC.Internal.Read | |||||
Integral Word64 | |||||
Real Word64 | |||||
Defined in GHC.Internal.Word Methods toRational :: Word64 -> Rational | |||||
Show Word64 | |||||
Eq Word64 | |||||
Ord Word64 | |||||
Cast Int64 Word64 Source # | |||||
Cast Word64 Int64 Source # | |||||
Cast Word64 Int Source # | |||||
Cast Word64 Word Source # | |||||
Cast Int Word64 Source # | |||||
Cast Word Word64 Source # | |||||
From Word16 Word64 Source # | |||||
From Word32 Word64 Source # | |||||
From Word64 Word128 Source # | |||||
From Word64 Word256 Source # | |||||
From Word8 Word64 Source # | |||||
From Word Word64 Source # | |||||
IntegralDownsize Word64 Word16 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Word64 Word32 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Word64 Word8 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Integer Word64 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Natural Word64 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralUpsize Word16 Word64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word16 -> Word64 Source # | |||||
IntegralUpsize Word32 Word64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word32 -> Word64 Source # | |||||
IntegralUpsize Word8 Word64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Word64 Source # | |||||
IntegralUpsize Word Word64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word -> Word64 Source # | |||||
(KnownNat n, NatWithinBound Word64 n) => From (Zn n) Word64 Source # | |||||
From (Zn64 n) Word64 Source # | |||||
type NatNumMaxBound Word64 Source # | |||||
Defined in Basement.Nat | |||||
type Difference Word64 Source # | |||||
Defined in Basement.Numerical.Subtractive | |||||
type PrimSize Word64 Source # | |||||
Defined in Basement.PrimType |
Instances
PrintfArg Word | |||||
Defined in Text.Printf | |||||
BitOps Word Source # | |||||
Defined in Basement.Bits Methods (.&.) :: Word -> Word -> Word Source # (.|.) :: Word -> Word -> Word Source # (.^.) :: Word -> Word -> Word Source # (.<<.) :: Word -> CountOf Bool -> Word Source # (.>>.) :: Word -> CountOf Bool -> Word Source # bit :: Offset Bool -> Word Source # isBitSet :: Word -> Offset Bool -> Bool Source # | |||||
FiniteBitsOps Word Source # | |||||
HasNegation Word Source # | |||||
Integral Word Source # | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Word Source # | |||||
NormalForm Word Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Word -> () Source # | |||||
Additive Word Source # | |||||
IDivisible Word Source # | |||||
Multiplicative Word Source # | |||||
IsIntegral Word Source # | |||||
IsNatural Word Source # | |||||
Subtractive Word Source # | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
PrimMemoryComparable Word Source # | |||||
Defined in Basement.PrimType | |||||
PrimType Word Source # | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word -> CountOf Word8 Source # primShiftToBytes :: Proxy Word -> Int Source # primBaUIndex :: ByteArray# -> Offset Word -> Word Source # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word -> prim Word Source # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word -> Word -> prim () Source # primAddrIndex :: Addr# -> Offset Word -> Word Source # primAddrRead :: PrimMonad prim => Addr# -> Offset Word -> prim Word Source # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word -> Word -> prim () Source # | |||||
Bits Word | |||||
Defined in GHC.Internal.Bits | |||||
FiniteBits Word | |||||
Defined in GHC.Internal.Bits Methods finiteBitSize :: Word -> Int countLeadingZeros :: Word -> Int countTrailingZeros :: Word -> Int | |||||
Data Word | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word # dataTypeOf :: Word -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) # gmapT :: (forall b. Data b => b -> b) -> Word -> Word # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r # gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word # | |||||
Bounded Word | |||||
Enum Word | |||||
Storable Word | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
Num Word | |||||
Read Word | |||||
Defined in GHC.Internal.Read | |||||
Integral Word | |||||
Real Word | |||||
Defined in GHC.Internal.Real Methods toRational :: Word -> Rational | |||||
Show Word | |||||
Eq Word | |||||
Ord Word | |||||
Cast Int64 Word Source # | |||||
Cast Word64 Word Source # | |||||
Cast Int Word Source # | |||||
Cast Word Int64 Source # | |||||
Cast Word Word64 Source # | |||||
Cast Word Int Source # | |||||
From Word16 Word Source # | |||||
From Word32 Word Source # | |||||
From Word8 Word Source # | |||||
From Word Word64 Source # | |||||
IntegralDownsize Word Word16 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Word Word32 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralDownsize Word Word8 Source # | |||||
Defined in Basement.IntegralConv | |||||
IntegralUpsize Word16 Word Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word16 -> Word Source # | |||||
IntegralUpsize Word32 Word Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word32 -> Word Source # | |||||
IntegralUpsize Word8 Word Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Word Source # | |||||
IntegralUpsize Word Word64 Source # | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word -> Word64 Source # | |||||
From Word (CountOf ty) Source # | |||||
From Word (Offset ty) Source # | |||||
Generic1 (URec Word :: k -> Type) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Foldable (UWord :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => UWord m -> m foldMap :: Monoid m => (a -> m) -> UWord a -> m foldMap' :: Monoid m => (a -> m) -> UWord a -> m foldr :: (a -> b -> b) -> b -> UWord a -> b foldr' :: (a -> b -> b) -> b -> UWord a -> b foldl :: (b -> a -> b) -> b -> UWord a -> b foldl' :: (b -> a -> b) -> b -> UWord a -> b foldr1 :: (a -> a -> a) -> UWord a -> a foldl1 :: (a -> a -> a) -> UWord a -> a toList :: UWord a -> [a] elem :: Eq a => a -> UWord a -> Bool maximum :: Ord a => UWord a -> a minimum :: Ord a => UWord a -> a sum :: Num a => UWord a -> a product :: Num a => UWord a -> a | |||||
Traversable (UWord :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UWord a -> f (UWord b) sequenceA :: Applicative f => UWord (f a) -> f (UWord a) | |||||
From (CountOf ty) Word Source # | |||||
Functor (URec Word :: Type -> Type) | |||||
Generic (URec Word p) | |||||
Defined in GHC.Internal.Generics | |||||
Show (URec Word p) | |||||
Eq (URec Word p) | |||||
Ord (URec Word p) | |||||
Defined in GHC.Internal.Generics | |||||
type NatNumMaxBound Word Source # | |||||
Defined in Basement.Nat | |||||
type Difference Word Source # | |||||
Defined in Basement.Numerical.Subtractive | |||||
type PrimSize Word Source # | |||||
Defined in Basement.PrimType | |||||
data URec Word (p :: k) | |||||
Defined in GHC.Internal.Generics | |||||
type Rep1 (URec Word :: k -> Type) | |||||
Defined in GHC.Internal.Generics | |||||
type Rep (URec Word p) | |||||
Instances
PrintfArg Double | |||||
Defined in Text.Printf | |||||
Fractional Double Source # | |||||
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> Double Source # | |||||
HasNegation Double Source # | |||||
Integral Double Source # | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Double Source # | |||||
NormalForm Double Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Double -> () Source # | |||||
Additive Double Source # | |||||
Divisible Double Source # | |||||
Multiplicative Double Source # | |||||
Subtractive Double Source # | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
PrimType Double Source # | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Double -> CountOf Word8 Source # primShiftToBytes :: Proxy Double -> Int Source # primBaUIndex :: ByteArray# -> Offset Double -> Double Source # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Double -> prim Double Source # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Double -> Double -> prim () Source # primAddrIndex :: Addr# -> Offset Double -> Double Source # primAddrRead :: PrimMonad prim => Addr# -> Offset Double -> prim Double Source # primAddrWrite :: PrimMonad prim => Addr# -> Offset Double -> Double -> prim () Source # | |||||
Data Double | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double # toConstr :: Double -> Constr # dataTypeOf :: Double -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Double) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) # gmapT :: (forall b. Data b => b -> b) -> Double -> Double # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r # gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double # | |||||
Floating Double | |||||
RealFloat Double | |||||
Defined in GHC.Internal.Float Methods floatRadix :: Double -> Integer floatDigits :: Double -> Int floatRange :: Double -> (Int, Int) decodeFloat :: Double -> (Integer, Int) encodeFloat :: Integer -> Int -> Double significand :: Double -> Double scaleFloat :: Int -> Double -> Double isInfinite :: Double -> Bool isDenormalized :: Double -> Bool isNegativeZero :: Double -> Bool | |||||
Storable Double | |||||
Read Double | |||||
Defined in GHC.Internal.Read | |||||
Eq Double | |||||
Ord Double | |||||
Generic1 (URec Double :: k -> Type) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Foldable (UDouble :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => UDouble m -> m foldMap :: Monoid m => (a -> m) -> UDouble a -> m foldMap' :: Monoid m => (a -> m) -> UDouble a -> m foldr :: (a -> b -> b) -> b -> UDouble a -> b foldr' :: (a -> b -> b) -> b -> UDouble a -> b foldl :: (b -> a -> b) -> b -> UDouble a -> b foldl' :: (b -> a -> b) -> b -> UDouble a -> b foldr1 :: (a -> a -> a) -> UDouble a -> a foldl1 :: (a -> a -> a) -> UDouble a -> a toList :: UDouble a -> [a] elem :: Eq a => a -> UDouble a -> Bool maximum :: Ord a => UDouble a -> a minimum :: Ord a => UDouble a -> a sum :: Num a => UDouble a -> a product :: Num a => UDouble a -> a | |||||
Traversable (UDouble :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UDouble a -> f (UDouble b) sequenceA :: Applicative f => UDouble (f a) -> f (UDouble a) | |||||
Functor (URec Double :: Type -> Type) | |||||
Generic (URec Double p) | |||||
Defined in GHC.Internal.Generics | |||||
Show (URec Double p) | |||||
Eq (URec Double p) | |||||
Ord (URec Double p) | |||||
Defined in GHC.Internal.Generics Methods compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # | |||||
type Difference Double Source # | |||||
Defined in Basement.Numerical.Subtractive | |||||
type PrimSize Double Source # | |||||
Defined in Basement.PrimType | |||||
data URec Double (p :: k) | |||||
Defined in GHC.Internal.Generics | |||||
type Rep1 (URec Double :: k -> Type) | |||||
Defined in GHC.Internal.Generics | |||||
type Rep (URec Double p) | |||||
Instances
PrintfArg Float | |||||
Defined in Text.Printf | |||||
Fractional Float Source # | |||||
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> Float Source # | |||||
HasNegation Float Source # | |||||
Integral Float Source # | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Float Source # | |||||
NormalForm Float Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Float -> () Source # | |||||
Additive Float Source # | |||||
Divisible Float Source # | |||||
Multiplicative Float Source # | |||||
Subtractive Float Source # | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
PrimType Float Source # | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Float -> CountOf Word8 Source # primShiftToBytes :: Proxy Float -> Int Source # primBaUIndex :: ByteArray# -> Offset Float -> Float Source # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Float -> prim Float Source # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Float -> Float -> prim () Source # primAddrIndex :: Addr# -> Offset Float -> Float Source # primAddrRead :: PrimMonad prim => Addr# -> Offset Float -> prim Float Source # primAddrWrite :: PrimMonad prim => Addr# -> Offset Float -> Float -> prim () Source # | |||||
Data Float | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float # dataTypeOf :: Float -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) # gmapT :: (forall b. Data b => b -> b) -> Float -> Float # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r # gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float # | |||||
Floating Float | |||||
RealFloat Float | |||||
Defined in GHC.Internal.Float Methods floatRadix :: Float -> Integer floatDigits :: Float -> Int floatRange :: Float -> (Int, Int) decodeFloat :: Float -> (Integer, Int) encodeFloat :: Integer -> Int -> Float significand :: Float -> Float scaleFloat :: Int -> Float -> Float isInfinite :: Float -> Bool isDenormalized :: Float -> Bool isNegativeZero :: Float -> Bool | |||||
Storable Float | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
Read Float | |||||
Defined in GHC.Internal.Read | |||||
Eq Float | |||||
Ord Float | |||||
Generic1 (URec Float :: k -> Type) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Foldable (UFloat :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => UFloat m -> m foldMap :: Monoid m => (a -> m) -> UFloat a -> m foldMap' :: Monoid m => (a -> m) -> UFloat a -> m foldr :: (a -> b -> b) -> b -> UFloat a -> b foldr' :: (a -> b -> b) -> b -> UFloat a -> b foldl :: (b -> a -> b) -> b -> UFloat a -> b foldl' :: (b -> a -> b) -> b -> UFloat a -> b foldr1 :: (a -> a -> a) -> UFloat a -> a foldl1 :: (a -> a -> a) -> UFloat a -> a toList :: UFloat a -> [a] elem :: Eq a => a -> UFloat a -> Bool maximum :: Ord a => UFloat a -> a minimum :: Ord a => UFloat a -> a sum :: Num a => UFloat a -> a product :: Num a => UFloat a -> a | |||||
Traversable (UFloat :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UFloat a -> f (UFloat b) sequenceA :: Applicative f => UFloat (f a) -> f (UFloat a) | |||||
Functor (URec Float :: Type -> Type) | |||||
Generic (URec Float p) | |||||
Defined in GHC.Internal.Generics | |||||
Show (URec Float p) | |||||
Eq (URec Float p) | |||||
Ord (URec Float p) | |||||
Defined in GHC.Internal.Generics | |||||
type Difference Float Source # | |||||
Defined in Basement.Numerical.Subtractive | |||||
type PrimSize Float Source # | |||||
Defined in Basement.PrimType | |||||
data URec Float (p :: k) | |||||
Defined in GHC.Internal.Generics | |||||
type Rep1 (URec Float :: k -> Type) | |||||
Defined in GHC.Internal.Generics | |||||
type Rep (URec Float p) | |||||
Instances
MonadIO IO | |||||||||
Defined in Control.Monad.IO.Class | |||||||||
PrimMonad IO Source # | |||||||||
Defined in Basement.Monad Associated Types
Methods primitive :: (State# (PrimState IO) -> (# State# (PrimState IO), a #)) -> IO a Source # primThrow :: Exception e => e -> IO a Source # unPrimMonad :: IO a -> State# (PrimState IO) -> (# State# (PrimState IO), a #) Source # primVarNew :: a -> IO (PrimVar IO a) Source # | |||||||||
Alternative IO | |||||||||
Applicative IO | |||||||||
Functor IO | |||||||||
Monad IO | |||||||||
MonadPlus IO | |||||||||
a ~ () => HPrintfType (IO a) | |||||||||
Defined in Text.Printf | |||||||||
a ~ () => PrintfType (IO a) | |||||||||
Defined in Text.Printf | |||||||||
Monoid a => Monoid (IO a) | |||||||||
Semigroup a => Semigroup (IO a) | |||||||||
type PrimState IO Source # | |||||||||
Defined in Basement.Monad | |||||||||
type PrimVar IO Source # | |||||||||
Defined in Basement.Monad |
Instances
IsList ByteArray | |||||
IsList AsciiString Source # | |||||
Defined in Basement.Types.AsciiString Associated Types
Methods fromList :: [Item AsciiString] -> AsciiString # fromListN :: Int -> [Item AsciiString] -> AsciiString # toList :: AsciiString -> [Item AsciiString] # | |||||
IsList String Source # | |||||
IsList Version | |||||
IsList CallStack | |||||
PrimType ty => IsList (Block ty) Source # | |||||
IsList (Array ty) Source # | |||||
IsList c => IsList (NonEmpty c) Source # | |||||
PrimType ty => IsList (UArray ty) Source # | |||||
IsList (NonEmpty a) | |||||
IsList (ZipList a) | |||||
IsList [a] | |||||
Methods
fromString :: String -> a #
Instances
IsString AsciiString Source # | |
Defined in Basement.Types.AsciiString Methods fromString :: String -> AsciiString # | |
IsString String Source # | |
Defined in Basement.UTF8.Base Methods fromString :: String -> String # | |
IsString a => IsString (Identity a) | |
Defined in GHC.Internal.Data.String Methods fromString :: String -> Identity a # | |
a ~ Char => IsString [a] | |
Defined in GHC.Internal.Data.String Methods fromString :: String -> [a] # | |
IsString a => IsString (Const a b) | |
Defined in GHC.Internal.Data.String Methods fromString :: String -> Const a b # |
Instances
Generic Void | |||||
Generic All | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
Generic Any | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
Generic Version | |||||
Defined in GHC.Internal.Data.Version Associated Types
| |||||
Generic Fingerprint | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic Associativity | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic DecidedStrictness | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic Fixity | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic SourceStrictness | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic SourceUnpackedness | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic ExitCode | |||||
Defined in GHC.Internal.IO.Exception Associated Types
| |||||
Generic CCFlags | |||||
Defined in GHC.Internal.RTS.Flags Associated Types
| |||||
Generic ConcFlags | |||||
Defined in GHC.Internal.RTS.Flags Associated Types
| |||||
Generic DebugFlags | |||||
Defined in GHC.Internal.RTS.Flags Associated Types
| |||||
Generic DoCostCentres | |||||
Defined in GHC.Internal.RTS.Flags Associated Types
| |||||
Generic DoHeapProfile | |||||
Defined in GHC.Internal.RTS.Flags Associated Types
| |||||
Generic DoTrace | |||||
Defined in GHC.Internal.RTS.Flags Associated Types
| |||||
Generic GCFlags | |||||
Defined in GHC.Internal.RTS.Flags Associated Types
| |||||
Generic GiveGCStats | |||||
Defined in GHC.Internal.RTS.Flags Associated Types
| |||||
Generic HpcFlags | |||||
Defined in GHC.Internal.RTS.Flags Associated Types
| |||||
Generic MiscFlags | |||||
Defined in GHC.Internal.RTS.Flags Associated Types
| |||||
Generic ParFlags | |||||
Defined in GHC.Internal.RTS.Flags Associated Types
| |||||
Generic ProfFlags | |||||
Defined in GHC.Internal.RTS.Flags Associated Types
| |||||
Generic RTSFlags | |||||
Defined in GHC.Internal.RTS.Flags Associated Types
| |||||
Generic TickyFlags | |||||
Defined in GHC.Internal.RTS.Flags Associated Types
| |||||
Generic TraceFlags | |||||
Defined in GHC.Internal.RTS.Flags Associated Types
| |||||
Generic SrcLoc | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic GeneralCategory | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic Ordering | |||||
Defined in GHC.Internal.Generics | |||||
Generic () | |||||
Generic Bool | |||||
Defined in GHC.Internal.Generics | |||||
Generic (Complex a) | |||||
Defined in Data.Complex Associated Types
| |||||
Generic (First a) | |||||
Defined in Data.Semigroup Associated Types
| |||||
Generic (Last a) | |||||
Defined in Data.Semigroup Associated Types
| |||||
Generic (Max a) | |||||
Defined in Data.Semigroup Associated Types
| |||||
Generic (Min a) | |||||
Defined in Data.Semigroup Associated Types
| |||||
Generic (WrappedMonoid m) | |||||
Defined in Data.Semigroup Associated Types
| |||||
Generic (NonEmpty a) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (Identity a) | |||||
Defined in GHC.Internal.Data.Functor.Identity | |||||
Generic (First a) | |||||
Defined in GHC.Internal.Data.Monoid Associated Types
| |||||
Generic (Last a) | |||||
Defined in GHC.Internal.Data.Monoid Associated Types
| |||||
Generic (Down a) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (Dual a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
Generic (Endo a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
Generic (Product a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
Generic (Sum a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
Generic (ZipList a) | |||||
Defined in GHC.Internal.Functor.ZipList Associated Types
| |||||
Generic (Par1 p) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (Maybe a) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (Solo a) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic [a] | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (WrappedMonad m a) | |||||
Defined in Control.Applicative Associated Types
| |||||
Generic (Arg a b) | |||||
Defined in Data.Semigroup Associated Types
| |||||
Generic (ListN n a) Source # | |||||
Defined in Basement.Sized.List | |||||
Generic (Either a b) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (Proxy t) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (U1 p) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (V1 p) | |||||
Generic (a, b) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (WrappedArrow a b c) | |||||
Defined in Control.Applicative Associated Types
| |||||
Generic (Kleisli m a b) | |||||
Defined in GHC.Internal.Control.Arrow Associated Types
| |||||
Generic (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const Associated Types
| |||||
Generic (Ap f a) | |||||
Defined in GHC.Internal.Data.Monoid Associated Types
| |||||
Generic (Alt f a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
Generic (Rec1 f p) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (URec (Ptr ()) p) | |||||
Defined in GHC.Internal.Generics | |||||
Generic (URec Char p) | |||||
Defined in GHC.Internal.Generics | |||||
Generic (URec Double p) | |||||
Defined in GHC.Internal.Generics | |||||
Generic (URec Float p) | |||||
Defined in GHC.Internal.Generics | |||||
Generic (URec Int p) | |||||
Defined in GHC.Internal.Generics | |||||
Generic (URec Word p) | |||||
Defined in GHC.Internal.Generics | |||||
Generic (a, b, c) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (Product f g a) | |||||
Defined in Data.Functor.Product Associated Types
| |||||
Generic (Sum f g a) | |||||
Defined in Data.Functor.Sum Associated Types
| |||||
Generic ((f :*: g) p) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic ((f :+: g) p) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (K1 i c p) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (a, b, c, d) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (Compose f g a) | |||||
Defined in Data.Functor.Compose Associated Types
| |||||
Generic ((f :.: g) p) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (M1 i c f p) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (a, b, c, d, e) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (a, b, c, d, e, f) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (a, b, c, d, e, f, g) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (a, b, c, d, e, f, g, h) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (a, b, c, d, e, f, g, h, i) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (a, b, c, d, e, f, g, h, i, j) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (a, b, c, d, e, f, g, h, i, j, k) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (a, b, c, d, e, f, g, h, i, j, k, l) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (a, b, c, d, e, f, g, h, i, j, k, l, m) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |||||
Defined in GHC.Internal.Generics Associated Types
|
Instances
Bifoldable Either | |||||
Bifoldable1 Either | |||||
Defined in Data.Bifoldable1 | |||||
Bifunctor Either | |||||
Bitraversable Either | |||||
Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d) | |||||
Eq2 Either | |||||
Ord2 Either | |||||
Defined in Data.Functor.Classes | |||||
Read2 Either | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Either a b) liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Either a b] liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Either a b) liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Either a b] | |||||
Show2 Either | |||||
Defined in Data.Functor.Classes Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Either a b -> ShowS liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Either a b] -> ShowS | |||||
Generic1 (Either a :: Type -> Type) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
Eq a => Eq1 (Either a) | |||||
Ord a => Ord1 (Either a) | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b -> Ordering) -> Either a a0 -> Either a b -> Ordering | |||||
Read a => Read1 (Either a) | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Either a a0) liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Either a a0] liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Either a a0) liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Either a a0] | |||||
Show a => Show1 (Either a) | |||||
Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Either a a0 -> ShowS liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Either a a0] -> ShowS | |||||
MonadFailure (Either a) Source # | |||||
Applicative (Either e) | |||||
Functor (Either a) | |||||
Monad (Either e) | |||||
Foldable (Either a) | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => Either a m -> m foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 elem :: Eq a0 => a0 -> Either a a0 -> Bool maximum :: Ord a0 => Either a a0 -> a0 minimum :: Ord a0 => Either a a0 -> a0 | |||||
Traversable (Either a) | |||||
Defined in GHC.Internal.Data.Traversable | |||||
From (Maybe a) (Either () a) Source # | |||||
(NormalForm l, NormalForm r) => NormalForm (Either l r) Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Either l r -> () Source # | |||||
Semigroup (Either a b) | |||||
(Data a, Data b) => Data (Either a b) | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Either a b -> c (Either a b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b) # toConstr :: Either a b -> Constr # dataTypeOf :: Either a b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Either a b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Either a b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Either a b -> Either a b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r # gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) # | |||||
Generic (Either a b) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
(Read a, Read b) => Read (Either a b) | |||||
Defined in GHC.Internal.Data.Either | |||||
(Show a, Show b) => Show (Either a b) | |||||
(Eq a, Eq b) => Eq (Either a b) | |||||
(Ord a, Ord b) => Ord (Either a b) | |||||
Defined in GHC.Internal.Data.Either | |||||
From (Either a b) (These a b) Source # | |||||
type Rep1 (Either a :: Type -> Type) | |||||
Defined in GHC.Internal.Generics type Rep1 (Either a :: Type -> Type) = D1 ('MetaData "Either" "GHC.Internal.Data.Either" "ghc-internal" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1)) | |||||
type Failure (Either a) Source # | |||||
Defined in Basement.Monad | |||||
type Rep (Either a b) | |||||
Defined in GHC.Internal.Generics type Rep (Either a b) = D1 ('MetaData "Either" "GHC.Internal.Data.Either" "ghc-internal" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 b))) |
class Typeable a => Data a where #
Minimal complete definition
Methods
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> a -> c a #
gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c a #
dataTypeOf :: a -> DataType #
dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c a) #
dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a) #
gmapT :: (forall b. Data b => b -> b) -> a -> a #
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r #
gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r #
gmapQ :: (forall d. Data d => d -> u) -> a -> [u] #
gmapQi :: Int -> (forall d. Data d => d -> u) -> a -> u #
gmapM :: Monad m => (forall d. Data d => d -> m d) -> a -> m a #
gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a #
gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a #
Instances
Data ByteArray | |
Defined in Data.Array.Byte Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ByteArray -> c ByteArray # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ByteArray # toConstr :: ByteArray -> Constr # dataTypeOf :: ByteArray -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ByteArray) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteArray) # gmapT :: (forall b. Data b => b -> b) -> ByteArray -> ByteArray # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ByteArray -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ByteArray -> r # gmapQ :: (forall d. Data d => d -> u) -> ByteArray -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ByteArray -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ByteArray -> m ByteArray # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteArray -> m ByteArray # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteArray -> m ByteArray # | |
Data Encoding Source # | |
Defined in Basement.String Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Encoding -> c Encoding # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Encoding # toConstr :: Encoding -> Constr # dataTypeOf :: Encoding -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Encoding) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Encoding) # gmapT :: (forall b. Data b => b -> b) -> Encoding -> Encoding # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Encoding -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Encoding -> r # gmapQ :: (forall d. Data d => d -> u) -> Encoding -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Encoding -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Encoding -> m Encoding # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Encoding -> m Encoding # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Encoding -> m Encoding # | |
Data String Source # | |
Defined in Basement.UTF8.Base Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> String -> c String # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c String # toConstr :: String -> Constr # dataTypeOf :: String -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c String) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c String) # gmapT :: (forall b. Data b => b -> b) -> String -> String # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> String -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> String -> r # gmapQ :: (forall d. Data d => d -> u) -> String -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> String -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> String -> m String # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> String -> m String # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> String -> m String # | |
Data Void | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Void -> c Void # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Void # dataTypeOf :: Void -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Void) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Void) # gmapT :: (forall b. Data b => b -> b) -> Void -> Void # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Void -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Void -> r # gmapQ :: (forall d. Data d => d -> u) -> Void -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Void -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Void -> m Void # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Void -> m Void # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Void -> m Void # | |
Data All | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> All -> c All # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c All # dataTypeOf :: All -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c All) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c All) # gmapT :: (forall b. Data b => b -> b) -> All -> All # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> All -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> All -> r # gmapQ :: (forall d. Data d => d -> u) -> All -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> All -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> All -> m All # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All # | |
Data Any | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Any -> c Any # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Any # dataTypeOf :: Any -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Any) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Any) # gmapT :: (forall b. Data b => b -> b) -> Any -> Any # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r # gmapQ :: (forall d. Data d => d -> u) -> Any -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Any -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Any -> m Any # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any # | |
Data Version | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Version -> c Version # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Version # toConstr :: Version -> Constr # dataTypeOf :: Version -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Version) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Version) # gmapT :: (forall b. Data b => b -> b) -> Version -> Version # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Version -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Version -> r # gmapQ :: (forall d. Data d => d -> u) -> Version -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Version -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Version -> m Version # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Version -> m Version # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Version -> m Version # | |
Data IntPtr | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntPtr -> c IntPtr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IntPtr # toConstr :: IntPtr -> Constr # dataTypeOf :: IntPtr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IntPtr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IntPtr) # gmapT :: (forall b. Data b => b -> b) -> IntPtr -> IntPtr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntPtr -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntPtr -> r # gmapQ :: (forall d. Data d => d -> u) -> IntPtr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IntPtr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntPtr -> m IntPtr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntPtr -> m IntPtr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntPtr -> m IntPtr # | |
Data WordPtr | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WordPtr -> c WordPtr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WordPtr # toConstr :: WordPtr -> Constr # dataTypeOf :: WordPtr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c WordPtr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WordPtr) # gmapT :: (forall b. Data b => b -> b) -> WordPtr -> WordPtr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WordPtr -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WordPtr -> r # gmapQ :: (forall d. Data d => d -> u) -> WordPtr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WordPtr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WordPtr -> m WordPtr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WordPtr -> m WordPtr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WordPtr -> m WordPtr # | |
Data Associativity | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Associativity -> c Associativity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Associativity # toConstr :: Associativity -> Constr # dataTypeOf :: Associativity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Associativity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Associativity) # gmapT :: (forall b. Data b => b -> b) -> Associativity -> Associativity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Associativity -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Associativity -> r # gmapQ :: (forall d. Data d => d -> u) -> Associativity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Associativity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity # | |
Data DecidedStrictness | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DecidedStrictness # toConstr :: DecidedStrictness -> Constr # dataTypeOf :: DecidedStrictness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DecidedStrictness) # gmapT :: (forall b. Data b => b -> b) -> DecidedStrictness -> DecidedStrictness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r # gmapQ :: (forall d. Data d => d -> u) -> DecidedStrictness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness # | |
Data Fixity | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity # toConstr :: Fixity -> Constr # dataTypeOf :: Fixity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) # gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # | |
Data SourceStrictness | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceStrictness # toConstr :: SourceStrictness -> Constr # dataTypeOf :: SourceStrictness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceStrictness) # gmapT :: (forall b. Data b => b -> b) -> SourceStrictness -> SourceStrictness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r # gmapQ :: (forall d. Data d => d -> u) -> SourceStrictness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness # | |
Data SourceUnpackedness | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceUnpackedness -> c SourceUnpackedness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceUnpackedness # toConstr :: SourceUnpackedness -> Constr # dataTypeOf :: SourceUnpackedness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceUnpackedness) # gmapT :: (forall b. Data b => b -> b) -> SourceUnpackedness -> SourceUnpackedness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r # gmapQ :: (forall d. Data d => d -> u) -> SourceUnpackedness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness # | |
Data Int16 | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int16 -> c Int16 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int16 # dataTypeOf :: Int16 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int16) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int16) # gmapT :: (forall b. Data b => b -> b) -> Int16 -> Int16 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int16 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int16 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 # | |
Data Int32 | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int32 -> c Int32 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int32 # dataTypeOf :: Int32 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int32) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int32) # gmapT :: (forall b. Data b => b -> b) -> Int32 -> Int32 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int32 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int32 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 # | |
Data Int64 | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int64 -> c Int64 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int64 # dataTypeOf :: Int64 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int64) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int64) # gmapT :: (forall b. Data b => b -> b) -> Int64 -> Int64 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int64 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int64 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 # | |
Data Int8 | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int8 -> c Int8 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int8 # dataTypeOf :: Int8 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int8) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int8) # gmapT :: (forall b. Data b => b -> b) -> Int8 -> Int8 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int8 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int8 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 # | |
Data Word16 | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word16 -> c Word16 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word16 # toConstr :: Word16 -> Constr # dataTypeOf :: Word16 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word16) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word16) # gmapT :: (forall b. Data b => b -> b) -> Word16 -> Word16 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word16 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word16 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 # | |
Data Word32 | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word32 -> c Word32 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word32 # toConstr :: Word32 -> Constr # dataTypeOf :: Word32 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word32) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word32) # gmapT :: (forall b. Data b => b -> b) -> Word32 -> Word32 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word32 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word32 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 # | |
Data Word64 | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word64 -> c Word64 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word64 # toConstr :: Word64 -> Constr # dataTypeOf :: Word64 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word64) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word64) # gmapT :: (forall b. Data b => b -> b) -> Word64 -> Word64 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word64 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word64 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 # | |
Data Word8 | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word8 -> c Word8 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word8 # dataTypeOf :: Word8 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word8) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word8) # gmapT :: (forall b. Data b => b -> b) -> Word8 -> Word8 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word8 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word8 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 # | |
Data Ordering | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering # toConstr :: Ordering -> Constr # dataTypeOf :: Ordering -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) # gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r # gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering # | |
Data Integer | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Integer -> c Integer # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Integer # toConstr :: Integer -> Constr # dataTypeOf :: Integer -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Integer) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Integer) # gmapT :: (forall b. Data b => b -> b) -> Integer -> Integer # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r # gmapQ :: (forall d. Data d => d -> u) -> Integer -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Integer -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Integer -> m Integer # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer # | |
Data Natural | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Natural -> c Natural # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Natural # toConstr :: Natural -> Constr # dataTypeOf :: Natural -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Natural) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Natural) # gmapT :: (forall b. Data b => b -> b) -> Natural -> Natural # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r # gmapQ :: (forall d. Data d => d -> u) -> Natural -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Natural -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Natural -> m Natural # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural # | |
Data () | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> () -> c () # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c () # dataTypeOf :: () -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ()) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ()) # gmapT :: (forall b. Data b => b -> b) -> () -> () # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> () -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> () -> r # gmapQ :: (forall d. Data d => d -> u) -> () -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> () -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> () -> m () # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> () -> m () # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> () -> m () # | |
Data Bool | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool # dataTypeOf :: Bool -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bool) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bool) # gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r # gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool # | |
Data Char | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char # dataTypeOf :: Char -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) # gmapT :: (forall b. Data b => b -> b) -> Char -> Char # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r # gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char # | |
Data Double | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double # toConstr :: Double -> Constr # dataTypeOf :: Double -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Double) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) # gmapT :: (forall b. Data b => b -> b) -> Double -> Double # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r # gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double # | |
Data Float | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float # dataTypeOf :: Float -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) # gmapT :: (forall b. Data b => b -> b) -> Float -> Float # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r # gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float # | |
Data Int | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int # dataTypeOf :: Int -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) # gmapT :: (forall b. Data b => b -> b) -> Int -> Int # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r # gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int # | |
Data Word | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word # dataTypeOf :: Word -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) # gmapT :: (forall b. Data b => b -> b) -> Word -> Word # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r # gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word # | |
Typeable s => Data (MutableByteArray s) | |
Defined in Data.Array.Byte Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MutableByteArray s -> c (MutableByteArray s) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MutableByteArray s) # toConstr :: MutableByteArray s -> Constr # dataTypeOf :: MutableByteArray s -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MutableByteArray s)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MutableByteArray s)) # gmapT :: (forall b. Data b => b -> b) -> MutableByteArray s -> MutableByteArray s # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MutableByteArray s -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MutableByteArray s -> r # gmapQ :: (forall d. Data d => d -> u) -> MutableByteArray s -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> MutableByteArray s -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> MutableByteArray s -> m (MutableByteArray s) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MutableByteArray s -> m (MutableByteArray s) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MutableByteArray s -> m (MutableByteArray s) # | |
Data a => Data (Complex a) | |
Defined in Data.Complex Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Complex a -> c (Complex a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Complex a) # toConstr :: Complex a -> Constr # dataTypeOf :: Complex a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Complex a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Complex a)) # gmapT :: (forall b. Data b => b -> b) -> Complex a -> Complex a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r # gmapQ :: (forall d. Data d => d -> u) -> Complex a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Complex a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) # | |
Data a => Data (First a) | |
Defined in Data.Semigroup Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> First a -> c (First a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (First a) # toConstr :: First a -> Constr # dataTypeOf :: First a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (First a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a)) # gmapT :: (forall b. Data b => b -> b) -> First a -> First a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r # gmapQ :: (forall d. Data d => d -> u) -> First a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> First a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> First a -> m (First a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) # | |
Data a => Data (Last a) | |
Defined in Data.Semigroup Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Last a -> c (Last a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Last a) # toConstr :: Last a -> Constr # dataTypeOf :: Last a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Last a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a)) # gmapT :: (forall b. Data b => b -> b) -> Last a -> Last a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r # gmapQ :: (forall d. Data d => d -> u) -> Last a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Last a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) # | |
Data a => Data (Max a) | |
Defined in Data.Semigroup Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Max a -> c (Max a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Max a) # dataTypeOf :: Max a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Max a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Max a)) # gmapT :: (forall b. Data b => b -> b) -> Max a -> Max a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r # gmapQ :: (forall d. Data d => d -> u) -> Max a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Max a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) # | |
Data a => Data (Min a) | |
Defined in Data.Semigroup Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Min a -> c (Min a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Min a) # dataTypeOf :: Min a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Min a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Min a)) # gmapT :: (forall b. Data b => b -> b) -> Min a -> Min a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r # gmapQ :: (forall d. Data d => d -> u) -> Min a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Min a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) # | |
Data m => Data (WrappedMonoid m) | |
Defined in Data.Semigroup Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WrappedMonoid m -> c (WrappedMonoid m) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrappedMonoid m) # toConstr :: WrappedMonoid m -> Constr # dataTypeOf :: WrappedMonoid m -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonoid m)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WrappedMonoid m)) # gmapT :: (forall b. Data b => b -> b) -> WrappedMonoid m -> WrappedMonoid m # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r # gmapQ :: (forall d. Data d => d -> u) -> WrappedMonoid m -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedMonoid m -> u # gmapM :: Monad m0 => (forall d. Data d => d -> m0 d) -> WrappedMonoid m -> m0 (WrappedMonoid m) # gmapMp :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonoid m -> m0 (WrappedMonoid m) # gmapMo :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonoid m -> m0 (WrappedMonoid m) # | |
Data ty => Data (Block ty) Source # | |
Defined in Basement.Block.Base Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Block ty -> c (Block ty) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Block ty) # toConstr :: Block ty -> Constr # dataTypeOf :: Block ty -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Block ty)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Block ty)) # gmapT :: (forall b. Data b => b -> b) -> Block ty -> Block ty # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Block ty -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Block ty -> r # gmapQ :: (forall d. Data d => d -> u) -> Block ty -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Block ty -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Block ty -> m (Block ty) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Block ty -> m (Block ty) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Block ty -> m (Block ty) # | |
Data ty => Data (Array ty) Source # | |
Defined in Basement.BoxedArray Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Array ty -> c (Array ty) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Array ty) # toConstr :: Array ty -> Constr # dataTypeOf :: Array ty -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Array ty)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array ty)) # gmapT :: (forall b. Data b => b -> b) -> Array ty -> Array ty # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Array ty -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Array ty -> r # gmapQ :: (forall d. Data d => d -> u) -> Array ty -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Array ty -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Array ty -> m (Array ty) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Array ty -> m (Array ty) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Array ty -> m (Array ty) # | |
Data ty => Data (UArray ty) Source # | |
Defined in Basement.UArray.Base Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UArray ty -> c (UArray ty) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UArray ty) # toConstr :: UArray ty -> Constr # dataTypeOf :: UArray ty -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UArray ty)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UArray ty)) # gmapT :: (forall b. Data b => b -> b) -> UArray ty -> UArray ty # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UArray ty -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UArray ty -> r # gmapQ :: (forall d. Data d => d -> u) -> UArray ty -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UArray ty -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UArray ty -> m (UArray ty) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UArray ty -> m (UArray ty) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UArray ty -> m (UArray ty) # | |
Data a => Data (NonEmpty a) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NonEmpty a -> c (NonEmpty a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NonEmpty a) # toConstr :: NonEmpty a -> Constr # dataTypeOf :: NonEmpty a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (NonEmpty a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NonEmpty a)) # gmapT :: (forall b. Data b => b -> b) -> NonEmpty a -> NonEmpty a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r # gmapQ :: (forall d. Data d => d -> u) -> NonEmpty a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NonEmpty a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) # | |
Data a => Data (Identity a) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Identity a -> c (Identity a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Identity a) # toConstr :: Identity a -> Constr # dataTypeOf :: Identity a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Identity a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Identity a)) # gmapT :: (forall b. Data b => b -> b) -> Identity a -> Identity a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r # gmapQ :: (forall d. Data d => d -> u) -> Identity a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Identity a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) # | |
Data a => Data (First a) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> First a -> c (First a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (First a) # toConstr :: First a -> Constr # dataTypeOf :: First a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (First a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a)) # gmapT :: (forall b. Data b => b -> b) -> First a -> First a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r # gmapQ :: (forall d. Data d => d -> u) -> First a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> First a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> First a -> m (First a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) # | |
Data a => Data (Last a) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Last a -> c (Last a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Last a) # toConstr :: Last a -> Constr # dataTypeOf :: Last a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Last a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a)) # gmapT :: (forall b. Data b => b -> b) -> Last a -> Last a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r # gmapQ :: (forall d. Data d => d -> u) -> Last a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Last a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) # | |
Data a => Data (Down a) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Down a -> c (Down a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Down a) # toConstr :: Down a -> Constr # dataTypeOf :: Down a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Down a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Down a)) # gmapT :: (forall b. Data b => b -> b) -> Down a -> Down a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Down a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Down a -> r # gmapQ :: (forall d. Data d => d -> u) -> Down a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Down a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Down a -> m (Down a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Down a -> m (Down a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Down a -> m (Down a) # | |
Data a => Data (Dual a) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dual a -> c (Dual a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Dual a) # toConstr :: Dual a -> Constr # dataTypeOf :: Dual a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Dual a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dual a)) # gmapT :: (forall b. Data b => b -> b) -> Dual a -> Dual a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dual a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dual a -> r # gmapQ :: (forall d. Data d => d -> u) -> Dual a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Dual a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) # | |
Data a => Data (Product a) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Product a -> c (Product a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Product a) # toConstr :: Product a -> Constr # dataTypeOf :: Product a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Product a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Product a)) # gmapT :: (forall b. Data b => b -> b) -> Product a -> Product a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Product a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Product a -> r # gmapQ :: (forall d. Data d => d -> u) -> Product a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Product a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) # | |
Data a => Data (Sum a) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Sum a -> c (Sum a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sum a) # dataTypeOf :: Sum a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Sum a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum a)) # gmapT :: (forall b. Data b => b -> b) -> Sum a -> Sum a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r # gmapQ :: (forall d. Data d => d -> u) -> Sum a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Sum a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) # | |
Data a => Data (ConstPtr a) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConstPtr a -> c (ConstPtr a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConstPtr a) # toConstr :: ConstPtr a -> Constr # dataTypeOf :: ConstPtr a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConstPtr a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ConstPtr a)) # gmapT :: (forall b. Data b => b -> b) -> ConstPtr a -> ConstPtr a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConstPtr a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConstPtr a -> r # gmapQ :: (forall d. Data d => d -> u) -> ConstPtr a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ConstPtr a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConstPtr a -> m (ConstPtr a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstPtr a -> m (ConstPtr a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstPtr a -> m (ConstPtr a) # | |
Data a => Data (ForeignPtr a) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignPtr a -> c (ForeignPtr a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignPtr a) # toConstr :: ForeignPtr a -> Constr # dataTypeOf :: ForeignPtr a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignPtr a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ForeignPtr a)) # gmapT :: (forall b. Data b => b -> b) -> ForeignPtr a -> ForeignPtr a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignPtr a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignPtr a -> r # gmapQ :: (forall d. Data d => d -> u) -> ForeignPtr a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignPtr a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) # | |
Data a => Data (ZipList a) | |
Defined in GHC.Internal.Functor.ZipList Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ZipList a -> c (ZipList a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ZipList a) # toConstr :: ZipList a -> Constr # dataTypeOf :: ZipList a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ZipList a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ZipList a)) # gmapT :: (forall b. Data b => b -> b) -> ZipList a -> ZipList a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r # gmapQ :: (forall d. Data d => d -> u) -> ZipList a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ZipList a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) # | |
Data p => Data (Par1 p) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Par1 p -> c (Par1 p) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Par1 p) # toConstr :: Par1 p -> Constr # dataTypeOf :: Par1 p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Par1 p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Par1 p)) # gmapT :: (forall b. Data b => b -> b) -> Par1 p -> Par1 p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Par1 p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Par1 p -> r # gmapQ :: (forall d. Data d => d -> u) -> Par1 p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Par1 p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) # | |
Data a => Data (Ptr a) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ptr a -> c (Ptr a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ptr a) # dataTypeOf :: Ptr a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ptr a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ptr a)) # gmapT :: (forall b. Data b => b -> b) -> Ptr a -> Ptr a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r # gmapQ :: (forall d. Data d => d -> u) -> Ptr a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ptr a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) # | |
(Data a, Integral a) => Data (Ratio a) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ratio a -> c (Ratio a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ratio a) # toConstr :: Ratio a -> Constr # dataTypeOf :: Ratio a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ratio a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ratio a)) # gmapT :: (forall b. Data b => b -> b) -> Ratio a -> Ratio a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ratio a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ratio a -> r # gmapQ :: (forall d. Data d => d -> u) -> Ratio a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ratio a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) # | |
Data a => Data (Maybe a) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) # toConstr :: Maybe a -> Constr # dataTypeOf :: Maybe a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) # gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r # gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # | |
Data a => Data (Solo a) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Solo a -> c (Solo a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Solo a) # toConstr :: Solo a -> Constr # dataTypeOf :: Solo a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Solo a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Solo a)) # gmapT :: (forall b. Data b => b -> b) -> Solo a -> Solo a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Solo a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Solo a -> r # gmapQ :: (forall d. Data d => d -> u) -> Solo a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Solo a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Solo a -> m (Solo a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Solo a -> m (Solo a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Solo a -> m (Solo a) # | |
Data a => Data [a] | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> [a] -> c [a] # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c [a] # dataTypeOf :: [a] -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c [a]) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c [a]) # gmapT :: (forall b. Data b => b -> b) -> [a] -> [a] # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> [a] -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> [a] -> r # gmapQ :: (forall d. Data d => d -> u) -> [a] -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> [a] -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> [a] -> m [a] # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> [a] -> m [a] # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> [a] -> m [a] # | |
(Typeable m, Typeable a, Data (m a)) => Data (WrappedMonad m a) | |
Defined in Control.Applicative Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WrappedMonad m a -> c (WrappedMonad m a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrappedMonad m a) # toConstr :: WrappedMonad m a -> Constr # dataTypeOf :: WrappedMonad m a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonad m a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WrappedMonad m a)) # gmapT :: (forall b. Data b => b -> b) -> WrappedMonad m a -> WrappedMonad m a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonad m a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonad m a -> r # gmapQ :: (forall d. Data d => d -> u) -> WrappedMonad m a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedMonad m a -> u # gmapM :: Monad m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) # gmapMp :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) # gmapMo :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) # | |
(Typeable k, Typeable a) => Data (Fixed a) | |
Defined in Data.Fixed Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixed a -> c (Fixed a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Fixed a) # toConstr :: Fixed a -> Constr # dataTypeOf :: Fixed a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Fixed a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Fixed a)) # gmapT :: (forall b. Data b => b -> b) -> Fixed a -> Fixed a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixed a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixed a -> r # gmapQ :: (forall d. Data d => d -> u) -> Fixed a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixed a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixed a -> m (Fixed a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixed a -> m (Fixed a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixed a -> m (Fixed a) # | |
(Data a, Data b) => Data (Arg a b) | |
Defined in Data.Semigroup Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Arg a b -> c (Arg a b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Arg a b) # toConstr :: Arg a b -> Constr # dataTypeOf :: Arg a b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Arg a b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Arg a b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Arg a b -> Arg a b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Arg a b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Arg a b -> r # gmapQ :: (forall d. Data d => d -> u) -> Arg a b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Arg a b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) # | |
(KnownNat n, Data a) => Data (BlockN n a) Source # | |
Defined in Basement.Sized.Block Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BlockN n a -> c (BlockN n a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BlockN n a) # toConstr :: BlockN n a -> Constr # dataTypeOf :: BlockN n a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (BlockN n a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BlockN n a)) # gmapT :: (forall b. Data b => b -> b) -> BlockN n a -> BlockN n a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BlockN n a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BlockN n a -> r # gmapQ :: (forall d. Data d => d -> u) -> BlockN n a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BlockN n a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BlockN n a -> m (BlockN n a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BlockN n a -> m (BlockN n a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BlockN n a -> m (BlockN n a) # | |
(Data a, Data b, Ix a) => Data (Array a b) | |
Defined in GHC.Internal.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) # | |
(Data a, Data b) => Data (Either a b) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Either a b -> c (Either a b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b) # toConstr :: Either a b -> Constr # dataTypeOf :: Either a b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Either a b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Either a b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Either a b -> Either a b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r # gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) # | |
Data t => Data (Proxy t) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Proxy t -> c (Proxy t) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Proxy t) # toConstr :: Proxy t -> Constr # dataTypeOf :: Proxy t -> DataType # dataCast1 :: Typeable t0 => (forall d. Data d => c (t0 d)) -> Maybe (c (Proxy t)) # dataCast2 :: Typeable t0 => (forall d e. (Data d, Data e) => c (t0 d e)) -> Maybe (c (Proxy t)) # gmapT :: (forall b. Data b => b -> b) -> Proxy t -> Proxy t # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Proxy t -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Proxy t -> r # gmapQ :: (forall d. Data d => d -> u) -> Proxy t -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Proxy t -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) # | |
Data p => Data (U1 p) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> U1 p -> c (U1 p) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (U1 p) # dataTypeOf :: U1 p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (U1 p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (U1 p)) # gmapT :: (forall b. Data b => b -> b) -> U1 p -> U1 p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> U1 p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> U1 p -> r # gmapQ :: (forall d. Data d => d -> u) -> U1 p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> U1 p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> U1 p -> m (U1 p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> U1 p -> m (U1 p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> U1 p -> m (U1 p) # | |
Data p => Data (V1 p) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> V1 p -> c (V1 p) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (V1 p) # dataTypeOf :: V1 p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (V1 p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V1 p)) # gmapT :: (forall b. Data b => b -> b) -> V1 p -> V1 p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V1 p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V1 p -> r # gmapQ :: (forall d. Data d => d -> u) -> V1 p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> V1 p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p) # | |
(Data a, Data b) => Data (a, b) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a, b) -> c (a, b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a, b) # toConstr :: (a, b) -> Constr # dataTypeOf :: (a, b) -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a, b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a, b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b) -> (a, b) # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a, b) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a, b) -> r # gmapQ :: (forall d. Data d => d -> u) -> (a, b) -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a, b) -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a, b) -> m (a, b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b) -> m (a, b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b) -> m (a, b) # | |
(Typeable a, Typeable b, Typeable c, Data (a b c)) => Data (WrappedArrow a b c) | |
Defined in Control.Applicative Methods gfoldl :: (forall d b0. Data d => c0 (d -> b0) -> d -> c0 b0) -> (forall g. g -> c0 g) -> WrappedArrow a b c -> c0 (WrappedArrow a b c) # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (WrappedArrow a b c) # toConstr :: WrappedArrow a b c -> Constr # dataTypeOf :: WrappedArrow a b c -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (WrappedArrow a b c)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (WrappedArrow a b c)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> WrappedArrow a b c -> WrappedArrow a b c # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedArrow a b c -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedArrow a b c -> r # gmapQ :: (forall d. Data d => d -> u) -> WrappedArrow a b c -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedArrow a b c -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) # | |
(Typeable k, Data a, Typeable b) => Data (Const a b) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Const a b -> c (Const a b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Const a b) # toConstr :: Const a b -> Constr # dataTypeOf :: Const a b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Const a b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Const a b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Const a b -> Const a b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const a b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const a b -> r # gmapQ :: (forall d. Data d => d -> u) -> Const a b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Const a b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) # | |
(Data (f a), Data a, Typeable f) => Data (Ap f a) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ap f a -> c (Ap f a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ap f a) # toConstr :: Ap f a -> Constr # dataTypeOf :: Ap f a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ap f a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ap f a)) # gmapT :: (forall b. Data b => b -> b) -> Ap f a -> Ap f a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ap f a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ap f a -> r # gmapQ :: (forall d. Data d => d -> u) -> Ap f a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ap f a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ap f a -> m (Ap f a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ap f a -> m (Ap f a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ap f a -> m (Ap f a) # | |
(Data (f a), Data a, Typeable f) => Data (Alt f a) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alt f a -> c (Alt f a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt f a) # toConstr :: Alt f a -> Constr # dataTypeOf :: Alt f a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Alt f a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt f a)) # gmapT :: (forall b. Data b => b -> b) -> Alt f a -> Alt f a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt f a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt f a -> r # gmapQ :: (forall d. Data d => d -> u) -> Alt f a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt f a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) # | |
(Coercible a b, Data a, Data b) => Data (Coercion a b) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Coercion a b -> c (Coercion a b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Coercion a b) # toConstr :: Coercion a b -> Constr # dataTypeOf :: Coercion a b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Coercion a b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Coercion a b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Coercion a b -> Coercion a b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Coercion a b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Coercion a b -> r # gmapQ :: (forall d. Data d => d -> u) -> Coercion a b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Coercion a b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Coercion a b -> m (Coercion a b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion a b -> m (Coercion a b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion a b -> m (Coercion a b) # | |
(a ~ b, Data a) => Data (a :~: b) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a :~: b) -> c (a :~: b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a :~: b) # toConstr :: (a :~: b) -> Constr # dataTypeOf :: (a :~: b) -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a :~: b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a :~: b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a :~: b) -> a :~: b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a :~: b) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a :~: b) -> r # gmapQ :: (forall d. Data d => d -> u) -> (a :~: b) -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a :~: b) -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) # | |
(Data (f p), Typeable f, Data p) => Data (Rec1 f p) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rec1 f p -> c (Rec1 f p) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Rec1 f p) # toConstr :: Rec1 f p -> Constr # dataTypeOf :: Rec1 f p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Rec1 f p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rec1 f p)) # gmapT :: (forall b. Data b => b -> b) -> Rec1 f p -> Rec1 f p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rec1 f p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rec1 f p -> r # gmapQ :: (forall d. Data d => d -> u) -> Rec1 f p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Rec1 f p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rec1 f p -> m (Rec1 f p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rec1 f p -> m (Rec1 f p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rec1 f p -> m (Rec1 f p) # | |
(Data a, Data b, Data c) => Data (a, b, c) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b0. Data d => c0 (d -> b0) -> d -> c0 b0) -> (forall g. g -> c0 g) -> (a, b, c) -> c0 (a, b, c) # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c) # toConstr :: (a, b, c) -> Constr # dataTypeOf :: (a, b, c) -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (a, b, c)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (a, b, c)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c) -> (a, b, c) # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a, b, c) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a, b, c) -> r # gmapQ :: (forall d. Data d => d -> u) -> (a, b, c) -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a, b, c) -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a, b, c) -> m (a, b, c) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b, c) -> m (a, b, c) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b, c) -> m (a, b, c) # | |
(Typeable a, Typeable f, Typeable g, Typeable k, Data (f a), Data (g a)) => Data (Product f g a) | |
Defined in Data.Functor.Product Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> Product f g a -> c (Product f g a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Product f g a) # toConstr :: Product f g a -> Constr # dataTypeOf :: Product f g a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Product f g a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Product f g a)) # gmapT :: (forall b. Data b => b -> b) -> Product f g a -> Product f g a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Product f g a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Product f g a -> r # gmapQ :: (forall d. Data d => d -> u) -> Product f g a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Product f g a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Product f g a -> m (Product f g a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Product f g a -> m (Product f g a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Product f g a -> m (Product f g a) # | |
(Typeable a, Typeable f, Typeable g, Typeable k, Data (f a), Data (g a)) => Data (Sum f g a) | |
Defined in Data.Functor.Sum Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> Sum f g a -> c (Sum f g a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sum f g a) # toConstr :: Sum f g a -> Constr # dataTypeOf :: Sum f g a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Sum f g a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum f g a)) # gmapT :: (forall b. Data b => b -> b) -> Sum f g a -> Sum f g a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum f g a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum f g a -> r # gmapQ :: (forall d. Data d => d -> u) -> Sum f g a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Sum f g a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sum f g a -> m (Sum f g a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum f g a -> m (Sum f g a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum f g a -> m (Sum f g a) # | |
(Typeable i, Typeable j, Typeable a, Typeable b, a ~~ b) => Data (a :~~: b) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a :~~: b) -> c (a :~~: b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a :~~: b) # toConstr :: (a :~~: b) -> Constr # dataTypeOf :: (a :~~: b) -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a :~~: b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a :~~: b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a :~~: b) -> a :~~: b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a :~~: b) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a :~~: b) -> r # gmapQ :: (forall d. Data d => d -> u) -> (a :~~: b) -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a :~~: b) -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a :~~: b) -> m (a :~~: b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~~: b) -> m (a :~~: b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~~: b) -> m (a :~~: b) # | |
(Typeable f, Typeable g, Data p, Data (f p), Data (g p)) => Data ((f :*: g) p) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :*: g) p -> c ((f :*: g) p) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :*: g) p) # toConstr :: (f :*: g) p -> Constr # dataTypeOf :: (f :*: g) p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ((f :*: g) p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :*: g) p)) # gmapT :: (forall b. Data b => b -> b) -> (f :*: g) p -> (f :*: g) p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :*: g) p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :*: g) p -> r # gmapQ :: (forall d. Data d => d -> u) -> (f :*: g) p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :*: g) p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :*: g) p -> m ((f :*: g) p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :*: g) p -> m ((f :*: g) p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :*: g) p -> m ((f :*: g) p) # | |
(Typeable f, Typeable g, Data p, Data (f p), Data (g p)) => Data ((f :+: g) p) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :+: g) p -> c ((f :+: g) p) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :+: g) p) # toConstr :: (f :+: g) p -> Constr # dataTypeOf :: (f :+: g) p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ((f :+: g) p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :+: g) p)) # gmapT :: (forall b. Data b => b -> b) -> (f :+: g) p -> (f :+: g) p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :+: g) p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :+: g) p -> r # gmapQ :: (forall d. Data d => d -> u) -> (f :+: g) p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :+: g) p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p) # | |
(Typeable i, Data p, Data c) => Data (K1 i c p) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c0 (d -> b) -> d -> c0 b) -> (forall g. g -> c0 g) -> K1 i c p -> c0 (K1 i c p) # gunfold :: (forall b r. Data b => c0 (b -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (K1 i c p) # toConstr :: K1 i c p -> Constr # dataTypeOf :: K1 i c p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (K1 i c p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (K1 i c p)) # gmapT :: (forall b. Data b => b -> b) -> K1 i c p -> K1 i c p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> K1 i c p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> K1 i c p -> r # gmapQ :: (forall d. Data d => d -> u) -> K1 i c p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> K1 i c p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> K1 i c p -> m (K1 i c p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> K1 i c p -> m (K1 i c p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> K1 i c p -> m (K1 i c p) # | |
(Data a, Data b, Data c, Data d) => Data (a, b, c, d) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g. g -> c0 g) -> (a, b, c, d) -> c0 (a, b, c, d) # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c, d) # toConstr :: (a, b, c, d) -> Constr # dataTypeOf :: (a, b, c, d) -> DataType # dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (a, b, c, d)) # dataCast2 :: Typeable t => (forall d0 e. (Data d0, Data e) => c0 (t d0 e)) -> Maybe (c0 (a, b, c, d)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c, d) -> (a, b, c, d) # gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d) -> r # gmapQ :: (forall d0. Data d0 => d0 -> u) -> (a, b, c, d) -> [u] # gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> (a, b, c, d) -> u # gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d) -> m (a, b, c, d) # gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d) -> m (a, b, c, d) # gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d) -> m (a, b, c, d) # | |
(Typeable a, Typeable f, Typeable g, Typeable k1, Typeable k2, Data (f (g a))) => Data (Compose f g a) | |
Defined in Data.Functor.Compose Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> Compose f g a -> c (Compose f g a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Compose f g a) # toConstr :: Compose f g a -> Constr # dataTypeOf :: Compose f g a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Compose f g a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Compose f g a)) # gmapT :: (forall b. Data b => b -> b) -> Compose f g a -> Compose f g a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Compose f g a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Compose f g a -> r # gmapQ :: (forall d. Data d => d -> u) -> Compose f g a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Compose f g a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a) # | |
(Typeable f, Typeable g, Data p, Data (f (g p))) => Data ((f :.: g) p) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :.: g) p -> c ((f :.: g) p) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :.: g) p) # toConstr :: (f :.: g) p -> Constr # dataTypeOf :: (f :.: g) p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ((f :.: g) p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :.: g) p)) # gmapT :: (forall b. Data b => b -> b) -> (f :.: g) p -> (f :.: g) p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :.: g) p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :.: g) p -> r # gmapQ :: (forall d. Data d => d -> u) -> (f :.: g) p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :.: g) p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :.: g) p -> m ((f :.: g) p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :.: g) p -> m ((f :.: g) p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :.: g) p -> m ((f :.: g) p) # | |
(Data p, Data (f p), Typeable c, Typeable i, Typeable f) => Data (M1 i c f p) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c0 (d -> b) -> d -> c0 b) -> (forall g. g -> c0 g) -> M1 i c f p -> c0 (M1 i c f p) # gunfold :: (forall b r. Data b => c0 (b -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (M1 i c f p) # toConstr :: M1 i c f p -> Constr # dataTypeOf :: M1 i c f p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (M1 i c f p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (M1 i c f p)) # gmapT :: (forall b. Data b => b -> b) -> M1 i c f p -> M1 i c f p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> M1 i c f p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> M1 i c f p -> r # gmapQ :: (forall d. Data d => d -> u) -> M1 i c f p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> M1 i c f p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> M1 i c f p -> m (M1 i c f p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> M1 i c f p -> m (M1 i c f p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> M1 i c f p -> m (M1 i c f p) # | |
(Data a, Data b, Data c, Data d, Data e) => Data (a, b, c, d, e) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g. g -> c0 g) -> (a, b, c, d, e) -> c0 (a, b, c, d, e) # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c, d, e) # toConstr :: (a, b, c, d, e) -> Constr # dataTypeOf :: (a, b, c, d, e) -> DataType # dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (a, b, c, d, e)) # dataCast2 :: Typeable t => (forall d0 e0. (Data d0, Data e0) => c0 (t d0 e0)) -> Maybe (c0 (a, b, c, d, e)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c, d, e) -> (a, b, c, d, e) # gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e) -> r # gmapQ :: (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e) -> [u] # gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e) -> u # gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e) -> m (a, b, c, d, e) # gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e) -> m (a, b, c, d, e) # gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e) -> m (a, b, c, d, e) # | |
(Data a, Data b, Data c, Data d, Data e, Data f) => Data (a, b, c, d, e, f) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g. g -> c0 g) -> (a, b, c, d, e, f) -> c0 (a, b, c, d, e, f) # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c, d, e, f) # toConstr :: (a, b, c, d, e, f) -> Constr # dataTypeOf :: (a, b, c, d, e, f) -> DataType # dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (a, b, c, d, e, f)) # dataCast2 :: Typeable t => (forall d0 e0. (Data d0, Data e0) => c0 (t d0 e0)) -> Maybe (c0 (a, b, c, d, e, f)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e, f) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e, f) -> r # gmapQ :: (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e, f) -> [u] # gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e, f) -> u # gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f) # gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f) # gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f) # | |
(Data a, Data b, Data c, Data d, Data e, Data f, Data g) => Data (a, b, c, d, e, f, g) | |
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g0. g0 -> c0 g0) -> (a, b, c, d, e, f, g) -> c0 (a, b, c, d, e, f, g) # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c, d, e, f, g) # toConstr :: (a, b, c, d, e, f, g) -> Constr # dataTypeOf :: (a, b, c, d, e, f, g) -> DataType # dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (a, b, c, d, e, f, g)) # dataCast2 :: Typeable t => (forall d0 e0. (Data d0, Data e0) => c0 (t d0 e0)) -> Maybe (c0 (a, b, c, d, e, f, g)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e, f, g) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e, f, g) -> r # gmapQ :: (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e, f, g) -> [u] # gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e, f, g) -> u # gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g) # gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g) # gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g) # |
mkNoRepType :: String -> DataType #
class Semigroup a => Monoid a where #
Instances
Monoid ByteArray | |
Monoid Builder Source # | |
Monoid Builder Source # | |
Monoid AsciiString Source # | |
Defined in Basement.Types.AsciiString Methods mempty :: AsciiString # mappend :: AsciiString -> AsciiString -> AsciiString # mconcat :: [AsciiString] -> AsciiString # | |
Monoid String Source # | |
Monoid All | |
Monoid Any | |
Monoid Ordering | |
Monoid () | |
Monoid (Comparison a) | |
Monoid (Equivalence a) | |
Monoid (Predicate a) | |
(Ord a, Bounded a) => Monoid (Max a) | |
(Ord a, Bounded a) => Monoid (Min a) | |
Monoid m => Monoid (WrappedMonoid m) | |
PrimType ty => Monoid (Block ty) Source # | |
Monoid (Array a) Source # | |
Monoid (CountOf ty) Source # | |
PrimType ty => Monoid (UArray ty) Source # | |
Monoid a => Monoid (Identity a) | |
Monoid (First a) | |
Monoid (Last a) | |
Monoid a => Monoid (Dual a) | |
Monoid (Endo a) | |
Num a => Monoid (Product a) | |
Num a => Monoid (Sum a) | |
(Generic a, Monoid (Rep a ())) => Monoid (Generically a) | |
Monoid p => Monoid (Par1 p) | |
Monoid a => Monoid (IO a) | |
Semigroup a => Monoid (Maybe a) | |
Monoid a => Monoid (Solo a) | |
Monoid [a] | |
Monoid a => Monoid (Op a b) | |
Monoid (Proxy s) | |
Monoid (U1 p) | |
Monoid a => Monoid (ST s a) | |
(Monoid a, Monoid b) => Monoid (a, b) | |
Monoid b => Monoid (a -> b) | |
Monoid a => Monoid (Const a b) | |
(Applicative f, Monoid a) => Monoid (Ap f a) | |
Alternative f => Monoid (Alt f a) | |
Monoid (f p) => Monoid (Rec1 f p) | |
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) | |
(Monoid (f a), Monoid (g a)) => Monoid (Product f g a) | |
(Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) | |
Monoid c => Monoid (K1 i c p) | |
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) | |
Monoid (f (g a)) => Monoid (Compose f g a) | |
Monoid (f (g p)) => Monoid ((f :.: g) p) | |
Monoid (f p) => Monoid (M1 i c f p) | |
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) | |
class (Typeable e, Show e) => Exception e #
Instances
Exception Timeout | |
Defined in System.Timeout Methods toException :: Timeout -> SomeException fromException :: SomeException -> Maybe Timeout displayException :: Timeout -> String backtraceDesired :: Timeout -> Bool | |
Exception InvalidRecast Source # | |
Defined in Basement.Exception Methods toException :: InvalidRecast -> SomeException fromException :: SomeException -> Maybe InvalidRecast displayException :: InvalidRecast -> String | |
Exception NonEmptyCollectionIsEmpty Source # | |
Defined in Basement.Exception Methods toException :: NonEmptyCollectionIsEmpty -> SomeException fromException :: SomeException -> Maybe NonEmptyCollectionIsEmpty displayException :: NonEmptyCollectionIsEmpty -> String | |
Exception OutOfBound Source # | |
Defined in Basement.Exception Methods toException :: OutOfBound -> SomeException fromException :: SomeException -> Maybe OutOfBound displayException :: OutOfBound -> String backtraceDesired :: OutOfBound -> Bool | |
Exception ValidationFailure Source # | |
Defined in Basement.UTF8.Types Methods toException :: ValidationFailure -> SomeException fromException :: SomeException -> Maybe ValidationFailure displayException :: ValidationFailure -> String | |
Exception Void | |
Defined in GHC.Internal.Exception.Type Methods toException :: Void -> SomeException fromException :: SomeException -> Maybe Void displayException :: Void -> String backtraceDesired :: Void -> Bool | |
Exception ErrorCall | |
Defined in GHC.Internal.Exception Methods toException :: ErrorCall -> SomeException fromException :: SomeException -> Maybe ErrorCall displayException :: ErrorCall -> String backtraceDesired :: ErrorCall -> Bool | |
Exception ArithException | |
Defined in GHC.Internal.Exception.Type Methods toException :: ArithException -> SomeException fromException :: SomeException -> Maybe ArithException displayException :: ArithException -> String backtraceDesired :: ArithException -> Bool | |
Exception SomeException | |
Defined in GHC.Internal.Exception.Type Methods toException :: SomeException -> SomeException fromException :: SomeException -> Maybe SomeException displayException :: SomeException -> String backtraceDesired :: SomeException -> Bool | |
Exception AllocationLimitExceeded | |
Defined in GHC.Internal.IO.Exception Methods toException :: AllocationLimitExceeded -> SomeException fromException :: SomeException -> Maybe AllocationLimitExceeded displayException :: AllocationLimitExceeded -> String backtraceDesired :: AllocationLimitExceeded -> Bool | |
Exception ArrayException | |
Defined in GHC.Internal.IO.Exception Methods toException :: ArrayException -> SomeException fromException :: SomeException -> Maybe ArrayException displayException :: ArrayException -> String backtraceDesired :: ArrayException -> Bool | |
Exception AssertionFailed | |
Defined in GHC.Internal.IO.Exception Methods toException :: AssertionFailed -> SomeException fromException :: SomeException -> Maybe AssertionFailed displayException :: AssertionFailed -> String backtraceDesired :: AssertionFailed -> Bool | |
Exception AsyncException | |
Defined in GHC.Internal.IO.Exception Methods toException :: AsyncException -> SomeException fromException :: SomeException -> Maybe AsyncException displayException :: AsyncException -> String backtraceDesired :: AsyncException -> Bool | |
Exception BlockedIndefinitelyOnMVar | |
Defined in GHC.Internal.IO.Exception Methods toException :: BlockedIndefinitelyOnMVar -> SomeException fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar displayException :: BlockedIndefinitelyOnMVar -> String backtraceDesired :: BlockedIndefinitelyOnMVar -> Bool | |
Exception BlockedIndefinitelyOnSTM | |
Defined in GHC.Internal.IO.Exception Methods toException :: BlockedIndefinitelyOnSTM -> SomeException fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM displayException :: BlockedIndefinitelyOnSTM -> String backtraceDesired :: BlockedIndefinitelyOnSTM -> Bool | |
Exception CompactionFailed | |
Defined in GHC.Internal.IO.Exception Methods toException :: CompactionFailed -> SomeException fromException :: SomeException -> Maybe CompactionFailed displayException :: CompactionFailed -> String backtraceDesired :: CompactionFailed -> Bool | |
Exception Deadlock | |
Defined in GHC.Internal.IO.Exception Methods toException :: Deadlock -> SomeException fromException :: SomeException -> Maybe Deadlock displayException :: Deadlock -> String backtraceDesired :: Deadlock -> Bool | |
Exception ExitCode | |
Defined in GHC.Internal.IO.Exception Methods toException :: ExitCode -> SomeException fromException :: SomeException -> Maybe ExitCode displayException :: ExitCode -> String backtraceDesired :: ExitCode -> Bool | |
Exception FixIOException | |
Defined in GHC.Internal.IO.Exception Methods toException :: FixIOException -> SomeException fromException :: SomeException -> Maybe FixIOException displayException :: FixIOException -> String backtraceDesired :: FixIOException -> Bool | |
Exception IOException | |
Defined in GHC.Internal.IO.Exception Methods toException :: IOException -> SomeException fromException :: SomeException -> Maybe IOException displayException :: IOException -> String backtraceDesired :: IOException -> Bool | |
Exception SomeAsyncException | |
Defined in GHC.Internal.IO.Exception Methods toException :: SomeAsyncException -> SomeException fromException :: SomeException -> Maybe SomeAsyncException displayException :: SomeAsyncException -> String backtraceDesired :: SomeAsyncException -> Bool | |
Exception a => Exception (ExceptionWithContext a) | |
Defined in GHC.Internal.Exception.Type Methods toException :: ExceptionWithContext a -> SomeException fromException :: SomeException -> Maybe (ExceptionWithContext a) displayException :: ExceptionWithContext a -> String backtraceDesired :: ExceptionWithContext a -> Bool | |
Exception e => Exception (NoBacktrace e) | |
Defined in GHC.Internal.Exception.Type Methods toException :: NoBacktrace e -> SomeException fromException :: SomeException -> Maybe (NoBacktrace e) displayException :: NoBacktrace e -> String backtraceDesired :: NoBacktrace e -> Bool |
throw :: forall a e. (HasCallStack, Exception e) => e -> a #
throwIO :: (HasCallStack, Exception e) => e -> IO a #
Constructors
Ptr Addr# |
Instances
Generic1 (URec (Ptr ()) :: k -> Type) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
NormalForm (Ptr a) Source # | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Ptr a -> () Source # | |||||
Data a => Data (Ptr a) | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ptr a -> c (Ptr a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ptr a) # dataTypeOf :: Ptr a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ptr a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ptr a)) # gmapT :: (forall b. Data b => b -> b) -> Ptr a -> Ptr a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r # gmapQ :: (forall d. Data d => d -> u) -> Ptr a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ptr a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) # | |||||
Foldable (UAddr :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => UAddr m -> m foldMap :: Monoid m => (a -> m) -> UAddr a -> m foldMap' :: Monoid m => (a -> m) -> UAddr a -> m foldr :: (a -> b -> b) -> b -> UAddr a -> b foldr' :: (a -> b -> b) -> b -> UAddr a -> b foldl :: (b -> a -> b) -> b -> UAddr a -> b foldl' :: (b -> a -> b) -> b -> UAddr a -> b foldr1 :: (a -> a -> a) -> UAddr a -> a foldl1 :: (a -> a -> a) -> UAddr a -> a toList :: UAddr a -> [a] elem :: Eq a => a -> UAddr a -> Bool maximum :: Ord a => UAddr a -> a minimum :: Ord a => UAddr a -> a sum :: Num a => UAddr a -> a product :: Num a => UAddr a -> a | |||||
Traversable (UAddr :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UAddr a -> f (UAddr b) sequenceA :: Applicative f => UAddr (f a) -> f (UAddr a) | |||||
Storable (Ptr a) | |||||
Show (Ptr a) | |||||
Eq (Ptr a) | |||||
Ord (Ptr a) | |||||
Functor (URec (Ptr ()) :: Type -> Type) | |||||
Generic (URec (Ptr ()) p) | |||||
Defined in GHC.Internal.Generics | |||||
Eq (URec (Ptr ()) p) | |||||
Ord (URec (Ptr ()) p) | |||||
Defined in GHC.Internal.Generics Methods compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering # (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # | |||||
data URec (Ptr ()) (p :: k) | |||||
Defined in GHC.Internal.Generics | |||||
type Rep1 (URec (Ptr ()) :: k -> Type) | |||||
Defined in GHC.Internal.Generics | |||||
type Rep (URec (Ptr ()) p) | |||||
ifThenElse :: Bool -> a -> a -> a Source #
for support of if .. then .. else
internalError :: [Char] -> a Source #
Only to use internally for internal error cases