Safe Haskell | None |
---|---|
Language | GHC2021 |
Documentation
error :: HasCallStack => [Char] -> a #
errorWithoutStackTrace :: [Char] -> a #
undefined :: HasCallStack => a #
ioError :: HasCallStack => IOError -> IO a #
(!!) :: HasCallStack => [a] -> Int -> a #
cycle :: HasCallStack => [a] -> [a] #
init :: HasCallStack => [a] -> [a] #
last :: HasCallStack => [a] -> a #
(^^) :: (Fractional a, Integral b) => a -> b -> a #
fromIntegral :: (Integral a, Num b) => a -> b #
realToFrac :: (Real a, Fractional b) => a -> b #
showString :: String -> ShowS #
appendFile :: FilePath -> String -> IO () #
getContents :: IO String #
class Functor (f :: Type -> Type) where #
Instances
class Applicative m => Monad (m :: Type -> Type) where #
Instances
class Semigroup a => Monoid a where #
Instances
Instances
class Monad m => MonadFail (m :: Type -> Type) where #
Instances
Instances
Bifoldable Either Source # | Since: base-4.10.0.0 | ||||
Bifoldable1 Either Source # | |||||
Bifunctor Either Source # | Since: base-4.8.0.0 | ||||
Bitraversable Either Source # | Since: base-4.10.0.0 | ||||
Defined in Data.Bitraversable bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d) Source # | |||||
Eq2 Either Source # | Since: base-4.9.0.0 | ||||
Ord2 Either Source # | Since: base-4.9.0.0 | ||||
Defined in Data.Functor.Classes | |||||
Read2 Either Source # | Since: base-4.9.0.0 | ||||
Defined in Data.Functor.Classes liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Either a b) Source # liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Either a b] Source # liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Either a b) Source # liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Either a b] Source # | |||||
Show2 Either Source # | Since: base-4.9.0.0 | ||||
NFData2 Either Source # | Since: deepseq-1.4.3.0 | ||||
Defined in Control.DeepSeq | |||||
Generic1 (Either a :: Type -> Type) # | |||||
Defined in GHC.Internal.Generics
| |||||
(Lift a, Lift b) => Lift (Either a b :: Type) # | |||||
Eq a => Eq1 (Either a) Source # | Since: base-4.9.0.0 | ||||
Ord a => Ord1 (Either a) Source # | Since: base-4.9.0.0 | ||||
Defined in Data.Functor.Classes | |||||
Read a => Read1 (Either a) Source # | Since: base-4.9.0.0 | ||||
Defined in Data.Functor.Classes liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Either a a0) Source # liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Either a a0] Source # liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Either a a0) Source # liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Either a a0] Source # | |||||
Show a => Show1 (Either a) Source # | Since: base-4.9.0.0 | ||||
NFData a => NFData1 (Either a) Source # | Since: deepseq-1.4.3.0 | ||||
Defined in Control.DeepSeq | |||||
e ~ SomeException => MonadCatch (Either e) Source # | Since: exceptions-0.8.3 | ||||
Defined in Control.Monad.Catch | |||||
e ~ SomeException => MonadMask (Either e) Source # | Since: exceptions-0.8.3 | ||||
Defined in Control.Monad.Catch mask :: HasCallStack => ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b Source # uninterruptibleMask :: HasCallStack => ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b Source # generalBracket :: HasCallStack => Either e a -> (a -> ExitCase b -> Either e c) -> (a -> Either e b) -> Either e (b, c) Source # | |||||
e ~ SomeException => MonadThrow (Either e) Source # | |||||
Defined in Control.Monad.Catch | |||||
Applicative (Either e) # | |||||
Functor (Either a) # | |||||
Monad (Either e) # | |||||
MonadFix (Either e) # | |||||
Defined in GHC.Internal.Control.Monad.Fix | |||||
Foldable (Either a) # | |||||
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => Either a m -> m # foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # toList :: Either a a0 -> [a0] # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # | |||||
Traversable (Either a) # | |||||
Defined in GHC.Internal.Data.Traversable | |||||
(Binary a, Binary b) => Binary (Either a b) Source # | |||||
(NFData a, NFData b) => NFData (Either a b) Source # | |||||
Defined in Control.DeepSeq | |||||
(Binary a, Binary b) => Binary (Either a b) Source # | |||||
(Outputable a, Outputable b) => Outputable (Either a b) Source # | |||||
Semigroup (Either a b) # | |||||
(Data a, Data b) => Data (Either a b) # | |||||
Defined in GHC.Internal.Data.Data gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Either a b -> c (Either a b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b) # toConstr :: Either a b -> Constr # dataTypeOf :: Either a b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Either a b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Either a b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Either a b -> Either a b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r # gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) # | |||||
Generic (Either a b) # | |||||
Defined in GHC.Internal.Generics
| |||||
(Read a, Read b) => Read (Either a b) # | |||||
(Show a, Show b) => Show (Either a b) # | |||||
(Eq a, Eq b) => Eq (Either a b) # | |||||
(Ord a, Ord b) => Ord (Either a b) # | |||||
type Rep1 (Either a :: Type -> Type) # | |||||
Defined in GHC.Internal.Generics type Rep1 (Either a :: Type -> Type) = D1 ('MetaData "Either" "GHC.Internal.Data.Either" "ghc-internal" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1)) | |||||
type Rep (Either a b) # | |||||
Defined in GHC.Internal.Generics type Rep (Either a b) = D1 ('MetaData "Either" "GHC.Internal.Data.Either" "ghc-internal" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 b))) |
class Foldable (t :: Type -> Type) where #
foldMap :: Monoid m => (a -> m) -> t a -> m #
foldr :: (a -> b -> b) -> b -> t a -> b #
foldl :: (b -> a -> b) -> b -> t a -> b #
foldl' :: (b -> a -> b) -> b -> t a -> b #
foldr1 :: (a -> a -> a) -> t a -> a #
foldl1 :: (a -> a -> a) -> t a -> a #
elem :: Eq a => a -> t a -> Bool #
maximum :: Ord a => t a -> a #
Instances
Foldable Complex Source # | Since: base-4.9.0.0 |
Defined in Data.Complex fold :: Monoid m => Complex m -> m # foldMap :: Monoid m => (a -> m) -> Complex a -> m # foldMap' :: Monoid m => (a -> m) -> Complex a -> m # foldr :: (a -> b -> b) -> b -> Complex a -> b # foldr' :: (a -> b -> b) -> b -> Complex a -> b # foldl :: (b -> a -> b) -> b -> Complex a -> b # foldl' :: (b -> a -> b) -> b -> Complex a -> b # foldr1 :: (a -> a -> a) -> Complex a -> a # foldl1 :: (a -> a -> a) -> Complex a -> a # elem :: Eq a => a -> Complex a -> Bool # maximum :: Ord a => Complex a -> a # minimum :: Ord a => Complex a -> a # | |
Foldable First Source # | Since: base-4.9.0.0 |
Defined in Data.Semigroup 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 # | |
Foldable Last Source # | Since: base-4.9.0.0 |
Defined in Data.Semigroup 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 # | |
Foldable Max Source # | Since: base-4.9.0.0 |
Defined in Data.Semigroup fold :: Monoid m => Max m -> m # foldMap :: Monoid m => (a -> m) -> Max a -> m # foldMap' :: Monoid m => (a -> m) -> Max a -> m # foldr :: (a -> b -> b) -> b -> Max a -> b # foldr' :: (a -> b -> b) -> b -> Max a -> b # foldl :: (b -> a -> b) -> b -> Max a -> b # foldl' :: (b -> a -> b) -> b -> Max a -> b # foldr1 :: (a -> a -> a) -> Max a -> a # foldl1 :: (a -> a -> a) -> Max a -> a # elem :: Eq a => a -> Max a -> Bool # maximum :: Ord a => Max a -> a # | |
Foldable Min Source # | Since: base-4.9.0.0 |
Defined in Data.Semigroup fold :: Monoid m => Min m -> m # foldMap :: Monoid m => (a -> m) -> Min a -> m # foldMap' :: Monoid m => (a -> m) -> Min a -> m # foldr :: (a -> b -> b) -> b -> Min a -> b # foldr' :: (a -> b -> b) -> b -> Min a -> b # foldl :: (b -> a -> b) -> b -> Min a -> b # foldl' :: (b -> a -> b) -> b -> Min a -> b # foldr1 :: (a -> a -> a) -> Min a -> a # foldl1 :: (a -> a -> a) -> Min a -> a # elem :: Eq a => a -> Min a -> Bool # maximum :: Ord a => Min a -> a # | |
Foldable SCC Source # | Since: containers-0.5.9 |
Defined in Data.Graph fold :: Monoid m => SCC m -> m # foldMap :: Monoid m => (a -> m) -> SCC a -> m # foldMap' :: Monoid m => (a -> m) -> SCC a -> m # foldr :: (a -> b -> b) -> b -> SCC a -> b # foldr' :: (a -> b -> b) -> b -> SCC a -> b # foldl :: (b -> a -> b) -> b -> SCC a -> b # foldl' :: (b -> a -> b) -> b -> SCC a -> b # foldr1 :: (a -> a -> a) -> SCC a -> a # foldl1 :: (a -> a -> a) -> SCC a -> a # elem :: Eq a => a -> SCC a -> Bool # maximum :: Ord a => SCC a -> a # | |
Foldable IntMap Source # | Folds in order of increasing key. |
Defined in Data.IntMap.Internal fold :: Monoid m => IntMap m -> m # foldMap :: Monoid m => (a -> m) -> IntMap a -> m # foldMap' :: Monoid m => (a -> m) -> IntMap a -> m # foldr :: (a -> b -> b) -> b -> IntMap a -> b # foldr' :: (a -> b -> b) -> b -> IntMap a -> b # foldl :: (b -> a -> b) -> b -> IntMap a -> b # foldl' :: (b -> a -> b) -> b -> IntMap a -> b # foldr1 :: (a -> a -> a) -> IntMap a -> a # foldl1 :: (a -> a -> a) -> IntMap a -> a # elem :: Eq a => a -> IntMap a -> Bool # maximum :: Ord a => IntMap a -> a # minimum :: Ord a => IntMap a -> a # | |
Foldable Digit Source # | |
Defined in Data.Sequence.Internal fold :: Monoid m => Digit m -> m # foldMap :: Monoid m => (a -> m) -> Digit a -> m # foldMap' :: Monoid m => (a -> m) -> Digit a -> m # foldr :: (a -> b -> b) -> b -> Digit a -> b # foldr' :: (a -> b -> b) -> b -> Digit a -> b # foldl :: (b -> a -> b) -> b -> Digit a -> b # foldl' :: (b -> a -> b) -> b -> Digit a -> b # foldr1 :: (a -> a -> a) -> Digit a -> a # foldl1 :: (a -> a -> a) -> Digit a -> a # elem :: Eq a => a -> Digit a -> Bool # maximum :: Ord a => Digit a -> a # minimum :: Ord a => Digit a -> a # | |
Foldable Elem Source # | |
Defined in Data.Sequence.Internal fold :: Monoid m => Elem m -> m # foldMap :: Monoid m => (a -> m) -> Elem a -> m # foldMap' :: Monoid m => (a -> m) -> Elem a -> m # foldr :: (a -> b -> b) -> b -> Elem a -> b # foldr' :: (a -> b -> b) -> b -> Elem a -> b # foldl :: (b -> a -> b) -> b -> Elem a -> b # foldl' :: (b -> a -> b) -> b -> Elem a -> b # foldr1 :: (a -> a -> a) -> Elem a -> a # foldl1 :: (a -> a -> a) -> Elem a -> a # elem :: Eq a => a -> Elem a -> Bool # maximum :: Ord a => Elem a -> a # | |
Foldable FingerTree Source # | |
Defined in Data.Sequence.Internal fold :: Monoid m => FingerTree m -> m # foldMap :: Monoid m => (a -> m) -> FingerTree a -> m # foldMap' :: Monoid m => (a -> m) -> FingerTree a -> m # foldr :: (a -> b -> b) -> b -> FingerTree a -> b # foldr' :: (a -> b -> b) -> b -> FingerTree a -> b # foldl :: (b -> a -> b) -> b -> FingerTree a -> b # foldl' :: (b -> a -> b) -> b -> FingerTree a -> b # foldr1 :: (a -> a -> a) -> FingerTree a -> a # foldl1 :: (a -> a -> a) -> FingerTree a -> a # toList :: FingerTree a -> [a] # null :: FingerTree a -> Bool # length :: FingerTree a -> Int # elem :: Eq a => a -> FingerTree a -> Bool # maximum :: Ord a => FingerTree a -> a # minimum :: Ord a => FingerTree a -> a # sum :: Num a => FingerTree a -> a # product :: Num a => FingerTree a -> a # | |
Foldable Node Source # | |
Defined in Data.Sequence.Internal fold :: Monoid m => Node m -> m # foldMap :: Monoid m => (a -> m) -> Node a -> m # foldMap' :: Monoid m => (a -> m) -> Node a -> m # foldr :: (a -> b -> b) -> b -> Node a -> b # foldr' :: (a -> b -> b) -> b -> Node a -> b # foldl :: (b -> a -> b) -> b -> Node a -> b # foldl' :: (b -> a -> b) -> b -> Node a -> b # foldr1 :: (a -> a -> a) -> Node a -> a # foldl1 :: (a -> a -> a) -> Node a -> a # elem :: Eq a => a -> Node a -> Bool # maximum :: Ord a => Node a -> a # | |
Foldable Seq Source # | |
Defined in Data.Sequence.Internal fold :: Monoid m => Seq m -> m # foldMap :: Monoid m => (a -> m) -> Seq a -> m # foldMap' :: Monoid m => (a -> m) -> Seq a -> m # foldr :: (a -> b -> b) -> b -> Seq a -> b # foldr' :: (a -> b -> b) -> b -> Seq a -> b # foldl :: (b -> a -> b) -> b -> Seq a -> b # foldl' :: (b -> a -> b) -> b -> Seq a -> b # foldr1 :: (a -> a -> a) -> Seq a -> a # foldl1 :: (a -> a -> a) -> Seq a -> a # elem :: Eq a => a -> Seq a -> Bool # maximum :: Ord a => Seq a -> a # | |
Foldable ViewL Source # | |
Defined in Data.Sequence.Internal fold :: Monoid m => ViewL m -> m # foldMap :: Monoid m => (a -> m) -> ViewL a -> m # foldMap' :: Monoid m => (a -> m) -> ViewL a -> m # foldr :: (a -> b -> b) -> b -> ViewL a -> b # foldr' :: (a -> b -> b) -> b -> ViewL a -> b # foldl :: (b -> a -> b) -> b -> ViewL a -> b # foldl' :: (b -> a -> b) -> b -> ViewL a -> b # foldr1 :: (a -> a -> a) -> ViewL a -> a # foldl1 :: (a -> a -> a) -> ViewL a -> a # elem :: Eq a => a -> ViewL a -> Bool # maximum :: Ord a => ViewL a -> a # minimum :: Ord a => ViewL a -> a # | |
Foldable ViewR Source # | |
Defined in Data.Sequence.Internal fold :: Monoid m => ViewR m -> m # foldMap :: Monoid m => (a -> m) -> ViewR a -> m # foldMap' :: Monoid m => (a -> m) -> ViewR a -> m # foldr :: (a -> b -> b) -> b -> ViewR a -> b # foldr' :: (a -> b -> b) -> b -> ViewR a -> b # foldl :: (b -> a -> b) -> b -> ViewR a -> b # foldl' :: (b -> a -> b) -> b -> ViewR a -> b # foldr1 :: (a -> a -> a) -> ViewR a -> a # foldl1 :: (a -> a -> a) -> ViewR a -> a # elem :: Eq a => a -> ViewR a -> Bool # maximum :: Ord a => ViewR a -> a # minimum :: Ord a => ViewR a -> a # | |
Foldable Set Source # | Folds in order of increasing key. |
Defined in Data.Set.Internal fold :: Monoid m => Set m -> m # foldMap :: Monoid m => (a -> m) -> Set a -> m # foldMap' :: Monoid m => (a -> m) -> Set a -> m # foldr :: (a -> b -> b) -> b -> Set a -> b # foldr' :: (a -> b -> b) -> b -> Set a -> b # foldl :: (b -> a -> b) -> b -> Set a -> b # foldl' :: (b -> a -> b) -> b -> Set a -> b # foldr1 :: (a -> a -> a) -> Set a -> a # foldl1 :: (a -> a -> a) -> Set a -> a # elem :: Eq a => a -> Set a -> Bool # maximum :: Ord a => Set a -> a # | |
Foldable Tree Source # | Folds in preorder |
Defined in Data.Tree fold :: Monoid m => Tree m -> m # foldMap :: Monoid m => (a -> m) -> Tree a -> m # foldMap' :: Monoid m => (a -> m) -> Tree a -> m # foldr :: (a -> b -> b) -> b -> Tree a -> b # foldr' :: (a -> b -> b) -> b -> Tree a -> b # foldl :: (b -> a -> b) -> b -> Tree a -> b # foldl' :: (b -> a -> b) -> b -> Tree a -> b # foldr1 :: (a -> a -> a) -> Tree a -> a # foldl1 :: (a -> a -> a) -> Tree a -> a # elem :: Eq a => a -> Tree a -> Bool # maximum :: Ord a => Tree a -> a # | |
Foldable LabelMap Source # | |
Defined in GHC.Cmm.Dataflow.Label fold :: Monoid m => LabelMap m -> m # foldMap :: Monoid m => (a -> m) -> LabelMap a -> m # foldMap' :: Monoid m => (a -> m) -> LabelMap a -> m # foldr :: (a -> b -> b) -> b -> LabelMap a -> b # foldr' :: (a -> b -> b) -> b -> LabelMap a -> b # foldl :: (b -> a -> b) -> b -> LabelMap a -> b # foldl' :: (b -> a -> b) -> b -> LabelMap a -> b # foldr1 :: (a -> a -> a) -> LabelMap a -> a # foldl1 :: (a -> a -> a) -> LabelMap a -> a # elem :: Eq a => a -> LabelMap a -> Bool # maximum :: Ord a => LabelMap a -> a # minimum :: Ord a => LabelMap a -> a # | |
Foldable Bag Source # | |
Defined in GHC.Data.Bag fold :: Monoid m => Bag m -> m # foldMap :: Monoid m => (a -> m) -> Bag a -> m # foldMap' :: Monoid m => (a -> m) -> Bag a -> m # foldr :: (a -> b -> b) -> b -> Bag a -> b # foldr' :: (a -> b -> b) -> b -> Bag a -> b # foldl :: (b -> a -> b) -> b -> Bag a -> b # foldl' :: (b -> a -> b) -> b -> Bag a -> b # foldr1 :: (a -> a -> a) -> Bag a -> a # foldl1 :: (a -> a -> a) -> Bag a -> a # elem :: Eq a => a -> Bag a -> Bool # maximum :: Ord a => Bag a -> a # | |
Foldable BooleanFormula Source # | |
Defined in GHC.Data.BooleanFormula fold :: Monoid m => BooleanFormula m -> m # foldMap :: Monoid m => (a -> m) -> BooleanFormula a -> m # foldMap' :: Monoid m => (a -> m) -> BooleanFormula a -> m # foldr :: (a -> b -> b) -> b -> BooleanFormula a -> b # foldr' :: (a -> b -> b) -> b -> BooleanFormula a -> b # foldl :: (b -> a -> b) -> b -> BooleanFormula a -> b # foldl' :: (b -> a -> b) -> b -> BooleanFormula a -> b # foldr1 :: (a -> a -> a) -> BooleanFormula a -> a # foldl1 :: (a -> a -> a) -> BooleanFormula a -> a # toList :: BooleanFormula a -> [a] # null :: BooleanFormula a -> Bool # length :: BooleanFormula a -> Int # elem :: Eq a => a -> BooleanFormula a -> Bool # maximum :: Ord a => BooleanFormula a -> a # minimum :: Ord a => BooleanFormula a -> a # sum :: Num a => BooleanFormula a -> a # product :: Num a => BooleanFormula a -> a # | |
Foldable FlatBag Source # | |
Defined in GHC.Data.FlatBag fold :: Monoid m => FlatBag m -> m # foldMap :: Monoid m => (a -> m) -> FlatBag a -> m # foldMap' :: Monoid m => (a -> m) -> FlatBag a -> m # foldr :: (a -> b -> b) -> b -> FlatBag a -> b # foldr' :: (a -> b -> b) -> b -> FlatBag a -> b # foldl :: (b -> a -> b) -> b -> FlatBag a -> b # foldl' :: (b -> a -> b) -> b -> FlatBag a -> b # foldr1 :: (a -> a -> a) -> FlatBag a -> a # foldl1 :: (a -> a -> a) -> FlatBag a -> a # elem :: Eq a => a -> FlatBag a -> Bool # maximum :: Ord a => FlatBag a -> a # minimum :: Ord a => FlatBag a -> a # | |
Foldable Infinite Source # | |
Defined in GHC.Data.List.Infinite fold :: Monoid m => Infinite m -> m # foldMap :: Monoid m => (a -> m) -> Infinite a -> m # foldMap' :: Monoid m => (a -> m) -> Infinite a -> m # foldr :: (a -> b -> b) -> b -> Infinite a -> b # foldr' :: (a -> b -> b) -> b -> Infinite a -> b # foldl :: (b -> a -> b) -> b -> Infinite a -> b # foldl' :: (b -> a -> b) -> b -> Infinite a -> b # foldr1 :: (a -> a -> a) -> Infinite a -> a # foldl1 :: (a -> a -> a) -> Infinite a -> a # elem :: Eq a => a -> Infinite a -> Bool # maximum :: Ord a => Infinite a -> a # minimum :: Ord a => Infinite a -> a # | |
Foldable OrdList Source # | |
Defined in GHC.Data.OrdList fold :: Monoid m => OrdList m -> m # foldMap :: Monoid m => (a -> m) -> OrdList a -> m # foldMap' :: Monoid m => (a -> m) -> OrdList a -> m # foldr :: (a -> b -> b) -> b -> OrdList a -> b # foldr' :: (a -> b -> b) -> b -> OrdList a -> b # foldl :: (b -> a -> b) -> b -> OrdList a -> b # foldl' :: (b -> a -> b) -> b -> OrdList a -> b # foldr1 :: (a -> a -> a) -> OrdList a -> a # foldl1 :: (a -> a -> a) -> OrdList a -> a # elem :: Eq a => a -> OrdList a -> Bool # maximum :: Ord a => OrdList a -> a # minimum :: Ord a => OrdList a -> a # | |
Foldable Pair Source # | |
Defined in GHC.Data.Pair fold :: Monoid m => Pair m -> m # foldMap :: Monoid m => (a -> m) -> Pair a -> m # foldMap' :: Monoid m => (a -> m) -> Pair a -> m # foldr :: (a -> b -> b) -> b -> Pair a -> b # foldr' :: (a -> b -> b) -> b -> Pair a -> b # foldl :: (b -> a -> b) -> b -> Pair a -> b # foldl' :: (b -> a -> b) -> b -> Pair a -> b # foldr1 :: (a -> a -> a) -> Pair a -> a # foldl1 :: (a -> a -> a) -> Pair a -> a # elem :: Eq a => a -> Pair a -> Bool # maximum :: Ord a => Pair a -> a # | |
Foldable Maybe Source # | |
Defined in GHC.Data.Strict 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 # | |
Foldable Word64Map Source # | Folds in order of increasing key. |
Defined in GHC.Data.Word64Map.Internal fold :: Monoid m => Word64Map m -> m # foldMap :: Monoid m => (a -> m) -> Word64Map a -> m # foldMap' :: Monoid m => (a -> m) -> Word64Map a -> m # foldr :: (a -> b -> b) -> b -> Word64Map a -> b # foldr' :: (a -> b -> b) -> b -> Word64Map a -> b # foldl :: (b -> a -> b) -> b -> Word64Map a -> b # foldl' :: (b -> a -> b) -> b -> Word64Map a -> b # foldr1 :: (a -> a -> a) -> Word64Map a -> a # foldl1 :: (a -> a -> a) -> Word64Map a -> a # toList :: Word64Map a -> [a] # length :: Word64Map a -> Int # elem :: Eq a => a -> Word64Map a -> Bool # maximum :: Ord a => Word64Map a -> a # minimum :: Ord a => Word64Map a -> a # | |
Foldable ModNodeMap Source # | |
Defined in GHC.Driver.Make fold :: Monoid m => ModNodeMap m -> m # foldMap :: Monoid m => (a -> m) -> ModNodeMap a -> m # foldMap' :: Monoid m => (a -> m) -> ModNodeMap a -> m # foldr :: (a -> b -> b) -> b -> ModNodeMap a -> b # foldr' :: (a -> b -> b) -> b -> ModNodeMap a -> b # foldl :: (b -> a -> b) -> b -> ModNodeMap a -> b # foldl' :: (b -> a -> b) -> b -> ModNodeMap a -> b # foldr1 :: (a -> a -> a) -> ModNodeMap a -> a # foldl1 :: (a -> a -> a) -> ModNodeMap a -> a # toList :: ModNodeMap a -> [a] # null :: ModNodeMap a -> Bool # length :: ModNodeMap a -> Int # elem :: Eq a => a -> ModNodeMap a -> Bool # maximum :: Ord a => ModNodeMap a -> a # minimum :: Ord a => ModNodeMap a -> a # sum :: Num a => ModNodeMap a -> a # product :: Num a => ModNodeMap a -> a # | |
Foldable HieAST Source # | |
Defined in GHC.Iface.Ext.Types fold :: Monoid m => HieAST m -> m # foldMap :: Monoid m => (a -> m) -> HieAST a -> m # foldMap' :: Monoid m => (a -> m) -> HieAST a -> m # foldr :: (a -> b -> b) -> b -> HieAST a -> b # foldr' :: (a -> b -> b) -> b -> HieAST a -> b # foldl :: (b -> a -> b) -> b -> HieAST a -> b # foldl' :: (b -> a -> b) -> b -> HieAST a -> b # foldr1 :: (a -> a -> a) -> HieAST a -> a # foldl1 :: (a -> a -> a) -> HieAST a -> a # elem :: Eq a => a -> HieAST a -> Bool # maximum :: Ord a => HieAST a -> a # minimum :: Ord a => HieAST a -> a # | |
Foldable HieASTs Source # | |
Defined in GHC.Iface.Ext.Types fold :: Monoid m => HieASTs m -> m # foldMap :: Monoid m => (a -> m) -> HieASTs a -> m # foldMap' :: Monoid m => (a -> m) -> HieASTs a -> m # foldr :: (a -> b -> b) -> b -> HieASTs a -> b # foldr' :: (a -> b -> b) -> b -> HieASTs a -> b # foldl :: (b -> a -> b) -> b -> HieASTs a -> b # foldl' :: (b -> a -> b) -> b -> HieASTs a -> b # foldr1 :: (a -> a -> a) -> HieASTs a -> a # foldl1 :: (a -> a -> a) -> HieASTs a -> a # elem :: Eq a => a -> HieASTs a -> Bool # maximum :: Ord a => HieASTs a -> a # minimum :: Ord a => HieASTs a -> a # | |
Foldable HieArgs Source # | |
Defined in GHC.Iface.Ext.Types fold :: Monoid m => HieArgs m -> m # foldMap :: Monoid m => (a -> m) -> HieArgs a -> m # foldMap' :: Monoid m => (a -> m) -> HieArgs a -> m # foldr :: (a -> b -> b) -> b -> HieArgs a -> b # foldr' :: (a -> b -> b) -> b -> HieArgs a -> b # foldl :: (b -> a -> b) -> b -> HieArgs a -> b # foldl' :: (b -> a -> b) -> b -> HieArgs a -> b # foldr1 :: (a -> a -> a) -> HieArgs a -> a # foldl1 :: (a -> a -> a) -> HieArgs a -> a # elem :: Eq a => a -> HieArgs a -> Bool # maximum :: Ord a => HieArgs a -> a # minimum :: Ord a => HieArgs a -> a # | |
Foldable HieType Source # | |
Defined in GHC.Iface.Ext.Types fold :: Monoid m => HieType m -> m # foldMap :: Monoid m => (a -> m) -> HieType a -> m # foldMap' :: Monoid m => (a -> m) -> HieType a -> m # foldr :: (a -> b -> b) -> b -> HieType a -> b # foldr' :: (a -> b -> b) -> b -> HieType a -> b # foldl :: (b -> a -> b) -> b -> HieType a -> b # foldl' :: (b -> a -> b) -> b -> HieType a -> b # foldr1 :: (a -> a -> a) -> HieType a -> a # foldl1 :: (a -> a -> a) -> HieType a -> a # elem :: Eq a => a -> HieType a -> Bool # maximum :: Ord a => HieType a -> a # minimum :: Ord a => HieType a -> a # | |
Foldable IdentifierDetails Source # | |
Defined in GHC.Iface.Ext.Types fold :: Monoid m => IdentifierDetails m -> m # foldMap :: Monoid m => (a -> m) -> IdentifierDetails a -> m # foldMap' :: Monoid m => (a -> m) -> IdentifierDetails a -> m # foldr :: (a -> b -> b) -> b -> IdentifierDetails a -> b # foldr' :: (a -> b -> b) -> b -> IdentifierDetails a -> b # foldl :: (b -> a -> b) -> b -> IdentifierDetails a -> b # foldl' :: (b -> a -> b) -> b -> IdentifierDetails a -> b # foldr1 :: (a -> a -> a) -> IdentifierDetails a -> a # foldl1 :: (a -> a -> a) -> IdentifierDetails a -> a # toList :: IdentifierDetails a -> [a] # null :: IdentifierDetails a -> Bool # length :: IdentifierDetails a -> Int # elem :: Eq a => a -> IdentifierDetails a -> Bool # maximum :: Ord a => IdentifierDetails a -> a # minimum :: Ord a => IdentifierDetails a -> a # sum :: Num a => IdentifierDetails a -> a # product :: Num a => IdentifierDetails a -> a # | |
Foldable NodeInfo Source # | |
Defined in GHC.Iface.Ext.Types fold :: Monoid m => NodeInfo m -> m # foldMap :: Monoid m => (a -> m) -> NodeInfo a -> m # foldMap' :: Monoid m => (a -> m) -> NodeInfo a -> m # foldr :: (a -> b -> b) -> b -> NodeInfo a -> b # foldr' :: (a -> b -> b) -> b -> NodeInfo a -> b # foldl :: (b -> a -> b) -> b -> NodeInfo a -> b # foldl' :: (b -> a -> b) -> b -> NodeInfo a -> b # foldr1 :: (a -> a -> a) -> NodeInfo a -> a # foldl1 :: (a -> a -> a) -> NodeInfo a -> a # elem :: Eq a => a -> NodeInfo a -> Bool # maximum :: Ord a => NodeInfo a -> a # minimum :: Ord a => NodeInfo a -> a # | |
Foldable SourcedNodeInfo Source # | |
Defined in GHC.Iface.Ext.Types fold :: Monoid m => SourcedNodeInfo m -> m # foldMap :: Monoid m => (a -> m) -> SourcedNodeInfo a -> m # foldMap' :: Monoid m => (a -> m) -> SourcedNodeInfo a -> m # foldr :: (a -> b -> b) -> b -> SourcedNodeInfo a -> b # foldr' :: (a -> b -> b) -> b -> SourcedNodeInfo a -> b # foldl :: (b -> a -> b) -> b -> SourcedNodeInfo a -> b # foldl' :: (b -> a -> b) -> b -> SourcedNodeInfo a -> b # foldr1 :: (a -> a -> a) -> SourcedNodeInfo a -> a # foldl1 :: (a -> a -> a) -> SourcedNodeInfo a -> a # toList :: SourcedNodeInfo a -> [a] # null :: SourcedNodeInfo a -> Bool # length :: SourcedNodeInfo a -> Int # elem :: Eq a => a -> SourcedNodeInfo a -> Bool # maximum :: Ord a => SourcedNodeInfo a -> a # minimum :: Ord a => SourcedNodeInfo a -> a # sum :: Num a => SourcedNodeInfo a -> a # product :: Num a => SourcedNodeInfo a -> a # | |
Foldable Messages Source # | |
Defined in GHC.Types.Error fold :: Monoid m => Messages m -> m # foldMap :: Monoid m => (a -> m) -> Messages a -> m # foldMap' :: Monoid m => (a -> m) -> Messages a -> m # foldr :: (a -> b -> b) -> b -> Messages a -> b # foldr' :: (a -> b -> b) -> b -> Messages a -> b # foldl :: (b -> a -> b) -> b -> Messages a -> b # foldl' :: (b -> a -> b) -> b -> Messages a -> b # foldr1 :: (a -> a -> a) -> Messages a -> a # foldl1 :: (a -> a -> a) -> Messages a -> a # elem :: Eq a => a -> Messages a -> Bool # maximum :: Ord a => Messages a -> a # minimum :: Ord a => Messages a -> a # | |
Foldable MsgEnvelope Source # | |
Defined in GHC.Types.Error fold :: Monoid m => MsgEnvelope m -> m # foldMap :: Monoid m => (a -> m) -> MsgEnvelope a -> m # foldMap' :: Monoid m => (a -> m) -> MsgEnvelope a -> m # foldr :: (a -> b -> b) -> b -> MsgEnvelope a -> b # foldr' :: (a -> b -> b) -> b -> MsgEnvelope a -> b # foldl :: (b -> a -> b) -> b -> MsgEnvelope a -> b # foldl' :: (b -> a -> b) -> b -> MsgEnvelope a -> b # foldr1 :: (a -> a -> a) -> MsgEnvelope a -> a # foldl1 :: (a -> a -> a) -> MsgEnvelope a -> a # toList :: MsgEnvelope a -> [a] # null :: MsgEnvelope a -> Bool # length :: MsgEnvelope a -> Int # elem :: Eq a => a -> MsgEnvelope a -> Bool # maximum :: Ord a => MsgEnvelope a -> a # minimum :: Ord a => MsgEnvelope a -> a # sum :: Num a => MsgEnvelope a -> a # product :: Num a => MsgEnvelope a -> a # | |
Foldable UnitEnvGraph Source # | |
Defined in GHC.Unit.Env fold :: Monoid m => UnitEnvGraph m -> m # foldMap :: Monoid m => (a -> m) -> UnitEnvGraph a -> m # foldMap' :: Monoid m => (a -> m) -> UnitEnvGraph a -> m # foldr :: (a -> b -> b) -> b -> UnitEnvGraph a -> b # foldr' :: (a -> b -> b) -> b -> UnitEnvGraph a -> b # foldl :: (b -> a -> b) -> b -> UnitEnvGraph a -> b # foldl' :: (b -> a -> b) -> b -> UnitEnvGraph a -> b # foldr1 :: (a -> a -> a) -> UnitEnvGraph a -> a # foldl1 :: (a -> a -> a) -> UnitEnvGraph a -> a # toList :: UnitEnvGraph a -> [a] # null :: UnitEnvGraph a -> Bool # length :: UnitEnvGraph a -> Int # elem :: Eq a => a -> UnitEnvGraph a -> Bool # maximum :: Ord a => UnitEnvGraph a -> a # minimum :: Ord a => UnitEnvGraph a -> a # sum :: Num a => UnitEnvGraph a -> a # product :: Num a => UnitEnvGraph a -> a # | |
Foldable GenWithIsBoot Source # | |
Defined in GHC.Unit.Types fold :: Monoid m => GenWithIsBoot m -> m # foldMap :: Monoid m => (a -> m) -> GenWithIsBoot a -> m # foldMap' :: Monoid m => (a -> m) -> GenWithIsBoot a -> m # foldr :: (a -> b -> b) -> b -> GenWithIsBoot a -> b # foldr' :: (a -> b -> b) -> b -> GenWithIsBoot a -> b # foldl :: (b -> a -> b) -> b -> GenWithIsBoot a -> b # foldl' :: (b -> a -> b) -> b -> GenWithIsBoot a -> b # foldr1 :: (a -> a -> a) -> GenWithIsBoot a -> a # foldl1 :: (a -> a -> a) -> GenWithIsBoot a -> a # toList :: GenWithIsBoot a -> [a] # null :: GenWithIsBoot a -> Bool # length :: GenWithIsBoot a -> Int # elem :: Eq a => a -> GenWithIsBoot a -> Bool # maximum :: Ord a => GenWithIsBoot a -> a # minimum :: Ord a => GenWithIsBoot a -> a # sum :: Num a => GenWithIsBoot a -> a # product :: Num a => GenWithIsBoot a -> a # | |
Foldable DataDefnCons Source # | |
Defined in Language.Haskell.Syntax.Decls fold :: Monoid m => DataDefnCons m -> m # foldMap :: Monoid m => (a -> m) -> DataDefnCons a -> m # foldMap' :: Monoid m => (a -> m) -> DataDefnCons a -> m # foldr :: (a -> b -> b) -> b -> DataDefnCons a -> b # foldr' :: (a -> b -> b) -> b -> DataDefnCons a -> b # foldl :: (b -> a -> b) -> b -> DataDefnCons a -> b # foldl' :: (b -> a -> b) -> b -> DataDefnCons a -> b # foldr1 :: (a -> a -> a) -> DataDefnCons a -> a # foldl1 :: (a -> a -> a) -> DataDefnCons a -> a # toList :: DataDefnCons a -> [a] # null :: DataDefnCons a -> Bool # length :: DataDefnCons a -> Int # elem :: Eq a => a -> DataDefnCons a -> Bool # maximum :: Ord a => DataDefnCons a -> a # minimum :: Ord a => DataDefnCons a -> a # sum :: Num a => DataDefnCons a -> a # product :: Num a => DataDefnCons a -> a # | |
Foldable SizedSeq Source # | |
Defined in GHC.Data.SizedSeq fold :: Monoid m => SizedSeq m -> m # foldMap :: Monoid m => (a -> m) -> SizedSeq a -> m # foldMap' :: Monoid m => (a -> m) -> SizedSeq a -> m # foldr :: (a -> b -> b) -> b -> SizedSeq a -> b # foldr' :: (a -> b -> b) -> b -> SizedSeq a -> b # foldl :: (b -> a -> b) -> b -> SizedSeq a -> b # foldl' :: (b -> a -> b) -> b -> SizedSeq a -> b # foldr1 :: (a -> a -> a) -> SizedSeq a -> a # foldl1 :: (a -> a -> a) -> SizedSeq a -> a # elem :: Eq a => a -> SizedSeq a -> Bool # maximum :: Ord a => SizedSeq a -> a # minimum :: Ord a => SizedSeq a -> a # | |
Foldable GenClosure Source # | |
Defined in GHC.Exts.Heap.Closures fold :: Monoid m => GenClosure m -> m # foldMap :: Monoid m => (a -> m) -> GenClosure a -> m # foldMap' :: Monoid m => (a -> m) -> GenClosure a -> m # foldr :: (a -> b -> b) -> b -> GenClosure a -> b # foldr' :: (a -> b -> b) -> b -> GenClosure a -> b # foldl :: (b -> a -> b) -> b -> GenClosure a -> b # foldl' :: (b -> a -> b) -> b -> GenClosure a -> b # foldr1 :: (a -> a -> a) -> GenClosure a -> a # foldl1 :: (a -> a -> a) -> GenClosure a -> a # toList :: GenClosure a -> [a] # null :: GenClosure a -> Bool # length :: GenClosure a -> Int # elem :: Eq a => a -> GenClosure a -> Bool # maximum :: Ord a => GenClosure a -> a # minimum :: Ord a => GenClosure a -> a # sum :: Num a => GenClosure a -> a # product :: Num a => GenClosure a -> a # | |
Foldable GenStackField Source # | |
Defined in GHC.Exts.Heap.Closures fold :: Monoid m => GenStackField m -> m # foldMap :: Monoid m => (a -> m) -> GenStackField a -> m # foldMap' :: Monoid m => (a -> m) -> GenStackField a -> m # foldr :: (a -> b -> b) -> b -> GenStackField a -> b # foldr' :: (a -> b -> b) -> b -> GenStackField a -> b # foldl :: (b -> a -> b) -> b -> GenStackField a -> b # foldl' :: (b -> a -> b) -> b -> GenStackField a -> b # foldr1 :: (a -> a -> a) -> GenStackField a -> a # foldl1 :: (a -> a -> a) -> GenStackField a -> a # toList :: GenStackField a -> [a] # null :: GenStackField a -> Bool # length :: GenStackField a -> Int # elem :: Eq a => a -> GenStackField a -> Bool # maximum :: Ord a => GenStackField a -> a # minimum :: Ord a => GenStackField a -> a # sum :: Num a => GenStackField a -> a # product :: Num a => GenStackField a -> a # | |
Foldable GenStackFrame Source # | |
Defined in GHC.Exts.Heap.Closures fold :: Monoid m => GenStackFrame m -> m # foldMap :: Monoid m => (a -> m) -> GenStackFrame a -> m # foldMap' :: Monoid m => (a -> m) -> GenStackFrame a -> m # foldr :: (a -> b -> b) -> b -> GenStackFrame a -> b # foldr' :: (a -> b -> b) -> b -> GenStackFrame a -> b # foldl :: (b -> a -> b) -> b -> GenStackFrame a -> b # foldl' :: (b -> a -> b) -> b -> GenStackFrame a -> b # foldr1 :: (a -> a -> a) -> GenStackFrame a -> a # foldl1 :: (a -> a -> a) -> GenStackFrame a -> a # toList :: GenStackFrame a -> [a] # null :: GenStackFrame a -> Bool # length :: GenStackFrame a -> Int # elem :: Eq a => a -> GenStackFrame a -> Bool # maximum :: Ord a => GenStackFrame a -> a # minimum :: Ord a => GenStackFrame a -> a # sum :: Num a => GenStackFrame a -> a # product :: Num a => GenStackFrame a -> a # | |
Foldable GenStgStackClosure Source # | |
Defined in GHC.Exts.Heap.Closures fold :: Monoid m => GenStgStackClosure m -> m # foldMap :: Monoid m => (a -> m) -> GenStgStackClosure a -> m # foldMap' :: Monoid m => (a -> m) -> GenStgStackClosure a -> m # foldr :: (a -> b -> b) -> b -> GenStgStackClosure a -> b # foldr' :: (a -> b -> b) -> b -> GenStgStackClosure a -> b # foldl :: (b -> a -> b) -> b -> GenStgStackClosure a -> b # foldl' :: (b -> a -> b) -> b -> GenStgStackClosure a -> b # foldr1 :: (a -> a -> a) -> GenStgStackClosure a -> a # foldl1 :: (a -> a -> a) -> GenStgStackClosure a -> a # toList :: GenStgStackClosure a -> [a] # null :: GenStgStackClosure a -> Bool # length :: GenStgStackClosure a -> Int # elem :: Eq a => a -> GenStgStackClosure a -> Bool # maximum :: Ord a => GenStgStackClosure a -> a # minimum :: Ord a => GenStgStackClosure a -> a # sum :: Num a => GenStgStackClosure a -> a # product :: Num a => GenStgStackClosure a -> a # | |
Foldable NonEmpty # | |
Defined in GHC.Internal.Data.Foldable 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 # | |
Foldable Identity # | |
Defined in GHC.Internal.Data.Functor.Identity fold :: Monoid m => Identity m -> m # foldMap :: Monoid m => (a -> m) -> Identity a -> m # foldMap' :: Monoid m => (a -> m) -> Identity a -> m # foldr :: (a -> b -> b) -> b -> Identity a -> b # foldr' :: (a -> b -> b) -> b -> Identity a -> b # foldl :: (b -> a -> b) -> b -> Identity a -> b # foldl' :: (b -> a -> b) -> b -> Identity a -> b # foldr1 :: (a -> a -> a) -> Identity a -> a # foldl1 :: (a -> a -> a) -> Identity a -> a # elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # | |
Foldable First # | |
Defined in GHC.Internal.Data.Foldable 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 # | |
Foldable Last # | |
Defined in GHC.Internal.Data.Foldable 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 # | |
Foldable Down # | |
Defined in GHC.Internal.Data.Foldable 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 # | |
Foldable Dual # | |
Defined in GHC.Internal.Data.Foldable 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 # | |
Foldable Product # | |
Defined in GHC.Internal.Data.Foldable 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 # | |
Foldable Sum # | |
Defined in GHC.Internal.Data.Foldable 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 # | |
Foldable ZipList # | |
Defined in GHC.Internal.Functor.ZipList 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 # | |
Foldable Par1 # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => Par1 m -> m # foldMap :: Monoid m => (a -> m) -> Par1 a -> m # foldMap' :: Monoid m => (a -> m) -> Par1 a -> m # foldr :: (a -> b -> b) -> b -> Par1 a -> b # foldr' :: (a -> b -> b) -> b -> Par1 a -> b # foldl :: (b -> a -> b) -> b -> Par1 a -> b # foldl' :: (b -> a -> b) -> b -> Par1 a -> b # foldr1 :: (a -> a -> a) -> Par1 a -> a # foldl1 :: (a -> a -> a) -> Par1 a -> a # elem :: Eq a => a -> Par1 a -> Bool # maximum :: Ord a => Par1 a -> a # | |
Foldable TyVarBndr # | |
Defined in GHC.Internal.TH.Syntax fold :: Monoid m => TyVarBndr m -> m # foldMap :: Monoid m => (a -> m) -> TyVarBndr a -> m # foldMap' :: Monoid m => (a -> m) -> TyVarBndr a -> m # foldr :: (a -> b -> b) -> b -> TyVarBndr a -> b # foldr' :: (a -> b -> b) -> b -> TyVarBndr a -> b # foldl :: (b -> a -> b) -> b -> TyVarBndr a -> b # foldl' :: (b -> a -> b) -> b -> TyVarBndr a -> b # foldr1 :: (a -> a -> a) -> TyVarBndr a -> a # foldl1 :: (a -> a -> a) -> TyVarBndr a -> a # toList :: TyVarBndr a -> [a] # length :: TyVarBndr a -> Int # elem :: Eq a => a -> TyVarBndr a -> Bool # maximum :: Ord a => TyVarBndr a -> a # minimum :: Ord a => TyVarBndr a -> a # | |
Foldable Maybe # | |
Defined in GHC.Internal.Data.Foldable 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 # | |
Foldable Solo # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => Solo m -> m # foldMap :: Monoid m => (a -> m) -> Solo a -> m # foldMap' :: Monoid m => (a -> m) -> Solo a -> m # foldr :: (a -> b -> b) -> b -> Solo a -> b # foldr' :: (a -> b -> b) -> b -> Solo a -> b # foldl :: (b -> a -> b) -> b -> Solo a -> b # foldl' :: (b -> a -> b) -> b -> Solo a -> b # foldr1 :: (a -> a -> a) -> Solo a -> a # foldl1 :: (a -> a -> a) -> Solo a -> a # elem :: Eq a => a -> Solo a -> Bool # maximum :: Ord a => Solo a -> a # | |
Foldable [] # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => [m] -> m # 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 # elem :: Eq a => a -> [a] -> Bool # maximum :: Ord a => [a] -> a # | |
Foldable (Arg a) Source # | Since: base-4.9.0.0 |
Defined in Data.Semigroup fold :: Monoid m => Arg a m -> m # foldMap :: Monoid m => (a0 -> m) -> Arg a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Arg a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Arg a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Arg a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Arg a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Arg a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # elem :: Eq a0 => a0 -> Arg a a0 -> Bool # maximum :: Ord a0 => Arg a a0 -> a0 # minimum :: Ord a0 => Arg a a0 -> a0 # | |
Foldable (Map k) Source # | Folds in order of increasing key. |
Defined in Data.Map.Internal fold :: Monoid m => Map k m -> m # foldMap :: Monoid m => (a -> m) -> Map k a -> m # foldMap' :: Monoid m => (a -> m) -> Map k a -> m # foldr :: (a -> b -> b) -> b -> Map k a -> b # foldr' :: (a -> b -> b) -> b -> Map k a -> b # foldl :: (b -> a -> b) -> b -> Map k a -> b # foldl' :: (b -> a -> b) -> b -> Map k a -> b # foldr1 :: (a -> a -> a) -> Map k a -> a # foldl1 :: (a -> a -> a) -> Map k a -> a # elem :: Eq a => a -> Map k a -> Bool # maximum :: Ord a => Map k a -> a # minimum :: Ord a => Map k a -> a # | |
Foldable m => Foldable (CatchT m) Source # | |
Defined in Control.Monad.Catch.Pure fold :: Monoid m0 => CatchT m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> CatchT m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> CatchT m a -> m0 # foldr :: (a -> b -> b) -> b -> CatchT m a -> b # foldr' :: (a -> b -> b) -> b -> CatchT m a -> b # foldl :: (b -> a -> b) -> b -> CatchT m a -> b # foldl' :: (b -> a -> b) -> b -> CatchT m a -> b # foldr1 :: (a -> a -> a) -> CatchT m a -> a # foldl1 :: (a -> a -> a) -> CatchT m a -> a # elem :: Eq a => a -> CatchT m a -> Bool # maximum :: Ord a => CatchT m a -> a # minimum :: Ord a => CatchT m a -> a # | |
Foldable (Pair a) Source # | |
Defined in GHC.Data.Strict fold :: Monoid m => Pair a m -> m # foldMap :: Monoid m => (a0 -> m) -> Pair a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Pair a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Pair a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Pair a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Pair a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Pair a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Pair a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Pair a a0 -> a0 # elem :: Eq a0 => a0 -> Pair a a0 -> Bool # maximum :: Ord a0 => Pair a a0 -> a0 # minimum :: Ord a0 => Pair a a0 -> a0 # | |
(Eq (Key m), TrieMap m) => Foldable (GenMap m) Source # | |
Defined in GHC.Data.TrieMap fold :: Monoid m0 => GenMap m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> GenMap m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> GenMap m a -> m0 # foldr :: (a -> b -> b) -> b -> GenMap m a -> b # foldr' :: (a -> b -> b) -> b -> GenMap m a -> b # foldl :: (b -> a -> b) -> b -> GenMap m a -> b # foldl' :: (b -> a -> b) -> b -> GenMap m a -> b # foldr1 :: (a -> a -> a) -> GenMap m a -> a # foldl1 :: (a -> a -> a) -> GenMap m a -> a # elem :: Eq a => a -> GenMap m a -> Bool # maximum :: Ord a => GenMap m a -> a # minimum :: Ord a => GenMap m a -> a # | |
TrieMap m => Foldable (ListMap m) Source # | |
Defined in GHC.Data.TrieMap fold :: Monoid m0 => ListMap m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> ListMap m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> ListMap m a -> m0 # foldr :: (a -> b -> b) -> b -> ListMap m a -> b # foldr' :: (a -> b -> b) -> b -> ListMap m a -> b # foldl :: (b -> a -> b) -> b -> ListMap m a -> b # foldl' :: (b -> a -> b) -> b -> ListMap m a -> b # foldr1 :: (a -> a -> a) -> ListMap m a -> a # foldl1 :: (a -> a -> a) -> ListMap m a -> a # toList :: ListMap m a -> [a] # length :: ListMap m a -> Int # elem :: Eq a => a -> ListMap m a -> Bool # maximum :: Ord a => ListMap m a -> a # minimum :: Ord a => ListMap m a -> a # | |
TrieMap m => Foldable (MaybeMap m) Source # | |
Defined in GHC.Data.TrieMap fold :: Monoid m0 => MaybeMap m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> MaybeMap m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> MaybeMap m a -> m0 # foldr :: (a -> b -> b) -> b -> MaybeMap m a -> b # foldr' :: (a -> b -> b) -> b -> MaybeMap m a -> b # foldl :: (b -> a -> b) -> b -> MaybeMap m a -> b # foldl' :: (b -> a -> b) -> b -> MaybeMap m a -> b # foldr1 :: (a -> a -> a) -> MaybeMap m a -> a # foldl1 :: (a -> a -> a) -> MaybeMap m a -> a # toList :: MaybeMap m a -> [a] # null :: MaybeMap m a -> Bool # length :: MaybeMap m a -> Int # elem :: Eq a => a -> MaybeMap m a -> Bool # maximum :: Ord a => MaybeMap m a -> a # minimum :: Ord a => MaybeMap m a -> a # | |
Foldable (IfaceBindingX r) Source # | |
Defined in GHC.Iface.Syntax fold :: Monoid m => IfaceBindingX r m -> m # foldMap :: Monoid m => (a -> m) -> IfaceBindingX r a -> m # foldMap' :: Monoid m => (a -> m) -> IfaceBindingX r a -> m # foldr :: (a -> b -> b) -> b -> IfaceBindingX r a -> b # foldr' :: (a -> b -> b) -> b -> IfaceBindingX r a -> b # foldl :: (b -> a -> b) -> b -> IfaceBindingX r a -> b # foldl' :: (b -> a -> b) -> b -> IfaceBindingX r a -> b # foldr1 :: (a -> a -> a) -> IfaceBindingX r a -> a # foldl1 :: (a -> a -> a) -> IfaceBindingX r a -> a # toList :: IfaceBindingX r a -> [a] # null :: IfaceBindingX r a -> Bool # length :: IfaceBindingX r a -> Int # elem :: Eq a => a -> IfaceBindingX r a -> Bool # maximum :: Ord a => IfaceBindingX r a -> a # minimum :: Ord a => IfaceBindingX r a -> a # sum :: Num a => IfaceBindingX r a -> a # product :: Num a => IfaceBindingX r a -> a # | |
Foldable (GenLocated l) Source # | |
Defined in GHC.Types.SrcLoc fold :: Monoid m => GenLocated l m -> m # foldMap :: Monoid m => (a -> m) -> GenLocated l a -> m # foldMap' :: Monoid m => (a -> m) -> GenLocated l a -> m # foldr :: (a -> b -> b) -> b -> GenLocated l a -> b # foldr' :: (a -> b -> b) -> b -> GenLocated l a -> b # foldl :: (b -> a -> b) -> b -> GenLocated l a -> b # foldl' :: (b -> a -> b) -> b -> GenLocated l a -> b # foldr1 :: (a -> a -> a) -> GenLocated l a -> a # foldl1 :: (a -> a -> a) -> GenLocated l a -> a # toList :: GenLocated l a -> [a] # null :: GenLocated l a -> Bool # length :: GenLocated l a -> Int # elem :: Eq a => a -> GenLocated l a -> Bool # maximum :: Ord a => GenLocated l a -> a # minimum :: Ord a => GenLocated l a -> a # sum :: Num a => GenLocated l a -> a # product :: Num a => GenLocated l a -> a # | |
Foldable (HsFieldBind lhs) Source # | |
Defined in Language.Haskell.Syntax.Pat fold :: Monoid m => HsFieldBind lhs m -> m # foldMap :: Monoid m => (a -> m) -> HsFieldBind lhs a -> m # foldMap' :: Monoid m => (a -> m) -> HsFieldBind lhs a -> m # foldr :: (a -> b -> b) -> b -> HsFieldBind lhs a -> b # foldr' :: (a -> b -> b) -> b -> HsFieldBind lhs a -> b # foldl :: (b -> a -> b) -> b -> HsFieldBind lhs a -> b # foldl' :: (b -> a -> b) -> b -> HsFieldBind lhs a -> b # foldr1 :: (a -> a -> a) -> HsFieldBind lhs a -> a # foldl1 :: (a -> a -> a) -> HsFieldBind lhs a -> a # toList :: HsFieldBind lhs a -> [a] # null :: HsFieldBind lhs a -> Bool # length :: HsFieldBind lhs a -> Int # elem :: Eq a => a -> HsFieldBind lhs a -> Bool # maximum :: Ord a => HsFieldBind lhs a -> a # minimum :: Ord a => HsFieldBind lhs a -> a # sum :: Num a => HsFieldBind lhs a -> a # product :: Num a => HsFieldBind lhs a -> a # | |
Foldable (DbOpenMode mode) Source # | |
Defined in GHC.Unit.Database fold :: Monoid m => DbOpenMode mode m -> m # foldMap :: Monoid m => (a -> m) -> DbOpenMode mode a -> m # foldMap' :: Monoid m => (a -> m) -> DbOpenMode mode a -> m # foldr :: (a -> b -> b) -> b -> DbOpenMode mode a -> b # foldr' :: (a -> b -> b) -> b -> DbOpenMode mode a -> b # foldl :: (b -> a -> b) -> b -> DbOpenMode mode a -> b # foldl' :: (b -> a -> b) -> b -> DbOpenMode mode a -> b # foldr1 :: (a -> a -> a) -> DbOpenMode mode a -> a # foldl1 :: (a -> a -> a) -> DbOpenMode mode a -> a # toList :: DbOpenMode mode a -> [a] # null :: DbOpenMode mode a -> Bool # length :: DbOpenMode mode a -> Int # elem :: Eq a => a -> DbOpenMode mode a -> Bool # maximum :: Ord a => DbOpenMode mode a -> a # minimum :: Ord a => DbOpenMode mode a -> a # sum :: Num a => DbOpenMode mode a -> a # product :: Num a => DbOpenMode mode a -> a # | |
Foldable (Array i) # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => Array i m -> m # foldMap :: Monoid m => (a -> m) -> Array i a -> m # foldMap' :: Monoid m => (a -> m) -> Array i a -> m # foldr :: (a -> b -> b) -> b -> Array i a -> b # foldr' :: (a -> b -> b) -> b -> Array i a -> b # foldl :: (b -> a -> b) -> b -> Array i a -> b # foldl' :: (b -> a -> b) -> b -> Array i a -> b # foldr1 :: (a -> a -> a) -> Array i a -> a # foldl1 :: (a -> a -> a) -> Array i a -> a # elem :: Eq a => a -> Array i a -> Bool # maximum :: Ord a => Array i a -> a # minimum :: Ord a => Array i a -> a # | |
Foldable (Either a) # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => Either a m -> m # foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # toList :: Either a a0 -> [a0] # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # | |
Foldable (Proxy :: Type -> Type) # | |
Defined in GHC.Internal.Data.Foldable 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 # | |
Foldable (U1 :: Type -> Type) # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => U1 m -> m # foldMap :: Monoid m => (a -> m) -> U1 a -> m # foldMap' :: Monoid m => (a -> m) -> U1 a -> m # foldr :: (a -> b -> b) -> b -> U1 a -> b # foldr' :: (a -> b -> b) -> b -> U1 a -> b # foldl :: (b -> a -> b) -> b -> U1 a -> b # foldl' :: (b -> a -> b) -> b -> U1 a -> b # foldr1 :: (a -> a -> a) -> U1 a -> a # foldl1 :: (a -> a -> a) -> U1 a -> a # elem :: Eq a => a -> U1 a -> Bool # maximum :: Ord a => U1 a -> a # | |
Foldable (UAddr :: Type -> Type) # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => UAddr m -> m # foldMap :: Monoid m => (a -> m) -> UAddr a -> m # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m # foldr :: (a -> b -> b) -> b -> UAddr a -> b # foldr' :: (a -> b -> b) -> b -> UAddr a -> b # foldl :: (b -> a -> b) -> b -> UAddr a -> b # foldl' :: (b -> a -> b) -> b -> UAddr a -> b # foldr1 :: (a -> a -> a) -> UAddr a -> a # foldl1 :: (a -> a -> a) -> UAddr a -> a # elem :: Eq a => a -> UAddr a -> Bool # maximum :: Ord a => UAddr a -> a # minimum :: Ord a => UAddr a -> a # | |
Foldable (UChar :: Type -> Type) # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => UChar m -> m # foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m # foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b # foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b # foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # minimum :: Ord a => UChar a -> a # | |
Foldable (UDouble :: Type -> Type) # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => UDouble m -> m # foldMap :: Monoid m => (a -> m) -> UDouble a -> m # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m # foldr :: (a -> b -> b) -> b -> UDouble a -> b # foldr' :: (a -> b -> b) -> b -> UDouble a -> b # foldl :: (b -> a -> b) -> b -> UDouble a -> b # foldl' :: (b -> a -> b) -> b -> UDouble a -> b # foldr1 :: (a -> a -> a) -> UDouble a -> a # foldl1 :: (a -> a -> a) -> UDouble a -> a # elem :: Eq a => a -> UDouble a -> Bool # maximum :: Ord a => UDouble a -> a # minimum :: Ord a => UDouble a -> a # | |
Foldable (UFloat :: Type -> Type) # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => UFloat m -> m # foldMap :: Monoid m => (a -> m) -> UFloat a -> m # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m # foldr :: (a -> b -> b) -> b -> UFloat a -> b # foldr' :: (a -> b -> b) -> b -> UFloat a -> b # foldl :: (b -> a -> b) -> b -> UFloat a -> b # foldl' :: (b -> a -> b) -> b -> UFloat a -> b # foldr1 :: (a -> a -> a) -> UFloat a -> a # foldl1 :: (a -> a -> a) -> UFloat a -> a # elem :: Eq a => a -> UFloat a -> Bool # maximum :: Ord a => UFloat a -> a # minimum :: Ord a => UFloat a -> a # | |
Foldable (UInt :: Type -> Type) # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => UInt m -> m # foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m # foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b # foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b # foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # | |
Foldable (UWord :: Type -> Type) # | |
Defined in GHC.Internal.Data.Foldable 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 # elem :: Eq a => a -> UWord a -> Bool # maximum :: Ord a => UWord a -> a # minimum :: Ord a => UWord a -> a # | |
Foldable (V1 :: Type -> Type) # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => V1 m -> m # foldMap :: Monoid m => (a -> m) -> V1 a -> m # foldMap' :: Monoid m => (a -> m) -> V1 a -> m # foldr :: (a -> b -> b) -> b -> V1 a -> b # foldr' :: (a -> b -> b) -> b -> V1 a -> b # foldl :: (b -> a -> b) -> b -> V1 a -> b # foldl' :: (b -> a -> b) -> b -> V1 a -> b # foldr1 :: (a -> a -> a) -> V1 a -> a # foldl1 :: (a -> a -> a) -> V1 a -> a # elem :: Eq a => a -> V1 a -> Bool # maximum :: Ord a => V1 a -> a # | |
Foldable f => Foldable (Lift f) Source # | |
Defined in Control.Applicative.Lift fold :: Monoid m => Lift f m -> m # foldMap :: Monoid m => (a -> m) -> Lift f a -> m # foldMap' :: Monoid m => (a -> m) -> Lift f a -> m # foldr :: (a -> b -> b) -> b -> Lift f a -> b # foldr' :: (a -> b -> b) -> b -> Lift f a -> b # foldl :: (b -> a -> b) -> b -> Lift f a -> b # foldl' :: (b -> a -> b) -> b -> Lift f a -> b # foldr1 :: (a -> a -> a) -> Lift f a -> a # foldl1 :: (a -> a -> a) -> Lift f a -> a # elem :: Eq a => a -> Lift f a -> Bool # maximum :: Ord a => Lift f a -> a # minimum :: Ord a => Lift f a -> a # | |
Foldable f => Foldable (MaybeT f) Source # | |
Defined in Control.Monad.Trans.Maybe fold :: Monoid m => MaybeT f m -> m # foldMap :: Monoid m => (a -> m) -> MaybeT f a -> m # foldMap' :: Monoid m => (a -> m) -> MaybeT f a -> m # foldr :: (a -> b -> b) -> b -> MaybeT f a -> b # foldr' :: (a -> b -> b) -> b -> MaybeT f a -> b # foldl :: (b -> a -> b) -> b -> MaybeT f a -> b # foldl' :: (b -> a -> b) -> b -> MaybeT f a -> b # foldr1 :: (a -> a -> a) -> MaybeT f a -> a # foldl1 :: (a -> a -> a) -> MaybeT f a -> a # elem :: Eq a => a -> MaybeT f a -> Bool # maximum :: Ord a => MaybeT f a -> a # minimum :: Ord a => MaybeT f a -> a # | |
Foldable ((,) a) # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => (a, m) -> m # foldMap :: Monoid m => (a0 -> m) -> (a, a0) -> m # foldMap' :: Monoid m => (a0 -> m) -> (a, a0) -> m # foldr :: (a0 -> b -> b) -> b -> (a, a0) -> b # foldr' :: (a0 -> b -> b) -> b -> (a, a0) -> b # foldl :: (b -> a0 -> b) -> b -> (a, a0) -> b # foldl' :: (b -> a0 -> b) -> b -> (a, a0) -> b # foldr1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # foldl1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # elem :: Eq a0 => a0 -> (a, a0) -> Bool # maximum :: Ord a0 => (a, a0) -> a0 # minimum :: Ord a0 => (a, a0) -> a0 # | |
Foldable (UniqDFM key) Source # | Deterministic, in O(n log n). |
Defined in GHC.Types.Unique.DFM fold :: Monoid m => UniqDFM key m -> m # foldMap :: Monoid m => (a -> m) -> UniqDFM key a -> m # foldMap' :: Monoid m => (a -> m) -> UniqDFM key a -> m # foldr :: (a -> b -> b) -> b -> UniqDFM key a -> b # foldr' :: (a -> b -> b) -> b -> UniqDFM key a -> b # foldl :: (b -> a -> b) -> b -> UniqDFM key a -> b # foldl' :: (b -> a -> b) -> b -> UniqDFM key a -> b # foldr1 :: (a -> a -> a) -> UniqDFM key a -> a # foldl1 :: (a -> a -> a) -> UniqDFM key a -> a # toList :: UniqDFM key a -> [a] # null :: UniqDFM key a -> Bool # length :: UniqDFM key a -> Int # elem :: Eq a => a -> UniqDFM key a -> Bool # maximum :: Ord a => UniqDFM key a -> a # minimum :: Ord a => UniqDFM key a -> a # | |
Foldable (NonDetUniqFM key) Source # | Inherently nondeterministic. If you use this please provide a justification why it doesn't introduce nondeterminism. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM to learn about determinism. |
Defined in GHC.Types.Unique.FM fold :: Monoid m => NonDetUniqFM key m -> m # foldMap :: Monoid m => (a -> m) -> NonDetUniqFM key a -> m # foldMap' :: Monoid m => (a -> m) -> NonDetUniqFM key a -> m # foldr :: (a -> b -> b) -> b -> NonDetUniqFM key a -> b # foldr' :: (a -> b -> b) -> b -> NonDetUniqFM key a -> b # foldl :: (b -> a -> b) -> b -> NonDetUniqFM key a -> b # foldl' :: (b -> a -> b) -> b -> NonDetUniqFM key a -> b # foldr1 :: (a -> a -> a) -> NonDetUniqFM key a -> a # foldl1 :: (a -> a -> a) -> NonDetUniqFM key a -> a # toList :: NonDetUniqFM key a -> [a] # null :: NonDetUniqFM key a -> Bool # length :: NonDetUniqFM key a -> Int # elem :: Eq a => a -> NonDetUniqFM key a -> Bool # maximum :: Ord a => NonDetUniqFM key a -> a # minimum :: Ord a => NonDetUniqFM key a -> a # sum :: Num a => NonDetUniqFM key a -> a # product :: Num a => NonDetUniqFM key a -> a # | |
Foldable (Const m :: Type -> Type) # | |
Defined in GHC.Internal.Data.Functor.Const 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 # | |
Foldable f => Foldable (Ap f) # | |
Defined in GHC.Internal.Data.Foldable 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 # | |
Foldable f => Foldable (Alt f) # | |
Defined in GHC.Internal.Data.Foldable 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 # | |
Foldable f => Foldable (Rec1 f) # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => Rec1 f m -> m # foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m # foldMap' :: Monoid m => (a -> m) -> Rec1 f a -> m # foldr :: (a -> b -> b) -> b -> Rec1 f a -> b # foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b # foldl :: (b -> a -> b) -> b -> Rec1 f a -> b # foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b # foldr1 :: (a -> a -> a) -> Rec1 f a -> a # foldl1 :: (a -> a -> a) -> Rec1 f a -> a # elem :: Eq a => a -> Rec1 f a -> Bool # maximum :: Ord a => Rec1 f a -> a # minimum :: Ord a => Rec1 f a -> a # | |
Foldable f => Foldable (Backwards f) Source # | Derived instance. |
Defined in Control.Applicative.Backwards fold :: Monoid m => Backwards f m -> m # foldMap :: Monoid m => (a -> m) -> Backwards f a -> m # foldMap' :: Monoid m => (a -> m) -> Backwards f a -> m # foldr :: (a -> b -> b) -> b -> Backwards f a -> b # foldr' :: (a -> b -> b) -> b -> Backwards f a -> b # foldl :: (b -> a -> b) -> b -> Backwards f a -> b # foldl' :: (b -> a -> b) -> b -> Backwards f a -> b # foldr1 :: (a -> a -> a) -> Backwards f a -> a # foldl1 :: (a -> a -> a) -> Backwards f a -> a # toList :: Backwards f a -> [a] # null :: Backwards f a -> Bool # length :: Backwards f a -> Int # elem :: Eq a => a -> Backwards f a -> Bool # maximum :: Ord a => Backwards f a -> a # minimum :: Ord a => Backwards f a -> a # | |
Foldable f => Foldable (ExceptT e f) Source # | |
Defined in Control.Monad.Trans.Except fold :: Monoid m => ExceptT e f m -> m # foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldMap' :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldr1 :: (a -> a -> a) -> ExceptT e f a -> a # foldl1 :: (a -> a -> a) -> ExceptT e f a -> a # toList :: ExceptT e f a -> [a] # null :: ExceptT e f a -> Bool # length :: ExceptT e f a -> Int # elem :: Eq a => a -> ExceptT e f a -> Bool # maximum :: Ord a => ExceptT e f a -> a # minimum :: Ord a => ExceptT e f a -> a # | |
Foldable f => Foldable (IdentityT f) Source # | |
Defined in Control.Monad.Trans.Identity fold :: Monoid m => IdentityT f m -> m # foldMap :: Monoid m => (a -> m) -> IdentityT f a -> m # foldMap' :: Monoid m => (a -> m) -> IdentityT f a -> m # foldr :: (a -> b -> b) -> b -> IdentityT f a -> b # foldr' :: (a -> b -> b) -> b -> IdentityT f a -> b # foldl :: (b -> a -> b) -> b -> IdentityT f a -> b # foldl' :: (b -> a -> b) -> b -> IdentityT f a -> b # foldr1 :: (a -> a -> a) -> IdentityT f a -> a # foldl1 :: (a -> a -> a) -> IdentityT f a -> a # toList :: IdentityT f a -> [a] # null :: IdentityT f a -> Bool # length :: IdentityT f a -> Int # elem :: Eq a => a -> IdentityT f a -> Bool # maximum :: Ord a => IdentityT f a -> a # minimum :: Ord a => IdentityT f a -> a # | |
Foldable f => Foldable (WriterT w f) Source # | |
Defined in Control.Monad.Trans.Writer.Lazy fold :: Monoid m => WriterT w f m -> m # foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m # foldMap' :: Monoid m => (a -> m) -> WriterT w f a -> m # foldr :: (a -> b -> b) -> b -> WriterT w f a -> b # foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b # foldl :: (b -> a -> b) -> b -> WriterT w f a -> b # foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b # foldr1 :: (a -> a -> a) -> WriterT w f a -> a # foldl1 :: (a -> a -> a) -> WriterT w f a -> a # toList :: WriterT w f a -> [a] # null :: WriterT w f a -> Bool # length :: WriterT w f a -> Int # elem :: Eq a => a -> WriterT w f a -> Bool # maximum :: Ord a => WriterT w f a -> a # minimum :: Ord a => WriterT w f a -> a # | |
Foldable f => Foldable (WriterT w f) Source # | |
Defined in Control.Monad.Trans.Writer.Strict fold :: Monoid m => WriterT w f m -> m # foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m # foldMap' :: Monoid m => (a -> m) -> WriterT w f a -> m # foldr :: (a -> b -> b) -> b -> WriterT w f a -> b # foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b # foldl :: (b -> a -> b) -> b -> WriterT w f a -> b # foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b # foldr1 :: (a -> a -> a) -> WriterT w f a -> a # foldl1 :: (a -> a -> a) -> WriterT w f a -> a # toList :: WriterT w f a -> [a] # null :: WriterT w f a -> Bool # length :: WriterT w f a -> Int # elem :: Eq a => a -> WriterT w f a -> Bool # maximum :: Ord a => WriterT w f a -> a # minimum :: Ord a => WriterT w f a -> a # | |
Foldable (Constant a :: Type -> Type) Source # | |
Defined in Data.Functor.Constant fold :: Monoid m => Constant a m -> m # foldMap :: Monoid m => (a0 -> m) -> Constant a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Constant a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Constant a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Constant a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Constant a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Constant a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Constant a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Constant a a0 -> a0 # toList :: Constant a a0 -> [a0] # null :: Constant a a0 -> Bool # length :: Constant a a0 -> Int # elem :: Eq a0 => a0 -> Constant a a0 -> Bool # maximum :: Ord a0 => Constant a a0 -> a0 # minimum :: Ord a0 => Constant a a0 -> a0 # | |
Foldable f => Foldable (Reverse f) Source # | Fold from right to left. |
Defined in Data.Functor.Reverse fold :: Monoid m => Reverse f m -> m # foldMap :: Monoid m => (a -> m) -> Reverse f a -> m # foldMap' :: Monoid m => (a -> m) -> Reverse f a -> m # foldr :: (a -> b -> b) -> b -> Reverse f a -> b # foldr' :: (a -> b -> b) -> b -> Reverse f a -> b # foldl :: (b -> a -> b) -> b -> Reverse f a -> b # foldl' :: (b -> a -> b) -> b -> Reverse f a -> b # foldr1 :: (a -> a -> a) -> Reverse f a -> a # foldl1 :: (a -> a -> a) -> Reverse f a -> a # toList :: Reverse f a -> [a] # length :: Reverse f a -> Int # elem :: Eq a => a -> Reverse f a -> Bool # maximum :: Ord a => Reverse f a -> a # minimum :: Ord a => Reverse f a -> a # | |
(Foldable f, Foldable g) => Foldable (Product f g) Source # | Since: base-4.9.0.0 |
Defined in Data.Functor.Product fold :: Monoid m => Product f g m -> m # foldMap :: Monoid m => (a -> m) -> Product f g a -> m # foldMap' :: Monoid m => (a -> m) -> Product f g a -> m # foldr :: (a -> b -> b) -> b -> Product f g a -> b # foldr' :: (a -> b -> b) -> b -> Product f g a -> b # foldl :: (b -> a -> b) -> b -> Product f g a -> b # foldl' :: (b -> a -> b) -> b -> Product f g a -> b # foldr1 :: (a -> a -> a) -> Product f g a -> a # foldl1 :: (a -> a -> a) -> Product f g a -> a # toList :: Product f g a -> [a] # null :: Product f g a -> Bool # length :: Product f g a -> Int # elem :: Eq a => a -> Product f g a -> Bool # maximum :: Ord a => Product f g a -> a # minimum :: Ord a => Product f g a -> a # | |
(Foldable f, Foldable g) => Foldable (Sum f g) Source # | Since: base-4.9.0.0 |
Defined in Data.Functor.Sum fold :: Monoid m => Sum f g m -> m # foldMap :: Monoid m => (a -> m) -> Sum f g a -> m # foldMap' :: Monoid m => (a -> m) -> Sum f g a -> m # foldr :: (a -> b -> b) -> b -> Sum f g a -> b # foldr' :: (a -> b -> b) -> b -> Sum f g a -> b # foldl :: (b -> a -> b) -> b -> Sum f g a -> b # foldl' :: (b -> a -> b) -> b -> Sum f g a -> b # foldr1 :: (a -> a -> a) -> Sum f g a -> a # foldl1 :: (a -> a -> a) -> Sum f g a -> a # elem :: Eq a => a -> Sum f g a -> Bool # maximum :: Ord a => Sum f g a -> a # minimum :: Ord a => Sum f g a -> a # | |
(Foldable f, Foldable g) => Foldable (f :*: g) # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => (f :*: g) m -> m # foldMap :: Monoid m => (a -> m) -> (f :*: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :*: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :*: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :*: g) a -> b # foldl :: (b -> a -> b) -> b -> (f :*: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :*: g) a -> b # foldr1 :: (a -> a -> a) -> (f :*: g) a -> a # foldl1 :: (a -> a -> a) -> (f :*: g) a -> a # toList :: (f :*: g) a -> [a] # length :: (f :*: g) a -> Int # elem :: Eq a => a -> (f :*: g) a -> Bool # maximum :: Ord a => (f :*: g) a -> a # minimum :: Ord a => (f :*: g) a -> a # | |
(Foldable f, Foldable g) => Foldable (f :+: g) # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => (f :+: g) m -> m # foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :+: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b # foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b # foldr1 :: (a -> a -> a) -> (f :+: g) a -> a # foldl1 :: (a -> a -> a) -> (f :+: g) a -> a # toList :: (f :+: g) a -> [a] # length :: (f :+: g) a -> Int # elem :: Eq a => a -> (f :+: g) a -> Bool # maximum :: Ord a => (f :+: g) a -> a # minimum :: Ord a => (f :+: g) a -> a # | |
Foldable (K1 i c :: Type -> Type) # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => K1 i c m -> m # foldMap :: Monoid m => (a -> m) -> K1 i c a -> m # foldMap' :: Monoid m => (a -> m) -> K1 i c a -> m # foldr :: (a -> b -> b) -> b -> K1 i c a -> b # foldr' :: (a -> b -> b) -> b -> K1 i c a -> b # foldl :: (b -> a -> b) -> b -> K1 i c a -> b # foldl' :: (b -> a -> b) -> b -> K1 i c a -> b # foldr1 :: (a -> a -> a) -> K1 i c a -> a # foldl1 :: (a -> a -> a) -> K1 i c a -> a # elem :: Eq a => a -> K1 i c a -> Bool # maximum :: Ord a => K1 i c a -> a # minimum :: Ord a => K1 i c a -> a # | |
(Foldable f, Foldable g) => Foldable (Compose f g) Source # | Since: base-4.9.0.0 |
Defined in Data.Functor.Compose fold :: Monoid m => Compose f g m -> m # foldMap :: Monoid m => (a -> m) -> Compose f g a -> m # foldMap' :: Monoid m => (a -> m) -> Compose f g a -> m # foldr :: (a -> b -> b) -> b -> Compose f g a -> b # foldr' :: (a -> b -> b) -> b -> Compose f g a -> b # foldl :: (b -> a -> b) -> b -> Compose f g a -> b # foldl' :: (b -> a -> b) -> b -> Compose f g a -> b # foldr1 :: (a -> a -> a) -> Compose f g a -> a # foldl1 :: (a -> a -> a) -> Compose f g a -> a # toList :: Compose f g a -> [a] # null :: Compose f g a -> Bool # length :: Compose f g a -> Int # elem :: Eq a => a -> Compose f g a -> Bool # maximum :: Ord a => Compose f g a -> a # minimum :: Ord a => Compose f g a -> a # | |
(Foldable f, Foldable g) => Foldable (f :.: g) # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => (f :.: g) m -> m # foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :.: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b # foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b # foldr1 :: (a -> a -> a) -> (f :.: g) a -> a # foldl1 :: (a -> a -> a) -> (f :.: g) a -> a # toList :: (f :.: g) a -> [a] # length :: (f :.: g) a -> Int # elem :: Eq a => a -> (f :.: g) a -> Bool # maximum :: Ord a => (f :.: g) a -> a # minimum :: Ord a => (f :.: g) a -> a # | |
Foldable f => Foldable (M1 i c f) # | |
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => M1 i c f m -> m # foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m # foldMap' :: Monoid m => (a -> m) -> M1 i c f a -> m # foldr :: (a -> b -> b) -> b -> M1 i c f a -> b # foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b # foldl :: (b -> a -> b) -> b -> M1 i c f a -> b # foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b # foldr1 :: (a -> a -> a) -> M1 i c f a -> a # foldl1 :: (a -> a -> a) -> M1 i c f a -> a # elem :: Eq a => a -> M1 i c f a -> Bool # maximum :: Ord a => M1 i c f a -> a # minimum :: Ord a => M1 i c f a -> a # |
class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where #
traverse :: Applicative f => (a -> f b) -> t a -> f (t b) #
sequenceA :: Applicative f => t (f a) -> f (t a) #
Instances
Instances
Instances
class Fractional a => Floating a where #
Instances
class (RealFrac a, Floating a) => RealFloat a where #
floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE
floatRadix :: a -> Integer #
floatDigits :: a -> Int #
floatRange :: a -> (Int, Int) #
decodeFloat :: a -> (Integer, Int) #
encodeFloat :: Integer -> Int -> a #
significand :: a -> a #
scaleFloat :: Int -> a -> a #
isInfinite :: a -> Bool #
isDenormalized :: a -> Bool #
isNegativeZero :: a -> Bool #
Instances
type IOError = IOException #
fromInteger :: Integer -> a #
Instances
Instances
class Num a => Fractional a where #
fromRational, (recip | (/))
Instances
class (Real a, Enum a) => Integral a where #
Instances
class (Num a, Ord a) => Real a where #
toRational :: a -> Rational #
Instances
class (Real a, Fractional a) => RealFrac a where #
properFraction :: Integral b => a -> (b, a) #
truncate :: Integral b => a -> b #
round :: Integral b => a -> b #
Instances
RealFrac CDouble # | |
RealFrac CFloat # | |
RealFrac DiffTime Source # | |
RealFrac NominalDiffTime Source # | |
Defined in Data.Time.Clock.Internal.NominalDiffTime properFraction :: Integral b => NominalDiffTime -> (b, NominalDiffTime) # truncate :: Integral b => NominalDiffTime -> b # round :: Integral b => NominalDiffTime -> b # ceiling :: Integral b => NominalDiffTime -> b # floor :: Integral b => NominalDiffTime -> b # | |
RealFrac a => RealFrac (Identity a) # | |
RealFrac a => RealFrac (Down a) # | |
Integral a => RealFrac (Ratio a) # | |
HasResolution a => RealFrac (Fixed a) Source # | Since: base-2.1 |
RealFrac a => RealFrac (Const a b) # | |
RealFrac (f (g a)) => RealFrac (Compose f g a) Source # | Since: base-4.20.0.0 |
Instances
Instances
Instances
Instances
Instances
Binary Ordering Source # | |
NFData Ordering Source # | |
Defined in Control.DeepSeq | |
Outputable Ordering Source # | |
Monoid Ordering # | |
Semigroup Ordering # | |
Data Ordering # | |
Defined in GHC.Internal.Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering # toConstr :: Ordering -> Constr # dataTypeOf :: Ordering -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) # gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r # gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering # | |
Bounded Ordering # | |
Enum Ordering # | |
Generic Ordering # | |
Defined in GHC.Internal.Generics | |
Ix Ordering # | |
Defined in GHC.Internal.Ix | |
Read Ordering # | |
Show Ordering # | |
Eq Ordering # | |
Ord Ordering # | |
Defined in GHC.Classes | |
type Rep Ordering # | |
Instances
Instances
Eq1 Maybe Source # | Since: base-4.9.0.0 | ||||
Ord1 Maybe Source # | Since: base-4.9.0.0 | ||||
Defined in Data.Functor.Classes | |||||
Read1 Maybe Source # | Since: base-4.9.0.0 | ||||
Defined in Data.Functor.Classes liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Maybe a) Source # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Maybe a] Source # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Maybe a) Source # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Maybe a] Source # | |||||
Show1 Maybe Source # | Since: base-4.9.0.0 | ||||
NFData1 Maybe Source # | Since: deepseq-1.4.3.0 | ||||
Defined in Control.DeepSeq | |||||
MonadThrow Maybe Source # | |||||
Defined in Control.Monad.Catch | |||||
Alternative Maybe # | |||||
Applicative Maybe # | |||||
Functor Maybe # | |||||
Monad Maybe # | |||||
MonadPlus Maybe # | |||||
MonadFail Maybe # | |||||
Defined in GHC.Internal.Control.Monad.Fail | |||||
MonadFix Maybe # | |||||
Defined in GHC.Internal.Control.Monad.Fix | |||||
Foldable Maybe # | |||||
Defined in GHC.Internal.Data.Foldable 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 # | |||||
Generic1 Maybe # | |||||
Defined in GHC.Internal.Generics
| |||||
OutputableP env a => OutputableP env (Maybe a) Source # | |||||
Lift a => Lift (Maybe a :: Type) # | |||||
Binary a => Binary (Maybe a) Source # | |||||
NFData a => NFData (Maybe a) Source # | |||||
Defined in Control.DeepSeq | |||||
HasLoc a => HasLoc (Maybe a) Source # | |||||
NoAnn (Maybe a) Source # | |||||
Defined in GHC.Parser.Annotation | |||||
Binary a => Binary (Maybe a) Source # | |||||
Outputable a => Outputable (Maybe a) Source # | |||||
Semigroup a => Monoid (Maybe a) # | |||||
Semigroup a => Semigroup (Maybe a) # | |||||
Data a => Data (Maybe a) # | |||||
Defined in GHC.Internal.Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) # toConstr :: Maybe a -> Constr # dataTypeOf :: Maybe a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) # gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r # gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # | |||||
Generic (Maybe a) # | |||||
Defined in GHC.Internal.Generics
| |||||
SingKind a => SingKind (Maybe a) # | |||||
Defined in GHC.Internal.Generics
| |||||
Read a => Read (Maybe a) # | |||||
Show a => Show (Maybe a) # | |||||
Eq (DeBruijn a) => Eq (DeBruijn (Maybe a)) Source # | |||||
Eq a => Eq (Maybe a) # | |||||
Ord a => Ord (Maybe a) # | |||||
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 Anno (Maybe Role) Source # | |||||
Defined in GHC.Hs.Decls | |||||
type DemoteRep (Maybe a) # | |||||
Defined in GHC.Internal.Generics | |||||
type Rep (Maybe a) # | |||||
Defined in GHC.Internal.Generics | |||||
data Sing (b :: Maybe a) # | |||||
Instances
Instances
IsChar Char Source # | Since: base-2.1 | ||||
PrintfArg Char Source # | Since: base-2.1 | ||||
Defined in Text.Printf formatArg :: Char -> FieldFormatter Source # parseFormat :: Char -> ModifierParser Source # | |||||
Binary Char Source # | |||||
NFData Char Source # | |||||
Defined in Control.DeepSeq | |||||
ToJExpr Char Source # | |||||
Binary Char Source # | |||||
ToJson String Source # | |||||
Data Char # | |||||
Defined in GHC.Internal.Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char # dataTypeOf :: Char -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) # gmapT :: (forall b. Data b => b -> b) -> Char -> Char # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r # gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char # | |||||
Bounded Char # | |||||
Enum Char # | |||||
Storable Char # | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
Ix Char # | |||||
Read Char # | |||||
Show Char # | |||||
Eq Char # | |||||
Ord Char # | |||||
HpcHash Char Source # | |||||
IArray UArray Char Source # | |||||
Defined in Data.Array.Base bounds :: Ix i => UArray i Char -> (i, i) Source # numElements :: Ix i => UArray i Char -> Int Source # unsafeArray :: Ix i => (i, i) -> [(Int, Char)] -> UArray i Char Source # unsafeAt :: Ix i => UArray i Char -> Int -> Char Source # unsafeReplace :: Ix i => UArray i Char -> [(Int, Char)] -> UArray i Char Source # unsafeAccum :: Ix i => (Char -> e' -> Char) -> UArray i Char -> [(Int, e')] -> UArray i Char Source # unsafeAccumArray :: Ix i => (Char -> e' -> Char) -> Char -> (i, i) -> [(Int, e')] -> UArray i Char Source # | |||||
TestCoercion SChar # | |||||
Defined in GHC.Internal.TypeLits | |||||
TestEquality SChar # | |||||
Defined in GHC.Internal.TypeLits | |||||
Lift Char # | |||||
MArray IOUArray Char IO Source # | |||||
Defined in Data.Array.IO.Internals getBounds :: Ix i => IOUArray i Char -> IO (i, i) Source # getNumElements :: Ix i => IOUArray i Char -> IO Int Source # newArray :: Ix i => (i, i) -> Char -> IO (IOUArray i Char) Source # newArray_ :: Ix i => (i, i) -> IO (IOUArray i Char) Source # unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Char) Source # unsafeRead :: Ix i => IOUArray i Char -> Int -> IO Char Source # unsafeWrite :: Ix i => IOUArray i Char -> Int -> Char -> IO () Source # | |||||
Generic1 (URec Char :: k -> Type) # | |||||
Defined in GHC.Internal.Generics
| |||||
Eq1 (UChar :: Type -> Type) Source # | Since: base-4.21.0.0 | ||||
Ord1 (UChar :: Type -> Type) Source # | Since: base-4.21.0.0 | ||||
Defined in Data.Functor.Classes | |||||
Show1 (UChar :: Type -> Type) Source # | Since: base-4.21.0.0 | ||||
Foldable (UChar :: Type -> Type) # | |||||
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => UChar m -> m # foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m # foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b # foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b # foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # minimum :: Ord a => UChar a -> a # | |||||
Traversable (UChar :: Type -> Type) # | |||||
MArray (STUArray s) Char (ST s) Source # | |||||
Defined in Data.Array.Base getBounds :: Ix i => STUArray s i Char -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Char -> ST s Int Source # newArray :: Ix i => (i, i) -> Char -> ST s (STUArray s i Char) Source # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Char) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Char) Source # unsafeRead :: Ix i => STUArray s i Char -> Int -> ST s Char Source # unsafeWrite :: Ix i => STUArray s i Char -> Int -> Char -> ST s () Source # | |||||
ToJExpr a => ToJExpr (Map String a) Source # | |||||
Functor (URec Char :: Type -> Type) # | |||||
Generic (URec Char p) # | |||||
Defined in GHC.Internal.Generics
| |||||
Show (URec Char p) # | |||||
Eq (URec Char p) # | |||||
Ord (URec Char p) # | |||||
Defined in GHC.Internal.Generics | |||||
data URec Char (p :: k) # | |||||
type Compare (a :: Char) (b :: Char) # | |||||
Defined in GHC.Internal.Data.Type.Ord | |||||
type Rep1 (URec Char :: k -> Type) # | |||||
Defined in GHC.Internal.Generics | |||||
type Rep (URec Char p) # | |||||
Defined in GHC.Internal.Generics |
Instances
PrintfArg Double Source # | Since: base-2.1 | ||||
Defined in Text.Printf formatArg :: Double -> FieldFormatter Source # parseFormat :: Double -> ModifierParser Source # | |||||
Binary Double Source # | Uses non-IEEE754 encoding. Does not round-trip NaN. | ||||
NFData Double Source # | |||||
Defined in Control.DeepSeq | |||||
ToJExpr Double Source # | |||||
Outputable Double Source # | |||||
Data Double # | |||||
Defined in GHC.Internal.Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double # toConstr :: Double -> Constr # dataTypeOf :: Double -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Double) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) # gmapT :: (forall b. Data b => b -> b) -> Double -> Double # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r # gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double # | |||||
Floating Double # | |||||
RealFloat Double # | |||||
Defined in GHC.Internal.Float floatRadix :: Double -> Integer # floatDigits :: Double -> Int # floatRange :: Double -> (Int, Int) # decodeFloat :: Double -> (Integer, Int) # encodeFloat :: Integer -> Int -> Double # significand :: Double -> Double # scaleFloat :: Int -> Double -> Double # isInfinite :: Double -> Bool # isDenormalized :: Double -> Bool # isNegativeZero :: Double -> Bool # | |||||
Storable Double # | |||||
Read Double # | |||||
Eq Double # | |||||
Ord Double # | |||||
IArray UArray Double Source # | |||||
Defined in Data.Array.Base bounds :: Ix i => UArray i Double -> (i, i) Source # numElements :: Ix i => UArray i Double -> Int Source # unsafeArray :: Ix i => (i, i) -> [(Int, Double)] -> UArray i Double Source # unsafeAt :: Ix i => UArray i Double -> Int -> Double Source # unsafeReplace :: Ix i => UArray i Double -> [(Int, Double)] -> UArray i Double Source # unsafeAccum :: Ix i => (Double -> e' -> Double) -> UArray i Double -> [(Int, e')] -> UArray i Double Source # unsafeAccumArray :: Ix i => (Double -> e' -> Double) -> Double -> (i, i) -> [(Int, e')] -> UArray i Double Source # | |||||
Lift Double # | |||||
MArray IOUArray Double IO Source # | |||||
Defined in Data.Array.IO.Internals getBounds :: Ix i => IOUArray i Double -> IO (i, i) Source # getNumElements :: Ix i => IOUArray i Double -> IO Int Source # newArray :: Ix i => (i, i) -> Double -> IO (IOUArray i Double) Source # newArray_ :: Ix i => (i, i) -> IO (IOUArray i Double) Source # unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Double) Source # unsafeRead :: Ix i => IOUArray i Double -> Int -> IO Double Source # unsafeWrite :: Ix i => IOUArray i Double -> Int -> Double -> IO () Source # | |||||
Generic1 (URec Double :: k -> Type) # | |||||
Defined in GHC.Internal.Generics
| |||||
Eq1 (UDouble :: Type -> Type) Source # | Since: base-4.21.0.0 | ||||
Ord1 (UDouble :: Type -> Type) Source # | Since: base-4.21.0.0 | ||||
Defined in Data.Functor.Classes | |||||
Show1 (UDouble :: Type -> Type) Source # | Since: base-4.21.0.0 | ||||
Foldable (UDouble :: Type -> Type) # | |||||
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => UDouble m -> m # foldMap :: Monoid m => (a -> m) -> UDouble a -> m # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m # foldr :: (a -> b -> b) -> b -> UDouble a -> b # foldr' :: (a -> b -> b) -> b -> UDouble a -> b # foldl :: (b -> a -> b) -> b -> UDouble a -> b # foldl' :: (b -> a -> b) -> b -> UDouble a -> b # foldr1 :: (a -> a -> a) -> UDouble a -> a # foldl1 :: (a -> a -> a) -> UDouble a -> a # elem :: Eq a => a -> UDouble a -> Bool # maximum :: Ord a => UDouble a -> a # minimum :: Ord a => UDouble a -> a # | |||||
Traversable (UDouble :: Type -> Type) # | |||||
MArray (STUArray s) Double (ST s) Source # | |||||
Defined in Data.Array.Base getBounds :: Ix i => STUArray s i Double -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Double -> ST s Int Source # newArray :: Ix i => (i, i) -> Double -> ST s (STUArray s i Double) Source # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Double) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Double) Source # unsafeRead :: Ix i => STUArray s i Double -> Int -> ST s Double Source # unsafeWrite :: Ix i => STUArray s i Double -> Int -> Double -> ST s () Source # | |||||
Functor (URec Double :: Type -> Type) # | |||||
Generic (URec Double p) # | |||||
Defined in GHC.Internal.Generics
| |||||
Show (URec Double p) # | |||||
Eq (URec Double p) # | |||||
Ord (URec Double p) # | |||||
Defined in GHC.Internal.Generics 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 # | |||||
data URec Double (p :: k) # | |||||
type Rep1 (URec Double :: k -> Type) # | |||||
Defined in GHC.Internal.Generics | |||||
type Rep (URec Double p) # | |||||
Defined in GHC.Internal.Generics |
Instances
PrintfArg Float Source # | Since: base-2.1 | ||||
Defined in Text.Printf formatArg :: Float -> FieldFormatter Source # parseFormat :: Float -> ModifierParser Source # | |||||
Binary Float Source # | Uses non-IEEE754 encoding. Does not round-trip NaN. | ||||
NFData Float Source # | |||||
Defined in Control.DeepSeq | |||||
Outputable Float Source # | |||||
Data Float # | |||||
Defined in GHC.Internal.Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float # dataTypeOf :: Float -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) # gmapT :: (forall b. Data b => b -> b) -> Float -> Float # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r # gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float # | |||||
Floating Float # | |||||
RealFloat Float # | |||||
Defined in GHC.Internal.Float floatRadix :: Float -> Integer # floatDigits :: Float -> Int # floatRange :: Float -> (Int, Int) # decodeFloat :: Float -> (Integer, Int) # encodeFloat :: Integer -> Int -> Float # significand :: Float -> Float # scaleFloat :: Int -> Float -> Float # isInfinite :: Float -> Bool # isDenormalized :: Float -> Bool # isNegativeZero :: Float -> Bool # | |||||
Storable Float # | |||||
Read Float # | |||||
Eq Float # | |||||
Ord Float # | |||||
IArray UArray Float Source # | |||||
Defined in Data.Array.Base bounds :: Ix i => UArray i Float -> (i, i) Source # numElements :: Ix i => UArray i Float -> Int Source # unsafeArray :: Ix i => (i, i) -> [(Int, Float)] -> UArray i Float Source # unsafeAt :: Ix i => UArray i Float -> Int -> Float Source # unsafeReplace :: Ix i => UArray i Float -> [(Int, Float)] -> UArray i Float Source # unsafeAccum :: Ix i => (Float -> e' -> Float) -> UArray i Float -> [(Int, e')] -> UArray i Float Source # unsafeAccumArray :: Ix i => (Float -> e' -> Float) -> Float -> (i, i) -> [(Int, e')] -> UArray i Float Source # | |||||
Lift Float # | |||||
MArray IOUArray Float IO Source # | |||||
Defined in Data.Array.IO.Internals getBounds :: Ix i => IOUArray i Float -> IO (i, i) Source # getNumElements :: Ix i => IOUArray i Float -> IO Int Source # newArray :: Ix i => (i, i) -> Float -> IO (IOUArray i Float) Source # newArray_ :: Ix i => (i, i) -> IO (IOUArray i Float) Source # unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Float) Source # unsafeRead :: Ix i => IOUArray i Float -> Int -> IO Float Source # unsafeWrite :: Ix i => IOUArray i Float -> Int -> Float -> IO () Source # | |||||
Generic1 (URec Float :: k -> Type) # | |||||
Defined in GHC.Internal.Generics
| |||||
Eq1 (UFloat :: Type -> Type) Source # | Since: base-4.21.0.0 | ||||
Ord1 (UFloat :: Type -> Type) Source # | Since: base-4.21.0.0 | ||||
Defined in Data.Functor.Classes | |||||
Show1 (UFloat :: Type -> Type) Source # | Since: base-4.21.0.0 | ||||
Foldable (UFloat :: Type -> Type) # | |||||
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => UFloat m -> m # foldMap :: Monoid m => (a -> m) -> UFloat a -> m # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m # foldr :: (a -> b -> b) -> b -> UFloat a -> b # foldr' :: (a -> b -> b) -> b -> UFloat a -> b # foldl :: (b -> a -> b) -> b -> UFloat a -> b # foldl' :: (b -> a -> b) -> b -> UFloat a -> b # foldr1 :: (a -> a -> a) -> UFloat a -> a # foldl1 :: (a -> a -> a) -> UFloat a -> a # elem :: Eq a => a -> UFloat a -> Bool # maximum :: Ord a => UFloat a -> a # minimum :: Ord a => UFloat a -> a # | |||||
Traversable (UFloat :: Type -> Type) # | |||||
MArray (STUArray s) Float (ST s) Source # | |||||
Defined in Data.Array.Base getBounds :: Ix i => STUArray s i Float -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Float -> ST s Int Source # newArray :: Ix i => (i, i) -> Float -> ST s (STUArray s i Float) Source # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Float) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Float) Source # unsafeRead :: Ix i => STUArray s i Float -> Int -> ST s Float Source # unsafeWrite :: Ix i => STUArray s i Float -> Int -> Float -> ST s () Source # | |||||
Functor (URec Float :: Type -> Type) # | |||||
Generic (URec Float p) # | |||||
Defined in GHC.Internal.Generics
| |||||
Show (URec Float p) # | |||||
Eq (URec Float p) # | |||||
Ord (URec Float p) # | |||||
Defined in GHC.Internal.Generics | |||||
data URec Float (p :: k) # | |||||
type Rep1 (URec Float :: k -> Type) # | |||||
Defined in GHC.Internal.Generics | |||||
type Rep (URec Float p) # | |||||
Defined in GHC.Internal.Generics |
Instances
PrintfArg Int Source # | Since: base-2.1 | ||||
Defined in Text.Printf formatArg :: Int -> FieldFormatter Source # parseFormat :: Int -> ModifierParser Source # | |||||
Binary Int Source # | |||||
NFData Int Source # | |||||
Defined in Control.DeepSeq | |||||
ToJExpr Int Source # | |||||
Uniquable Int Source # | |||||
Binary Int Source # | |||||
ToJson Int Source # | |||||
Outputable Int Source # | |||||
Bits Int # | |||||
Defined in GHC.Internal.Bits | |||||
FiniteBits Int # | |||||
Defined in GHC.Internal.Bits | |||||
Data Int # | |||||
Defined in GHC.Internal.Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int # dataTypeOf :: Int -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) # gmapT :: (forall b. Data b => b -> b) -> Int -> Int # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r # gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int # | |||||
Bounded Int # | |||||
Enum Int # | |||||
Storable Int # | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
Ix Int # | |||||
Num Int # | |||||
Read Int # | |||||
Integral Int # | |||||
Real Int # | |||||
Defined in GHC.Internal.Real toRational :: Int -> Rational # | |||||
Show Int # | |||||
Eq Int # | |||||
Ord Int # | |||||
HpcHash Int Source # | |||||
IArray UArray Int Source # | |||||
Defined in Data.Array.Base bounds :: Ix i => UArray i Int -> (i, i) Source # numElements :: Ix i => UArray i Int -> Int Source # unsafeArray :: Ix i => (i, i) -> [(Int, Int)] -> UArray i Int Source # unsafeAt :: Ix i => UArray i Int -> Int -> Int Source # unsafeReplace :: Ix i => UArray i Int -> [(Int, Int)] -> UArray i Int Source # unsafeAccum :: Ix i => (Int -> e' -> Int) -> UArray i Int -> [(Int, e')] -> UArray i Int Source # unsafeAccumArray :: Ix i => (Int -> e' -> Int) -> Int -> (i, i) -> [(Int, e')] -> UArray i Int Source # | |||||
Lift Int # | |||||
MArray IOUArray Int IO Source # | |||||
Defined in Data.Array.IO.Internals getBounds :: Ix i => IOUArray i Int -> IO (i, i) Source # getNumElements :: Ix i => IOUArray i Int -> IO Int Source # newArray :: Ix i => (i, i) -> Int -> IO (IOUArray i Int) Source # newArray_ :: Ix i => (i, i) -> IO (IOUArray i Int) Source # unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Int) Source # unsafeRead :: Ix i => IOUArray i Int -> Int -> IO Int Source # unsafeWrite :: Ix i => IOUArray i Int -> Int -> Int -> IO () Source # | |||||
Generic1 (URec Int :: k -> Type) # | |||||
Defined in GHC.Internal.Generics
| |||||
Eq1 (UInt :: Type -> Type) Source # | Since: base-4.21.0.0 | ||||
Ord1 (UInt :: Type -> Type) Source # | Since: base-4.21.0.0 | ||||
Defined in Data.Functor.Classes | |||||
Show1 (UInt :: Type -> Type) Source # | Since: base-4.21.0.0 | ||||
Binary (HieAST TypeIndex) Source # | |||||
Binary (HieASTs TypeIndex) Source # | |||||
Binary (HieArgs TypeIndex) Source # | |||||
Binary (HieType TypeIndex) Source # | |||||
Binary (IdentifierDetails TypeIndex) Source # | |||||
Defined in GHC.Iface.Ext.Types put_ :: WriteBinHandle -> IdentifierDetails TypeIndex -> IO () Source # put :: WriteBinHandle -> IdentifierDetails TypeIndex -> IO (Bin (IdentifierDetails TypeIndex)) Source # get :: ReadBinHandle -> IO (IdentifierDetails TypeIndex) Source # | |||||
Binary (NodeInfo TypeIndex) Source # | |||||
Binary (SourcedNodeInfo TypeIndex) Source # | |||||
Defined in GHC.Iface.Ext.Types put_ :: WriteBinHandle -> SourcedNodeInfo TypeIndex -> IO () Source # put :: WriteBinHandle -> SourcedNodeInfo TypeIndex -> IO (Bin (SourcedNodeInfo TypeIndex)) Source # get :: ReadBinHandle -> IO (SourcedNodeInfo TypeIndex) Source # | |||||
Foldable (UInt :: Type -> Type) # | |||||
Defined in GHC.Internal.Data.Foldable fold :: Monoid m => UInt m -> m # foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m # foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b # foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b # foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # | |||||
Traversable (UInt :: Type -> Type) # | |||||
MArray (STUArray s) Int (ST s) Source # | |||||
Defined in Data.Array.Base getBounds :: Ix i => STUArray s i Int -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Int -> ST s Int Source # newArray :: Ix i => (i, i) -> Int -> ST s (STUArray s i Int) Source # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int) Source # unsafeRead :: Ix i => STUArray s i Int -> Int -> ST s Int Source # unsafeWrite :: Ix i => STUArray s i Int -> Int -> Int -> ST s () Source # | |||||
Functor (URec Int :: Type -> Type) # | |||||
Generic (URec Int p) # | |||||
Defined in GHC.Internal.Generics
| |||||
Show (URec Int p) # | |||||
Eq (URec Int p) # | |||||
Ord (URec Int p) # | |||||
data URec Int (p :: k) # | |||||
type Rep1 (URec Int :: k -> Type) # | |||||
Defined in GHC.Internal.Generics | |||||
type Rep (URec Int p) # | |||||
Defined in GHC.Internal.Generics |
Instances
PrintfArg Word Source # | Since: base-2.1 | ||||
Defined in Text.Printf formatArg :: Word -> FieldFormatter Source # parseFormat :: Word -> ModifierParser Source # | |||||
Binary Word Source # | |||||
NFData Word Source # | |||||
Defined in Control.DeepSeq | |||||
Outputable Word Source # | |||||
Bits Word # | |||||
Defined in GHC.Internal.Bits (.&.) :: 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 | |||||
Data Word # | |||||
Defined in GHC.Internal.Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word # dataTypeOf :: Word -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) # gmapT :: (forall b. Data b => b -> b) -> Word -> Word # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r # gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word # | |||||
Bounded Word # | |||||
Enum Word # | |||||
Storable Word # | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
Ix Word # | |||||
Num Word # | |||||
Read Word # | |||||
Integral Word # | |||||
Real Word # | |||||
Defined in GHC.Internal.Real toRational :: Word -> Rational # | |||||
Show Word # | |||||
Eq Word # | |||||
Ord Word # | |||||
IArray UArray Word Source # | |||||
Defined in Data.Array.Base bounds :: Ix i => UArray i Word -> (i, i) Source # numElements :: Ix i => UArray i Word -> Int Source # unsafeArray :: Ix i => (i, i) -> [(Int, Word)] -> UArray i Word Source # unsafeAt :: Ix i => UArray i Word -> Int -> Word Source # unsafeReplace :: Ix i => UArray i Word -> [(Int, Word)] -> UArray i Word Source # unsafeAccum :: Ix i => (Word -> e' -> Word) -> UArray i Word -> [(Int, e')] -> UArray i Word Source # unsafeAccumArray :: Ix i => (Word -> e' -> Word) -> Word -> (i, i) -> [(Int, e')] -> UArray i Word Source # | |||||
Lift Word # | |||||
MArray IOUArray Word IO Source # | |||||
Defined in Data.Array.IO.Internals getBounds :: Ix i => IOUArray i Word -> IO (i, i) Source # getNumElements :: Ix i => IOUArray i Word -> IO Int Source # newArray :: Ix i => (i, i) -> Word -> IO (IOUArray i Word) Source # newArray_ :: Ix i => (i, i) -> IO (IOUArray i Word) Source # unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Word) Source # unsafeRead :: Ix i => IOUArray i Word -> Int -> IO Word Source # unsafeWrite :: Ix i => IOUArray i Word -> Int -> Word -> IO () Source # | |||||
Generic1 (URec Word :: k -> Type) # | |||||
Defined in GHC.Internal.Generics
| |||||
Eq1 (UWord :: Type -> Type) Source # | Since: base-4.21.0.0 | ||||
Ord1 (UWord :: Type -> Type) Source # | Since: base-4.21.0.0 | ||||
Defined in Data.Functor.Classes | |||||
Show1 (UWord :: Type -> Type) Source # | Since: base-4.21.0.0 | ||||
Foldable (UWord :: Type -> Type) # | |||||
Defined in GHC.Internal.Data.Foldable 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 # elem :: Eq a => a -> UWord a -> Bool # maximum :: Ord a => UWord a -> a # minimum :: Ord a => UWord a -> a # | |||||
Traversable (UWord :: Type -> Type) # | |||||
Show (BCOByteArray Word) Source # | |||||
Defined in GHCi.ResolvedBCO | |||||
MArray (STUArray s) Word (ST s) Source # | |||||
Defined in Data.Array.Base getBounds :: Ix i => STUArray s i Word -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Word -> ST s Int Source # newArray :: Ix i => (i, i) -> Word -> ST s (STUArray s i Word) Source # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word) Source # unsafeRead :: Ix i => STUArray s i Word -> Int -> ST s Word Source # unsafeWrite :: Ix i => STUArray s i Word -> Int -> Word -> ST s () Source # | |||||
Functor (URec Word :: Type -> Type) # | |||||
Generic (URec Word p) # | |||||
Defined in GHC.Internal.Generics
| |||||
Show (URec Word p) # | |||||
Eq (URec Word p) # | |||||
Ord (URec Word p) # | |||||
Defined in GHC.Internal.Generics | |||||
data URec Word (p :: k) # | |||||
type Rep1 (URec Word :: k -> Type) # | |||||
Defined in GHC.Internal.Generics | |||||
type Rep (URec Word p) # | |||||
Defined in GHC.Internal.Generics |
class Functor f => Applicative (f :: Type -> Type) where #
Instances
Applicative Complex Source # | Since: base-4.9.0.0 |
Applicative First Source # | Since: base-4.9.0.0 |
Applicative Last Source # | Since: base-4.9.0.0 |
Applicative Max Source # | Since: base-4.9.0.0 |
Applicative Min Source # | Since: base-4.9.0.0 |
Applicative Get Source # | |
Applicative PutM Source # | |
Applicative Put Source # | |
Applicative Seq Source # | Since: containers-0.5.4 |
Applicative Tree Source # | |
Applicative Opt Source # | |
Applicative PD Source # | |
Applicative NatM Source # | |
Applicative LlvmM Source # | |
Applicative CoreM Source # | |
Applicative SimplM Source # | |
Applicative UnifyResultM Source # | |
Defined in GHC.Core.Unify pure :: a -> UnifyResultM a # (<*>) :: UnifyResultM (a -> b) -> UnifyResultM a -> UnifyResultM b # liftA2 :: (a -> b -> c) -> UnifyResultM a -> UnifyResultM b -> UnifyResultM c # (*>) :: UnifyResultM a -> UnifyResultM b -> UnifyResultM b # (<*) :: UnifyResultM a -> UnifyResultM b -> UnifyResultM a # | |
Applicative NullCollapseViz Source # | |
Defined in GHC.Data.Graph.Collapse pure :: a -> NullCollapseViz a # (<*>) :: NullCollapseViz (a -> b) -> NullCollapseViz a -> NullCollapseViz b # liftA2 :: (a -> b -> c) -> NullCollapseViz a -> NullCollapseViz b -> NullCollapseViz c # (*>) :: NullCollapseViz a -> NullCollapseViz b -> NullCollapseViz b # (<*) :: NullCollapseViz a -> NullCollapseViz b -> NullCollapseViz a # | |
Applicative Infinite Source # | |
Applicative Pair Source # | |
Applicative Maybe Source # | |
Applicative Hsc Source # | |
Applicative Ghc Source # | |
Applicative HookedUse Source # | |
Applicative MatchResult Source # | Product is an "or" on fallibility---the combined match result is infallible only if the left and right argument match results both were. This is useful for combining a bunch of alternatives together and then
getting the overall fallibility of the entire group. See |
Defined in GHC.HsToCore.Monad pure :: a -> MatchResult a # (<*>) :: MatchResult (a -> b) -> MatchResult a -> MatchResult b # liftA2 :: (a -> b -> c) -> MatchResult a -> MatchResult b -> MatchResult c # (*>) :: MatchResult a -> MatchResult b -> MatchResult b # (<*) :: MatchResult a -> MatchResult b -> MatchResult a # | |
Applicative P Source # | |
Applicative PV Source # | |
Applicative CpsRn Source # | |
Applicative LiftM Source # | |
Applicative CmmParse Source # | |
Applicative FCode Source # | |
Applicative SolverStage Source # | |
Defined in GHC.Tc.Solver.Monad pure :: a -> SolverStage a # (<*>) :: SolverStage (a -> b) -> SolverStage a -> SolverStage b # liftA2 :: (a -> b -> c) -> SolverStage a -> SolverStage b -> SolverStage c # (*>) :: SolverStage a -> SolverStage b -> SolverStage b # (<*) :: SolverStage a -> SolverStage b -> SolverStage a # | |
Applicative TcS Source # | |
Applicative TcPluginM Source # | |
Applicative ZonkM Source # | |
Applicative UniqDSM Source # | |
Applicative UniqSM Source # | |
Applicative PprM Source # | |
Applicative NonEmpty # | |
Applicative STM # | |
Applicative Identity # | |
Applicative First # | |
Applicative Last # | |
Applicative Down # | |
Applicative Dual # | |
Applicative Product # | |
Applicative Sum # | |
Applicative ZipList # | |
Applicative Par1 # | |
Applicative Q # | |
Applicative P # | |
Applicative ReadP # | |
Applicative ReadPrec # | |
Defined in GHC.Internal.Text.ParserCombinators.ReadPrec | |
Applicative IO # | |
Applicative GHCiQ Source # | |
Applicative Maybe # | |
Applicative Solo # | |
Applicative [] # | |
Monad m => Applicative (WrappedMonad m) Source # | Since: base-2.1 |
Defined in Control.Applicative 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) Source # | |
Monad m => Applicative (CatchT m) Source # | |
Applicative (RegM freeRegs) Source # | |
Defined in GHC.CmmToAsm.Reg.Linear.State pure :: a -> RegM freeRegs a # (<*>) :: RegM freeRegs (a -> b) -> RegM freeRegs a -> RegM freeRegs b # liftA2 :: (a -> b -> c) -> RegM freeRegs a -> RegM freeRegs b -> RegM freeRegs c # (*>) :: RegM freeRegs a -> RegM freeRegs b -> RegM freeRegs b # (<*) :: RegM freeRegs a -> RegM freeRegs b -> RegM freeRegs a # | |
Applicative (WasmCodeGenM w) Source # | |
Defined in GHC.CmmToAsm.Wasm.Types pure :: a -> WasmCodeGenM w a # (<*>) :: WasmCodeGenM w (a -> b) -> WasmCodeGenM w a -> WasmCodeGenM w b # liftA2 :: (a -> b -> c) -> WasmCodeGenM w a -> WasmCodeGenM w b -> WasmCodeGenM w c # (*>) :: WasmCodeGenM w a -> WasmCodeGenM w b -> WasmCodeGenM w b # (<*) :: WasmCodeGenM w a -> WasmCodeGenM w b -> WasmCodeGenM w a # | |
Applicative (IOEnv m) Source # | |
Applicative (MaybeErr err) Source # | |
Defined in GHC.Data.Maybe | |
Monad m => Applicative (EwM m) Source # | |
Applicative m => Applicative (GhcT m) Source # | |
Applicative (CmdLineP s) Source # | |
Defined in GHC.Driver.Session | |
Applicative (PuResult a) Source # | |
Defined in GHC.Tc.Utils.Unify | |
Applicative (ZonkBndrT m) Source # | |
Defined in GHC.Tc.Zonk.Env | |
Applicative m => Applicative (ZonkT m) Source # | |
Monad m => Applicative (UniqDSMT m) Source # | |
Defined in GHC.Types.Unique.DSM | |
Applicative (Codensity f) Source # | |
Defined in GHC.Utils.Monad.Codensity | |
Applicative (State s) Source # | |
Arrow a => Applicative (ArrowMonad a) # | |
Defined in GHC.Internal.Control.Arrow 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) # | |
Applicative f => Applicative (Lift f) Source # | A combination is |
(Functor m, Monad m) => Applicative (MaybeT m) Source # | |
Monoid a => Applicative ((,) a) # | |
Arrow a => Applicative (WrappedArrow a b) Source # | Since: base-2.1 |
Defined in Control.Applicative 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) Source # | Equivalent to Since: containers-0.5.9 |
Defined in Data.IntMap.Internal 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 (Stream m a) Source # | |
Defined in GHC.Data.Stream | |
Monad m => Applicative (StreamS m a) Source # | |
Defined in GHC.Data.Stream | |
(Applicative f, Monad f) => Applicative (WhenMissing f x) Source # | Equivalent to Since: ghc-0.5.9 |
Defined in GHC.Data.Word64Map.Internal 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 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 f => Applicative (Backwards f) Source # | Apply |
Defined in Control.Applicative.Backwards | |
(Monoid w, Functor m, Monad m) => Applicative (AccumT w m) Source # | |
Defined in Control.Monad.Trans.Accum | |
(Functor m, Monad m) => Applicative (ExceptT e m) Source # | |
Defined in Control.Monad.Trans.Except | |
Applicative m => Applicative (IdentityT m) Source # | |
Defined in Control.Monad.Trans.Identity | |
Applicative m => Applicative (ReaderT r m) Source # | |
Defined in Control.Monad.Trans.Reader | |
(Functor m, Monad m) => Applicative (SelectT r m) Source # | |
Defined in Control.Monad.Trans.Select | |
(Functor m, Monad m) => Applicative (StateT s m) Source # | |
Defined in Control.Monad.Trans.State.Lazy | |
(Functor m, Monad m) => Applicative (StateT s m) Source # | |
Defined in Control.Monad.Trans.State.Strict | |
(Functor m, Monad m) => Applicative (WriterT w m) Source # | |
Defined in Control.Monad.Trans.Writer.CPS | |
(Monoid w, Applicative m) => Applicative (WriterT w m) Source # | |
Defined in Control.Monad.Trans.Writer.Lazy | |
(Monoid w, Applicative m) => Applicative (WriterT w m) Source # | |
Defined in Control.Monad.Trans.Writer.Strict | |
Monoid a => Applicative (Constant a :: Type -> Type) Source # | |
Defined in Data.Functor.Constant | |
Applicative f => Applicative (Reverse f) Source # | Derived instance. |
(Monoid a, Monoid b) => Applicative ((,,) a b) # | |
(Applicative f, Applicative g) => Applicative (Product f g) Source # | Since: base-4.9.0.0 |
Defined in Data.Functor.Product | |
(Monad f, Applicative f) => Applicative (WhenMatched f x y) Source # | Equivalent to Since: containers-0.5.9 |
Defined in Data.IntMap.Internal 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) Source # | Equivalent to Since: containers-0.5.9 |
Defined in Data.Map.Internal 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 # | |
(Monad f, Applicative f) => Applicative (WhenMatched f x y) Source # | Equivalent to Since: ghc-0.5.9 |
Defined in GHC.Data.Word64Map.Internal 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, Applicative g) => Applicative (f :*: g) # | |
Monoid c => Applicative (K1 i c :: Type -> Type) # | |
Applicative (ContT r m) Source # | |
(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) Source # | Since: base-4.9.0.0 |
Defined in Data.Functor.Compose | |
(Monad f, Applicative f) => Applicative (WhenMatched f k x y) Source # | Equivalent to Since: containers-0.5.9 |
Defined in Data.Map.Internal 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) Source # | |
Defined in Control.Monad.Trans.RWS.CPS | |
(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) Source # | |
Defined in Control.Monad.Trans.RWS.Lazy | |
(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) Source # | |
Defined in Control.Monad.Trans.RWS.Strict |
bitDefault :: (Bits a, Num a) => Int -> a #
popCountDefault :: (Bits a, Num a) => a -> Int #
(.&.), (.|.), xor, complement, (shift | shiftL, shiftR), (rotate | rotateL, rotateR), bitSize, bitSizeMaybe, isSigned, testBit, bit, popCount
complement :: a -> a #
complementBit :: a -> Int -> a #
bitSizeMaybe :: a -> Maybe Int #
unsafeShiftL :: a -> Int -> a #
unsafeShiftR :: a -> Int -> a #
Instances
Bits RegBitmap Source # | |
Defined in GHC.ByteCode.Types (.&.) :: RegBitmap -> RegBitmap -> RegBitmap # (.|.) :: RegBitmap -> RegBitmap -> RegBitmap # xor :: RegBitmap -> RegBitmap -> RegBitmap # complement :: RegBitmap -> RegBitmap # shift :: RegBitmap -> Int -> RegBitmap # rotate :: RegBitmap -> Int -> RegBitmap # setBit :: RegBitmap -> Int -> RegBitmap # clearBit :: RegBitmap -> Int -> RegBitmap # complementBit :: RegBitmap -> Int -> RegBitmap # testBit :: RegBitmap -> Int -> Bool # bitSizeMaybe :: RegBitmap -> Maybe Int # isSigned :: RegBitmap -> Bool # shiftL :: RegBitmap -> Int -> RegBitmap # unsafeShiftL :: RegBitmap -> Int -> RegBitmap # shiftR :: RegBitmap -> Int -> RegBitmap # unsafeShiftR :: RegBitmap -> Int -> RegBitmap # rotateL :: RegBitmap -> Int -> RegBitmap # | |
Bits StgWord Source # | |
Defined in GHC.Runtime.Heap.Layout (.&.) :: StgWord -> StgWord -> StgWord # (.|.) :: StgWord -> StgWord -> StgWord # xor :: StgWord -> StgWord -> StgWord # complement :: StgWord -> StgWord # shift :: StgWord -> Int -> StgWord # rotate :: StgWord -> Int -> StgWord # setBit :: StgWord -> Int -> StgWord # clearBit :: StgWord -> Int -> StgWord # complementBit :: StgWord -> Int -> StgWord # testBit :: StgWord -> Int -> Bool # bitSizeMaybe :: StgWord -> Maybe Int # shiftL :: StgWord -> Int -> StgWord # unsafeShiftL :: StgWord -> Int -> StgWord # shiftR :: StgWord -> Int -> StgWord # unsafeShiftR :: StgWord -> Int -> StgWord # rotateL :: StgWord -> Int -> StgWord # | |
Bits CBool # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CBool -> CBool -> CBool # (.|.) :: CBool -> CBool -> CBool # xor :: CBool -> CBool -> CBool # complement :: CBool -> CBool # shift :: CBool -> Int -> CBool # rotate :: CBool -> Int -> CBool # setBit :: CBool -> Int -> CBool # clearBit :: CBool -> Int -> CBool # complementBit :: CBool -> Int -> CBool # testBit :: CBool -> Int -> Bool # bitSizeMaybe :: CBool -> Maybe Int # shiftL :: CBool -> Int -> CBool # unsafeShiftL :: CBool -> Int -> CBool # shiftR :: CBool -> Int -> CBool # unsafeShiftR :: CBool -> Int -> CBool # rotateL :: CBool -> Int -> CBool # | |
Bits CChar # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CChar -> CChar -> CChar # (.|.) :: CChar -> CChar -> CChar # xor :: CChar -> CChar -> CChar # complement :: CChar -> CChar # shift :: CChar -> Int -> CChar # rotate :: CChar -> Int -> CChar # setBit :: CChar -> Int -> CChar # clearBit :: CChar -> Int -> CChar # complementBit :: CChar -> Int -> CChar # testBit :: CChar -> Int -> Bool # bitSizeMaybe :: CChar -> Maybe Int # shiftL :: CChar -> Int -> CChar # unsafeShiftL :: CChar -> Int -> CChar # shiftR :: CChar -> Int -> CChar # unsafeShiftR :: CChar -> Int -> CChar # rotateL :: CChar -> Int -> CChar # | |
Bits CInt # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CInt -> CInt -> CInt # (.|.) :: CInt -> CInt -> CInt # complement :: CInt -> CInt # shift :: CInt -> Int -> CInt # rotate :: CInt -> Int -> CInt # setBit :: CInt -> Int -> CInt # clearBit :: CInt -> Int -> CInt # complementBit :: CInt -> Int -> CInt # testBit :: CInt -> Int -> Bool # bitSizeMaybe :: CInt -> Maybe Int # shiftL :: CInt -> Int -> CInt # unsafeShiftL :: CInt -> Int -> CInt # shiftR :: CInt -> Int -> CInt # unsafeShiftR :: CInt -> Int -> CInt # rotateL :: CInt -> Int -> CInt # | |
Bits CIntMax # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CIntMax -> CIntMax -> CIntMax # (.|.) :: CIntMax -> CIntMax -> CIntMax # xor :: CIntMax -> CIntMax -> CIntMax # complement :: CIntMax -> CIntMax # shift :: CIntMax -> Int -> CIntMax # rotate :: CIntMax -> Int -> CIntMax # setBit :: CIntMax -> Int -> CIntMax # clearBit :: CIntMax -> Int -> CIntMax # complementBit :: CIntMax -> Int -> CIntMax # testBit :: CIntMax -> Int -> Bool # bitSizeMaybe :: CIntMax -> Maybe Int # shiftL :: CIntMax -> Int -> CIntMax # unsafeShiftL :: CIntMax -> Int -> CIntMax # shiftR :: CIntMax -> Int -> CIntMax # unsafeShiftR :: CIntMax -> Int -> CIntMax # rotateL :: CIntMax -> Int -> CIntMax # | |
Bits CIntPtr # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CIntPtr -> CIntPtr -> CIntPtr # (.|.) :: CIntPtr -> CIntPtr -> CIntPtr # xor :: CIntPtr -> CIntPtr -> CIntPtr # complement :: CIntPtr -> CIntPtr # shift :: CIntPtr -> Int -> CIntPtr # rotate :: CIntPtr -> Int -> CIntPtr # setBit :: CIntPtr -> Int -> CIntPtr # clearBit :: CIntPtr -> Int -> CIntPtr # complementBit :: CIntPtr -> Int -> CIntPtr # testBit :: CIntPtr -> Int -> Bool # bitSizeMaybe :: CIntPtr -> Maybe Int # shiftL :: CIntPtr -> Int -> CIntPtr # unsafeShiftL :: CIntPtr -> Int -> CIntPtr # shiftR :: CIntPtr -> Int -> CIntPtr # unsafeShiftR :: CIntPtr -> Int -> CIntPtr # rotateL :: CIntPtr -> Int -> CIntPtr # | |
Bits CLLong # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CLLong -> CLLong -> CLLong # (.|.) :: CLLong -> CLLong -> CLLong # xor :: CLLong -> CLLong -> CLLong # complement :: CLLong -> CLLong # shift :: CLLong -> Int -> CLLong # rotate :: CLLong -> Int -> CLLong # setBit :: CLLong -> Int -> CLLong # clearBit :: CLLong -> Int -> CLLong # complementBit :: CLLong -> Int -> CLLong # testBit :: CLLong -> Int -> Bool # bitSizeMaybe :: CLLong -> Maybe Int # shiftL :: CLLong -> Int -> CLLong # unsafeShiftL :: CLLong -> Int -> CLLong # shiftR :: CLLong -> Int -> CLLong # unsafeShiftR :: CLLong -> Int -> CLLong # rotateL :: CLLong -> Int -> CLLong # | |
Bits CLong # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CLong -> CLong -> CLong # (.|.) :: CLong -> CLong -> CLong # xor :: CLong -> CLong -> CLong # complement :: CLong -> CLong # shift :: CLong -> Int -> CLong # rotate :: CLong -> Int -> CLong # setBit :: CLong -> Int -> CLong # clearBit :: CLong -> Int -> CLong # complementBit :: CLong -> Int -> CLong # testBit :: CLong -> Int -> Bool # bitSizeMaybe :: CLong -> Maybe Int # shiftL :: CLong -> Int -> CLong # unsafeShiftL :: CLong -> Int -> CLong # shiftR :: CLong -> Int -> CLong # unsafeShiftR :: CLong -> Int -> CLong # rotateL :: CLong -> Int -> CLong # | |
Bits CPtrdiff # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CPtrdiff -> CPtrdiff -> CPtrdiff # (.|.) :: CPtrdiff -> CPtrdiff -> CPtrdiff # xor :: CPtrdiff -> CPtrdiff -> CPtrdiff # complement :: CPtrdiff -> CPtrdiff # shift :: CPtrdiff -> Int -> CPtrdiff # rotate :: CPtrdiff -> Int -> CPtrdiff # setBit :: CPtrdiff -> Int -> CPtrdiff # clearBit :: CPtrdiff -> Int -> CPtrdiff # complementBit :: CPtrdiff -> Int -> CPtrdiff # testBit :: CPtrdiff -> Int -> Bool # bitSizeMaybe :: CPtrdiff -> Maybe Int # isSigned :: CPtrdiff -> Bool # shiftL :: CPtrdiff -> Int -> CPtrdiff # unsafeShiftL :: CPtrdiff -> Int -> CPtrdiff # shiftR :: CPtrdiff -> Int -> CPtrdiff # unsafeShiftR :: CPtrdiff -> Int -> CPtrdiff # rotateL :: CPtrdiff -> Int -> CPtrdiff # | |
Bits CSChar # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CSChar -> CSChar -> CSChar # (.|.) :: CSChar -> CSChar -> CSChar # xor :: CSChar -> CSChar -> CSChar # complement :: CSChar -> CSChar # shift :: CSChar -> Int -> CSChar # rotate :: CSChar -> Int -> CSChar # setBit :: CSChar -> Int -> CSChar # clearBit :: CSChar -> Int -> CSChar # complementBit :: CSChar -> Int -> CSChar # testBit :: CSChar -> Int -> Bool # bitSizeMaybe :: CSChar -> Maybe Int # shiftL :: CSChar -> Int -> CSChar # unsafeShiftL :: CSChar -> Int -> CSChar # shiftR :: CSChar -> Int -> CSChar # unsafeShiftR :: CSChar -> Int -> CSChar # rotateL :: CSChar -> Int -> CSChar # | |
Bits CShort # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CShort -> CShort -> CShort # (.|.) :: CShort -> CShort -> CShort # xor :: CShort -> CShort -> CShort # complement :: CShort -> CShort # shift :: CShort -> Int -> CShort # rotate :: CShort -> Int -> CShort # setBit :: CShort -> Int -> CShort # clearBit :: CShort -> Int -> CShort # complementBit :: CShort -> Int -> CShort # testBit :: CShort -> Int -> Bool # bitSizeMaybe :: CShort -> Maybe Int # shiftL :: CShort -> Int -> CShort # unsafeShiftL :: CShort -> Int -> CShort # shiftR :: CShort -> Int -> CShort # unsafeShiftR :: CShort -> Int -> CShort # rotateL :: CShort -> Int -> CShort # | |
Bits CSigAtomic # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CSigAtomic -> CSigAtomic -> CSigAtomic # (.|.) :: CSigAtomic -> CSigAtomic -> CSigAtomic # xor :: CSigAtomic -> CSigAtomic -> CSigAtomic # complement :: CSigAtomic -> CSigAtomic # shift :: CSigAtomic -> Int -> CSigAtomic # rotate :: CSigAtomic -> Int -> CSigAtomic # zeroBits :: CSigAtomic # bit :: Int -> CSigAtomic # setBit :: CSigAtomic -> Int -> CSigAtomic # clearBit :: CSigAtomic -> Int -> CSigAtomic # complementBit :: CSigAtomic -> Int -> CSigAtomic # testBit :: CSigAtomic -> Int -> Bool # bitSizeMaybe :: CSigAtomic -> Maybe Int # bitSize :: CSigAtomic -> Int # isSigned :: CSigAtomic -> Bool # shiftL :: CSigAtomic -> Int -> CSigAtomic # unsafeShiftL :: CSigAtomic -> Int -> CSigAtomic # shiftR :: CSigAtomic -> Int -> CSigAtomic # unsafeShiftR :: CSigAtomic -> Int -> CSigAtomic # rotateL :: CSigAtomic -> Int -> CSigAtomic # rotateR :: CSigAtomic -> Int -> CSigAtomic # popCount :: CSigAtomic -> Int # | |
Bits CSize # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CSize -> CSize -> CSize # (.|.) :: CSize -> CSize -> CSize # xor :: CSize -> CSize -> CSize # complement :: CSize -> CSize # shift :: CSize -> Int -> CSize # rotate :: CSize -> Int -> CSize # setBit :: CSize -> Int -> CSize # clearBit :: CSize -> Int -> CSize # complementBit :: CSize -> Int -> CSize # testBit :: CSize -> Int -> Bool # bitSizeMaybe :: CSize -> Maybe Int # shiftL :: CSize -> Int -> CSize # unsafeShiftL :: CSize -> Int -> CSize # shiftR :: CSize -> Int -> CSize # unsafeShiftR :: CSize -> Int -> CSize # rotateL :: CSize -> Int -> CSize # | |
Bits CUChar # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CUChar -> CUChar -> CUChar # (.|.) :: CUChar -> CUChar -> CUChar # xor :: CUChar -> CUChar -> CUChar # complement :: CUChar -> CUChar # shift :: CUChar -> Int -> CUChar # rotate :: CUChar -> Int -> CUChar # setBit :: CUChar -> Int -> CUChar # clearBit :: CUChar -> Int -> CUChar # complementBit :: CUChar -> Int -> CUChar # testBit :: CUChar -> Int -> Bool # bitSizeMaybe :: CUChar -> Maybe Int # shiftL :: CUChar -> Int -> CUChar # unsafeShiftL :: CUChar -> Int -> CUChar # shiftR :: CUChar -> Int -> CUChar # unsafeShiftR :: CUChar -> Int -> CUChar # rotateL :: CUChar -> Int -> CUChar # | |
Bits CUInt # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CUInt -> CUInt -> CUInt # (.|.) :: CUInt -> CUInt -> CUInt # xor :: CUInt -> CUInt -> CUInt # complement :: CUInt -> CUInt # shift :: CUInt -> Int -> CUInt # rotate :: CUInt -> Int -> CUInt # setBit :: CUInt -> Int -> CUInt # clearBit :: CUInt -> Int -> CUInt # complementBit :: CUInt -> Int -> CUInt # testBit :: CUInt -> Int -> Bool # bitSizeMaybe :: CUInt -> Maybe Int # shiftL :: CUInt -> Int -> CUInt # unsafeShiftL :: CUInt -> Int -> CUInt # shiftR :: CUInt -> Int -> CUInt # unsafeShiftR :: CUInt -> Int -> CUInt # rotateL :: CUInt -> Int -> CUInt # | |
Bits CUIntMax # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CUIntMax -> CUIntMax -> CUIntMax # (.|.) :: CUIntMax -> CUIntMax -> CUIntMax # xor :: CUIntMax -> CUIntMax -> CUIntMax # complement :: CUIntMax -> CUIntMax # shift :: CUIntMax -> Int -> CUIntMax # rotate :: CUIntMax -> Int -> CUIntMax # setBit :: CUIntMax -> Int -> CUIntMax # clearBit :: CUIntMax -> Int -> CUIntMax # complementBit :: CUIntMax -> Int -> CUIntMax # testBit :: CUIntMax -> Int -> Bool # bitSizeMaybe :: CUIntMax -> Maybe Int # isSigned :: CUIntMax -> Bool # shiftL :: CUIntMax -> Int -> CUIntMax # unsafeShiftL :: CUIntMax -> Int -> CUIntMax # shiftR :: CUIntMax -> Int -> CUIntMax # unsafeShiftR :: CUIntMax -> Int -> CUIntMax # rotateL :: CUIntMax -> Int -> CUIntMax # | |
Bits CUIntPtr # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CUIntPtr -> CUIntPtr -> CUIntPtr # (.|.) :: CUIntPtr -> CUIntPtr -> CUIntPtr # xor :: CUIntPtr -> CUIntPtr -> CUIntPtr # complement :: CUIntPtr -> CUIntPtr # shift :: CUIntPtr -> Int -> CUIntPtr # rotate :: CUIntPtr -> Int -> CUIntPtr # setBit :: CUIntPtr -> Int -> CUIntPtr # clearBit :: CUIntPtr -> Int -> CUIntPtr # complementBit :: CUIntPtr -> Int -> CUIntPtr # testBit :: CUIntPtr -> Int -> Bool # bitSizeMaybe :: CUIntPtr -> Maybe Int # isSigned :: CUIntPtr -> Bool # shiftL :: CUIntPtr -> Int -> CUIntPtr # unsafeShiftL :: CUIntPtr -> Int -> CUIntPtr # shiftR :: CUIntPtr -> Int -> CUIntPtr # unsafeShiftR :: CUIntPtr -> Int -> CUIntPtr # rotateL :: CUIntPtr -> Int -> CUIntPtr # | |
Bits CULLong # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CULLong -> CULLong -> CULLong # (.|.) :: CULLong -> CULLong -> CULLong # xor :: CULLong -> CULLong -> CULLong # complement :: CULLong -> CULLong # shift :: CULLong -> Int -> CULLong # rotate :: CULLong -> Int -> CULLong # setBit :: CULLong -> Int -> CULLong # clearBit :: CULLong -> Int -> CULLong # complementBit :: CULLong -> Int -> CULLong # testBit :: CULLong -> Int -> Bool # bitSizeMaybe :: CULLong -> Maybe Int # shiftL :: CULLong -> Int -> CULLong # unsafeShiftL :: CULLong -> Int -> CULLong # shiftR :: CULLong -> Int -> CULLong # unsafeShiftR :: CULLong -> Int -> CULLong # rotateL :: CULLong -> Int -> CULLong # | |
Bits CULong # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CULong -> CULong -> CULong # (.|.) :: CULong -> CULong -> CULong # xor :: CULong -> CULong -> CULong # complement :: CULong -> CULong # shift :: CULong -> Int -> CULong # rotate :: CULong -> Int -> CULong # setBit :: CULong -> Int -> CULong # clearBit :: CULong -> Int -> CULong # complementBit :: CULong -> Int -> CULong # testBit :: CULong -> Int -> Bool # bitSizeMaybe :: CULong -> Maybe Int # shiftL :: CULong -> Int -> CULong # unsafeShiftL :: CULong -> Int -> CULong # shiftR :: CULong -> Int -> CULong # unsafeShiftR :: CULong -> Int -> CULong # rotateL :: CULong -> Int -> CULong # | |
Bits CUShort # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CUShort -> CUShort -> CUShort # (.|.) :: CUShort -> CUShort -> CUShort # xor :: CUShort -> CUShort -> CUShort # complement :: CUShort -> CUShort # shift :: CUShort -> Int -> CUShort # rotate :: CUShort -> Int -> CUShort # setBit :: CUShort -> Int -> CUShort # clearBit :: CUShort -> Int -> CUShort # complementBit :: CUShort -> Int -> CUShort # testBit :: CUShort -> Int -> Bool # bitSizeMaybe :: CUShort -> Maybe Int # shiftL :: CUShort -> Int -> CUShort # unsafeShiftL :: CUShort -> Int -> CUShort # shiftR :: CUShort -> Int -> CUShort # unsafeShiftR :: CUShort -> Int -> CUShort # rotateL :: CUShort -> Int -> CUShort # | |
Bits CWchar # | |
Defined in GHC.Internal.Foreign.C.Types (.&.) :: CWchar -> CWchar -> CWchar # (.|.) :: CWchar -> CWchar -> CWchar # xor :: CWchar -> CWchar -> CWchar # complement :: CWchar -> CWchar # shift :: CWchar -> Int -> CWchar # rotate :: CWchar -> Int -> CWchar # setBit :: CWchar -> Int -> CWchar # clearBit :: CWchar -> Int -> CWchar # complementBit :: CWchar -> Int -> CWchar # testBit :: CWchar -> Int -> Bool # bitSizeMaybe :: CWchar -> Maybe Int # shiftL :: CWchar -> Int -> CWchar # unsafeShiftL :: CWchar -> Int -> CWchar # shiftR :: CWchar -> Int -> CWchar # unsafeShiftR :: CWchar -> Int -> CWchar # rotateL :: CWchar -> Int -> CWchar # | |
Bits Int16 # | |
Defined in GHC.Internal.Int (.&.) :: 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 (.&.) :: 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 (.&.) :: 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 (.&.) :: 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 CBlkCnt # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CBlkCnt -> CBlkCnt -> CBlkCnt # (.|.) :: CBlkCnt -> CBlkCnt -> CBlkCnt # xor :: CBlkCnt -> CBlkCnt -> CBlkCnt # complement :: CBlkCnt -> CBlkCnt # shift :: CBlkCnt -> Int -> CBlkCnt # rotate :: CBlkCnt -> Int -> CBlkCnt # setBit :: CBlkCnt -> Int -> CBlkCnt # clearBit :: CBlkCnt -> Int -> CBlkCnt # complementBit :: CBlkCnt -> Int -> CBlkCnt # testBit :: CBlkCnt -> Int -> Bool # bitSizeMaybe :: CBlkCnt -> Maybe Int # shiftL :: CBlkCnt -> Int -> CBlkCnt # unsafeShiftL :: CBlkCnt -> Int -> CBlkCnt # shiftR :: CBlkCnt -> Int -> CBlkCnt # unsafeShiftR :: CBlkCnt -> Int -> CBlkCnt # rotateL :: CBlkCnt -> Int -> CBlkCnt # | |
Bits CBlkSize # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CBlkSize -> CBlkSize -> CBlkSize # (.|.) :: CBlkSize -> CBlkSize -> CBlkSize # xor :: CBlkSize -> CBlkSize -> CBlkSize # complement :: CBlkSize -> CBlkSize # shift :: CBlkSize -> Int -> CBlkSize # rotate :: CBlkSize -> Int -> CBlkSize # setBit :: CBlkSize -> Int -> CBlkSize # clearBit :: CBlkSize -> Int -> CBlkSize # complementBit :: CBlkSize -> Int -> CBlkSize # testBit :: CBlkSize -> Int -> Bool # bitSizeMaybe :: CBlkSize -> Maybe Int # isSigned :: CBlkSize -> Bool # shiftL :: CBlkSize -> Int -> CBlkSize # unsafeShiftL :: CBlkSize -> Int -> CBlkSize # shiftR :: CBlkSize -> Int -> CBlkSize # unsafeShiftR :: CBlkSize -> Int -> CBlkSize # rotateL :: CBlkSize -> Int -> CBlkSize # | |
Bits CClockId # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CClockId -> CClockId -> CClockId # (.|.) :: CClockId -> CClockId -> CClockId # xor :: CClockId -> CClockId -> CClockId # complement :: CClockId -> CClockId # shift :: CClockId -> Int -> CClockId # rotate :: CClockId -> Int -> CClockId # setBit :: CClockId -> Int -> CClockId # clearBit :: CClockId -> Int -> CClockId # complementBit :: CClockId -> Int -> CClockId # testBit :: CClockId -> Int -> Bool # bitSizeMaybe :: CClockId -> Maybe Int # isSigned :: CClockId -> Bool # shiftL :: CClockId -> Int -> CClockId # unsafeShiftL :: CClockId -> Int -> CClockId # shiftR :: CClockId -> Int -> CClockId # unsafeShiftR :: CClockId -> Int -> CClockId # rotateL :: CClockId -> Int -> CClockId # | |
Bits CDev # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CDev -> CDev -> CDev # (.|.) :: CDev -> CDev -> CDev # complement :: CDev -> CDev # shift :: CDev -> Int -> CDev # rotate :: CDev -> Int -> CDev # setBit :: CDev -> Int -> CDev # clearBit :: CDev -> Int -> CDev # complementBit :: CDev -> Int -> CDev # testBit :: CDev -> Int -> Bool # bitSizeMaybe :: CDev -> Maybe Int # shiftL :: CDev -> Int -> CDev # unsafeShiftL :: CDev -> Int -> CDev # shiftR :: CDev -> Int -> CDev # unsafeShiftR :: CDev -> Int -> CDev # rotateL :: CDev -> Int -> CDev # | |
Bits CFsBlkCnt # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt # (.|.) :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt # xor :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt # complement :: CFsBlkCnt -> CFsBlkCnt # shift :: CFsBlkCnt -> Int -> CFsBlkCnt # rotate :: CFsBlkCnt -> Int -> CFsBlkCnt # setBit :: CFsBlkCnt -> Int -> CFsBlkCnt # clearBit :: CFsBlkCnt -> Int -> CFsBlkCnt # complementBit :: CFsBlkCnt -> Int -> CFsBlkCnt # testBit :: CFsBlkCnt -> Int -> Bool # bitSizeMaybe :: CFsBlkCnt -> Maybe Int # isSigned :: CFsBlkCnt -> Bool # shiftL :: CFsBlkCnt -> Int -> CFsBlkCnt # unsafeShiftL :: CFsBlkCnt -> Int -> CFsBlkCnt # shiftR :: CFsBlkCnt -> Int -> CFsBlkCnt # unsafeShiftR :: CFsBlkCnt -> Int -> CFsBlkCnt # rotateL :: CFsBlkCnt -> Int -> CFsBlkCnt # | |
Bits CFsFilCnt # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt # (.|.) :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt # xor :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt # complement :: CFsFilCnt -> CFsFilCnt # shift :: CFsFilCnt -> Int -> CFsFilCnt # rotate :: CFsFilCnt -> Int -> CFsFilCnt # setBit :: CFsFilCnt -> Int -> CFsFilCnt # clearBit :: CFsFilCnt -> Int -> CFsFilCnt # complementBit :: CFsFilCnt -> Int -> CFsFilCnt # testBit :: CFsFilCnt -> Int -> Bool # bitSizeMaybe :: CFsFilCnt -> Maybe Int # isSigned :: CFsFilCnt -> Bool # shiftL :: CFsFilCnt -> Int -> CFsFilCnt # unsafeShiftL :: CFsFilCnt -> Int -> CFsFilCnt # shiftR :: CFsFilCnt -> Int -> CFsFilCnt # unsafeShiftR :: CFsFilCnt -> Int -> CFsFilCnt # rotateL :: CFsFilCnt -> Int -> CFsFilCnt # | |
Bits CGid # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CGid -> CGid -> CGid # (.|.) :: CGid -> CGid -> CGid # complement :: CGid -> CGid # shift :: CGid -> Int -> CGid # rotate :: CGid -> Int -> CGid # setBit :: CGid -> Int -> CGid # clearBit :: CGid -> Int -> CGid # complementBit :: CGid -> Int -> CGid # testBit :: CGid -> Int -> Bool # bitSizeMaybe :: CGid -> Maybe Int # shiftL :: CGid -> Int -> CGid # unsafeShiftL :: CGid -> Int -> CGid # shiftR :: CGid -> Int -> CGid # unsafeShiftR :: CGid -> Int -> CGid # rotateL :: CGid -> Int -> CGid # | |
Bits CId # | |
Defined in GHC.Internal.System.Posix.Types | |
Bits CIno # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CIno -> CIno -> CIno # (.|.) :: CIno -> CIno -> CIno # complement :: CIno -> CIno # shift :: CIno -> Int -> CIno # rotate :: CIno -> Int -> CIno # setBit :: CIno -> Int -> CIno # clearBit :: CIno -> Int -> CIno # complementBit :: CIno -> Int -> CIno # testBit :: CIno -> Int -> Bool # bitSizeMaybe :: CIno -> Maybe Int # shiftL :: CIno -> Int -> CIno # unsafeShiftL :: CIno -> Int -> CIno # shiftR :: CIno -> Int -> CIno # unsafeShiftR :: CIno -> Int -> CIno # rotateL :: CIno -> Int -> CIno # | |
Bits CKey # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CKey -> CKey -> CKey # (.|.) :: CKey -> CKey -> CKey # complement :: CKey -> CKey # shift :: CKey -> Int -> CKey # rotate :: CKey -> Int -> CKey # setBit :: CKey -> Int -> CKey # clearBit :: CKey -> Int -> CKey # complementBit :: CKey -> Int -> CKey # testBit :: CKey -> Int -> Bool # bitSizeMaybe :: CKey -> Maybe Int # shiftL :: CKey -> Int -> CKey # unsafeShiftL :: CKey -> Int -> CKey # shiftR :: CKey -> Int -> CKey # unsafeShiftR :: CKey -> Int -> CKey # rotateL :: CKey -> Int -> CKey # | |
Bits CMode # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CMode -> CMode -> CMode # (.|.) :: CMode -> CMode -> CMode # xor :: CMode -> CMode -> CMode # complement :: CMode -> CMode # shift :: CMode -> Int -> CMode # rotate :: CMode -> Int -> CMode # setBit :: CMode -> Int -> CMode # clearBit :: CMode -> Int -> CMode # complementBit :: CMode -> Int -> CMode # testBit :: CMode -> Int -> Bool # bitSizeMaybe :: CMode -> Maybe Int # shiftL :: CMode -> Int -> CMode # unsafeShiftL :: CMode -> Int -> CMode # shiftR :: CMode -> Int -> CMode # unsafeShiftR :: CMode -> Int -> CMode # rotateL :: CMode -> Int -> CMode # | |
Bits CNfds # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CNfds -> CNfds -> CNfds # (.|.) :: CNfds -> CNfds -> CNfds # xor :: CNfds -> CNfds -> CNfds # complement :: CNfds -> CNfds # shift :: CNfds -> Int -> CNfds # rotate :: CNfds -> Int -> CNfds # setBit :: CNfds -> Int -> CNfds # clearBit :: CNfds -> Int -> CNfds # complementBit :: CNfds -> Int -> CNfds # testBit :: CNfds -> Int -> Bool # bitSizeMaybe :: CNfds -> Maybe Int # shiftL :: CNfds -> Int -> CNfds # unsafeShiftL :: CNfds -> Int -> CNfds # shiftR :: CNfds -> Int -> CNfds # unsafeShiftR :: CNfds -> Int -> CNfds # rotateL :: CNfds -> Int -> CNfds # | |
Bits CNlink # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CNlink -> CNlink -> CNlink # (.|.) :: CNlink -> CNlink -> CNlink # xor :: CNlink -> CNlink -> CNlink # complement :: CNlink -> CNlink # shift :: CNlink -> Int -> CNlink # rotate :: CNlink -> Int -> CNlink # setBit :: CNlink -> Int -> CNlink # clearBit :: CNlink -> Int -> CNlink # complementBit :: CNlink -> Int -> CNlink # testBit :: CNlink -> Int -> Bool # bitSizeMaybe :: CNlink -> Maybe Int # shiftL :: CNlink -> Int -> CNlink # unsafeShiftL :: CNlink -> Int -> CNlink # shiftR :: CNlink -> Int -> CNlink # unsafeShiftR :: CNlink -> Int -> CNlink # rotateL :: CNlink -> Int -> CNlink # | |
Bits COff # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: COff -> COff -> COff # (.|.) :: COff -> COff -> COff # complement :: COff -> COff # shift :: COff -> Int -> COff # rotate :: COff -> Int -> COff # setBit :: COff -> Int -> COff # clearBit :: COff -> Int -> COff # complementBit :: COff -> Int -> COff # testBit :: COff -> Int -> Bool # bitSizeMaybe :: COff -> Maybe Int # shiftL :: COff -> Int -> COff # unsafeShiftL :: COff -> Int -> COff # shiftR :: COff -> Int -> COff # unsafeShiftR :: COff -> Int -> COff # rotateL :: COff -> Int -> COff # | |
Bits CPid # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CPid -> CPid -> CPid # (.|.) :: CPid -> CPid -> CPid # complement :: CPid -> CPid # shift :: CPid -> Int -> CPid # rotate :: CPid -> Int -> CPid # setBit :: CPid -> Int -> CPid # clearBit :: CPid -> Int -> CPid # complementBit :: CPid -> Int -> CPid # testBit :: CPid -> Int -> Bool # bitSizeMaybe :: CPid -> Maybe Int # shiftL :: CPid -> Int -> CPid # unsafeShiftL :: CPid -> Int -> CPid # shiftR :: CPid -> Int -> CPid # unsafeShiftR :: CPid -> Int -> CPid # rotateL :: CPid -> Int -> CPid # | |
Bits CRLim # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CRLim -> CRLim -> CRLim # (.|.) :: CRLim -> CRLim -> CRLim # xor :: CRLim -> CRLim -> CRLim # complement :: CRLim -> CRLim # shift :: CRLim -> Int -> CRLim # rotate :: CRLim -> Int -> CRLim # setBit :: CRLim -> Int -> CRLim # clearBit :: CRLim -> Int -> CRLim # complementBit :: CRLim -> Int -> CRLim # testBit :: CRLim -> Int -> Bool # bitSizeMaybe :: CRLim -> Maybe Int # shiftL :: CRLim -> Int -> CRLim # unsafeShiftL :: CRLim -> Int -> CRLim # shiftR :: CRLim -> Int -> CRLim # unsafeShiftR :: CRLim -> Int -> CRLim # rotateL :: CRLim -> Int -> CRLim # | |
Bits CSocklen # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CSocklen -> CSocklen -> CSocklen # (.|.) :: CSocklen -> CSocklen -> CSocklen # xor :: CSocklen -> CSocklen -> CSocklen # complement :: CSocklen -> CSocklen # shift :: CSocklen -> Int -> CSocklen # rotate :: CSocklen -> Int -> CSocklen # setBit :: CSocklen -> Int -> CSocklen # clearBit :: CSocklen -> Int -> CSocklen # complementBit :: CSocklen -> Int -> CSocklen # testBit :: CSocklen -> Int -> Bool # bitSizeMaybe :: CSocklen -> Maybe Int # isSigned :: CSocklen -> Bool # shiftL :: CSocklen -> Int -> CSocklen # unsafeShiftL :: CSocklen -> Int -> CSocklen # shiftR :: CSocklen -> Int -> CSocklen # unsafeShiftR :: CSocklen -> Int -> CSocklen # rotateL :: CSocklen -> Int -> CSocklen # | |
Bits CSsize # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CSsize -> CSsize -> CSsize # (.|.) :: CSsize -> CSsize -> CSsize # xor :: CSsize -> CSsize -> CSsize # complement :: CSsize -> CSsize # shift :: CSsize -> Int -> CSsize # rotate :: CSsize -> Int -> CSsize # setBit :: CSsize -> Int -> CSsize # clearBit :: CSsize -> Int -> CSsize # complementBit :: CSsize -> Int -> CSsize # testBit :: CSsize -> Int -> Bool # bitSizeMaybe :: CSsize -> Maybe Int # shiftL :: CSsize -> Int -> CSsize # unsafeShiftL :: CSsize -> Int -> CSsize # shiftR :: CSsize -> Int -> CSsize # unsafeShiftR :: CSsize -> Int -> CSsize # rotateL :: CSsize -> Int -> CSsize # | |
Bits CTcflag # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CTcflag -> CTcflag -> CTcflag # (.|.) :: CTcflag -> CTcflag -> CTcflag # xor :: CTcflag -> CTcflag -> CTcflag # complement :: CTcflag -> CTcflag # shift :: CTcflag -> Int -> CTcflag # rotate :: CTcflag -> Int -> CTcflag # setBit :: CTcflag -> Int -> CTcflag # clearBit :: CTcflag -> Int -> CTcflag # complementBit :: CTcflag -> Int -> CTcflag # testBit :: CTcflag -> Int -> Bool # bitSizeMaybe :: CTcflag -> Maybe Int # shiftL :: CTcflag -> Int -> CTcflag # unsafeShiftL :: CTcflag -> Int -> CTcflag # shiftR :: CTcflag -> Int -> CTcflag # unsafeShiftR :: CTcflag -> Int -> CTcflag # rotateL :: CTcflag -> Int -> CTcflag # | |
Bits CUid # | |
Defined in GHC.Internal.System.Posix.Types (.&.) :: CUid -> CUid -> CUid # (.|.) :: CUid -> CUid -> CUid # complement :: CUid -> CUid # shift :: CUid -> Int -> CUid # rotate :: CUid -> Int -> CUid # setBit :: CUid -> Int -> CUid # clearBit :: CUid -> Int -> CUid # complementBit :: CUid -> Int -> CUid # testBit :: CUid -> Int -> Bool # bitSizeMaybe :: CUid -> Maybe Int # shiftL :: CUid -> Int -> CUid # unsafeShiftL :: CUid -> Int -> CUid # shiftR :: CUid -> Int -> CUid # unsafeShiftR :: CUid -> Int -> CUid # rotateL :: CUid -> Int -> CUid # | |
Bits Fd # | |
Defined in GHC.Internal.System.Posix.Types complement :: Fd -> Fd # complementBit :: Fd -> Int -> Fd # testBit :: Fd -> Int -> Bool # bitSizeMaybe :: Fd -> Maybe Int # unsafeShiftL :: Fd -> Int -> Fd # unsafeShiftR :: Fd -> Int -> Fd # | |
Bits Word16 # | |
Defined in GHC.Internal.Word (.&.) :: 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 (.&.) :: 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 (.&.) :: 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 (.&.) :: 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 CAttributes Source # | |
Defined in System.Posix.Files.Common (.&.) :: CAttributes -> CAttributes -> CAttributes # (.|.) :: CAttributes -> CAttributes -> CAttributes # xor :: CAttributes -> CAttributes -> CAttributes # complement :: CAttributes -> CAttributes # shift :: CAttributes -> Int -> CAttributes # rotate :: CAttributes -> Int -> CAttributes # zeroBits :: CAttributes # bit :: Int -> CAttributes # setBit :: CAttributes -> Int -> CAttributes # clearBit :: CAttributes -> Int -> CAttributes # complementBit :: CAttributes -> Int -> CAttributes # testBit :: CAttributes -> Int -> Bool # bitSizeMaybe :: CAttributes -> Maybe Int # bitSize :: CAttributes -> Int # isSigned :: CAttributes -> Bool # shiftL :: CAttributes -> Int -> CAttributes # unsafeShiftL :: CAttributes -> Int -> CAttributes # shiftR :: CAttributes -> Int -> CAttributes # unsafeShiftR :: CAttributes -> Int -> CAttributes # rotateL :: CAttributes -> Int -> CAttributes # rotateR :: CAttributes -> Int -> CAttributes # popCount :: CAttributes -> Int # | |
Bits StatxFlags Source # | |
Defined in System.Posix.Files.Common (.&.) :: StatxFlags -> StatxFlags -> StatxFlags # (.|.) :: StatxFlags -> StatxFlags -> StatxFlags # xor :: StatxFlags -> StatxFlags -> StatxFlags # complement :: StatxFlags -> StatxFlags # shift :: StatxFlags -> Int -> StatxFlags # rotate :: StatxFlags -> Int -> StatxFlags # zeroBits :: StatxFlags # bit :: Int -> StatxFlags # setBit :: StatxFlags -> Int -> StatxFlags # clearBit :: StatxFlags -> Int -> StatxFlags # complementBit :: StatxFlags -> Int -> StatxFlags # testBit :: StatxFlags -> Int -> Bool # bitSizeMaybe :: StatxFlags -> Maybe Int # bitSize :: StatxFlags -> Int # isSigned :: StatxFlags -> Bool # shiftL :: StatxFlags -> Int -> StatxFlags # unsafeShiftL :: StatxFlags -> Int -> StatxFlags # shiftR :: StatxFlags -> Int -> StatxFlags # unsafeShiftR :: StatxFlags -> Int -> StatxFlags # rotateL :: StatxFlags -> Int -> StatxFlags # rotateR :: StatxFlags -> Int -> StatxFlags # popCount :: StatxFlags -> Int # | |
Bits StatxMask Source # | |
Defined in System.Posix.Files.Common (.&.) :: StatxMask -> StatxMask -> StatxMask # (.|.) :: StatxMask -> StatxMask -> StatxMask # xor :: StatxMask -> StatxMask -> StatxMask # complement :: StatxMask -> StatxMask # shift :: StatxMask -> Int -> StatxMask # rotate :: StatxMask -> Int -> StatxMask # setBit :: StatxMask -> Int -> StatxMask # clearBit :: StatxMask -> Int -> StatxMask # complementBit :: StatxMask -> Int -> StatxMask # testBit :: StatxMask -> Int -> Bool # bitSizeMaybe :: StatxMask -> Maybe Int # isSigned :: StatxMask -> Bool # shiftL :: StatxMask -> Int -> StatxMask # unsafeShiftL :: StatxMask -> Int -> StatxMask # shiftR :: StatxMask -> Int -> StatxMask # unsafeShiftR :: StatxMask -> Int -> StatxMask # rotateL :: StatxMask -> Int -> StatxMask # | |
Bits Integer # | |
Defined in GHC.Internal.Bits (.&.) :: 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 (.&.) :: 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 (.&.) :: 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 | |
Bits Word # | |
Defined in GHC.Internal.Bits (.&.) :: 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 (.&.) :: 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 (.&.) :: 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 (.&.) :: 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 (.&.) :: 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 (.&.) :: 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 (.&.) :: 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 (.&.) :: 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 # |
class Bits b => FiniteBits b where #
Instances
FiniteBits RegBitmap Source # | |
Defined in GHC.ByteCode.Types finiteBitSize :: RegBitmap -> Int # countLeadingZeros :: RegBitmap -> Int # countTrailingZeros :: RegBitmap -> Int # | |
FiniteBits CBool # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CBool -> Int # countLeadingZeros :: CBool -> Int # countTrailingZeros :: CBool -> Int # | |
FiniteBits CChar # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CChar -> Int # countLeadingZeros :: CChar -> Int # countTrailingZeros :: CChar -> Int # | |
FiniteBits CInt # | |
Defined in GHC.Internal.Foreign.C.Types | |
FiniteBits CIntMax # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CIntMax -> Int # countLeadingZeros :: CIntMax -> Int # countTrailingZeros :: CIntMax -> Int # | |
FiniteBits CIntPtr # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CIntPtr -> Int # countLeadingZeros :: CIntPtr -> Int # countTrailingZeros :: CIntPtr -> Int # | |
FiniteBits CLLong # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CLLong -> Int # countLeadingZeros :: CLLong -> Int # countTrailingZeros :: CLLong -> Int # | |
FiniteBits CLong # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CLong -> Int # countLeadingZeros :: CLong -> Int # countTrailingZeros :: CLong -> Int # | |
FiniteBits CPtrdiff # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CPtrdiff -> Int # countLeadingZeros :: CPtrdiff -> Int # countTrailingZeros :: CPtrdiff -> Int # | |
FiniteBits CSChar # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CSChar -> Int # countLeadingZeros :: CSChar -> Int # countTrailingZeros :: CSChar -> Int # | |
FiniteBits CShort # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CShort -> Int # countLeadingZeros :: CShort -> Int # countTrailingZeros :: CShort -> Int # | |
FiniteBits CSigAtomic # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CSigAtomic -> Int # countLeadingZeros :: CSigAtomic -> Int # countTrailingZeros :: CSigAtomic -> Int # | |
FiniteBits CSize # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CSize -> Int # countLeadingZeros :: CSize -> Int # countTrailingZeros :: CSize -> Int # | |
FiniteBits CUChar # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CUChar -> Int # countLeadingZeros :: CUChar -> Int # countTrailingZeros :: CUChar -> Int # | |
FiniteBits CUInt # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CUInt -> Int # countLeadingZeros :: CUInt -> Int # countTrailingZeros :: CUInt -> Int # | |
FiniteBits CUIntMax # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CUIntMax -> Int # countLeadingZeros :: CUIntMax -> Int # countTrailingZeros :: CUIntMax -> Int # | |
FiniteBits CUIntPtr # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CUIntPtr -> Int # countLeadingZeros :: CUIntPtr -> Int # countTrailingZeros :: CUIntPtr -> Int # | |
FiniteBits CULLong # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CULLong -> Int # countLeadingZeros :: CULLong -> Int # countTrailingZeros :: CULLong -> Int # | |
FiniteBits CULong # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CULong -> Int # countLeadingZeros :: CULong -> Int # countTrailingZeros :: CULong -> Int # | |
FiniteBits CUShort # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CUShort -> Int # countLeadingZeros :: CUShort -> Int # countTrailingZeros :: CUShort -> Int # | |
FiniteBits CWchar # | |
Defined in GHC.Internal.Foreign.C.Types finiteBitSize :: CWchar -> Int # countLeadingZeros :: CWchar -> Int # countTrailingZeros :: CWchar -> Int # | |
FiniteBits Int16 # | |
Defined in GHC.Internal.Int finiteBitSize :: Int16 -> Int # countLeadingZeros :: Int16 -> Int # countTrailingZeros :: Int16 -> Int # | |
FiniteBits Int32 # | |
Defined in GHC.Internal.Int finiteBitSize :: Int32 -> Int # countLeadingZeros :: Int32 -> Int # countTrailingZeros :: Int32 -> Int # | |
FiniteBits Int64 # | |
Defined in GHC.Internal.Int finiteBitSize :: Int64 -> Int # countLeadingZeros :: Int64 -> Int # countTrailingZeros :: Int64 -> Int # | |
FiniteBits Int8 # | |
Defined in GHC.Internal.Int | |
FiniteBits CBlkCnt # | |
Defined in GHC.Internal.System.Posix.Types finiteBitSize :: CBlkCnt -> Int # countLeadingZeros :: CBlkCnt -> Int # countTrailingZeros :: CBlkCnt -> Int # | |
FiniteBits CBlkSize # | |
Defined in GHC.Internal.System.Posix.Types finiteBitSize :: CBlkSize -> Int # countLeadingZeros :: CBlkSize -> Int # countTrailingZeros :: CBlkSize -> Int # | |
FiniteBits CClockId # | |
Defined in GHC.Internal.System.Posix.Types finiteBitSize :: CClockId -> Int # countLeadingZeros :: CClockId -> Int # countTrailingZeros :: CClockId -> Int # | |
FiniteBits CDev # | |
Defined in GHC.Internal.System.Posix.Types | |
FiniteBits CFsBlkCnt # | |
Defined in GHC.Internal.System.Posix.Types finiteBitSize :: CFsBlkCnt -> Int # countLeadingZeros :: CFsBlkCnt -> Int # countTrailingZeros :: CFsBlkCnt -> Int # | |
FiniteBits CFsFilCnt # | |
Defined in GHC.Internal.System.Posix.Types finiteBitSize :: CFsFilCnt -> Int # countLeadingZeros :: CFsFilCnt -> Int # countTrailingZeros :: CFsFilCnt -> Int # | |
FiniteBits CGid # | |
Defined in GHC.Internal.System.Posix.Types | |
FiniteBits CId # | |
Defined in GHC.Internal.System.Posix.Types | |
FiniteBits CIno # | |
Defined in GHC.Internal.System.Posix.Types | |
FiniteBits CKey # | |
Defined in GHC.Internal.System.Posix.Types | |
FiniteBits CMode # | |
Defined in GHC.Internal.System.Posix.Types finiteBitSize :: CMode -> Int # countLeadingZeros :: CMode -> Int # countTrailingZeros :: CMode -> Int # | |
FiniteBits CNfds # | |
Defined in GHC.Internal.System.Posix.Types finiteBitSize :: CNfds -> Int # countLeadingZeros :: CNfds -> Int # countTrailingZeros :: CNfds -> Int # | |
FiniteBits CNlink # | |
Defined in GHC.Internal.System.Posix.Types finiteBitSize :: CNlink -> Int # countLeadingZeros :: CNlink -> Int # countTrailingZeros :: CNlink -> Int # | |
FiniteBits COff # | |
Defined in GHC.Internal.System.Posix.Types | |
FiniteBits CPid # | |
Defined in GHC.Internal.System.Posix.Types | |
FiniteBits CRLim # | |
Defined in GHC.Internal.System.Posix.Types finiteBitSize :: CRLim -> Int # countLeadingZeros :: CRLim -> Int # countTrailingZeros :: CRLim -> Int # | |
FiniteBits CSocklen # | |
Defined in GHC.Internal.System.Posix.Types finiteBitSize :: CSocklen -> Int # countLeadingZeros :: CSocklen -> Int # countTrailingZeros :: CSocklen -> Int # | |
FiniteBits CSsize # | |
Defined in GHC.Internal.System.Posix.Types finiteBitSize :: CSsize -> Int # countLeadingZeros :: CSsize -> Int # countTrailingZeros :: CSsize -> Int # | |
FiniteBits CTcflag # | |
Defined in GHC.Internal.System.Posix.Types finiteBitSize :: CTcflag -> Int # countLeadingZeros :: CTcflag -> Int # countTrailingZeros :: CTcflag -> Int # | |
FiniteBits CUid # | |
Defined in GHC.Internal.System.Posix.Types | |
FiniteBits Fd # | |
Defined in GHC.Internal.System.Posix.Types | |
FiniteBits Word16 # | |
Defined in GHC.Internal.Word finiteBitSize :: Word16 -> Int # countLeadingZeros :: Word16 -> Int # countTrailingZeros :: Word16 -> Int # | |
FiniteBits Word32 # | |
Defined in GHC.Internal.Word finiteBitSize :: Word32 -> Int # countLeadingZeros :: Word32 -> Int # countTrailingZeros :: Word32 -> Int # | |
FiniteBits Word64 # | |
Defined in GHC.Internal.Word finiteBitSize :: Word64 -> Int # countLeadingZeros :: Word64 -> Int # countTrailingZeros :: Word64 -> Int # | |
FiniteBits Word8 # | |
Defined in GHC.Internal.Word finiteBitSize :: Word8 -> Int # countLeadingZeros :: Word8 -> Int # countTrailingZeros :: Word8 -> Int # | |
FiniteBits Bool # | |
Defined in GHC.Internal.Bits | |
FiniteBits Int # | |
Defined in GHC.Internal.Bits | |
FiniteBits Word # | |
Defined in GHC.Internal.Bits | |
FiniteBits a => FiniteBits (And a) # | |
Defined in GHC.Internal.Data.Bits finiteBitSize :: And a -> Int # countLeadingZeros :: And a -> Int # countTrailingZeros :: And a -> Int # | |
FiniteBits a => FiniteBits (Iff a) # | |
Defined in GHC.Internal.Data.Bits finiteBitSize :: Iff a -> Int # countLeadingZeros :: Iff a -> Int # countTrailingZeros :: Iff a -> Int # | |
FiniteBits a => FiniteBits (Ior a) # | |
Defined in GHC.Internal.Data.Bits finiteBitSize :: Ior a -> Int # countLeadingZeros :: Ior a -> Int # countTrailingZeros :: Ior a -> Int # | |
FiniteBits a => FiniteBits (Xor a) # | |
Defined in GHC.Internal.Data.Bits finiteBitSize :: Xor a -> Int # countLeadingZeros :: Xor a -> Int # countTrailingZeros :: Xor a -> Int # | |
FiniteBits a => FiniteBits (Identity a) # | |
Defined in GHC.Internal.Data.Functor.Identity finiteBitSize :: Identity a -> Int # countLeadingZeros :: Identity a -> Int # countTrailingZeros :: Identity a -> Int # | |
FiniteBits a => FiniteBits (Down a) # | |
Defined in GHC.Internal.Data.Ord 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 finiteBitSize :: Const a b -> Int # countLeadingZeros :: Const a b -> Int # countTrailingZeros :: Const a b -> Int # |
head :: HasCallStack => [a] -> a Source #
tail :: HasCallStack => [a] -> [a] Source #