| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
Network.DNS.Imports
Documentation
data ByteString #
Instances
Instances
| PrintfArg Int64 | |
Defined in Text.Printf | |
| NFData Int64 | |
Defined in Control.DeepSeq | |
| 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 # | |
| Bounded Int64 | |
Defined in GHC.Internal.Int | |
| Enum Int64 | |
| 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 | |
| Hashable Int64 | |
Defined in Data.Hashable.Class | |
| IArray UArray Int64 | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Int64 -> (i, i) numElements :: Ix i => UArray i Int64 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Int64)] -> UArray i Int64 unsafeAt :: Ix i => UArray i Int64 -> Int -> Int64 unsafeReplace :: Ix i => UArray i Int64 -> [(Int, Int64)] -> UArray i Int64 unsafeAccum :: Ix i => (Int64 -> e' -> Int64) -> UArray i Int64 -> [(Int, e')] -> UArray i Int64 unsafeAccumArray :: Ix i => (Int64 -> e' -> Int64) -> Int64 -> (i, i) -> [(Int, e')] -> UArray i Int64 | |
| Lift Int64 | |
| MArray IOUArray Int64 IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Int64 -> IO (i, i) getNumElements :: Ix i => IOUArray i Int64 -> IO Int newArray :: Ix i => (i, i) -> Int64 -> IO (IOUArray i Int64) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Int64) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Int64) unsafeRead :: Ix i => IOUArray i Int64 -> Int -> IO Int64 unsafeWrite :: Ix i => IOUArray i Int64 -> Int -> Int64 -> IO () | |
| MArray (STUArray s) Int64 (ST s) | |
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Int64 -> ST s (i, i) getNumElements :: Ix i => STUArray s i Int64 -> ST s Int newArray :: Ix i => (i, i) -> Int64 -> ST s (STUArray s i Int64) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int64) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int64) unsafeRead :: Ix i => STUArray s i Int64 -> Int -> ST s Int64 unsafeWrite :: Ix i => STUArray s i Int64 -> Int -> Int64 -> ST s () | |
Constructors
| a :| [a] |
Instances
| MonadZip NonEmpty | |||||
| Foldable1 NonEmpty | |||||
Defined in Data.Foldable1 Methods fold1 :: Semigroup m => NonEmpty m -> m foldMap1 :: Semigroup m => (a -> m) -> NonEmpty a -> m foldMap1' :: Semigroup m => (a -> m) -> NonEmpty a -> m toNonEmpty :: NonEmpty a -> NonEmpty a maximum :: Ord a => NonEmpty a -> a minimum :: Ord a => NonEmpty a -> a foldrMap1 :: (a -> b) -> (a -> b -> b) -> NonEmpty a -> b foldlMap1' :: (a -> b) -> (b -> a -> b) -> NonEmpty a -> b foldlMap1 :: (a -> b) -> (b -> a -> b) -> NonEmpty a -> b foldrMap1' :: (a -> b) -> (a -> b -> b) -> NonEmpty a -> b | |||||
| Eq1 NonEmpty | |||||
Defined in Data.Functor.Classes | |||||
| Ord1 NonEmpty | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> NonEmpty a -> NonEmpty b -> Ordering | |||||
| Read1 NonEmpty | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (NonEmpty a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [NonEmpty a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (NonEmpty a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [NonEmpty a] | |||||
| Show1 NonEmpty | |||||
Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> NonEmpty a -> ShowS liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [NonEmpty a] -> ShowS | |||||
| NFData1 NonEmpty | |||||
Defined in Control.DeepSeq | |||||
| Applicative NonEmpty | |||||
| Functor NonEmpty | |||||
| Monad NonEmpty | |||||
| Foldable NonEmpty | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => NonEmpty m -> m foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m foldr :: (a -> b -> b) -> b -> NonEmpty a -> b # foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b foldl :: (b -> a -> b) -> b -> NonEmpty a -> b # foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b # foldr1 :: (a -> a -> a) -> NonEmpty a -> a # foldl1 :: (a -> a -> a) -> NonEmpty a -> a # elem :: Eq a => a -> NonEmpty a -> Bool # maximum :: Ord a => NonEmpty a -> a # minimum :: Ord a => NonEmpty a -> a # | |||||
| Traversable NonEmpty | |||||
Defined in GHC.Internal.Data.Traversable | |||||
| Hashable1 NonEmpty | |||||
Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> NonEmpty a -> Int | |||||
| GetAddrInfo NonEmpty | |||||
Defined in Network.Socket.Info Methods getAddrInfo :: Maybe AddrInfo -> Maybe HostName -> Maybe ServiceName -> IO (NonEmpty AddrInfo) | |||||
| Generic1 NonEmpty | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Lift a => Lift (NonEmpty a :: Type) | |||||
| NFData a => NFData (NonEmpty a) | |||||
Defined in Control.DeepSeq | |||||
| Semigroup (NonEmpty a) | |||||
| Generic (NonEmpty a) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| IsList (NonEmpty a) | |||||
| Read a => Read (NonEmpty a) | |||||
Defined in GHC.Internal.Read | |||||
| Show a => Show (NonEmpty a) | |||||
| Eq a => Eq (NonEmpty a) | |||||
| Ord a => Ord (NonEmpty a) | |||||
| Hashable a => Hashable (NonEmpty a) | |||||
Defined in Data.Hashable.Class | |||||
| type Rep1 NonEmpty | |||||
Defined in GHC.Internal.Generics type Rep1 NonEmpty = D1 ('MetaData "NonEmpty" "GHC.Internal.Base" "ghc-internal" 'False) (C1 ('MetaCons ":|" ('InfixI 'RightAssociative 5) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 []))) | |||||
| type Rep (NonEmpty a) | |||||
Defined in GHC.Internal.Generics type Rep (NonEmpty a) = D1 ('MetaData "NonEmpty" "GHC.Internal.Base" "ghc-internal" 'False) (C1 ('MetaCons ":|" ('InfixI 'RightAssociative 5) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [a]))) | |||||
| type Item (NonEmpty a) | |||||
Defined in GHC.Internal.IsList type Item (NonEmpty a) = a | |||||
class Functor f => Applicative (f :: Type -> Type) where #
Instances
| Applicative Concurrently | |
Defined in Control.Concurrent.Async.Internal | |
| Applicative Complex | |
| Applicative First | |
| Applicative Last | |
| Applicative Max | |
| Applicative Min | |
| Applicative Put | |
| Applicative Seq | |
| Applicative Tree | |
| Applicative NonEmpty | |
| Applicative Identity | |
| Applicative First | |
| Applicative Last | |
| Applicative Down | |
| Applicative Dual | |
| Applicative Product | |
| Applicative Sum | |
| Applicative ZipList | |
| Applicative Par1 | |
| Applicative P | |
| Applicative ReadP | |
| Applicative IO | |
| Applicative Q | |
| Applicative Maybe | |
| Applicative Solo | |
| Applicative [] | |
| Applicative (ConcurrentlyE e) | |
Defined in Control.Concurrent.Async.Internal Methods pure :: a -> ConcurrentlyE e a # (<*>) :: ConcurrentlyE e (a -> b) -> ConcurrentlyE e a -> ConcurrentlyE e b # liftA2 :: (a -> b -> c) -> ConcurrentlyE e a -> ConcurrentlyE e b -> ConcurrentlyE e c # (*>) :: ConcurrentlyE e a -> ConcurrentlyE e b -> ConcurrentlyE e b # (<*) :: ConcurrentlyE e a -> ConcurrentlyE e b -> ConcurrentlyE e a # | |
| Applicative (Parser i) | |
| Monad m => Applicative (ZeptoT m) | |
| 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 # | |
| Applicative (SetM s) | |
| DRG gen => Applicative (MonadPseudoRandom gen) | |
Defined in Crypto.Random.Types Methods pure :: a -> MonadPseudoRandom gen a # (<*>) :: MonadPseudoRandom gen (a -> b) -> MonadPseudoRandom gen a -> MonadPseudoRandom gen b # liftA2 :: (a -> b -> c) -> MonadPseudoRandom gen a -> MonadPseudoRandom gen b -> MonadPseudoRandom gen c # (*>) :: MonadPseudoRandom gen a -> MonadPseudoRandom gen b -> MonadPseudoRandom gen b # (<*) :: MonadPseudoRandom gen a -> MonadPseudoRandom gen b -> MonadPseudoRandom gen 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) | |
| (Functor m, Monad m) => Applicative (MaybeT m) | |
| 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 # | |
| (Applicative f, Monad f) => Applicative (WhenMissing f x) | |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMissing f x a # (<*>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b # liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c # (*>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # (<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a # | |
| 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) | |
| Applicative (t m) => Applicative (LiftingAccum t m) | |
Defined in Control.Monad.Accum Methods pure :: a -> LiftingAccum t m a # (<*>) :: LiftingAccum t m (a -> b) -> LiftingAccum t m a -> LiftingAccum t m b # liftA2 :: (a -> b -> c) -> LiftingAccum t m a -> LiftingAccum t m b -> LiftingAccum t m c # (*>) :: LiftingAccum t m a -> LiftingAccum t m b -> LiftingAccum t m b # (<*) :: LiftingAccum t m a -> LiftingAccum t m b -> LiftingAccum t m a # | |
| Applicative (t m) => Applicative (LiftingSelect t m) | |
Defined in Control.Monad.Select Methods pure :: a -> LiftingSelect t m a # (<*>) :: LiftingSelect t m (a -> b) -> LiftingSelect t m a -> LiftingSelect t m b # liftA2 :: (a -> b -> c) -> LiftingSelect t m a -> LiftingSelect t m b -> LiftingSelect t m c # (*>) :: LiftingSelect t m a -> LiftingSelect t m b -> LiftingSelect t m b # (<*) :: LiftingSelect t m a -> LiftingSelect t m b -> LiftingSelect t m a # | |
| (Monoid w, Functor m, Monad m) => Applicative (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
| (Functor m, Monad m) => Applicative (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
| Applicative m => Applicative (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
| Applicative m => Applicative (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
| (Functor m, Monad m) => Applicative (SelectT r m) | |
Defined in Control.Monad.Trans.Select | |
| (Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
| (Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
| (Functor m, Monad m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
| (Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
| (Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
| (Monoid a, Monoid b) => Applicative ((,,) a b) | |
| (Applicative f, Applicative g) => Applicative (Product f g) | |
Defined in Data.Functor.Product | |
| (Monad f, Applicative f) => Applicative (WhenMatched f x y) | |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMatched f x y a # (<*>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b # liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c # (*>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b # (<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a # | |
| (Applicative f, Monad f) => Applicative (WhenMissing f k x) | |
Defined in Data.Map.Internal Methods pure :: a -> WhenMissing f k x a # (<*>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b # liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c # (*>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b # (<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a # | |
| (Applicative f, Applicative g) => Applicative (f :*: g) | |
| Monoid c => Applicative (K1 i c :: Type -> Type) | |
| Applicative (ContT r m) | |
Defined in Control.Monad.Trans.Cont | |
| (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 | |
| (Monad f, Applicative f) => Applicative (WhenMatched f k x y) | |
Defined in Data.Map.Internal Methods pure :: a -> WhenMatched f k x y a # (<*>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b # liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c # (*>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b # (<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a # | |
| (Applicative f, Applicative g) => Applicative (f :.: g) | |
| Applicative f => Applicative (M1 i c f) | |
| (Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
| (Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy | |
| (Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict | |
newtype WrappedArrow (a :: Type -> Type -> Type) b c #
Constructors
| WrapArrow | |
Fields
| |
Instances
| Generic1 (WrappedArrow a b :: Type -> Type) | |||||
Defined in Control.Applicative Associated Types
Methods from1 :: WrappedArrow a b a0 -> Rep1 (WrappedArrow a b) a0 to1 :: Rep1 (WrappedArrow a b) a0 -> WrappedArrow a b a0 | |||||
| (ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) | |||||
Defined in Control.Applicative Methods empty :: WrappedArrow a b a0 # (<|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0 # some :: WrappedArrow a b a0 -> WrappedArrow a b [a0] # many :: WrappedArrow a b a0 -> WrappedArrow a b [a0] # | |||||
| 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 # | |||||
| Arrow a => Functor (WrappedArrow a b) | |||||
Defined in Control.Applicative Methods fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # (<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # | |||||
| (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) | |||||
| Generic (WrappedArrow a b c) | |||||
Defined in Control.Applicative Associated Types
Methods from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c | |||||
| type Rep1 (WrappedArrow a b :: Type -> Type) | |||||
Defined in Control.Applicative type Rep1 (WrappedArrow a b :: Type -> Type) = D1 ('MetaData "WrappedArrow" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapArrow" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapArrow") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (a b)))) | |||||
| type Rep (WrappedArrow a b c) | |||||
Defined in Control.Applicative type Rep (WrappedArrow a b c) = D1 ('MetaData "WrappedArrow" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapArrow" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapArrow") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (a b c)))) | |||||
newtype WrappedMonad (m :: Type -> Type) a #
Constructors
| WrapMonad | |
Fields
| |
Instances
| Generic1 (WrappedMonad m :: Type -> Type) | |||||
Defined in Control.Applicative Associated Types
Methods from1 :: WrappedMonad m a -> Rep1 (WrappedMonad m) a to1 :: Rep1 (WrappedMonad m) a -> WrappedMonad m a | |||||
| MonadPlus m => Alternative (WrappedMonad m) | |||||
Defined in Control.Applicative Methods empty :: WrappedMonad m a # (<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a # some :: WrappedMonad m a -> WrappedMonad m [a] # many :: WrappedMonad m a -> WrappedMonad m [a] # | |||||
| 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 # | |||||
| Monad m => Functor (WrappedMonad m) | |||||
Defined in Control.Applicative Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a # | |||||
| Monad m => Monad (WrappedMonad m) | |||||
Defined in Control.Applicative Methods (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # return :: a -> WrappedMonad 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) | |||||
| Generic (WrappedMonad m a) | |||||
Defined in Control.Applicative Associated Types
Methods from :: WrappedMonad m a -> Rep (WrappedMonad m a) x to :: Rep (WrappedMonad m a) x -> WrappedMonad m a | |||||
| type Rep1 (WrappedMonad m :: Type -> Type) | |||||
Defined in Control.Applicative type Rep1 (WrappedMonad m :: Type -> Type) = D1 ('MetaData "WrappedMonad" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapMonad" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapMonad") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 m))) | |||||
| type Rep (WrappedMonad m a) | |||||
Defined in Control.Applicative type Rep (WrappedMonad m a) = D1 ('MetaData "WrappedMonad" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapMonad" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapMonad") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (m a)))) | |||||
optional :: Alternative f => f a -> f (Maybe a) #
(<**>) :: Applicative f => f a -> f (a -> b) -> f b #
liftA :: Applicative f => (a -> b) -> f a -> f b #
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d #
asum :: (Foldable t, Alternative f) => t (f a) -> f a #
class Applicative f => Alternative (f :: Type -> Type) where #
Instances
| Alternative Concurrently | |
| Alternative Seq | |
| Alternative ZipList | |
| Alternative P | |
| Alternative ReadP | |
| Alternative IO | |
| Alternative Maybe | |
| Alternative [] | |
| Alternative (Parser i) | |
| Monad m => Alternative (ZeptoT m) | |
| MonadPlus m => Alternative (WrappedMonad m) | |
Defined in Control.Applicative Methods empty :: WrappedMonad m a # (<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a # some :: WrappedMonad m a -> WrappedMonad m [a] # many :: WrappedMonad m a -> WrappedMonad m [a] # | |
| ArrowPlus a => Alternative (ArrowMonad a) | |
| Alternative (Proxy :: Type -> Type) | |
| Alternative (U1 :: Type -> Type) | |
| (Functor m, Monad m) => Alternative (MaybeT m) | |
| (ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) | |
Defined in Control.Applicative Methods empty :: WrappedArrow a b a0 # (<|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0 # some :: WrappedArrow a b a0 -> WrappedArrow a b [a0] # many :: WrappedArrow a b a0 -> WrappedArrow a b [a0] # | |
| Alternative m => Alternative (Kleisli m a) | |
| Alternative f => Alternative (Ap f) | |
| Alternative f => Alternative (Alt f) | |
| (Generic1 f, Alternative (Rep1 f)) => Alternative (Generically1 f) | |
| Alternative f => Alternative (Rec1 f) | |
| (Monoid w, Functor m, MonadPlus m) => Alternative (AccumT w m) | |
| (Functor m, Monad m, Monoid e) => Alternative (ExceptT e m) | |
| Alternative m => Alternative (IdentityT m) | |
| Alternative m => Alternative (ReaderT r m) | |
| (Functor m, MonadPlus m) => Alternative (SelectT r m) | |
| (Functor m, MonadPlus m) => Alternative (StateT s m) | |
| (Functor m, MonadPlus m) => Alternative (StateT s m) | |
| (Functor m, MonadPlus m) => Alternative (WriterT w m) | |
| (Monoid w, Alternative m) => Alternative (WriterT w m) | |
| (Monoid w, Alternative m) => Alternative (WriterT w m) | |
| (Alternative f, Alternative g) => Alternative (Product f g) | |
| (Alternative f, Alternative g) => Alternative (f :*: g) | |
| (Alternative f, Applicative g) => Alternative (Compose f g) | |
| (Alternative f, Applicative g) => Alternative (f :.: g) | |
| Alternative f => Alternative (M1 i c f) | |
| (Functor m, MonadPlus m) => Alternative (RWST r w s m) | |
| (Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m) | |
| (Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m) | |
Instances
| Generic1 (Const a :: k -> Type) | |||||
Defined in GHC.Internal.Data.Functor.Const Associated Types
| |||||
| Bifoldable (Const :: Type -> Type -> Type) | |||||
| Bifoldable1 (Const :: Type -> Type -> Type) | |||||
Defined in Data.Bifoldable1 Methods bifold1 :: Semigroup m => Const m m -> m bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Const a b -> m | |||||
| Bifunctor (Const :: Type -> Type -> Type) | |||||
| Bitraversable (Const :: Type -> Type -> Type) | |||||
Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Const a b -> f (Const c d) | |||||
| Eq2 (Const :: Type -> Type -> Type) | |||||
Defined in Data.Functor.Classes | |||||
| Ord2 (Const :: Type -> Type -> Type) | |||||
Defined in Data.Functor.Classes | |||||
| Read2 (Const :: Type -> Type -> Type) | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Const a b) liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const a b] liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Const a b) liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Const a b] | |||||
| Show2 (Const :: Type -> Type -> Type) | |||||
Defined in Data.Functor.Classes Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Const a b -> ShowS liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Const a b] -> ShowS | |||||
| NFData2 (Const :: Type -> Type -> Type) | |||||
Defined in Control.DeepSeq | |||||
| Hashable2 (Const :: Type -> Type -> Type) | |||||
Defined in Data.Hashable.Class Methods liftHashWithSalt2 :: (Int -> a -> Int) -> (Int -> b -> Int) -> Int -> Const a b -> Int | |||||
| Eq a => Eq1 (Const a :: Type -> Type) | |||||
Defined in Data.Functor.Classes | |||||
| Ord a => Ord1 (Const a :: Type -> Type) | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b -> Ordering) -> Const a a0 -> Const a b -> Ordering | |||||
| Read a => Read1 (Const a :: Type -> Type) | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Const a a0) liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Const a a0] liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Const a a0) liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Const a a0] | |||||
| Show a => Show1 (Const a :: Type -> Type) | |||||
Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Const a a0 -> ShowS liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Const a a0] -> ShowS | |||||
| Contravariant (Const a :: Type -> Type) | |||||
| NFData a => NFData1 (Const a :: Type -> Type) | |||||
Defined in Control.DeepSeq | |||||
| Monoid m => Applicative (Const m :: Type -> Type) | |||||
| Functor (Const m :: Type -> Type) | |||||
| Foldable (Const m :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 foldr :: (a -> b -> b) -> b -> Const m a -> b # foldr' :: (a -> b -> b) -> b -> Const m a -> b foldl :: (b -> a -> b) -> b -> Const m a -> b # foldl' :: (b -> a -> b) -> b -> Const m a -> b # foldr1 :: (a -> a -> a) -> Const m a -> a # foldl1 :: (a -> a -> a) -> Const m a -> a # elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # | |||||
| Traversable (Const m :: Type -> Type) | |||||
| Hashable a => Hashable1 (Const a :: Type -> Type) | |||||
Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a0 -> Int) -> Int -> Const a a0 -> Int | |||||
| NFData a => NFData (Const a b) | |||||
Defined in Control.DeepSeq | |||||
| Monoid a => Monoid (Const a b) | |||||
| Semigroup a => Semigroup (Const a b) | |||||
| Bits a => Bits (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const Methods (.&.) :: Const a b -> Const a b -> Const a b # (.|.) :: Const a b -> Const a b -> Const a b # xor :: Const a b -> Const a b -> Const a b # complement :: Const a b -> Const a b # shift :: Const a b -> Int -> Const a b # rotate :: Const a b -> Int -> Const a b # setBit :: Const a b -> Int -> Const a b # clearBit :: Const a b -> Int -> Const a b # complementBit :: Const a b -> Int -> Const a b # testBit :: Const a b -> Int -> Bool # bitSizeMaybe :: Const a b -> Maybe Int # isSigned :: Const a b -> Bool # shiftL :: Const a b -> Int -> Const a b # unsafeShiftL :: Const a b -> Int -> Const a b # shiftR :: Const a b -> Int -> Const a b # unsafeShiftR :: Const a b -> Int -> Const a b # rotateL :: Const a b -> Int -> Const a b # | |||||
| FiniteBits a => FiniteBits (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const Methods finiteBitSize :: Const a b -> Int # countLeadingZeros :: Const a b -> Int # countTrailingZeros :: Const a b -> Int # | |||||
| IsString a => IsString (Const a b) | |||||
Defined in GHC.Internal.Data.String Methods fromString :: String -> Const a b | |||||
| Bounded a => Bounded (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const | |||||
| Enum a => Enum (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const | |||||
| Floating a => Floating (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const Methods exp :: Const a b -> Const a b # log :: Const a b -> Const a b # sqrt :: Const a b -> Const a b # (**) :: Const a b -> Const a b -> Const a b # logBase :: Const a b -> Const a b -> Const a b # sin :: Const a b -> Const a b # cos :: Const a b -> Const a b # tan :: Const a b -> Const a b # asin :: Const a b -> Const a b # acos :: Const a b -> Const a b # atan :: Const a b -> Const a b # sinh :: Const a b -> Const a b # cosh :: Const a b -> Const a b # tanh :: Const a b -> Const a b # asinh :: Const a b -> Const a b # acosh :: Const a b -> Const a b # atanh :: Const a b -> Const a b # log1p :: Const a b -> Const a b # expm1 :: Const a b -> Const a b # | |||||
| RealFloat a => RealFloat (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const Methods floatRadix :: Const a b -> Integer floatDigits :: Const a b -> Int floatRange :: Const a b -> (Int, Int) decodeFloat :: Const a b -> (Integer, Int) encodeFloat :: Integer -> Int -> Const a b significand :: Const a b -> Const a b scaleFloat :: Int -> Const a b -> Const a b isInfinite :: Const a b -> Bool isDenormalized :: Const a b -> Bool isNegativeZero :: Const a b -> Bool | |||||
| Storable a => Storable (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const Methods peekElemOff :: Ptr (Const a b) -> Int -> IO (Const a b) pokeElemOff :: Ptr (Const a b) -> Int -> Const a b -> IO () peekByteOff :: Ptr b0 -> Int -> IO (Const a b) pokeByteOff :: Ptr b0 -> Int -> Const a b -> IO () | |||||
| Generic (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const Associated Types
| |||||
| Ix a => Ix (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const Methods range :: (Const a b, Const a b) -> [Const a b] index :: (Const a b, Const a b) -> Const a b -> Int unsafeIndex :: (Const a b, Const a b) -> Const a b -> Int inRange :: (Const a b, Const a b) -> Const a b -> Bool rangeSize :: (Const a b, Const a b) -> Int unsafeRangeSize :: (Const a b, Const a b) -> Int | |||||
| Num a => Num (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const | |||||
| Read a => Read (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const | |||||
| Fractional a => Fractional (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const | |||||
| Integral a => Integral (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const | |||||
| Real a => Real (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const Methods toRational :: Const a b -> Rational | |||||
| RealFrac a => RealFrac (Const a b) | |||||
| Show a => Show (Const a b) | |||||
| Eq a => Eq (Const a b) | |||||
| Ord a => Ord (Const a b) | |||||
| Hashable a => Hashable (Const a b) | |||||
Defined in Data.Hashable.Class | |||||
| type Rep1 (Const a :: k -> Type) | |||||
Defined in GHC.Internal.Data.Functor.Const | |||||
| type Rep (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const | |||||
Constructors
| ZipList | |
Fields
| |
Instances
| NFData1 ZipList | |||||
Defined in Control.DeepSeq | |||||
| Alternative ZipList | |||||
| Applicative ZipList | |||||
| Functor ZipList | |||||
| Foldable ZipList | |||||
Defined in GHC.Internal.Functor.ZipList Methods fold :: Monoid m => ZipList m -> m foldMap :: Monoid m => (a -> m) -> ZipList a -> m foldMap' :: Monoid m => (a -> m) -> ZipList a -> m foldr :: (a -> b -> b) -> b -> ZipList a -> b # foldr' :: (a -> b -> b) -> b -> ZipList a -> b foldl :: (b -> a -> b) -> b -> ZipList a -> b # foldl' :: (b -> a -> b) -> b -> ZipList a -> b # foldr1 :: (a -> a -> a) -> ZipList a -> a # foldl1 :: (a -> a -> a) -> ZipList a -> a # elem :: Eq a => a -> ZipList a -> Bool # maximum :: Ord a => ZipList a -> a # minimum :: Ord a => ZipList a -> a # | |||||
| Traversable ZipList | |||||
| Generic1 ZipList | |||||
Defined in GHC.Internal.Functor.ZipList Associated Types
| |||||
| NFData a => NFData (ZipList a) | |||||
Defined in Control.DeepSeq | |||||
| 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) | |||||
| Generic (ZipList a) | |||||
Defined in GHC.Internal.Functor.ZipList Associated Types
| |||||
| IsList (ZipList a) | |||||
| Read a => Read (ZipList a) | |||||
Defined in GHC.Internal.Functor.ZipList | |||||
| Show a => Show (ZipList a) | |||||
| Eq a => Eq (ZipList a) | |||||
| Ord a => Ord (ZipList a) | |||||
| type Rep1 ZipList | |||||
Defined in GHC.Internal.Functor.ZipList | |||||
| type Rep (ZipList a) | |||||
Defined in GHC.Internal.Functor.ZipList | |||||
| type Item (ZipList a) | |||||
Defined in GHC.Internal.IsList type Item (ZipList a) = a | |||||
class Applicative m => Monad (m :: Type -> Type) where #
Minimal complete definition
Instances
| Monad Complex | |
| Monad First | |
| Monad Last | |
| Monad Max | |
| Monad Min | |
| Monad Put | |
| Monad Seq | |
| Monad Tree | |
| Monad NonEmpty | |
| Monad Identity | |
| Monad First | |
| Monad Last | |
| Monad Down | |
| Monad Dual | |
| Monad Product | |
| Monad Sum | |
| Monad Par1 | |
| Monad P | |
| Monad ReadP | |
| Monad IO | |
| Monad Q | |
| Monad Maybe | |
| Monad Solo | |
| Monad [] | |
| Monad (Parser i) | |
| Monad m => Monad (ZeptoT m) | |
| Monad m => Monad (WrappedMonad m) | |
Defined in Control.Applicative Methods (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # return :: a -> WrappedMonad m a # | |
| Monad (SetM s) | |
| DRG gen => Monad (MonadPseudoRandom gen) | |
| ArrowApply a => Monad (ArrowMonad a) | |
| Monad (Either e) | |
| Monad (Proxy :: Type -> Type) | |
| Monad (U1 :: Type -> Type) | |
| Monad (ST s) | |
| Monad m => Monad (MaybeT m) | |
| Monoid a => Monad ((,) a) | |
| (Applicative f, Monad f) => Monad (WhenMissing f x) | |
| Monad m => Monad (Kleisli m a) | |
| Monad f => Monad (Ap f) | |
| Monad f => Monad (Alt f) | |
| Monad f => Monad (Rec1 f) | |
| Monad (t m) => Monad (LiftingAccum t m) | |
| Monad (t m) => Monad (LiftingSelect t m) | |
| (Monoid w, Functor m, Monad m) => Monad (AccumT w m) | |
| Monad m => Monad (ExceptT e m) | |
| Monad m => Monad (IdentityT m) | |
| Monad m => Monad (ReaderT r m) | |
| Monad m => Monad (SelectT r m) | |
| Monad m => Monad (StateT s m) | |
| Monad m => Monad (StateT s m) | |
| Monad m => Monad (WriterT w m) | |
| (Monoid w, Monad m) => Monad (WriterT w m) | |
| (Monoid w, Monad m) => Monad (WriterT w m) | |
| (Monoid a, Monoid b) => Monad ((,,) a b) | |
| (Monad f, Monad g) => Monad (Product f g) | |
| (Monad f, Applicative f) => Monad (WhenMatched f x y) | |
| (Applicative f, Monad f) => Monad (WhenMissing f k x) | |
| (Monad f, Monad g) => Monad (f :*: g) | |
| Monad (ContT r m) | |
| (Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | |
| Monad ((->) r) | |
| (Monad f, Applicative f) => Monad (WhenMatched f k x y) | |
| Monad f => Monad (M1 i c f) | |
| Monad m => Monad (RWST r w s m) | |
| (Monoid w, Monad m) => Monad (RWST r w s m) | |
| (Monoid w, Monad m) => Monad (RWST r w s m) | |
class Functor (f :: Type -> Type) where #
Minimal complete definition
Instances
| Functor Async | |
Defined in Control.Concurrent.Async.Internal | |
| Functor Concurrently | |
Defined in Control.Concurrent.Async.Internal | |
| Functor Result | |
Defined in Data.Attoparsec.ByteString.Lazy | |
| Functor Result | |
Defined in Data.Attoparsec.Text.Lazy | |
| Functor Complex | |
Defined in Data.Complex | |
| Functor First | |
Defined in Data.Semigroup | |
| Functor Last | |
Defined in Data.Semigroup | |
| Functor Max | |
Defined in Data.Semigroup | |
| Functor Min | |
Defined in Data.Semigroup | |
| Functor ArgDescr | |
Defined in System.Console.GetOpt | |
| Functor ArgOrder | |
Defined in System.Console.GetOpt | |
| Functor OptDescr | |
Defined in System.Console.GetOpt | |
| Functor Put | |
Defined in Data.ByteString.Builder.Internal | |
| Functor SCC | |
Defined in Data.Graph | |
| Functor IntMap | |
Defined in Data.IntMap.Internal | |
| Functor Digit | |
Defined in Data.Sequence.Internal | |
| Functor Elem | |
Defined in Data.Sequence.Internal | |
| Functor FingerTree | |
Defined in Data.Sequence.Internal | |
| Functor Node | |
Defined in Data.Sequence.Internal | |
| Functor Seq | |
Defined in Data.Sequence.Internal | |
| Functor ViewL | |
Defined in Data.Sequence.Internal | |
| Functor ViewR | |
Defined in Data.Sequence.Internal | |
| Functor Tree | |
| Functor NonEmpty | |
| Functor Identity | |
Defined in GHC.Internal.Data.Functor.Identity | |
| Functor First | |
| Functor Last | |
| Functor Down | |
| Functor Dual | |
| Functor Product | |
| Functor Sum | |
| Functor ZipList | |
| Functor Par1 | |
Defined in GHC.Internal.Generics | |
| Functor P | |
Defined in GHC.Internal.Text.ParserCombinators.ReadP | |
| Functor ReadP | |
Defined in GHC.Internal.Text.ParserCombinators.ReadP | |
| Functor IO | |
Defined in GHC.Internal.Base | |
| Functor AnnotDetails | |
Defined in Text.PrettyPrint.Annotated.HughesPJ | |
| Functor Doc | |
Defined in Text.PrettyPrint.Annotated.HughesPJ | |
| Functor Span | |
Defined in Text.PrettyPrint.Annotated.HughesPJ | |
| Functor Q | |
Defined in Language.Haskell.TH.Syntax | |
| Functor TyVarBndr | |
Defined in Language.Haskell.TH.Syntax | |
| Functor Maybe | |
| Functor Solo | |
Defined in GHC.Internal.Base | |
| Functor [] | |
Defined in GHC.Internal.Base | |
| Functor (ConcurrentlyE e) | |
Defined in Control.Concurrent.Async.Internal | |
| Functor (IResult i) | |
Defined in Data.Attoparsec.Internal.Types | |
| Functor (Parser i) | |
Defined in Data.Attoparsec.Internal.Types | |
| Monad m => Functor (ZeptoT m) | |
Defined in Data.Attoparsec.Zepto | |
| Monad m => Functor (WrappedMonad m) | |
Defined in Control.Applicative Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a # | |
| Functor (Arg a) | |
Defined in Data.Semigroup | |
| Functor (SetM s) | |
Defined in Data.Graph | |
| Functor (Map k) | |
Defined in Data.Map.Internal | |
| DRG gen => Functor (MonadPseudoRandom gen) | |
Defined in Crypto.Random.Types | |
| Arrow a => Functor (ArrowMonad a) | |
Defined in GHC.Internal.Control.Arrow | |
| Functor (Either a) | |
Defined in GHC.Internal.Data.Either | |
| Functor (Proxy :: Type -> Type) | |
| Functor (U1 :: Type -> Type) | |
Defined in GHC.Internal.Generics | |
| Functor (V1 :: Type -> Type) | |
Defined in GHC.Internal.Generics | |
| Functor (ST s) | |
Defined in GHC.Internal.ST | |
| Functor (IPRTable k) | |
Defined in Data.IP.RouteTable.Internal | |
| Functor m => Functor (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
| Functor ((,) a) | |
Defined in GHC.Internal.Base | |
| Arrow a => Functor (WrappedArrow a b) | |
Defined in Control.Applicative Methods fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # (<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # | |
| (Applicative f, Monad f) => Functor (WhenMissing f x) | |
Defined in Data.IntMap.Internal | |
| Functor m => Functor (Kleisli m a) | |
Defined in GHC.Internal.Control.Arrow | |
| Functor (Const m :: Type -> Type) | |
| Functor f => Functor (Ap f) | |
| Functor f => Functor (Alt f) | |
| (Generic1 f, Functor (Rep1 f)) => Functor (Generically1 f) | |
Defined in GHC.Internal.Generics | |
| Functor f => Functor (Rec1 f) | |
Defined in GHC.Internal.Generics | |
| Functor (URec (Ptr ()) :: Type -> Type) | |
Defined in GHC.Internal.Generics | |
| Functor (URec Char :: Type -> Type) | |
Defined in GHC.Internal.Generics | |
| Functor (URec Double :: Type -> Type) | |
Defined in GHC.Internal.Generics | |
| Functor (URec Float :: Type -> Type) | |
Defined in GHC.Internal.Generics | |
| Functor (URec Int :: Type -> Type) | |
Defined in GHC.Internal.Generics | |
| Functor (URec Word :: Type -> Type) | |
| Functor (t m) => Functor (LiftingAccum t m) | |
Defined in Control.Monad.Accum | |
| Functor (t m) => Functor (LiftingSelect t m) | |
Defined in Control.Monad.Select | |
| Functor (Elem k p) | |
Defined in Data.OrdPSQ.Internal | |
| Functor (LTree k p) | |
Defined in Data.OrdPSQ.Internal | |
| Functor (OrdPSQ k p) | |
Defined in Data.OrdPSQ.Internal | |
| Functor m => Functor (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
| Functor m => Functor (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
| Functor m => Functor (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
| Functor m => Functor (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
| Functor m => Functor (SelectT r m) | |
Defined in Control.Monad.Trans.Select | |
| Functor m => Functor (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
| Functor m => Functor (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
| Functor m => Functor (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
| Functor m => Functor (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
| Functor m => Functor (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
| Functor ((,,) a b) | |
Defined in GHC.Internal.Base | |
| (Functor f, Functor g) => Functor (Product f g) | |
Defined in Data.Functor.Product | |
| (Functor f, Functor g) => Functor (Sum f g) | |
Defined in Data.Functor.Sum | |
| Functor f => Functor (WhenMatched f x y) | |
Defined in Data.IntMap.Internal | |
| (Applicative f, Monad f) => Functor (WhenMissing f k x) | |
Defined in Data.Map.Internal | |
| (Functor f, Functor g) => Functor (f :*: g) | |
Defined in GHC.Internal.Generics | |
| (Functor f, Functor g) => Functor (f :+: g) | |
Defined in GHC.Internal.Generics | |
| Functor (K1 i c :: Type -> Type) | |
Defined in GHC.Internal.Generics | |
| Functor (ContT r m) | |
Defined in Control.Monad.Trans.Cont | |
| Functor ((,,,) a b c) | |
Defined in GHC.Internal.Base | |
| Functor ((->) r) | |
Defined in GHC.Internal.Base | |
| (Functor f, Functor g) => Functor (Compose f g) | |
Defined in Data.Functor.Compose | |
| Functor f => Functor (WhenMatched f k x y) | |
Defined in Data.Map.Internal | |
| (Functor f, Functor g) => Functor (f :.: g) | |
Defined in GHC.Internal.Generics | |
| Functor f => Functor (M1 i c f) | |
Defined in GHC.Internal.Generics | |
| Functor m => Functor (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
| Functor m => Functor (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy | |
| Functor m => Functor (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict | |
| Functor ((,,,,) a b c d) | |
Defined in GHC.Internal.Base | |
| Functor ((,,,,,) a b c d e) | |
Defined in GHC.Internal.Base | |
| Functor ((,,,,,,) a b c d e f) | |
Defined in GHC.Internal.Base | |
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where #
Minimal complete definition
Nothing
Instances
| MonadPlus Seq | |
Defined in Data.Sequence.Internal | |
| MonadPlus P | |
Defined in GHC.Internal.Text.ParserCombinators.ReadP | |
| MonadPlus ReadP | |
Defined in GHC.Internal.Text.ParserCombinators.ReadP | |
| MonadPlus IO | |
Defined in GHC.Internal.Base | |
| MonadPlus Maybe | |
| MonadPlus [] | |
Defined in GHC.Internal.Base | |
| MonadPlus (Parser i) | |
Defined in Data.Attoparsec.Internal.Types | |
| Monad m => MonadPlus (ZeptoT m) | |
Defined in Data.Attoparsec.Zepto | |
| (ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a) | |
Defined in GHC.Internal.Control.Arrow | |
| MonadPlus (Proxy :: Type -> Type) | |
| MonadPlus (U1 :: Type -> Type) | |
Defined in GHC.Internal.Generics | |
| Monad m => MonadPlus (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
| MonadPlus m => MonadPlus (Kleisli m a) | |
Defined in GHC.Internal.Control.Arrow | |
| MonadPlus f => MonadPlus (Ap f) | |
| MonadPlus f => MonadPlus (Alt f) | |
| MonadPlus f => MonadPlus (Rec1 f) | |
Defined in GHC.Internal.Generics | |
| (Monoid w, Functor m, MonadPlus m) => MonadPlus (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
| (Monad m, Monoid e) => MonadPlus (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
| MonadPlus m => MonadPlus (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
| MonadPlus m => MonadPlus (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
| MonadPlus m => MonadPlus (SelectT r m) | |
Defined in Control.Monad.Trans.Select | |
| MonadPlus m => MonadPlus (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
| MonadPlus m => MonadPlus (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
| (Functor m, MonadPlus m) => MonadPlus (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
| (Monoid w, MonadPlus m) => MonadPlus (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
| (Monoid w, MonadPlus m) => MonadPlus (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
| (MonadPlus f, MonadPlus g) => MonadPlus (Product f g) | |
Defined in Data.Functor.Product | |
| (MonadPlus f, MonadPlus g) => MonadPlus (f :*: g) | |
Defined in GHC.Internal.Generics | |
| MonadPlus f => MonadPlus (M1 i c f) | |
Defined in GHC.Internal.Generics | |
| (Functor m, MonadPlus m) => MonadPlus (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
| (Monoid w, MonadPlus m) => MonadPlus (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy | |
| (Monoid w, MonadPlus m) => MonadPlus (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict | |
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r #
when :: Applicative f => Bool -> f () -> f () #
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a] #
forever :: Applicative f => f a -> f b #
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c]) #
replicateM :: Applicative m => Int -> m a -> m [a] #
replicateM_ :: Applicative m => Int -> m a -> m () #
unless :: Applicative f => Bool -> f () -> f () #
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c] #
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m () #
guard :: Alternative f => Bool -> f () #
class Monad m => MonadFail (m :: Type -> Type) where #
Instances
| MonadFail P | |
Defined in GHC.Internal.Text.ParserCombinators.ReadP | |
| MonadFail ReadP | |
Defined in GHC.Internal.Text.ParserCombinators.ReadP | |
| MonadFail IO | |
Defined in GHC.Internal.Control.Monad.Fail | |
| MonadFail Q | |
Defined in Language.Haskell.TH.Syntax | |
| MonadFail Maybe | |
Defined in GHC.Internal.Control.Monad.Fail | |
| MonadFail [] | |
Defined in GHC.Internal.Control.Monad.Fail | |
| MonadFail (Parser i) | |
Defined in Data.Attoparsec.Internal.Types | |
| Monad m => MonadFail (ZeptoT m) | |
Defined in Data.Attoparsec.Zepto | |
| Monad m => MonadFail (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
| MonadFail f => MonadFail (Ap f) | |
Defined in GHC.Internal.Data.Monoid | |
| (Monoid w, MonadFail m) => MonadFail (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
| MonadFail m => MonadFail (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
| MonadFail m => MonadFail (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
| MonadFail m => MonadFail (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
| MonadFail m => MonadFail (SelectT r m) | |
Defined in Control.Monad.Trans.Select | |
| MonadFail m => MonadFail (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
| MonadFail m => MonadFail (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
| MonadFail m => MonadFail (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
| (Monoid w, MonadFail m) => MonadFail (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
| (Monoid w, MonadFail m) => MonadFail (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
| MonadFail m => MonadFail (ContT r m) | |
Defined in Control.Monad.Trans.Cont | |
| MonadFail m => MonadFail (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
| (Monoid w, MonadFail m) => MonadFail (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy | |
| (Monoid w, MonadFail m) => MonadFail (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict | |
Minimal complete definition
(.&.), (.|.), xor, complement, (shift | shiftL, shiftR), (rotate | rotateL, rotateR), bitSize, bitSizeMaybe, isSigned, testBit, bit, popCount
Methods
complement :: a -> a #
complementBit :: a -> Int -> a #
bitSizeMaybe :: a -> Maybe Int #
unsafeShiftL :: a -> Int -> a #
unsafeShiftR :: a -> Int -> a #
Instances
| 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 # | |
| 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 # | |
| 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 # | |
| Bits Int8 | |
Defined in GHC.Internal.Int Methods (.&.) :: Int8 -> Int8 -> Int8 # (.|.) :: Int8 -> Int8 -> Int8 # complement :: Int8 -> Int8 # shift :: Int8 -> Int -> Int8 # rotate :: Int8 -> Int -> Int8 # setBit :: Int8 -> Int -> Int8 # clearBit :: Int8 -> Int -> Int8 # complementBit :: Int8 -> Int -> Int8 # testBit :: Int8 -> Int -> Bool # bitSizeMaybe :: Int8 -> Maybe Int # shiftL :: Int8 -> Int -> Int8 # unsafeShiftL :: Int8 -> Int -> Int8 # shiftR :: Int8 -> Int -> Int8 # unsafeShiftR :: Int8 -> Int -> Int8 # rotateL :: Int8 -> Int -> Int8 # | |
| 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 # | |
| 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 # | |
| 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 # | |
| 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 # | |
| 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 # | |
| Bits Natural | |
Defined in GHC.Internal.Bits Methods (.&.) :: Natural -> Natural -> Natural # (.|.) :: Natural -> Natural -> Natural # xor :: Natural -> Natural -> Natural # complement :: Natural -> Natural # shift :: Natural -> Int -> Natural # rotate :: Natural -> Int -> Natural # setBit :: Natural -> Int -> Natural # clearBit :: Natural -> Int -> Natural # complementBit :: Natural -> Int -> Natural # testBit :: Natural -> Int -> Bool # bitSizeMaybe :: Natural -> Maybe Int # shiftL :: Natural -> Int -> Natural # unsafeShiftL :: Natural -> Int -> Natural # shiftR :: Natural -> Int -> Natural # unsafeShiftR :: Natural -> Int -> Natural # rotateL :: Natural -> Int -> Natural # | |
| Bits Bool | |
Defined in GHC.Internal.Bits Methods (.&.) :: Bool -> Bool -> Bool # (.|.) :: Bool -> Bool -> Bool # complement :: Bool -> Bool # shift :: Bool -> Int -> Bool # rotate :: Bool -> Int -> Bool # setBit :: Bool -> Int -> Bool # clearBit :: Bool -> Int -> Bool # complementBit :: Bool -> Int -> Bool # testBit :: Bool -> Int -> Bool # bitSizeMaybe :: Bool -> Maybe Int # shiftL :: Bool -> Int -> Bool # unsafeShiftL :: Bool -> Int -> Bool # shiftR :: Bool -> Int -> Bool # unsafeShiftR :: Bool -> Int -> Bool # rotateL :: Bool -> Int -> Bool # | |
| Bits Int | |
Defined in GHC.Internal.Bits Methods complement :: Int -> Int # clearBit :: Int -> Int -> Int # complementBit :: Int -> Int -> Int # testBit :: Int -> Int -> Bool # bitSizeMaybe :: Int -> Maybe Int # unsafeShiftL :: Int -> Int -> Int # unsafeShiftR :: Int -> Int -> Int # rotateL :: Int -> Int -> Int # | |
| Bits Word | |
Defined in GHC.Internal.Bits Methods (.&.) :: Word -> Word -> Word # (.|.) :: Word -> Word -> Word # complement :: Word -> Word # shift :: Word -> Int -> Word # rotate :: Word -> Int -> Word # setBit :: Word -> Int -> Word # clearBit :: Word -> Int -> Word # complementBit :: Word -> Int -> Word # testBit :: Word -> Int -> Bool # bitSizeMaybe :: Word -> Maybe Int # shiftL :: Word -> Int -> Word # unsafeShiftL :: Word -> Int -> Word # shiftR :: Word -> Int -> Word # unsafeShiftR :: Word -> Int -> Word # rotateL :: Word -> Int -> Word # | |
| Bits a => Bits (And a) | |
Defined in GHC.Internal.Data.Bits Methods (.&.) :: And a -> And a -> And a # (.|.) :: And a -> And a -> And a # xor :: And a -> And a -> And a # complement :: And a -> And a # shift :: And a -> Int -> And a # rotate :: And a -> Int -> And a # setBit :: And a -> Int -> And a # clearBit :: And a -> Int -> And a # complementBit :: And a -> Int -> And a # testBit :: And a -> Int -> Bool # bitSizeMaybe :: And a -> Maybe Int # shiftL :: And a -> Int -> And a # unsafeShiftL :: And a -> Int -> And a # shiftR :: And a -> Int -> And a # unsafeShiftR :: And a -> Int -> And a # rotateL :: And a -> Int -> And a # | |
| Bits a => Bits (Iff a) | |
Defined in GHC.Internal.Data.Bits Methods (.&.) :: Iff a -> Iff a -> Iff a # (.|.) :: Iff a -> Iff a -> Iff a # xor :: Iff a -> Iff a -> Iff a # complement :: Iff a -> Iff a # shift :: Iff a -> Int -> Iff a # rotate :: Iff a -> Int -> Iff a # setBit :: Iff a -> Int -> Iff a # clearBit :: Iff a -> Int -> Iff a # complementBit :: Iff a -> Int -> Iff a # testBit :: Iff a -> Int -> Bool # bitSizeMaybe :: Iff a -> Maybe Int # shiftL :: Iff a -> Int -> Iff a # unsafeShiftL :: Iff a -> Int -> Iff a # shiftR :: Iff a -> Int -> Iff a # unsafeShiftR :: Iff a -> Int -> Iff a # rotateL :: Iff a -> Int -> Iff a # | |
| Bits a => Bits (Ior a) | |
Defined in GHC.Internal.Data.Bits Methods (.&.) :: Ior a -> Ior a -> Ior a # (.|.) :: Ior a -> Ior a -> Ior a # xor :: Ior a -> Ior a -> Ior a # complement :: Ior a -> Ior a # shift :: Ior a -> Int -> Ior a # rotate :: Ior a -> Int -> Ior a # setBit :: Ior a -> Int -> Ior a # clearBit :: Ior a -> Int -> Ior a # complementBit :: Ior a -> Int -> Ior a # testBit :: Ior a -> Int -> Bool # bitSizeMaybe :: Ior a -> Maybe Int # shiftL :: Ior a -> Int -> Ior a # unsafeShiftL :: Ior a -> Int -> Ior a # shiftR :: Ior a -> Int -> Ior a # unsafeShiftR :: Ior a -> Int -> Ior a # rotateL :: Ior a -> Int -> Ior a # | |
| Bits a => Bits (Xor a) | |
Defined in GHC.Internal.Data.Bits Methods (.&.) :: Xor a -> Xor a -> Xor a # (.|.) :: Xor a -> Xor a -> Xor a # xor :: Xor a -> Xor a -> Xor a # complement :: Xor a -> Xor a # shift :: Xor a -> Int -> Xor a # rotate :: Xor a -> Int -> Xor a # setBit :: Xor a -> Int -> Xor a # clearBit :: Xor a -> Int -> Xor a # complementBit :: Xor a -> Int -> Xor a # testBit :: Xor a -> Int -> Bool # bitSizeMaybe :: Xor a -> Maybe Int # shiftL :: Xor a -> Int -> Xor a # unsafeShiftL :: Xor a -> Int -> Xor a # shiftR :: Xor a -> Int -> Xor a # unsafeShiftR :: Xor a -> Int -> Xor a # rotateL :: Xor a -> Int -> Xor a # | |
| Bits a => Bits (Identity a) | |
Defined in GHC.Internal.Data.Functor.Identity Methods (.&.) :: Identity a -> Identity a -> Identity a # (.|.) :: Identity a -> Identity a -> Identity a # xor :: Identity a -> Identity a -> Identity a # complement :: Identity a -> Identity a # shift :: Identity a -> Int -> Identity a # rotate :: Identity a -> Int -> Identity a # setBit :: Identity a -> Int -> Identity a # clearBit :: Identity a -> Int -> Identity a # complementBit :: Identity a -> Int -> Identity a # testBit :: Identity a -> Int -> Bool # bitSizeMaybe :: Identity a -> Maybe Int # bitSize :: Identity a -> Int # isSigned :: Identity a -> Bool # shiftL :: Identity a -> Int -> Identity a # unsafeShiftL :: Identity a -> Int -> Identity a # shiftR :: Identity a -> Int -> Identity a # unsafeShiftR :: Identity a -> Int -> Identity a # rotateL :: Identity a -> Int -> Identity a # | |
| Bits a => Bits (Down a) | |
Defined in GHC.Internal.Data.Ord Methods (.&.) :: Down a -> Down a -> Down a # (.|.) :: Down a -> Down a -> Down a # xor :: Down a -> Down a -> Down a # complement :: Down a -> Down a # shift :: Down a -> Int -> Down a # rotate :: Down a -> Int -> Down a # setBit :: Down a -> Int -> Down a # clearBit :: Down a -> Int -> Down a # complementBit :: Down a -> Int -> Down a # testBit :: Down a -> Int -> Bool # bitSizeMaybe :: Down a -> Maybe Int # shiftL :: Down a -> Int -> Down a # unsafeShiftL :: Down a -> Int -> Down a # shiftR :: Down a -> Int -> Down a # unsafeShiftR :: Down a -> Int -> Down a # rotateL :: Down a -> Int -> Down a # | |
| Bits a => Bits (Const a b) | |
Defined in GHC.Internal.Data.Functor.Const Methods (.&.) :: Const a b -> Const a b -> Const a b # (.|.) :: Const a b -> Const a b -> Const a b # xor :: Const a b -> Const a b -> Const a b # complement :: Const a b -> Const a b # shift :: Const a b -> Int -> Const a b # rotate :: Const a b -> Int -> Const a b # setBit :: Const a b -> Int -> Const a b # clearBit :: Const a b -> Int -> Const a b # complementBit :: Const a b -> Int -> Const a b # testBit :: Const a b -> Int -> Bool # bitSizeMaybe :: Const a b -> Maybe Int # isSigned :: Const a b -> Bool # shiftL :: Const a b -> Int -> Const a b # unsafeShiftL :: Const a b -> Int -> Const a b # shiftR :: Const a b -> Int -> Const a b # unsafeShiftR :: Const a b -> Int -> Const a b # rotateL :: Const a b -> Int -> Const a b # | |
bitDefault :: (Bits a, Num a) => Int -> a #
popCountDefault :: (Bits a, Num a) => a -> Int #
testBitDefault :: (Bits a, Num a) => a -> Int -> Bool #
toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b #
oneBits :: FiniteBits a => a #
class Bits b => FiniteBits b where #
Minimal complete definition
Instances
| FiniteBits Int16 | |
Defined in GHC.Internal.Int Methods finiteBitSize :: Int16 -> Int # countLeadingZeros :: Int16 -> Int # countTrailingZeros :: Int16 -> Int # | |
| FiniteBits Int32 | |
Defined in GHC.Internal.Int Methods finiteBitSize :: Int32 -> Int # countLeadingZeros :: Int32 -> Int # countTrailingZeros :: Int32 -> Int # | |
| FiniteBits Int64 | |
Defined in GHC.Internal.Int Methods finiteBitSize :: Int64 -> Int # countLeadingZeros :: Int64 -> Int # countTrailingZeros :: Int64 -> Int # | |
| FiniteBits Int8 | |
Defined in GHC.Internal.Int Methods finiteBitSize :: Int8 -> Int # countLeadingZeros :: Int8 -> Int # countTrailingZeros :: Int8 -> Int # | |
| FiniteBits Word16 | |
Defined in GHC.Internal.Word Methods finiteBitSize :: Word16 -> Int # countLeadingZeros :: Word16 -> Int # countTrailingZeros :: Word16 -> Int # | |
| FiniteBits Word32 | |
Defined in GHC.Internal.Word Methods finiteBitSize :: Word32 -> Int # countLeadingZeros :: Word32 -> Int # countTrailingZeros :: Word32 -> Int # | |
| FiniteBits Word64 | |
Defined in GHC.Internal.Word Methods finiteBitSize :: Word64 -> Int # countLeadingZeros :: Word64 -> Int # countTrailingZeros :: Word64 -> Int # | |
| FiniteBits Word8 | |
Defined in GHC.Internal.Word Methods finiteBitSize :: Word8 -> Int # countLeadingZeros :: Word8 -> Int # countTrailingZeros :: Word8 -> Int # | |
| FiniteBits Bool | |
Defined in GHC.Internal.Bits Methods finiteBitSize :: Bool -> Int # countLeadingZeros :: Bool -> Int # countTrailingZeros :: Bool -> Int # | |
| FiniteBits Int | |
Defined in GHC.Internal.Bits Methods finiteBitSize :: Int -> Int # countLeadingZeros :: Int -> Int # countTrailingZeros :: Int -> Int # | |
| FiniteBits Word | |
Defined in GHC.Internal.Bits Methods finiteBitSize :: Word -> Int # countLeadingZeros :: Word -> Int # countTrailingZeros :: Word -> Int # | |
| FiniteBits a => FiniteBits (And a) | |
Defined in GHC.Internal.Data.Bits Methods finiteBitSize :: And a -> Int # countLeadingZeros :: And a -> Int # countTrailingZeros :: And a -> Int # | |
| FiniteBits a => FiniteBits (Iff a) | |
Defined in GHC.Internal.Data.Bits Methods finiteBitSize :: Iff a -> Int # countLeadingZeros :: Iff a -> Int # countTrailingZeros :: Iff a -> Int # | |
| FiniteBits a => FiniteBits (Ior a) | |
Defined in GHC.Internal.Data.Bits Methods finiteBitSize :: Ior a -> Int # countLeadingZeros :: Ior a -> Int # countTrailingZeros :: Ior a -> Int # | |
| FiniteBits a => FiniteBits (Xor a) | |
Defined in GHC.Internal.Data.Bits Methods finiteBitSize :: Xor a -> Int # countLeadingZeros :: Xor a -> Int # countTrailingZeros :: Xor a -> Int # | |
| FiniteBits a => FiniteBits (Identity a) | |
Defined in GHC.Internal.Data.Functor.Identity Methods finiteBitSize :: Identity a -> Int # countLeadingZeros :: Identity a -> Int # countTrailingZeros :: Identity a -> Int # | |
| FiniteBits a => FiniteBits (Down a) | |
Defined in GHC.Internal.Data.Ord Methods finiteBitSize :: Down a -> Int # countLeadingZeros :: Down a -> Int # countTrailingZeros :: Down a -> Int # | |
| FiniteBits a => FiniteBits (Const a b) | |
Defined in GHC.Internal.Data.Functor.Const Methods finiteBitSize :: Const a b -> Int # countLeadingZeros :: Const a b -> Int # countTrailingZeros :: Const a b -> Int # | |
Instances
| FiniteBits a => Monoid (And a) | |
| Bits a => Semigroup (And a) | |
| Bits a => Bits (And a) | |
Defined in GHC.Internal.Data.Bits Methods (.&.) :: And a -> And a -> And a # (.|.) :: And a -> And a -> And a # xor :: And a -> And a -> And a # complement :: And a -> And a # shift :: And a -> Int -> And a # rotate :: And a -> Int -> And a # setBit :: And a -> Int -> And a # clearBit :: And a -> Int -> And a # complementBit :: And a -> Int -> And a # testBit :: And a -> Int -> Bool # bitSizeMaybe :: And a -> Maybe Int # shiftL :: And a -> Int -> And a # unsafeShiftL :: And a -> Int -> And a # shiftR :: And a -> Int -> And a # unsafeShiftR :: And a -> Int -> And a # rotateL :: And a -> Int -> And a # | |
| FiniteBits a => FiniteBits (And a) | |
Defined in GHC.Internal.Data.Bits Methods finiteBitSize :: And a -> Int # countLeadingZeros :: And a -> Int # countTrailingZeros :: And a -> Int # | |
| Bounded a => Bounded (And a) | |
Defined in GHC.Internal.Data.Bits | |
| Enum a => Enum (And a) | |
| Read a => Read (And a) | |
Defined in GHC.Internal.Data.Bits | |
| Show a => Show (And a) | |
| Eq a => Eq (And a) | |
Instances
| FiniteBits a => Monoid (Iff a) | |
| FiniteBits a => Semigroup (Iff a) | |
| Bits a => Bits (Iff a) | |
Defined in GHC.Internal.Data.Bits Methods (.&.) :: Iff a -> Iff a -> Iff a # (.|.) :: Iff a -> Iff a -> Iff a # xor :: Iff a -> Iff a -> Iff a # complement :: Iff a -> Iff a # shift :: Iff a -> Int -> Iff a # rotate :: Iff a -> Int -> Iff a # setBit :: Iff a -> Int -> Iff a # clearBit :: Iff a -> Int -> Iff a # complementBit :: Iff a -> Int -> Iff a # testBit :: Iff a -> Int -> Bool # bitSizeMaybe :: Iff a -> Maybe Int # shiftL :: Iff a -> Int -> Iff a # unsafeShiftL :: Iff a -> Int -> Iff a # shiftR :: Iff a -> Int -> Iff a # unsafeShiftR :: Iff a -> Int -> Iff a # rotateL :: Iff a -> Int -> Iff a # | |
| FiniteBits a => FiniteBits (Iff a) | |
Defined in GHC.Internal.Data.Bits Methods finiteBitSize :: Iff a -> Int # countLeadingZeros :: Iff a -> Int # countTrailingZeros :: Iff a -> Int # | |
| Bounded a => Bounded (Iff a) | |
Defined in GHC.Internal.Data.Bits | |
| Enum a => Enum (Iff a) | |
| Read a => Read (Iff a) | |
Defined in GHC.Internal.Data.Bits | |
| Show a => Show (Iff a) | |
| Eq a => Eq (Iff a) | |
Instances
| Bits a => Monoid (Ior a) | |
| Bits a => Semigroup (Ior a) | |
| Bits a => Bits (Ior a) | |
Defined in GHC.Internal.Data.Bits Methods (.&.) :: Ior a -> Ior a -> Ior a # (.|.) :: Ior a -> Ior a -> Ior a # xor :: Ior a -> Ior a -> Ior a # complement :: Ior a -> Ior a # shift :: Ior a -> Int -> Ior a # rotate :: Ior a -> Int -> Ior a # setBit :: Ior a -> Int -> Ior a # clearBit :: Ior a -> Int -> Ior a # complementBit :: Ior a -> Int -> Ior a # testBit :: Ior a -> Int -> Bool # bitSizeMaybe :: Ior a -> Maybe Int # shiftL :: Ior a -> Int -> Ior a # unsafeShiftL :: Ior a -> Int -> Ior a # shiftR :: Ior a -> Int -> Ior a # unsafeShiftR :: Ior a -> Int -> Ior a # rotateL :: Ior a -> Int -> Ior a # | |
| FiniteBits a => FiniteBits (Ior a) | |
Defined in GHC.Internal.Data.Bits Methods finiteBitSize :: Ior a -> Int # countLeadingZeros :: Ior a -> Int # countTrailingZeros :: Ior a -> Int # | |
| Bounded a => Bounded (Ior a) | |
Defined in GHC.Internal.Data.Bits | |
| Enum a => Enum (Ior a) | |
| Read a => Read (Ior a) | |
Defined in GHC.Internal.Data.Bits | |
| Show a => Show (Ior a) | |
| Eq a => Eq (Ior a) | |
Instances
| Bits a => Monoid (Xor a) | |
| Bits a => Semigroup (Xor a) | |
| Bits a => Bits (Xor a) | |
Defined in GHC.Internal.Data.Bits Methods (.&.) :: Xor a -> Xor a -> Xor a # (.|.) :: Xor a -> Xor a -> Xor a # xor :: Xor a -> Xor a -> Xor a # complement :: Xor a -> Xor a # shift :: Xor a -> Int -> Xor a # rotate :: Xor a -> Int -> Xor a # setBit :: Xor a -> Int -> Xor a # clearBit :: Xor a -> Int -> Xor a # complementBit :: Xor a -> Int -> Xor a # testBit :: Xor a -> Int -> Bool # bitSizeMaybe :: Xor a -> Maybe Int # shiftL :: Xor a -> Int -> Xor a # unsafeShiftL :: Xor a -> Int -> Xor a # shiftR :: Xor a -> Int -> Xor a # unsafeShiftR :: Xor a -> Int -> Xor a # rotateL :: Xor a -> Int -> Xor a # | |
| FiniteBits a => FiniteBits (Xor a) | |
Defined in GHC.Internal.Data.Bits Methods finiteBitSize :: Xor a -> Int # countLeadingZeros :: Xor a -> Int # countTrailingZeros :: Xor a -> Int # | |
| Bounded a => Bounded (Xor a) | |
Defined in GHC.Internal.Data.Bits | |
| Enum a => Enum (Xor a) | |
| Read a => Read (Xor a) | |
Defined in GHC.Internal.Data.Bits | |
| Show a => Show (Xor a) | |
| Eq a => Eq (Xor a) | |
Instances
| MonadZip [] | |||||
Defined in Control.Monad.Zip | |||||
| Eq1 [] | |||||
Defined in Data.Functor.Classes Methods liftEq :: (a -> b -> Bool) -> [a] -> [b] -> Bool | |||||
| Ord1 [] | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> [a] -> [b] -> Ordering | |||||
| Read1 [] | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS [a] liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [[a]] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [a] liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [[a]] | |||||
| Show1 [] | |||||
Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> [a] -> ShowS liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [[a]] -> ShowS | |||||
| NFData1 [] | |||||
Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> [a] -> () | |||||
| Alternative [] | |||||
| Applicative [] | |||||
| Functor [] | |||||
Defined in GHC.Internal.Base | |||||
| Monad [] | |||||
| MonadPlus [] | |||||
Defined in GHC.Internal.Base | |||||
| MonadFail [] | |||||
Defined in GHC.Internal.Control.Monad.Fail | |||||
| Foldable [] | |||||
Defined in GHC.Internal.Data.Foldable Methods foldMap :: Monoid m => (a -> m) -> [a] -> m foldMap' :: Monoid m => (a -> m) -> [a] -> m foldr :: (a -> b -> b) -> b -> [a] -> b # foldr' :: (a -> b -> b) -> b -> [a] -> b foldl :: (b -> a -> b) -> b -> [a] -> b # foldl' :: (b -> a -> b) -> b -> [a] -> b # foldr1 :: (a -> a -> a) -> [a] -> a # foldl1 :: (a -> a -> a) -> [a] -> a # toList :: [a] -> [a] elem :: Eq a => a -> [a] -> Bool # maximum :: Ord a => [a] -> a # | |||||
| Traversable [] | |||||
Defined in GHC.Internal.Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> [a] -> f [b] sequenceA :: Applicative f => [f a] -> f [a] | |||||
| Hashable1 [] | |||||
Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> [a] -> Int | |||||
| TimeFormat String | |||||
Defined in Data.Hourglass.Format Methods toFormat :: String -> TimeFormatString | |||||
| GetAddrInfo [] | |||||
Defined in Network.Socket.Info Methods getAddrInfo :: Maybe AddrInfo -> Maybe HostName -> Maybe ServiceName -> IO [AddrInfo] | |||||
| Generic1 [] | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Lift a => Lift ([a] :: Type) | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| IsChar c => PrintfArg [c] | |||||
Defined in Text.Printf | |||||
| IsChar c => PrintfType [c] | |||||
Defined in Text.Printf Methods spr :: String -> [UPrintf] -> [c] | |||||
| FoldCase a => FoldCase [a] | |||||
Defined in Data.CaseInsensitive.Internal | |||||
| NFData a => NFData [a] | |||||
Defined in Control.DeepSeq Methods rnf :: [a] -> () | |||||
| Monoid [a] | |||||
| Semigroup [a] | |||||
| a ~ Char => IsString [a] | |||||
Defined in GHC.Internal.Data.String Methods fromString :: String -> [a] | |||||
| Generic [a] | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| IsList [a] | |||||
Defined in GHC.Internal.IsList Associated Types
| |||||
| Read a => Read [a] | |||||
Defined in GHC.Internal.Read Methods readsPrec :: Int -> ReadS [a] readList :: ReadS [[a]] readPrec :: ReadPrec [a] readListPrec :: ReadPrec [[a]] | |||||
| Show a => Show [a] | |||||
Defined in GHC.Internal.Show | |||||
| Eq a => Eq [a] | |||||
Defined in GHC.Classes | |||||
| Ord a => Ord [a] | |||||
| Hashable a => Hashable [a] | |||||
Defined in Data.Hashable.Class | |||||
| TimeFormat [TimeFormatElem] | |||||
Defined in Data.Hourglass.Format Methods toFormat :: [TimeFormatElem] -> TimeFormatString | |||||
| type Rep1 [] | |||||
Defined in GHC.Internal.Generics type Rep1 [] = D1 ('MetaData "List" "GHC.Types" "ghc-prim" 'False) (C1 ('MetaCons "[]" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons ":" ('InfixI 'RightAssociative 5) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 []))) | |||||
| type Rep [a] | |||||
Defined in GHC.Internal.Generics type Rep [a] = D1 ('MetaData "List" "GHC.Types" "ghc-prim" 'False) (C1 ('MetaCons "[]" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons ":" ('InfixI 'RightAssociative 5) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [a]))) | |||||
| type Item [a] | |||||
Defined in GHC.Internal.IsList type Item [a] = a | |||||
findIndices :: (a -> Bool) -> [a] -> [Int] #
dropWhileEnd :: (a -> Bool) -> [a] -> [a] #
elemIndices :: Eq a => a -> [a] -> [Int] #
intercalate :: [a] -> [[a]] -> [a] #
intersperse :: a -> [a] -> [a] #
isPrefixOf :: Eq a => [a] -> [a] -> Bool #
isSuffixOf :: Eq a => [a] -> [a] -> Bool #
stripPrefix :: Eq a => [a] -> [a] -> Maybe [a] #
isSubsequenceOf :: Eq a => [a] -> [a] -> Bool #
deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] #
genericDrop :: Integral i => i -> [a] -> [a] #
genericIndex :: Integral i => [a] -> i -> a #
genericLength :: Num i => [a] -> i #
genericReplicate :: Integral i => i -> a -> [a] #
genericSplitAt :: Integral i => i -> [a] -> ([a], [a]) #
genericTake :: Integral i => i -> [a] -> [a] #
intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] #
permutations :: [a] -> [[a]] #
subsequences :: [a] -> [[a]] #
zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h] #
Instances
| MonadZip Maybe | |||||
| Eq1 Maybe | |||||
Defined in Data.Functor.Classes | |||||
| 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 | |||||
| NFData1 Maybe | |||||
Defined in Control.DeepSeq | |||||
| Alternative Maybe | |||||
| Applicative Maybe | |||||
| Functor Maybe | |||||
| Monad Maybe | |||||
| MonadPlus Maybe | |||||
| MonadFail Maybe | |||||
Defined in GHC.Internal.Control.Monad.Fail | |||||
| 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 # minimum :: Ord a => Maybe a -> a # | |||||
| Traversable Maybe | |||||
| Hashable1 Maybe | |||||
Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Maybe a -> Int | |||||
| Generic1 Maybe | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| MonadError () Maybe | |||||
Defined in Control.Monad.Error.Class | |||||
| Lift a => Lift (Maybe a :: Type) | |||||
| NFData a => NFData (Maybe a) | |||||
Defined in Control.DeepSeq | |||||
| Semigroup a => Monoid (Maybe a) | |||||
| Semigroup a => Semigroup (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) | |||||
| Hashable a => Hashable (Maybe a) | |||||
Defined in Data.Hashable.Class | |||||
| SingI ('Nothing :: Maybe a) | |||||
Defined in GHC.Internal.Generics | |||||
| SingI a2 => SingI ('Just a2 :: Maybe a1) | |||||
Defined in GHC.Internal.Generics | |||||
| 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) | |||||
listToMaybe :: [a] -> Maybe a #
maybeToList :: Maybe a -> [a] #
class Semigroup a => Monoid a where #
Instances
| Monoid More | |
| Monoid ByteArray | |
| Monoid Builder | |
| Monoid ByteString | |
Defined in Data.ByteString.Internal.Type Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString # | |
| Monoid ByteString | |
| Monoid ShortByteString | |
| Monoid IntSet | |
| Monoid SharedSecret | |
| Monoid SPut Source # | |
| Monoid All | |
| Monoid Any | |
| Monoid ExceptionContext | |
| Monoid Ordering | |
| Monoid OsString | |
| Monoid PosixString | |
| Monoid WindowsString | |
| Monoid Doc | |
| Monoid Text | |
| Monoid Text | |
| Monoid () | |
| (Semigroup a, Monoid a) => Monoid (Concurrently a) | |
| 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) | |
| Monoid s => Monoid (CI s) | |
| Monoid (IntMap a) | |
| Monoid (Seq a) | |
| Monoid (MergeSet a) | |
| Ord a => Monoid (Set a) | |
| FiniteBits a => Monoid (And a) | |
| FiniteBits a => Monoid (Iff a) | |
| Bits a => Monoid (Ior a) | |
| Bits a => Monoid (Xor a) | |
| Monoid a => Monoid (Identity a) | |
| Monoid (First a) | |
| Monoid (Last a) | |
| Monoid a => Monoid (Down 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) | |
| Monoid (Doc a) | |
| Monoid a => Monoid (Q a) | |
| Semigroup a => Monoid (Maybe a) | |
| Monoid a => Monoid (Solo a) | |
| Monoid [a] | |
| (Semigroup a, Monoid a) => Monoid (ConcurrentlyE e a) | |
| Monoid (Parser i a) | |
| Monad m => Monoid (ZeptoT m a) | |
| Monoid a => Monoid (Op a b) | |
| Ord k => Monoid (Map k v) | |
| Monoid (Proxy s) | |
| Monoid (U1 p) | |
| Monoid a => Monoid (ST s a) | |
| Routable k => Monoid (IPRTable k 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) | |
Instances
| NFData Any | |||||
Defined in Control.DeepSeq | |||||
| Monoid Any | |||||
| Semigroup Any | |||||
| Bounded Any | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| Generic Any | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
| Read Any | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| Show Any | |||||
| Eq Any | |||||
| Ord Any | |||||
| type Rep Any | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
newtype Ap (f :: k -> Type) (a :: k) #
Instances
| Generic1 (Ap f :: k -> Type) | |||||
Defined in GHC.Internal.Data.Monoid Associated Types
| |||||
| Foldable1 f => Foldable1 (Ap f) | |||||
Defined in Data.Foldable1 Methods fold1 :: Semigroup m => Ap f m -> m foldMap1 :: Semigroup m => (a -> m) -> Ap f a -> m foldMap1' :: Semigroup m => (a -> m) -> Ap f a -> m toNonEmpty :: Ap f a -> NonEmpty a maximum :: Ord a => Ap f a -> a minimum :: Ord a => Ap f a -> a foldrMap1 :: (a -> b) -> (a -> b -> b) -> Ap f a -> b foldlMap1' :: (a -> b) -> (b -> a -> b) -> Ap f a -> b foldlMap1 :: (a -> b) -> (b -> a -> b) -> Ap f a -> b foldrMap1' :: (a -> b) -> (a -> b -> b) -> Ap f a -> b | |||||
| Alternative f => Alternative (Ap f) | |||||
| Applicative f => Applicative (Ap f) | |||||
| Functor f => Functor (Ap f) | |||||
| Monad f => Monad (Ap f) | |||||
| MonadPlus f => MonadPlus (Ap f) | |||||
| MonadFail f => MonadFail (Ap f) | |||||
Defined in GHC.Internal.Data.Monoid | |||||
| Foldable f => Foldable (Ap f) | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => Ap f m -> m foldMap :: Monoid m => (a -> m) -> Ap f a -> m foldMap' :: Monoid m => (a -> m) -> Ap f a -> m foldr :: (a -> b -> b) -> b -> Ap f a -> b # foldr' :: (a -> b -> b) -> b -> Ap f a -> b foldl :: (b -> a -> b) -> b -> Ap f a -> b # foldl' :: (b -> a -> b) -> b -> Ap f a -> b # foldr1 :: (a -> a -> a) -> Ap f a -> a # foldl1 :: (a -> a -> a) -> Ap f a -> a # elem :: Eq a => a -> Ap f a -> Bool # maximum :: Ord a => Ap f a -> a # | |||||
| Traversable f => Traversable (Ap f) | |||||
| (Applicative f, Monoid a) => Monoid (Ap f a) | |||||
| (Applicative f, Semigroup a) => Semigroup (Ap f a) | |||||
| (Applicative f, Bounded a) => Bounded (Ap f a) | |||||
Defined in GHC.Internal.Data.Monoid | |||||
| Enum (f a) => Enum (Ap f a) | |||||
Defined in GHC.Internal.Data.Monoid | |||||
| Generic (Ap f a) | |||||
Defined in GHC.Internal.Data.Monoid Associated Types
| |||||
| (Applicative f, Num a) => Num (Ap f a) | |||||
| Read (f a) => Read (Ap f a) | |||||
Defined in GHC.Internal.Data.Monoid | |||||
| Show (f a) => Show (Ap f a) | |||||
| Eq (f a) => Eq (Ap f a) | |||||
| Ord (f a) => Ord (Ap f a) | |||||
| type Rep1 (Ap f :: k -> Type) | |||||
Defined in GHC.Internal.Data.Monoid | |||||
| type Rep (Ap f a) | |||||
Defined in GHC.Internal.Data.Monoid | |||||
Instances
| MonadZip First | |||||
| NFData1 First | |||||
Defined in Control.DeepSeq | |||||
| Applicative First | |||||
| Functor First | |||||
| Monad First | |||||
| Foldable First | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => First m -> m foldMap :: Monoid m => (a -> m) -> First a -> m foldMap' :: Monoid m => (a -> m) -> First a -> m foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b # foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # | |||||
| Traversable First | |||||
| Generic1 First | |||||
Defined in GHC.Internal.Data.Monoid Associated Types
| |||||
| NFData a => NFData (First a) | |||||
Defined in Control.DeepSeq | |||||
| Monoid (First a) | |||||
| Semigroup (First a) | |||||
| Generic (First a) | |||||
Defined in GHC.Internal.Data.Monoid Associated Types
| |||||
| Read a => Read (First a) | |||||
Defined in GHC.Internal.Data.Monoid | |||||
| Show a => Show (First a) | |||||
| Eq a => Eq (First a) | |||||
| Ord a => Ord (First a) | |||||
Defined in GHC.Internal.Data.Monoid | |||||
| type Rep1 First | |||||
Defined in GHC.Internal.Data.Monoid | |||||
| type Rep (First a) | |||||
Defined in GHC.Internal.Data.Monoid | |||||
Instances
| MonadZip Last | |||||
| NFData1 Last | |||||
Defined in Control.DeepSeq | |||||
| Applicative Last | |||||
| Functor Last | |||||
| Monad Last | |||||
| Foldable Last | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => Last m -> m foldMap :: Monoid m => (a -> m) -> Last a -> m foldMap' :: Monoid m => (a -> m) -> Last a -> m foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b # foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |||||
| Traversable Last | |||||
| Generic1 Last | |||||
Defined in GHC.Internal.Data.Monoid Associated Types
| |||||
| NFData a => NFData (Last a) | |||||
Defined in Control.DeepSeq | |||||
| Monoid (Last a) | |||||
| Semigroup (Last a) | |||||
| Generic (Last a) | |||||
Defined in GHC.Internal.Data.Monoid Associated Types
| |||||
| Read a => Read (Last a) | |||||
Defined in GHC.Internal.Data.Monoid | |||||
| Show a => Show (Last a) | |||||
| Eq a => Eq (Last a) | |||||
| Ord a => Ord (Last a) | |||||
| type Rep1 Last | |||||
Defined in GHC.Internal.Data.Monoid | |||||
| type Rep (Last a) | |||||
Defined in GHC.Internal.Data.Monoid | |||||
Instances
| NFData All | |||||
Defined in Control.DeepSeq | |||||
| Monoid All | |||||
| Semigroup All | |||||
| Bounded All | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| Generic All | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
| Read All | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| Show All | |||||
| Eq All | |||||
| Ord All | |||||
| type Rep All | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
newtype Alt (f :: k -> Type) (a :: k) #
Instances
| Generic1 (Alt f :: k -> Type) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
| MonadZip f => MonadZip (Alt f) | |||||
| Foldable1 f => Foldable1 (Alt f) | |||||
Defined in Data.Foldable1 Methods fold1 :: Semigroup m => Alt f m -> m foldMap1 :: Semigroup m => (a -> m) -> Alt f a -> m foldMap1' :: Semigroup m => (a -> m) -> Alt f a -> m toNonEmpty :: Alt f a -> NonEmpty a maximum :: Ord a => Alt f a -> a minimum :: Ord a => Alt f a -> a foldrMap1 :: (a -> b) -> (a -> b -> b) -> Alt f a -> b foldlMap1' :: (a -> b) -> (b -> a -> b) -> Alt f a -> b foldlMap1 :: (a -> b) -> (b -> a -> b) -> Alt f a -> b foldrMap1' :: (a -> b) -> (a -> b -> b) -> Alt f a -> b | |||||
| Contravariant f => Contravariant (Alt f) | |||||
| Alternative f => Alternative (Alt f) | |||||
| Applicative f => Applicative (Alt f) | |||||
| Functor f => Functor (Alt f) | |||||
| Monad f => Monad (Alt f) | |||||
| MonadPlus f => MonadPlus (Alt f) | |||||
| Foldable f => Foldable (Alt f) | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => Alt f m -> m foldMap :: Monoid m => (a -> m) -> Alt f a -> m foldMap' :: Monoid m => (a -> m) -> Alt f a -> m foldr :: (a -> b -> b) -> b -> Alt f a -> b # foldr' :: (a -> b -> b) -> b -> Alt f a -> b foldl :: (b -> a -> b) -> b -> Alt f a -> b # foldl' :: (b -> a -> b) -> b -> Alt f a -> b # foldr1 :: (a -> a -> a) -> Alt f a -> a # foldl1 :: (a -> a -> a) -> Alt f a -> a # elem :: Eq a => a -> Alt f a -> Bool # maximum :: Ord a => Alt f a -> a # minimum :: Ord a => Alt f a -> a # | |||||
| Traversable f => Traversable (Alt f) | |||||
| Alternative f => Monoid (Alt f a) | |||||
| Alternative f => Semigroup (Alt f a) | |||||
| Enum (f a) => Enum (Alt f a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| Generic (Alt f a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
| Num (f a) => Num (Alt f a) | |||||
| Read (f a) => Read (Alt f a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| Show (f a) => Show (Alt f a) | |||||
| Eq (f a) => Eq (Alt f a) | |||||
| Ord (f a) => Ord (Alt f a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| type Rep1 (Alt f :: k -> Type) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| type Rep (Alt f a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
Instances
| MonadZip Dual | |||||
| Foldable1 Dual | |||||
Defined in Data.Foldable1 Methods fold1 :: Semigroup m => Dual m -> m foldMap1 :: Semigroup m => (a -> m) -> Dual a -> m foldMap1' :: Semigroup m => (a -> m) -> Dual a -> m toNonEmpty :: Dual a -> NonEmpty a maximum :: Ord a => Dual a -> a minimum :: Ord a => Dual a -> a foldrMap1 :: (a -> b) -> (a -> b -> b) -> Dual a -> b foldlMap1' :: (a -> b) -> (b -> a -> b) -> Dual a -> b foldlMap1 :: (a -> b) -> (b -> a -> b) -> Dual a -> b foldrMap1' :: (a -> b) -> (a -> b -> b) -> Dual a -> b | |||||
| NFData1 Dual | |||||
Defined in Control.DeepSeq | |||||
| Applicative Dual | |||||
| Functor Dual | |||||
| Monad Dual | |||||
| Foldable Dual | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => Dual m -> m foldMap :: Monoid m => (a -> m) -> Dual a -> m foldMap' :: Monoid m => (a -> m) -> Dual a -> m foldr :: (a -> b -> b) -> b -> Dual a -> b # foldr' :: (a -> b -> b) -> b -> Dual a -> b foldl :: (b -> a -> b) -> b -> Dual a -> b # foldl' :: (b -> a -> b) -> b -> Dual a -> b # foldr1 :: (a -> a -> a) -> Dual a -> a # foldl1 :: (a -> a -> a) -> Dual a -> a # elem :: Eq a => a -> Dual a -> Bool # maximum :: Ord a => Dual a -> a # | |||||
| Traversable Dual | |||||
| Generic1 Dual | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
| NFData a => NFData (Dual a) | |||||
Defined in Control.DeepSeq | |||||
| Monoid a => Monoid (Dual a) | |||||
| Semigroup a => Semigroup (Dual a) | |||||
| Bounded a => Bounded (Dual a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| Generic (Dual a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
| Read a => Read (Dual a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| Show a => Show (Dual a) | |||||
| Eq a => Eq (Dual a) | |||||
| Ord a => Ord (Dual a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| type Rep1 Dual | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| type Rep (Dual a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
Instances
| Monoid (Endo a) | |||||
| Semigroup (Endo a) | |||||
| Generic (Endo a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
| type Rep (Endo a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
Constructors
| Product | |
Fields
| |
Instances
| MonadZip Product | |||||
| Foldable1 Product | |||||
Defined in Data.Foldable1 Methods fold1 :: Semigroup m => Product m -> m foldMap1 :: Semigroup m => (a -> m) -> Product a -> m foldMap1' :: Semigroup m => (a -> m) -> Product a -> m toNonEmpty :: Product a -> NonEmpty a maximum :: Ord a => Product a -> a minimum :: Ord a => Product a -> a foldrMap1 :: (a -> b) -> (a -> b -> b) -> Product a -> b foldlMap1' :: (a -> b) -> (b -> a -> b) -> Product a -> b foldlMap1 :: (a -> b) -> (b -> a -> b) -> Product a -> b foldrMap1' :: (a -> b) -> (a -> b -> b) -> Product a -> b | |||||
| NFData1 Product | |||||
Defined in Control.DeepSeq | |||||
| Applicative Product | |||||
| Functor Product | |||||
| Monad Product | |||||
| Foldable Product | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => Product m -> m foldMap :: Monoid m => (a -> m) -> Product a -> m foldMap' :: Monoid m => (a -> m) -> Product a -> m foldr :: (a -> b -> b) -> b -> Product a -> b # foldr' :: (a -> b -> b) -> b -> Product a -> b foldl :: (b -> a -> b) -> b -> Product a -> b # foldl' :: (b -> a -> b) -> b -> Product a -> b # foldr1 :: (a -> a -> a) -> Product a -> a # foldl1 :: (a -> a -> a) -> Product a -> a # elem :: Eq a => a -> Product a -> Bool # maximum :: Ord a => Product a -> a # minimum :: Ord a => Product a -> a # | |||||
| Traversable Product | |||||
| Generic1 Product | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
| NFData a => NFData (Product a) | |||||
Defined in Control.DeepSeq | |||||
| Num a => Monoid (Product a) | |||||
| Num a => Semigroup (Product a) | |||||
| Bounded a => Bounded (Product a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| Generic (Product a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
| Num a => Num (Product a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| Read a => Read (Product a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| Show a => Show (Product a) | |||||
| Eq a => Eq (Product a) | |||||
| Ord a => Ord (Product a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| type Rep1 Product | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| type Rep (Product a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
Instances
| MonadZip Sum | |||||
| Foldable1 Sum | |||||
Defined in Data.Foldable1 Methods fold1 :: Semigroup m => Sum m -> m foldMap1 :: Semigroup m => (a -> m) -> Sum a -> m foldMap1' :: Semigroup m => (a -> m) -> Sum a -> m toNonEmpty :: Sum a -> NonEmpty a maximum :: Ord a => Sum a -> a minimum :: Ord a => Sum a -> a foldrMap1 :: (a -> b) -> (a -> b -> b) -> Sum a -> b foldlMap1' :: (a -> b) -> (b -> a -> b) -> Sum a -> b foldlMap1 :: (a -> b) -> (b -> a -> b) -> Sum a -> b foldrMap1' :: (a -> b) -> (a -> b -> b) -> Sum a -> b | |||||
| NFData1 Sum | |||||
Defined in Control.DeepSeq | |||||
| Applicative Sum | |||||
| Functor Sum | |||||
| Monad Sum | |||||
| Foldable Sum | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => Sum m -> m foldMap :: Monoid m => (a -> m) -> Sum a -> m foldMap' :: Monoid m => (a -> m) -> Sum a -> m foldr :: (a -> b -> b) -> b -> Sum a -> b # foldr' :: (a -> b -> b) -> b -> Sum a -> b foldl :: (b -> a -> b) -> b -> Sum a -> b # foldl' :: (b -> a -> b) -> b -> Sum a -> b # foldr1 :: (a -> a -> a) -> Sum a -> a # foldl1 :: (a -> a -> a) -> Sum a -> a # elem :: Eq a => a -> Sum a -> Bool # maximum :: Ord a => Sum a -> a # | |||||
| Traversable Sum | |||||
| Generic1 Sum | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
| NFData a => NFData (Sum a) | |||||
Defined in Control.DeepSeq | |||||
| Num a => Monoid (Sum a) | |||||
| Num a => Semigroup (Sum a) | |||||
| Bounded a => Bounded (Sum a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| Generic (Sum a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal Associated Types
| |||||
| Num a => Num (Sum a) | |||||
| Read a => Read (Sum a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| Show a => Show (Sum a) | |||||
| Eq a => Eq (Sum a) | |||||
| Ord a => Ord (Sum a) | |||||
| type Rep1 Sum | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
| type Rep (Sum a) | |||||
Defined in GHC.Internal.Data.Semigroup.Internal | |||||
Instances
| Ord Pos | |
| Ord Number | |
| Ord ByteArray | |
| Ord ByteString | |
Defined in Data.ByteString.Internal.Type Methods compare :: ByteString -> ByteString -> Ordering # (<) :: ByteString -> ByteString -> Bool # (<=) :: ByteString -> ByteString -> Bool # (>) :: ByteString -> ByteString -> Bool # (>=) :: ByteString -> ByteString -> Bool # max :: ByteString -> ByteString -> ByteString # min :: ByteString -> ByteString -> ByteString # | |
| Ord ByteString | |
Defined in Data.ByteString.Lazy.Internal | |
| Ord ShortByteString | |
Defined in Data.ByteString.Short.Internal Methods compare :: ShortByteString -> ShortByteString -> Ordering # (<) :: ShortByteString -> ShortByteString -> Bool # (<=) :: ShortByteString -> ShortByteString -> Bool # (>) :: ShortByteString -> ShortByteString -> Bool # (>=) :: ShortByteString -> ShortByteString -> Bool # max :: ShortByteString -> ShortByteString -> ShortByteString # min :: ShortByteString -> ShortByteString -> ShortByteString # | |
| Ord IntSet | |
| Ord Options | |
| Ord Variant | |
| Ord Version | |
| Ord Parameters | |
Defined in Crypto.KDF.BCryptPBKDF | |
| Ord PrivateNumber | |
Defined in Crypto.PubKey.DH Methods compare :: PrivateNumber -> PrivateNumber -> Ordering # (<) :: PrivateNumber -> PrivateNumber -> Bool # (<=) :: PrivateNumber -> PrivateNumber -> Bool # (>) :: PrivateNumber -> PrivateNumber -> Bool # (>=) :: PrivateNumber -> PrivateNumber -> Bool # | |
| Ord PublicNumber | |
Defined in Crypto.PubKey.DH | |
| Ord CurveName | |
| Ord Section Source # | |
| Ord BigNat | |
| Ord Extension | |
| Ord Void | |
| Ord ByteOrder | |
| Ord All | |
| Ord Any | |
| Ord SomeTypeRep | |
Defined in GHC.Internal.Data.Typeable.Internal | |
| 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 Fingerprint | |
Defined in GHC.Internal.Fingerprint.Type | |
| 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 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 Date | |
| Ord DateTime | |
Defined in Time.Types | |
| Ord Elapsed | |
| Ord ElapsedP | |
Defined in Time.Types | |
| Ord Hours | |
| Ord Minutes | |
| Ord Month | |
| Ord NanoSeconds | |
Defined in Time.Types | |
| Ord Seconds | |
| Ord TimeOfDay | |
| Ord TimezoneOffset | |
Defined in Time.Types Methods compare :: TimezoneOffset -> TimezoneOffset -> Ordering # (<) :: TimezoneOffset -> TimezoneOffset -> Bool # (<=) :: TimezoneOffset -> TimezoneOffset -> Bool # (>) :: TimezoneOffset -> TimezoneOffset -> Bool # (>=) :: TimezoneOffset -> TimezoneOffset -> Bool # | |
| Ord WeekDay | |
| Ord IP | |
| Ord IPv4 | |
| Ord IPv6 | |
| Ord IPRange | |
| Ord Family | |
| Ord PortNumber | |
Defined in Network.Socket.Types | |
| Ord SockAddr | |
Defined in Network.Socket.Types | |
| Ord SocketType | |
Defined in Network.Socket.Types | |
| Ord OsChar | |
| Ord OsString | |
Defined in System.OsString.Internal.Types | |
| Ord PosixChar | |
| Ord PosixString | |
Defined in System.OsString.Internal.Types | |
| Ord WindowsChar | |
Defined in System.OsString.Internal.Types | |
| Ord WindowsString | |
Defined in System.OsString.Internal.Types Methods compare :: WindowsString -> WindowsString -> Ordering # (<) :: WindowsString -> WindowsString -> Bool # (<=) :: WindowsString -> WindowsString -> Bool # (>) :: WindowsString -> WindowsString -> Bool # (>=) :: WindowsString -> WindowsString -> Bool # | |
| Ord AnnLookup | |
| Ord AnnTarget | |
| Ord Bang | |
| Ord BndrVis | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Body | |
| Ord Bytes | |
| Ord Callconv | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Clause | |
| Ord Con | |
| Ord Dec | |
| Ord DecidedStrictness | |
Defined in Language.Haskell.TH.Syntax 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 DerivClause | |
Defined in Language.Haskell.TH.Syntax | |
| Ord DerivStrategy | |
Defined in Language.Haskell.TH.Syntax Methods compare :: DerivStrategy -> DerivStrategy -> Ordering # (<) :: DerivStrategy -> DerivStrategy -> Bool # (<=) :: DerivStrategy -> DerivStrategy -> Bool # (>) :: DerivStrategy -> DerivStrategy -> Bool # (>=) :: DerivStrategy -> DerivStrategy -> Bool # | |
| Ord DocLoc | |
| Ord Exp | |
| Ord FamilyResultSig | |
Defined in Language.Haskell.TH.Syntax Methods compare :: FamilyResultSig -> FamilyResultSig -> Ordering # (<) :: FamilyResultSig -> FamilyResultSig -> Bool # (<=) :: FamilyResultSig -> FamilyResultSig -> Bool # (>) :: FamilyResultSig -> FamilyResultSig -> Bool # (>=) :: FamilyResultSig -> FamilyResultSig -> Bool # max :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig # min :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig # | |
| Ord Fixity | |
| Ord FixityDirection | |
Defined in Language.Haskell.TH.Syntax Methods compare :: FixityDirection -> FixityDirection -> Ordering # (<) :: FixityDirection -> FixityDirection -> Bool # (<=) :: FixityDirection -> FixityDirection -> Bool # (>) :: FixityDirection -> FixityDirection -> Bool # (>=) :: FixityDirection -> FixityDirection -> Bool # max :: FixityDirection -> FixityDirection -> FixityDirection # min :: FixityDirection -> FixityDirection -> FixityDirection # | |
| Ord Foreign | |
Defined in Language.Haskell.TH.Syntax | |
| Ord FunDep | |
| Ord Guard | |
| Ord Info | |
| Ord InjectivityAnn | |
Defined in Language.Haskell.TH.Syntax Methods compare :: InjectivityAnn -> InjectivityAnn -> Ordering # (<) :: InjectivityAnn -> InjectivityAnn -> Bool # (<=) :: InjectivityAnn -> InjectivityAnn -> Bool # (>) :: InjectivityAnn -> InjectivityAnn -> Bool # (>=) :: InjectivityAnn -> InjectivityAnn -> Bool # | |
| Ord Inline | |
| Ord Lit | |
| Ord Loc | |
| Ord Match | |
| Ord ModName | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Module | |
| Ord ModuleInfo | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Name | |
| Ord NameFlavour | |
Defined in Language.Haskell.TH.Syntax | |
| Ord NameSpace | |
| Ord NamespaceSpecifier | |
Defined in Language.Haskell.TH.Syntax Methods compare :: NamespaceSpecifier -> NamespaceSpecifier -> Ordering # (<) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool # (<=) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool # (>) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool # (>=) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool # max :: NamespaceSpecifier -> NamespaceSpecifier -> NamespaceSpecifier # min :: NamespaceSpecifier -> NamespaceSpecifier -> NamespaceSpecifier # | |
| Ord OccName | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Overlap | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Pat | |
| Ord PatSynArgs | |
Defined in Language.Haskell.TH.Syntax | |
| Ord PatSynDir | |
| Ord Phases | |
| Ord PkgName | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Pragma | |
| Ord Range | |
| Ord Role | |
| Ord RuleBndr | |
Defined in Language.Haskell.TH.Syntax | |
| Ord RuleMatch | |
| Ord Safety | |
| Ord SourceStrictness | |
Defined in Language.Haskell.TH.Syntax 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 Language.Haskell.TH.Syntax 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 Specificity | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Stmt | |
| Ord TyLit | |
| Ord TySynEqn | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Type | |
| Ord TypeFamilyHead | |
Defined in Language.Haskell.TH.Syntax Methods compare :: TypeFamilyHead -> TypeFamilyHead -> Ordering # (<) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (<=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (>) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (>=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # | |
| Ord Text | |
| Ord Text | |
| Ord LocalTime | |
Defined in Data.Time.LocalTime.Internal.LocalTime | |
| Ord Integer | |
| Ord Natural | |
| Ord () | |
| Ord Bool | |
| Ord Char | |
| Ord Double | |
| Ord Float | |
| Ord Int | |
| Ord Word | |
| Ord (Async a) | |
Defined in Control.Concurrent.Async.Internal | |
| 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 s => Ord (CI s) | |
| Ord a => Ord (IntMap a) | |
Defined in Data.IntMap.Internal | |
| Ord a => Ord (Seq a) | |
| Ord a => Ord (ViewL a) | |
Defined in Data.Sequence.Internal | |
| Ord a => Ord (ViewR a) | |
Defined in Data.Sequence.Internal | |
| Ord a => Ord (Intersection a) | |
Defined in Data.Set.Internal Methods compare :: Intersection a -> Intersection a -> Ordering # (<) :: Intersection a -> Intersection a -> Bool # (<=) :: Intersection a -> Intersection a -> Bool # (>) :: Intersection a -> Intersection a -> Bool # (>=) :: Intersection a -> Intersection a -> Bool # | |
| Ord a => Ord (Set a) | |
| Ord a => Ord (Tree a) | |
| 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 (Down 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) | |
| Integral a => Ord (Ratio a) | |
| Ord a => Ord (Hashed a) | |
Defined in Data.Hashable.Class | |
| Ord (ElapsedSince epoch) | |
Defined in Data.Hourglass.Epoch Methods compare :: ElapsedSince epoch -> ElapsedSince epoch -> Ordering # (<) :: ElapsedSince epoch -> ElapsedSince epoch -> Bool # (<=) :: ElapsedSince epoch -> ElapsedSince epoch -> Bool # (>) :: ElapsedSince epoch -> ElapsedSince epoch -> Bool # (>=) :: ElapsedSince epoch -> ElapsedSince epoch -> Bool # max :: ElapsedSince epoch -> ElapsedSince epoch -> ElapsedSince epoch # min :: ElapsedSince epoch -> ElapsedSince epoch -> ElapsedSince epoch # | |
| Ord (ElapsedSinceP epoch) | |
Defined in Data.Hourglass.Epoch Methods compare :: ElapsedSinceP epoch -> ElapsedSinceP epoch -> Ordering # (<) :: ElapsedSinceP epoch -> ElapsedSinceP epoch -> Bool # (<=) :: ElapsedSinceP epoch -> ElapsedSinceP epoch -> Bool # (>) :: ElapsedSinceP epoch -> ElapsedSinceP epoch -> Bool # (>=) :: ElapsedSinceP epoch -> ElapsedSinceP epoch -> Bool # max :: ElapsedSinceP epoch -> ElapsedSinceP epoch -> ElapsedSinceP epoch # min :: ElapsedSinceP epoch -> ElapsedSinceP epoch -> ElapsedSinceP epoch # | |
| Ord a => Ord (AddrRange a) | |
Defined in Data.IP.Range | |
| Ord flag => Ord (TyVarBndr flag) | |
Defined in Language.Haskell.TH.Syntax Methods compare :: TyVarBndr flag -> TyVarBndr flag -> Ordering # (<) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (<=) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (>) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (>=) :: TyVarBndr flag -> TyVarBndr flag -> Bool # | |
| Ord a => Ord (Maybe a) | |
| Ord a => Ord (Solo a) | |
| Ord a => Ord [a] | |
| (Ix ix, Ord e, IArray UArray e) => Ord (UArray ix e) | |
Defined in Data.Array.Base | |
| Ord (Fixed a) | |
| Ord a => Ord (Arg a b) | |
| (Ord k, Ord v) => Ord (Map k v) | |
| (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) | |
| (Ord1 m, Ord a) => Ord (MaybeT m a) | |
Defined in Control.Monad.Trans.Maybe | |
| (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 | |
| Ord (a :~: b) | |
Defined in GHC.Internal.Data.Type.Equality | |
| (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 e, Ord1 m, Ord a) => Ord (ExceptT e m a) | |
Defined in Control.Monad.Trans.Except Methods compare :: ExceptT e m a -> ExceptT e m a -> Ordering # (<) :: ExceptT e m a -> ExceptT e m a -> Bool # (<=) :: ExceptT e m a -> ExceptT e m a -> Bool # (>) :: ExceptT e m a -> ExceptT e m a -> Bool # (>=) :: ExceptT e m a -> ExceptT e m a -> Bool # | |
| (Ord1 f, Ord a) => Ord (IdentityT f a) | |
Defined in Control.Monad.Trans.Identity Methods compare :: IdentityT f a -> IdentityT f a -> Ordering # (<) :: IdentityT f a -> IdentityT f a -> Bool # (<=) :: IdentityT f a -> IdentityT f a -> Bool # (>) :: IdentityT f a -> IdentityT f a -> Bool # (>=) :: IdentityT f a -> IdentityT f a -> Bool # | |
| (Ord w, Ord1 m, Ord a) => Ord (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Lazy Methods compare :: WriterT w m a -> WriterT w m a -> Ordering # (<) :: WriterT w m a -> WriterT w m a -> Bool # (<=) :: WriterT w m a -> WriterT w m a -> Bool # (>) :: WriterT w m a -> WriterT w m a -> Bool # (>=) :: WriterT w m a -> WriterT w m a -> Bool # | |
| (Ord w, Ord1 m, Ord a) => Ord (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Strict Methods compare :: WriterT w m a -> WriterT w m a -> Ordering # (<) :: WriterT w m a -> WriterT w m a -> Bool # (<=) :: WriterT w m a -> WriterT w m a -> Bool # (>) :: WriterT w m a -> WriterT w m a -> Bool # (>=) :: WriterT w m a -> WriterT w m a -> Bool # | |
| (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 (a :~~: b) | |
Defined in GHC.Internal.Data.Type.Equality | |
| (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
| NFData Ordering | |||||
Defined in Control.DeepSeq | |||||
| Monoid Ordering | |||||
| Semigroup Ordering | |||||
| Bounded Ordering | |||||
Defined in GHC.Internal.Enum | |||||
| Enum Ordering | |||||
Defined in GHC.Internal.Enum | |||||
| Generic Ordering | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Ix Ordering | |||||
Defined in GHC.Internal.Ix | |||||
| Read Ordering | |||||
Defined in GHC.Internal.Read | |||||
| Show Ordering | |||||
| Eq Ordering | |||||
| Ord Ordering | |||||
Defined in GHC.Classes | |||||
| Hashable Ordering | |||||
Defined in Data.Hashable.Class | |||||
| type Rep Ordering | |||||
Defined in GHC.Internal.Generics type Rep Ordering = D1 ('MetaData "Ordering" "GHC.Types" "ghc-prim" 'False) (C1 ('MetaCons "LT" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "EQ" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "GT" 'PrefixI 'False) (U1 :: Type -> Type))) | |||||
Instances
| MonadZip Down | |||||
| Foldable1 Down | |||||
Defined in Data.Foldable1 Methods fold1 :: Semigroup m => Down m -> m foldMap1 :: Semigroup m => (a -> m) -> Down a -> m foldMap1' :: Semigroup m => (a -> m) -> Down a -> m toNonEmpty :: Down a -> NonEmpty a maximum :: Ord a => Down a -> a minimum :: Ord a => Down a -> a foldrMap1 :: (a -> b) -> (a -> b -> b) -> Down a -> b foldlMap1' :: (a -> b) -> (b -> a -> b) -> Down a -> b foldlMap1 :: (a -> b) -> (b -> a -> b) -> Down a -> b foldrMap1' :: (a -> b) -> (a -> b -> b) -> Down a -> b | |||||
| Eq1 Down | |||||
Defined in Data.Functor.Classes | |||||
| Ord1 Down | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Down a -> Down b -> Ordering | |||||
| Read1 Down | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Down a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Down a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Down a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Down a] | |||||
| Show1 Down | |||||
Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Down a -> ShowS liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Down a] -> ShowS | |||||
| NFData1 Down | |||||
Defined in Control.DeepSeq | |||||
| Applicative Down | |||||
| Functor Down | |||||
| Monad Down | |||||
| Foldable Down | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => Down m -> m foldMap :: Monoid m => (a -> m) -> Down a -> m foldMap' :: Monoid m => (a -> m) -> Down a -> m foldr :: (a -> b -> b) -> b -> Down a -> b # foldr' :: (a -> b -> b) -> b -> Down a -> b foldl :: (b -> a -> b) -> b -> Down a -> b # foldl' :: (b -> a -> b) -> b -> Down a -> b # foldr1 :: (a -> a -> a) -> Down a -> a # foldl1 :: (a -> a -> a) -> Down a -> a # elem :: Eq a => a -> Down a -> Bool # maximum :: Ord a => Down a -> a # | |||||
| Traversable Down | |||||
| Generic1 Down | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| NFData a => NFData (Down a) | |||||
Defined in Control.DeepSeq | |||||
| Monoid a => Monoid (Down a) | |||||
| Semigroup a => Semigroup (Down a) | |||||
| Bits a => Bits (Down a) | |||||
Defined in GHC.Internal.Data.Ord Methods (.&.) :: Down a -> Down a -> Down a # (.|.) :: Down a -> Down a -> Down a # xor :: Down a -> Down a -> Down a # complement :: Down a -> Down a # shift :: Down a -> Int -> Down a # rotate :: Down a -> Int -> Down a # setBit :: Down a -> Int -> Down a # clearBit :: Down a -> Int -> Down a # complementBit :: Down a -> Int -> Down a # testBit :: Down a -> Int -> Bool # bitSizeMaybe :: Down a -> Maybe Int # shiftL :: Down a -> Int -> Down a # unsafeShiftL :: Down a -> Int -> Down a # shiftR :: Down a -> Int -> Down a # unsafeShiftR :: Down a -> Int -> Down a # rotateL :: Down a -> Int -> Down a # | |||||
| FiniteBits a => FiniteBits (Down a) | |||||
Defined in GHC.Internal.Data.Ord Methods finiteBitSize :: Down a -> Int # countLeadingZeros :: Down a -> Int # countTrailingZeros :: Down a -> Int # | |||||
| Bounded a => Bounded (Down a) | |||||
Defined in GHC.Internal.Data.Ord | |||||
| (Enum a, Bounded a, Eq a) => Enum (Down a) | |||||
Defined in GHC.Internal.Data.Ord | |||||
| Floating a => Floating (Down a) | |||||
| RealFloat a => RealFloat (Down a) | |||||
Defined in GHC.Internal.Data.Ord Methods floatRadix :: Down a -> Integer floatDigits :: Down a -> Int floatRange :: Down a -> (Int, Int) decodeFloat :: Down a -> (Integer, Int) encodeFloat :: Integer -> Int -> Down a significand :: Down a -> Down a scaleFloat :: Int -> Down a -> Down a isInfinite :: Down a -> Bool isDenormalized :: Down a -> Bool isNegativeZero :: Down a -> Bool | |||||
| Storable a => Storable (Down a) | |||||
Defined in GHC.Internal.Data.Ord Methods peekElemOff :: Ptr (Down a) -> Int -> IO (Down a) pokeElemOff :: Ptr (Down a) -> Int -> Down a -> IO () peekByteOff :: Ptr b -> Int -> IO (Down a) pokeByteOff :: Ptr b -> Int -> Down a -> IO () | |||||
| Generic (Down a) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Ix a => Ix (Down a) | |||||
| Num a => Num (Down a) | |||||
| Read a => Read (Down a) | |||||
Defined in GHC.Internal.Data.Ord | |||||
| Fractional a => Fractional (Down a) | |||||
Defined in GHC.Internal.Data.Ord | |||||
| Real a => Real (Down a) | |||||
Defined in GHC.Internal.Data.Ord Methods toRational :: Down a -> Rational | |||||
| RealFrac a => RealFrac (Down a) | |||||
| Show a => Show (Down a) | |||||
| Eq a => Eq (Down a) | |||||
| Ord a => Ord (Down a) | |||||
| type Rep1 Down | |||||
Defined in GHC.Internal.Generics | |||||
| type Rep (Down a) | |||||
Defined in GHC.Internal.Generics | |||||
decT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => Either ((a :~: b) -> Void) (a :~: b) #
gcast1 :: forall {k1} {k2} c (t :: k2 -> k1) (t' :: k2 -> k1) (a :: k2). (Typeable t, Typeable t') => c (t a) -> Maybe (c (t' a)) #
gcast2 :: forall {k1} {k2} {k3} c (t :: k2 -> k3 -> k1) (t' :: k2 -> k3 -> k1) (a :: k2) (b :: k3). (Typeable t, Typeable t') => c (t a b) -> Maybe (c (t' a b)) #
hdecT :: forall {k1} {k2} (a :: k1) (b :: k2). (Typeable a, Typeable b) => Either ((a :~~: b) -> Void) (a :~~: b) #
rnfTypeRep :: TypeRep -> () #
showsTypeRep :: TypeRep -> ShowS #
splitTyConApp :: TypeRep -> (TyCon, [TypeRep]) #
typeRepArgs :: TypeRep -> [TypeRep] #
typeRepFingerprint :: TypeRep -> Fingerprint #
typeRepTyCon :: TypeRep -> TyCon #
trLiftedRep :: TypeRep LiftedRep #
tyConFingerprint :: TyCon -> Fingerprint #
tyConModule :: TyCon -> String #
tyConPackage :: TyCon -> String #
Constructors
| Proxy |
Instances
| Generic1 (Proxy :: k -> Type) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| MonadZip (Proxy :: Type -> Type) | |||||
| Eq1 (Proxy :: Type -> Type) | |||||
Defined in Data.Functor.Classes | |||||
| Ord1 (Proxy :: Type -> Type) | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Proxy a -> Proxy b -> Ordering | |||||
| Read1 (Proxy :: Type -> Type) | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Proxy a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Proxy a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Proxy a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Proxy a] | |||||
| Show1 (Proxy :: Type -> Type) | |||||
Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Proxy a -> ShowS liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Proxy a] -> ShowS | |||||
| Contravariant (Proxy :: Type -> Type) | |||||
| NFData1 (Proxy :: Type -> Type) | |||||
Defined in Control.DeepSeq | |||||
| Alternative (Proxy :: Type -> Type) | |||||
| Applicative (Proxy :: Type -> Type) | |||||
| Functor (Proxy :: Type -> Type) | |||||
| Monad (Proxy :: Type -> Type) | |||||
| MonadPlus (Proxy :: Type -> Type) | |||||
| Foldable (Proxy :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => Proxy m -> m foldMap :: Monoid m => (a -> m) -> Proxy a -> m foldMap' :: Monoid m => (a -> m) -> Proxy a -> m foldr :: (a -> b -> b) -> b -> Proxy a -> b # foldr' :: (a -> b -> b) -> b -> Proxy a -> b foldl :: (b -> a -> b) -> b -> Proxy a -> b # foldl' :: (b -> a -> b) -> b -> Proxy a -> b # foldr1 :: (a -> a -> a) -> Proxy a -> a # foldl1 :: (a -> a -> a) -> Proxy a -> a # elem :: Eq a => a -> Proxy a -> Bool # maximum :: Ord a => Proxy a -> a # minimum :: Ord a => Proxy a -> a # | |||||
| Traversable (Proxy :: Type -> Type) | |||||
| Hashable1 (Proxy :: Type -> Type) | |||||
Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Proxy a -> Int | |||||
| NFData (Proxy a) | |||||
Defined in Control.DeepSeq | |||||
| Monoid (Proxy s) | |||||
| Semigroup (Proxy s) | |||||
| Bounded (Proxy t) | |||||
Defined in GHC.Internal.Data.Proxy | |||||
| Enum (Proxy s) | |||||
Defined in GHC.Internal.Data.Proxy | |||||
| Generic (Proxy t) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Ix (Proxy s) | |||||
Defined in GHC.Internal.Data.Proxy | |||||
| Read (Proxy t) | |||||
Defined in GHC.Internal.Data.Proxy | |||||
| Show (Proxy s) | |||||
| Eq (Proxy s) | |||||
| Ord (Proxy s) | |||||
Defined in GHC.Internal.Data.Proxy | |||||
| Hashable (Proxy a) | |||||
Defined in Data.Hashable.Class | |||||
| type Rep1 (Proxy :: k -> Type) | |||||
Defined in GHC.Internal.Generics type Rep1 (Proxy :: k -> Type) = D1 ('MetaData "Proxy" "GHC.Internal.Data.Proxy" "ghc-internal" 'False) (C1 ('MetaCons "Proxy" 'PrefixI 'False) (U1 :: k -> Type)) | |||||
| type Rep (Proxy t) | |||||
Defined in GHC.Internal.Generics type Rep (Proxy t) = D1 ('MetaData "Proxy" "GHC.Internal.Data.Proxy" "ghc-internal" 'False) (C1 ('MetaCons "Proxy" 'PrefixI 'False) (U1 :: Type -> Type)) | |||||
data (a :: k) :~: (b :: k) where #
Instances
| TestEquality ((:~:) a :: k -> Type) | |
Defined in GHC.Internal.Data.Type.Equality Methods testEquality :: forall (a0 :: k) (b :: k). (a :~: a0) -> (a :~: b) -> Maybe (a0 :~: b) | |
| NFData2 ((:~:) :: Type -> Type -> Type) | |
Defined in Control.DeepSeq | |
| NFData1 ((:~:) a) | |
Defined in Control.DeepSeq | |
| NFData (a :~: b) | |
Defined in Control.DeepSeq | |
| a ~ b => Bounded (a :~: b) | |
Defined in GHC.Internal.Data.Type.Equality | |
| a ~ b => Enum (a :~: b) | |
Defined in GHC.Internal.Data.Type.Equality | |
| a ~ b => Read (a :~: b) | |
Defined in GHC.Internal.Data.Type.Equality | |
| Show (a :~: b) | |
| Eq (a :~: b) | |
| Ord (a :~: b) | |
Defined in GHC.Internal.Data.Type.Equality | |
data (a :: k1) :~~: (b :: k2) where #
Instances
| TestEquality ((:~~:) a :: k -> Type) | |
Defined in GHC.Internal.Data.Type.Equality Methods testEquality :: forall (a0 :: k) (b :: k). (a :~~: a0) -> (a :~~: b) -> Maybe (a0 :~: b) | |
| NFData2 ((:~~:) :: Type -> Type -> Type) | |
Defined in Control.DeepSeq | |
| NFData1 ((:~~:) a :: Type -> Type) | |
Defined in Control.DeepSeq | |
| NFData (a :~~: b) | |
Defined in Control.DeepSeq | |
| a ~~ b => Bounded (a :~~: b) | |
Defined in GHC.Internal.Data.Type.Equality | |
| a ~~ b => Enum (a :~~: b) | |
Defined in GHC.Internal.Data.Type.Equality | |
| a ~~ b => Read (a :~~: b) | |
Defined in GHC.Internal.Data.Type.Equality | |
| Show (a :~~: b) | |
| Eq (a :~~: b) | |
| Ord (a :~~: b) | |
Defined in GHC.Internal.Data.Type.Equality | |
Instances
| PrintfArg Word | |||||
Defined in Text.Printf | |||||
| NFData Word | |||||
Defined in Control.DeepSeq | |||||
| Bits Word | |||||
Defined in GHC.Internal.Bits Methods (.&.) :: Word -> Word -> Word # (.|.) :: Word -> Word -> Word # complement :: Word -> Word # shift :: Word -> Int -> Word # rotate :: Word -> Int -> Word # setBit :: Word -> Int -> Word # clearBit :: Word -> Int -> Word # complementBit :: Word -> Int -> Word # testBit :: Word -> Int -> Bool # bitSizeMaybe :: Word -> Maybe Int # shiftL :: Word -> Int -> Word # unsafeShiftL :: Word -> Int -> Word # shiftR :: Word -> Int -> Word # unsafeShiftR :: Word -> Int -> Word # rotateL :: Word -> Int -> Word # | |||||
| FiniteBits Word | |||||
Defined in GHC.Internal.Bits Methods finiteBitSize :: Word -> Int # countLeadingZeros :: Word -> Int # countTrailingZeros :: Word -> Int # | |||||
| Bounded Word | |||||
Defined in GHC.Internal.Enum | |||||
| Enum Word | |||||
| Ix Word | |||||
| 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 | |||||
| Hashable Word | |||||
Defined in Data.Hashable.Class | |||||
| IArray UArray Word | |||||
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word -> (i, i) numElements :: Ix i => UArray i Word -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word)] -> UArray i Word unsafeAt :: Ix i => UArray i Word -> Int -> Word unsafeReplace :: Ix i => UArray i Word -> [(Int, Word)] -> UArray i Word unsafeAccum :: Ix i => (Word -> e' -> Word) -> UArray i Word -> [(Int, e')] -> UArray i Word unsafeAccumArray :: Ix i => (Word -> e' -> Word) -> Word -> (i, i) -> [(Int, e')] -> UArray i Word | |||||
| Lift Word | |||||
| MArray IOUArray Word IO | |||||
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Word -> IO (i, i) getNumElements :: Ix i => IOUArray i Word -> IO Int newArray :: Ix i => (i, i) -> Word -> IO (IOUArray i Word) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Word) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Word) unsafeRead :: Ix i => IOUArray i Word -> Int -> IO Word unsafeWrite :: Ix i => IOUArray i Word -> Int -> Word -> IO () | |||||
| 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 # | |||||
| 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) | |||||
| MArray (STUArray s) Word (ST s) | |||||
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word -> ST s (i, i) getNumElements :: Ix i => STUArray s i Word -> ST s Int newArray :: Ix i => (i, i) -> Word -> ST s (STUArray s i Word) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word) unsafeRead :: Ix i => STUArray s i Word -> Int -> ST s Word unsafeWrite :: Ix i => STUArray s i Word -> Int -> Word -> ST s () | |||||
| Functor (URec Word :: Type -> Type) | |||||
| Generic (URec Word p) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Show (URec Word p) | |||||
| Eq (URec Word p) | |||||
| Ord (URec Word p) | |||||
Defined in GHC.Internal.Generics | |||||
| 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) | |||||
Defined in GHC.Internal.Generics | |||||
Instances
| PrintfArg Word64 | |
Defined in Text.Printf | |
| NFData Word64 | |
Defined in Control.DeepSeq | |
| 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 # | |
| Bounded Word64 | |
Defined in GHC.Internal.Word | |
| Enum Word64 | |
Defined in GHC.Internal.Word | |
| 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 | |
| Hashable Word64 | |
Defined in Data.Hashable.Class | |
| IArray UArray Word64 | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word64 -> (i, i) numElements :: Ix i => UArray i Word64 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word64)] -> UArray i Word64 unsafeAt :: Ix i => UArray i Word64 -> Int -> Word64 unsafeReplace :: Ix i => UArray i Word64 -> [(Int, Word64)] -> UArray i Word64 unsafeAccum :: Ix i => (Word64 -> e' -> Word64) -> UArray i Word64 -> [(Int, e')] -> UArray i Word64 unsafeAccumArray :: Ix i => (Word64 -> e' -> Word64) -> Word64 -> (i, i) -> [(Int, e')] -> UArray i Word64 | |
| Lift Word64 | |
| MArray IOUArray Word64 IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Word64 -> IO (i, i) getNumElements :: Ix i => IOUArray i Word64 -> IO Int newArray :: Ix i => (i, i) -> Word64 -> IO (IOUArray i Word64) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Word64) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Word64) unsafeRead :: Ix i => IOUArray i Word64 -> Int -> IO Word64 unsafeWrite :: Ix i => IOUArray i Word64 -> Int -> Word64 -> IO () | |
| MArray (STUArray s) Word64 (ST s) | |
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word64 -> ST s (i, i) getNumElements :: Ix i => STUArray s i Word64 -> ST s Int newArray :: Ix i => (i, i) -> Word64 -> ST s (STUArray s i Word64) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word64) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word64) unsafeRead :: Ix i => STUArray s i Word64 -> Int -> ST s Word64 unsafeWrite :: Ix i => STUArray s i Word64 -> Int -> Word64 -> ST s () | |
Instances
| PrintfArg Word32 | |
Defined in Text.Printf | |
| NFData Word32 | |
Defined in Control.DeepSeq | |
| 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 # | |
| Bounded Word32 | |
Defined in GHC.Internal.Word | |
| Enum Word32 | |
Defined in GHC.Internal.Word | |
| 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 | |
| Hashable Word32 | |
Defined in Data.Hashable.Class | |
| IArray UArray Word32 | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word32 -> (i, i) numElements :: Ix i => UArray i Word32 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word32)] -> UArray i Word32 unsafeAt :: Ix i => UArray i Word32 -> Int -> Word32 unsafeReplace :: Ix i => UArray i Word32 -> [(Int, Word32)] -> UArray i Word32 unsafeAccum :: Ix i => (Word32 -> e' -> Word32) -> UArray i Word32 -> [(Int, e')] -> UArray i Word32 unsafeAccumArray :: Ix i => (Word32 -> e' -> Word32) -> Word32 -> (i, i) -> [(Int, e')] -> UArray i Word32 | |
| Lift Word32 | |
| MArray IOUArray Word32 IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Word32 -> IO (i, i) getNumElements :: Ix i => IOUArray i Word32 -> IO Int newArray :: Ix i => (i, i) -> Word32 -> IO (IOUArray i Word32) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Word32) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Word32) unsafeRead :: Ix i => IOUArray i Word32 -> Int -> IO Word32 unsafeWrite :: Ix i => IOUArray i Word32 -> Int -> Word32 -> IO () | |
| MArray (STUArray s) Word32 (ST s) | |
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word32 -> ST s (i, i) getNumElements :: Ix i => STUArray s i Word32 -> ST s Int newArray :: Ix i => (i, i) -> Word32 -> ST s (STUArray s i Word32) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word32) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word32) unsafeRead :: Ix i => STUArray s i Word32 -> Int -> ST s Word32 unsafeWrite :: Ix i => STUArray s i Word32 -> Int -> Word32 -> ST s () | |
Instances
| PrintfArg Word16 | |
Defined in Text.Printf | |
| NFData Word16 | |
Defined in Control.DeepSeq | |
| 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 # | |
| Bounded Word16 | |
Defined in GHC.Internal.Word | |
| Enum Word16 | |
Defined in GHC.Internal.Word | |
| 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 | |
| Hashable Word16 | |
Defined in Data.Hashable.Class | |
| IArray UArray Word16 | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word16 -> (i, i) numElements :: Ix i => UArray i Word16 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word16)] -> UArray i Word16 unsafeAt :: Ix i => UArray i Word16 -> Int -> Word16 unsafeReplace :: Ix i => UArray i Word16 -> [(Int, Word16)] -> UArray i Word16 unsafeAccum :: Ix i => (Word16 -> e' -> Word16) -> UArray i Word16 -> [(Int, e')] -> UArray i Word16 unsafeAccumArray :: Ix i => (Word16 -> e' -> Word16) -> Word16 -> (i, i) -> [(Int, e')] -> UArray i Word16 | |
| Lift Word16 | |
| MArray IOUArray Word16 IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Word16 -> IO (i, i) getNumElements :: Ix i => IOUArray i Word16 -> IO Int newArray :: Ix i => (i, i) -> Word16 -> IO (IOUArray i Word16) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Word16) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Word16) unsafeRead :: Ix i => IOUArray i Word16 -> Int -> IO Word16 unsafeWrite :: Ix i => IOUArray i Word16 -> Int -> Word16 -> IO () | |
| MArray (STUArray s) Word16 (ST s) | |
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word16 -> ST s (i, i) getNumElements :: Ix i => STUArray s i Word16 -> ST s Int newArray :: Ix i => (i, i) -> Word16 -> ST s (STUArray s i Word16) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word16) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word16) unsafeRead :: Ix i => STUArray s i Word16 -> Int -> ST s Word16 unsafeWrite :: Ix i => STUArray s i Word16 -> Int -> Word16 -> ST s () | |
Instances
| PrintfArg Word8 | |
Defined in Text.Printf | |
| NFData Word8 | |
Defined in Control.DeepSeq | |
| 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 # | |
| Bounded Word8 | |
Defined in GHC.Internal.Word | |
| Enum Word8 | |
| 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 | |
| Hashable Word8 | |
Defined in Data.Hashable.Class | |
| IArray UArray Word8 | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word8 -> (i, i) numElements :: Ix i => UArray i Word8 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word8)] -> UArray i Word8 unsafeAt :: Ix i => UArray i Word8 -> Int -> Word8 unsafeReplace :: Ix i => UArray i Word8 -> [(Int, Word8)] -> UArray i Word8 unsafeAccum :: Ix i => (Word8 -> e' -> Word8) -> UArray i Word8 -> [(Int, e')] -> UArray i Word8 unsafeAccumArray :: Ix i => (Word8 -> e' -> Word8) -> Word8 -> (i, i) -> [(Int, e')] -> UArray i Word8 | |
| Lift Word8 | |
| MArray IOUArray Word8 IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Word8 -> IO (i, i) getNumElements :: Ix i => IOUArray i Word8 -> IO Int newArray :: Ix i => (i, i) -> Word8 -> IO (IOUArray i Word8) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Word8) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Word8) unsafeRead :: Ix i => IOUArray i Word8 -> Int -> IO Word8 unsafeWrite :: Ix i => IOUArray i Word8 -> Int -> Word8 -> IO () | |
| MArray (STUArray s) Word8 (ST s) | |
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word8 -> ST s (i, i) getNumElements :: Ix i => STUArray s i Word8 -> ST s Int newArray :: Ix i => (i, i) -> Word8 -> ST s (STUArray s i Word8) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word8) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word8) unsafeRead :: Ix i => STUArray s i Word8 -> Int -> ST s Word8 unsafeWrite :: Ix i => STUArray s i Word8 -> Int -> Word8 -> ST s () | |
bitReverse16 :: Word16 -> Word16 #
bitReverse32 :: Word32 -> Word32 #
bitReverse64 :: Word64 -> Word64 #
bitReverse8 :: Word8 -> Word8 #
byteSwap16 :: Word16 -> Word16 #
byteSwap32 :: Word32 -> Word32 #
byteSwap64 :: Word64 -> Word64 #
class Fractional a => Floating a where #
Minimal complete definition
pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh
Methods
Instances
| Floating Double | |
| Floating Float | |
Defined in GHC.Internal.Float | |
| RealFloat a => Floating (Complex a) | |
Defined in Data.Complex Methods exp :: Complex a -> Complex a # log :: Complex a -> Complex a # sqrt :: Complex a -> Complex a # (**) :: Complex a -> Complex a -> Complex a # logBase :: Complex a -> Complex a -> Complex a # sin :: Complex a -> Complex a # cos :: Complex a -> Complex a # tan :: Complex a -> Complex a # asin :: Complex a -> Complex a # acos :: Complex a -> Complex a # atan :: Complex a -> Complex a # sinh :: Complex a -> Complex a # cosh :: Complex a -> Complex a # tanh :: Complex a -> Complex a # asinh :: Complex a -> Complex a # acosh :: Complex a -> Complex a # atanh :: Complex a -> Complex a # log1p :: Complex a -> Complex a # expm1 :: Complex a -> Complex a # | |
| Floating a => Floating (Identity a) | |
Defined in GHC.Internal.Data.Functor.Identity Methods exp :: Identity a -> Identity a # log :: Identity a -> Identity a # sqrt :: Identity a -> Identity a # (**) :: Identity a -> Identity a -> Identity a # logBase :: Identity a -> Identity a -> Identity a # sin :: Identity a -> Identity a # cos :: Identity a -> Identity a # tan :: Identity a -> Identity a # asin :: Identity a -> Identity a # acos :: Identity a -> Identity a # atan :: Identity a -> Identity a # sinh :: Identity a -> Identity a # cosh :: Identity a -> Identity a # tanh :: Identity a -> Identity a # asinh :: Identity a -> Identity a # acosh :: Identity a -> Identity a # atanh :: Identity a -> Identity a # log1p :: Identity a -> Identity a # expm1 :: Identity a -> Identity a # | |
| Floating a => Floating (Down a) | |
| Floating a => Floating (Op a b) | |
| Floating a => Floating (Const a b) | |
Defined in GHC.Internal.Data.Functor.Const Methods exp :: Const a b -> Const a b # log :: Const a b -> Const a b # sqrt :: Const a b -> Const a b # (**) :: Const a b -> Const a b -> Const a b # logBase :: Const a b -> Const a b -> Const a b # sin :: Const a b -> Const a b # cos :: Const a b -> Const a b # tan :: Const a b -> Const a b # asin :: Const a b -> Const a b # acos :: Const a b -> Const a b # atan :: Const a b -> Const a b # sinh :: Const a b -> Const a b # cosh :: Const a b -> Const a b # tanh :: Const a b -> Const a b # asinh :: Const a b -> Const a b # acosh :: Const a b -> Const a b # atanh :: Const a b -> Const a b # log1p :: Const a b -> Const a b # expm1 :: Const a b -> Const a b # | |
| Floating (f (g a)) => Floating (Compose f g a) | |
Defined in Data.Functor.Compose Methods exp :: Compose f g a -> Compose f g a # log :: Compose f g a -> Compose f g a # sqrt :: Compose f g a -> Compose f g a # (**) :: Compose f g a -> Compose f g a -> Compose f g a # logBase :: Compose f g a -> Compose f g a -> Compose f g a # sin :: Compose f g a -> Compose f g a # cos :: Compose f g a -> Compose f g a # tan :: Compose f g a -> Compose f g a # asin :: Compose f g a -> Compose f g a # acos :: Compose f g a -> Compose f g a # atan :: Compose f g a -> Compose f g a # sinh :: Compose f g a -> Compose f g a # cosh :: Compose f g a -> Compose f g a # tanh :: Compose f g a -> Compose f g a # asinh :: Compose f g a -> Compose f g a # acosh :: Compose f g a -> Compose f g a # atanh :: Compose f g a -> Compose f g a # log1p :: Compose f g a -> Compose f g a # expm1 :: Compose f g a -> Compose f g a # | |
floatToDigits :: RealFloat a => Integer -> a -> ([Int], Int) #
readSigned :: Real a => ReadS a -> ReadS a #
showEFloat :: RealFloat a => Maybe Int -> a -> ShowS #
showFFloat :: RealFloat a => Maybe Int -> a -> ShowS #
showFFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS #
showGFloat :: RealFloat a => Maybe Int -> a -> ShowS #
showGFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS #
showHFloat :: RealFloat a => a -> ShowS #
showIntAtBase :: Integral a => a -> (Int -> Char) -> a -> ShowS #
showSigned :: Real a => (a -> ShowS) -> Int -> a -> ShowS #