| License | BSD-style |
|---|---|
| Maintainer | Vincent Hanquez <vincent@snarc.org> |
| Stability | experimental |
| Portability | portable |
| Safe Haskell | None |
| Language | Haskell2010 |
Foundation
Description
I tried to picture clusters of information As they moved through the computer What do they look like?
Alternative Prelude
Synopsis
- ($) :: (a -> b) -> a -> b
- ($!) :: (a -> b) -> a -> b
- (&&) :: Bool -> Bool -> Bool
- (||) :: Bool -> Bool -> Bool
- (.) :: forall (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
- not :: Bool -> Bool
- otherwise :: Bool
- data Tuple2 a b = Tuple2 !a !b
- data Tuple3 a b c = Tuple3 !a !b !c
- data Tuple4 a b c d = Tuple4 !a !b !c !d
- class Fstable a where
- type ProductFirst a
- fst :: a -> ProductFirst a
- class Sndable a where
- type ProductSecond a
- snd :: a -> ProductSecond a
- class Thdable a where
- type ProductThird a
- thd :: a -> ProductThird a
- type family ProductFirst a
- type family ProductSecond a
- type family ProductThird a
- id :: forall (a :: k). Category cat => cat a a
- maybe :: b -> (a -> b) -> Maybe a -> b
- either :: (a -> c) -> (b -> c) -> Either a b -> c
- flip :: (a -> b -> c) -> b -> a -> c
- const :: a -> b -> a
- error :: HasCallStack => String -> a
- putStr :: String -> IO ()
- putStrLn :: String -> IO ()
- getArgs :: IO [String]
- uncurry :: (a -> b -> c) -> (a, b) -> c
- curry :: ((a, b) -> c) -> a -> b -> c
- swap :: (a, b) -> (b, a)
- until :: (a -> Bool) -> (a -> a) -> a -> a
- asTypeOf :: a -> a -> a
- undefined :: HasCallStack => a
- seq :: a -> b -> b
- class NormalForm a
- deepseq :: NormalForm a => a -> b -> b
- force :: NormalForm a => a -> a
- class Show a
- show :: Show a => a -> String
- class Eq a => Ord a where
- class Eq a where
- class Bounded a where
- class Enum a where
- succ :: a -> a
- pred :: a -> a
- toEnum :: Int -> a
- fromEnum :: a -> Int
- enumFrom :: a -> [a]
- enumFromThen :: a -> a -> [a]
- enumFromTo :: a -> a -> [a]
- enumFromThenTo :: a -> a -> a -> [a]
- class Functor (f :: Type -> Type) where
- class Integral a where
- fromInteger :: Integer -> a
- class Fractional a where
- fromRational :: Rational -> a
- class HasNegation a where
- negate :: a -> a
- class (forall a. Functor (p a)) => Bifunctor (p :: Type -> Type -> Type) where
- class Functor f => Applicative (f :: Type -> Type) where
- class Applicative m => Monad (m :: Type -> Type) where
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- class IsString a where
- fromString :: String -> a
- class IsList l where
- class (Integral a, Eq a, Ord a) => IsIntegral a where
- class IsIntegral a => IsNatural a where
- class Signed a where
- class Additive a where
- class Subtractive a where
- type Difference a
- (-) :: a -> a -> Difference a
- class Multiplicative a where
- class (Additive a, Multiplicative a) => IDivisible a where
- class Multiplicative a => Divisible a where
- (/) :: a -> a -> a
- data Maybe a
- data Ordering
- data Bool
- data Char
- data Char7
- data IO a
- data Either a b
- data Int8
- data Int16
- data Int32
- data Int64
- data Word8
- data Word16
- data Word32
- data Word64
- data Word
- data Word128
- data Word256
- data Int
- data Integer
- data Natural
- type Rational = Ratio Integer
- data Float
- data Double
- newtype CountOf ty = CountOf Int
- newtype Offset ty = Offset Int
- toCount :: Int -> CountOf ty
- fromCount :: CountOf ty -> Int
- data UArray ty
- class Eq ty => PrimType ty
- data Array a
- data String
- (^^) :: (Fractional a, Integral b) => a -> b -> a
- fromIntegral :: (Integral a, Num b) => a -> b
- realToFrac :: (Real a, Fractional b) => a -> b
- class Semigroup a
- class Semigroup a => Monoid a where
- (<>) :: Semigroup a => a -> a -> a
- class (IsList c, Item c ~ Element c) => Collection c where
- null :: c -> Bool
- length :: c -> CountOf (Element c)
- elem :: (Eq a, a ~ Element c) => Element c -> c -> Bool
- notElem :: (Eq a, a ~ Element c) => Element c -> c -> Bool
- maximum :: (Ord a, a ~ Element c) => NonEmpty c -> Element c
- minimum :: (Ord a, a ~ Element c) => NonEmpty c -> Element c
- any :: (Element c -> Bool) -> c -> Bool
- all :: (Element c -> Bool) -> c -> Bool
- and :: (Collection col, Element col ~ Bool) => col -> Bool
- or :: (Collection col, Element col ~ Bool) => col -> Bool
- class (IsList c, Item c ~ Element c, Monoid c, Collection c) => Sequential c where
- take :: CountOf (Element c) -> c -> c
- revTake :: CountOf (Element c) -> c -> c
- drop :: CountOf (Element c) -> c -> c
- revDrop :: CountOf (Element c) -> c -> c
- splitAt :: CountOf (Element c) -> c -> (c, c)
- revSplitAt :: CountOf (Element c) -> c -> (c, c)
- splitOn :: (Element c -> Bool) -> c -> [c]
- break :: (Element c -> Bool) -> c -> (c, c)
- breakEnd :: (Element c -> Bool) -> c -> (c, c)
- breakElem :: Element c -> c -> (c, c)
- takeWhile :: (Element c -> Bool) -> c -> c
- dropWhile :: (Element c -> Bool) -> c -> c
- intersperse :: Element c -> c -> c
- intercalate :: Element c -> c -> Element c
- span :: (Element c -> Bool) -> c -> (c, c)
- spanEnd :: (Element c -> Bool) -> c -> (c, c)
- filter :: (Element c -> Bool) -> c -> c
- partition :: (Element c -> Bool) -> c -> (c, c)
- reverse :: c -> c
- uncons :: c -> Maybe (Element c, c)
- unsnoc :: c -> Maybe (c, Element c)
- snoc :: c -> Element c -> c
- cons :: Element c -> c -> c
- find :: (Element c -> Bool) -> c -> Maybe (Element c)
- sortBy :: (Element c -> Element c -> Ordering) -> c -> c
- singleton :: Element c -> c
- head :: NonEmpty c -> Element c
- last :: NonEmpty c -> Element c
- tail :: NonEmpty c -> c
- init :: NonEmpty c -> c
- replicate :: CountOf (Element c) -> Element c -> c
- isPrefixOf :: c -> c -> Bool
- isSuffixOf :: c -> c -> Bool
- isInfixOf :: c -> c -> Bool
- stripPrefix :: c -> c -> Maybe c
- stripSuffix :: c -> c -> Maybe c
- data NonEmpty a
- nonEmpty :: Collection c => c -> Maybe (NonEmpty c)
- class Foldable collection where
- mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- catMaybes :: [Maybe a] -> [a]
- fromMaybe :: a -> Maybe a -> a
- isJust :: Maybe a -> Bool
- isNothing :: Maybe a -> Bool
- listToMaybe :: [a] -> Maybe a
- maybeToList :: Maybe a -> [a]
- partitionEithers :: [Either a b] -> ([a], [b])
- lefts :: [Either a b] -> [a]
- rights :: [Either a b] -> [b]
- on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- (<|>) :: Alternative f => f a -> f a -> f a
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- class (Typeable e, Show e) => Exception e where
- toException :: e -> SomeException
- fromException :: SomeException -> Maybe e
- displayException :: e -> String
- backtraceDesired :: e -> Bool
- class Typeable (a :: k)
- data SomeException
- data IOException
- data Proxy (t :: k) = Proxy
- asProxyTypeOf :: a -> proxy a -> a
- data Partial a
- partial :: a -> Partial a
- data PartialError
- fromPartial :: Partial a -> a
- ifThenElse :: Bool -> a -> a -> a
- type LString = String
Standard
Operators
Functions
Strict tuple (a,b)
Constructors
| Tuple2 !a !b |
Instances
| Nthable 1 (Tuple2 a b) Source # | |||||
| Nthable 2 (Tuple2 a b) Source # | |||||
| (NormalForm a, NormalForm b) => NormalForm (Tuple2 a b) Source # | |||||
Defined in Foundation.Tuple Methods toNormalForm :: Tuple2 a b -> () # | |||||
| (Hashable a, Hashable b) => Hashable (Tuple2 a b) Source # | |||||
| Fstable (Tuple2 a b) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| Sndable (Tuple2 a b) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| (Data a, Data b) => Data (Tuple2 a b) Source # | |||||
Defined in Foundation.Tuple Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Tuple2 a b -> c (Tuple2 a b) gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Tuple2 a b) toConstr :: Tuple2 a b -> Constr dataTypeOf :: Tuple2 a b -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Tuple2 a b)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Tuple2 a b)) gmapT :: (forall b0. Data b0 => b0 -> b0) -> Tuple2 a b -> Tuple2 a b gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tuple2 a b -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tuple2 a b -> r gmapQ :: (forall d. Data d => d -> u) -> Tuple2 a b -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Tuple2 a b -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Tuple2 a b -> m (Tuple2 a b) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Tuple2 a b -> m (Tuple2 a b) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Tuple2 a b -> m (Tuple2 a b) | |||||
| Generic (Tuple2 a b) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| (Show a, Show b) => Show (Tuple2 a b) Source # | |||||
| (Eq a, Eq b) => Eq (Tuple2 a b) Source # | |||||
| (Ord a, Ord b) => Ord (Tuple2 a b) Source # | |||||
| type NthTy 1 (Tuple2 a b) Source # | |||||
Defined in Foundation.Tuple.Nth | |||||
| type NthTy 2 (Tuple2 a b) Source # | |||||
Defined in Foundation.Tuple.Nth | |||||
| type ProductFirst (Tuple2 a b) Source # | |||||
Defined in Foundation.Tuple | |||||
| type ProductSecond (Tuple2 a b) Source # | |||||
Defined in Foundation.Tuple | |||||
| type Rep (Tuple2 a b) Source # | |||||
Defined in Foundation.Tuple type Rep (Tuple2 a b) = D1 ('MetaData "Tuple2" "Foundation.Tuple" "foundation-0.0.30-JgS4dsHmMPhFcmItevGLIX" 'False) (C1 ('MetaCons "Tuple2" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 b))) | |||||
Strict tuple (a,b,c)
Constructors
| Tuple3 !a !b !c |
Instances
| Nthable 1 (Tuple3 a b c) Source # | |||||
| Nthable 2 (Tuple3 a b c) Source # | |||||
| Nthable 3 (Tuple3 a b c) Source # | |||||
| (NormalForm a, NormalForm b, NormalForm c) => NormalForm (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple Methods toNormalForm :: Tuple3 a b c -> () # | |||||
| (Hashable a, Hashable b, Hashable c) => Hashable (Tuple3 a b c) Source # | |||||
| Fstable (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| Sndable (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| Thdable (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| (Data a, Data b, Data c) => Data (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple Methods gfoldl :: (forall d b0. Data d => c0 (d -> b0) -> d -> c0 b0) -> (forall g. g -> c0 g) -> Tuple3 a b c -> c0 (Tuple3 a b c) gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (Tuple3 a b c) toConstr :: Tuple3 a b c -> Constr dataTypeOf :: Tuple3 a b c -> DataType dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (Tuple3 a b c)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (Tuple3 a b c)) gmapT :: (forall b0. Data b0 => b0 -> b0) -> Tuple3 a b c -> Tuple3 a b c gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tuple3 a b c -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tuple3 a b c -> r gmapQ :: (forall d. Data d => d -> u) -> Tuple3 a b c -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Tuple3 a b c -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Tuple3 a b c -> m (Tuple3 a b c) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Tuple3 a b c -> m (Tuple3 a b c) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Tuple3 a b c -> m (Tuple3 a b c) | |||||
| Generic (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| (Show a, Show b, Show c) => Show (Tuple3 a b c) Source # | |||||
| (Eq a, Eq b, Eq c) => Eq (Tuple3 a b c) Source # | |||||
| (Ord a, Ord b, Ord c) => Ord (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple | |||||
| type NthTy 1 (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple.Nth | |||||
| type NthTy 2 (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple.Nth | |||||
| type NthTy 3 (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple.Nth | |||||
| type ProductFirst (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple | |||||
| type ProductSecond (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple | |||||
| type ProductThird (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple | |||||
| type Rep (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple type Rep (Tuple3 a b c) = D1 ('MetaData "Tuple3" "Foundation.Tuple" "foundation-0.0.30-JgS4dsHmMPhFcmItevGLIX" 'False) (C1 ('MetaCons "Tuple3" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 b) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 c)))) | |||||
Strict tuple (a,b,c,d)
Constructors
| Tuple4 !a !b !c !d |
Instances
| Nthable 1 (Tuple4 a b c d) Source # | |||||
| Nthable 2 (Tuple4 a b c d) Source # | |||||
| Nthable 3 (Tuple4 a b c d) Source # | |||||
| Nthable 4 (Tuple4 a b c d) Source # | |||||
| (NormalForm a, NormalForm b, NormalForm c, NormalForm d) => NormalForm (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple Methods toNormalForm :: Tuple4 a b c d -> () # | |||||
| (Hashable a, Hashable b, Hashable c, Hashable d) => Hashable (Tuple4 a b c d) Source # | |||||
| Fstable (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| Sndable (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| Thdable (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| (Data a, Data b, Data c, Data d) => Data (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple Methods gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g. g -> c0 g) -> Tuple4 a b c d -> c0 (Tuple4 a b c d) gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (Tuple4 a b c d) toConstr :: Tuple4 a b c d -> Constr dataTypeOf :: Tuple4 a b c d -> DataType dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (Tuple4 a b c d)) dataCast2 :: Typeable t => (forall d0 e. (Data d0, Data e) => c0 (t d0 e)) -> Maybe (c0 (Tuple4 a b c d)) gmapT :: (forall b0. Data b0 => b0 -> b0) -> Tuple4 a b c d -> Tuple4 a b c d gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> Tuple4 a b c d -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> Tuple4 a b c d -> r gmapQ :: (forall d0. Data d0 => d0 -> u) -> Tuple4 a b c d -> [u] gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> Tuple4 a b c d -> u gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> Tuple4 a b c d -> m (Tuple4 a b c d) gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> Tuple4 a b c d -> m (Tuple4 a b c d) gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> Tuple4 a b c d -> m (Tuple4 a b c d) | |||||
| Generic (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| (Show a, Show b, Show c, Show d) => Show (Tuple4 a b c d) Source # | |||||
| (Eq a, Eq b, Eq c, Eq d) => Eq (Tuple4 a b c d) Source # | |||||
| (Ord a, Ord b, Ord c, Ord d) => Ord (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple Methods compare :: Tuple4 a b c d -> Tuple4 a b c d -> Ordering # (<) :: Tuple4 a b c d -> Tuple4 a b c d -> Bool # (<=) :: Tuple4 a b c d -> Tuple4 a b c d -> Bool # (>) :: Tuple4 a b c d -> Tuple4 a b c d -> Bool # (>=) :: Tuple4 a b c d -> Tuple4 a b c d -> Bool # | |||||
| type NthTy 1 (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple.Nth | |||||
| type NthTy 2 (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple.Nth | |||||
| type NthTy 3 (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple.Nth | |||||
| type NthTy 4 (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple.Nth | |||||
| type ProductFirst (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple | |||||
| type ProductSecond (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple | |||||
| type ProductThird (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple | |||||
| type Rep (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple type Rep (Tuple4 a b c d) = D1 ('MetaData "Tuple4" "Foundation.Tuple" "foundation-0.0.30-JgS4dsHmMPhFcmItevGLIX" 'False) (C1 ('MetaCons "Tuple4" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 b)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 c) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 d)))) | |||||
class Fstable a where Source #
Class of product types that have a first element
Associated Types
type ProductFirst a Source #
Methods
fst :: a -> ProductFirst a Source #
Instances
| Fstable (Tuple2 a b) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| Fstable (a, b) Source # | |||||
Defined in Foundation.Tuple Associated Types
Methods fst :: (a, b) -> ProductFirst (a, b) Source # | |||||
| Fstable (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| Fstable (a, b, c) Source # | |||||
Defined in Foundation.Tuple Associated Types
Methods fst :: (a, b, c) -> ProductFirst (a, b, c) Source # | |||||
| Fstable (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| Fstable (a, b, c, d) Source # | |||||
Defined in Foundation.Tuple Associated Types
Methods fst :: (a, b, c, d) -> ProductFirst (a, b, c, d) Source # | |||||
class Sndable a where Source #
Class of product types that have a second element
Associated Types
type ProductSecond a Source #
Methods
snd :: a -> ProductSecond a Source #
Instances
| Sndable (Tuple2 a b) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| Sndable (a, b) Source # | |||||
Defined in Foundation.Tuple Associated Types
Methods snd :: (a, b) -> ProductSecond (a, b) Source # | |||||
| Sndable (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| Sndable (a, b, c) Source # | |||||
Defined in Foundation.Tuple Associated Types
Methods snd :: (a, b, c) -> ProductSecond (a, b, c) Source # | |||||
| Sndable (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| Sndable (a, b, c, d) Source # | |||||
Defined in Foundation.Tuple Associated Types
Methods snd :: (a, b, c, d) -> ProductSecond (a, b, c, d) Source # | |||||
class Thdable a where Source #
Class of product types that have a third element
Associated Types
type ProductThird a Source #
Methods
thd :: a -> ProductThird a Source #
Instances
| Thdable (Tuple3 a b c) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| Thdable (a, b, c) Source # | |||||
Defined in Foundation.Tuple Associated Types
Methods thd :: (a, b, c) -> ProductThird (a, b, c) Source # | |||||
| Thdable (Tuple4 a b c d) Source # | |||||
Defined in Foundation.Tuple Associated Types
| |||||
| Thdable (a, b, c, d) Source # | |||||
Defined in Foundation.Tuple Associated Types
Methods thd :: (a, b, c, d) -> ProductThird (a, b, c, d) Source # | |||||
type family ProductFirst a Source #
Instances
| type ProductFirst (Tuple2 a b) Source # | |
Defined in Foundation.Tuple | |
| type ProductFirst (a, b) Source # | |
Defined in Foundation.Tuple type ProductFirst (a, b) = a | |
| type ProductFirst (Tuple3 a b c) Source # | |
Defined in Foundation.Tuple | |
| type ProductFirst (a, b, c) Source # | |
Defined in Foundation.Tuple type ProductFirst (a, b, c) = a | |
| type ProductFirst (Tuple4 a b c d) Source # | |
Defined in Foundation.Tuple | |
| type ProductFirst (a, b, c, d) Source # | |
Defined in Foundation.Tuple type ProductFirst (a, b, c, d) = a | |
type family ProductSecond a Source #
Instances
| type ProductSecond (Tuple2 a b) Source # | |
Defined in Foundation.Tuple | |
| type ProductSecond (a, b) Source # | |
Defined in Foundation.Tuple type ProductSecond (a, b) = b | |
| type ProductSecond (Tuple3 a b c) Source # | |
Defined in Foundation.Tuple | |
| type ProductSecond (a, b, c) Source # | |
Defined in Foundation.Tuple type ProductSecond (a, b, c) = b | |
| type ProductSecond (Tuple4 a b c d) Source # | |
Defined in Foundation.Tuple | |
| type ProductSecond (a, b, c, d) Source # | |
Defined in Foundation.Tuple type ProductSecond (a, b, c, d) = b | |
type family ProductThird a Source #
Instances
| type ProductThird (Tuple3 a b c) Source # | |
Defined in Foundation.Tuple | |
| type ProductThird (a, b, c) Source # | |
Defined in Foundation.Tuple type ProductThird (a, b, c) = c | |
| type ProductThird (Tuple4 a b c d) Source # | |
Defined in Foundation.Tuple | |
| type ProductThird (a, b, c, d) Source # | |
Defined in Foundation.Tuple type ProductThird (a, b, c, d) = c | |
class NormalForm a #
Minimal complete definition
Instances
deepseq :: NormalForm a => a -> b -> b #
force :: NormalForm a => a -> a #
Type classes
Minimal complete definition
showsPrec | show
Instances
Instances
| Ord ByteArray | |
| Ord Encoding | |
Defined in Basement.String | |
| Ord UTF32_Invalid | |
Defined in Basement.String.Encoding.UTF32 Methods compare :: UTF32_Invalid -> UTF32_Invalid -> Ordering # (<) :: UTF32_Invalid -> UTF32_Invalid -> Bool # (<=) :: UTF32_Invalid -> UTF32_Invalid -> Bool # (>) :: UTF32_Invalid -> UTF32_Invalid -> Bool # (>=) :: UTF32_Invalid -> UTF32_Invalid -> Bool # | |
| Ord AsciiString | |
Defined in Basement.Types.AsciiString Methods compare :: AsciiString -> AsciiString -> Ordering # (<) :: AsciiString -> AsciiString -> Bool # (<=) :: AsciiString -> AsciiString -> Bool # (>) :: AsciiString -> AsciiString -> Bool # (>=) :: AsciiString -> AsciiString -> Bool # max :: AsciiString -> AsciiString -> AsciiString # min :: AsciiString -> AsciiString -> AsciiString # | |
| Ord Char7 | |
| Ord FileSize | |
Defined in Basement.Types.OffsetSize | |
| Ord Addr | |
| Ord Word128 | |
Defined in Basement.Types.Word128 | |
| Ord Word256 | |
Defined in Basement.Types.Word256 | |
| Ord String | |
| Ord Bitmap Source # | |
| Ord Escaping Source # | |
Defined in Foundation.Format.CSV.Types | |
| Ord IPv4 Source # | |
| Ord IPv6 Source # | |
| Ord Arch Source # | |
| Ord OS Source # | |
| Ord NanoSeconds Source # | |
Defined in Foundation.Time.Types Methods compare :: NanoSeconds -> NanoSeconds -> Ordering # (<) :: NanoSeconds -> NanoSeconds -> Bool # (<=) :: NanoSeconds -> NanoSeconds -> Bool # (>) :: NanoSeconds -> NanoSeconds -> Bool # (>=) :: NanoSeconds -> NanoSeconds -> Bool # max :: NanoSeconds -> NanoSeconds -> NanoSeconds # min :: NanoSeconds -> NanoSeconds -> NanoSeconds # | |
| Ord Seconds Source # | |
Defined in Foundation.Time.Types | |
| Ord UUID Source # | |
| Ord FilePath Source # | |
Defined in Foundation.VFS.FilePath | |
| Ord BigNat | |
| Ord Void | |
| Ord BlockReason | |
Defined in GHC.Internal.Conc.Sync | |
| Ord ThreadId | |
Defined in GHC.Internal.Conc.Sync | |
| Ord ThreadStatus | |
Defined in GHC.Internal.Conc.Sync | |
| Ord All | |
| Ord Any | |
| Ord SomeTypeRep | |
Defined in GHC.Internal.Data.Typeable.Internal | |
| Ord Version | |
Defined in GHC.Internal.Data.Version | |
| Ord ErrorCall | |
| Ord ArithException | |
Defined in GHC.Internal.Exception.Type Methods compare :: ArithException -> ArithException -> Ordering # (<) :: ArithException -> ArithException -> Bool # (<=) :: ArithException -> ArithException -> Bool # (>) :: ArithException -> ArithException -> Bool # (>=) :: ArithException -> ArithException -> Bool # | |
| Ord CBool | |
| Ord CChar | |
| Ord CClock | |
| Ord CDouble | |
Defined in GHC.Internal.Foreign.C.Types | |
| Ord CFloat | |
| Ord CInt | |
| Ord CIntMax | |
Defined in GHC.Internal.Foreign.C.Types | |
| Ord CIntPtr | |
Defined in GHC.Internal.Foreign.C.Types | |
| Ord CLLong | |
| Ord CLong | |
| Ord CPtrdiff | |
Defined in GHC.Internal.Foreign.C.Types | |
| Ord CSChar | |
| Ord CSUSeconds | |
Defined in GHC.Internal.Foreign.C.Types Methods compare :: CSUSeconds -> CSUSeconds -> Ordering # (<) :: CSUSeconds -> CSUSeconds -> Bool # (<=) :: CSUSeconds -> CSUSeconds -> Bool # (>) :: CSUSeconds -> CSUSeconds -> Bool # (>=) :: CSUSeconds -> CSUSeconds -> Bool # max :: CSUSeconds -> CSUSeconds -> CSUSeconds # min :: CSUSeconds -> CSUSeconds -> CSUSeconds # | |
| Ord CShort | |
| Ord CSigAtomic | |
Defined in GHC.Internal.Foreign.C.Types Methods compare :: CSigAtomic -> CSigAtomic -> Ordering # (<) :: CSigAtomic -> CSigAtomic -> Bool # (<=) :: CSigAtomic -> CSigAtomic -> Bool # (>) :: CSigAtomic -> CSigAtomic -> Bool # (>=) :: CSigAtomic -> CSigAtomic -> Bool # max :: CSigAtomic -> CSigAtomic -> CSigAtomic # min :: CSigAtomic -> CSigAtomic -> CSigAtomic # | |
| Ord CSize | |
| Ord CTime | |
| Ord CUChar | |
| Ord CUInt | |
| Ord CUIntMax | |
Defined in GHC.Internal.Foreign.C.Types | |
| Ord CUIntPtr | |
Defined in GHC.Internal.Foreign.C.Types | |
| Ord CULLong | |
Defined in GHC.Internal.Foreign.C.Types | |
| Ord CULong | |
| Ord CUSeconds | |
| Ord CUShort | |
Defined in GHC.Internal.Foreign.C.Types | |
| Ord CWchar | |
| Ord Associativity | |
Defined in GHC.Internal.Generics Methods compare :: Associativity -> Associativity -> Ordering # (<) :: Associativity -> Associativity -> Bool # (<=) :: Associativity -> Associativity -> Bool # (>) :: Associativity -> Associativity -> Bool # (>=) :: Associativity -> Associativity -> Bool # | |
| Ord DecidedStrictness | |
Defined in GHC.Internal.Generics Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering # (<) :: DecidedStrictness -> DecidedStrictness -> Bool # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool # (>) :: DecidedStrictness -> DecidedStrictness -> Bool # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # | |
| Ord Fixity | |
| Ord SourceStrictness | |
Defined in GHC.Internal.Generics Methods compare :: SourceStrictness -> SourceStrictness -> Ordering # (<) :: SourceStrictness -> SourceStrictness -> Bool # (<=) :: SourceStrictness -> SourceStrictness -> Bool # (>) :: SourceStrictness -> SourceStrictness -> Bool # (>=) :: SourceStrictness -> SourceStrictness -> Bool # max :: SourceStrictness -> SourceStrictness -> SourceStrictness # min :: SourceStrictness -> SourceStrictness -> SourceStrictness # | |
| Ord SourceUnpackedness | |
Defined in GHC.Internal.Generics Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # | |
| Ord SeekMode | |
Defined in GHC.Internal.IO.Device | |
| Ord ArrayException | |
Defined in GHC.Internal.IO.Exception Methods compare :: ArrayException -> ArrayException -> Ordering # (<) :: ArrayException -> ArrayException -> Bool # (<=) :: ArrayException -> ArrayException -> Bool # (>) :: ArrayException -> ArrayException -> Bool # (>=) :: ArrayException -> ArrayException -> Bool # | |
| Ord AsyncException | |
Defined in GHC.Internal.IO.Exception Methods compare :: AsyncException -> AsyncException -> Ordering # (<) :: AsyncException -> AsyncException -> Bool # (<=) :: AsyncException -> AsyncException -> Bool # (>) :: AsyncException -> AsyncException -> Bool # (>=) :: AsyncException -> AsyncException -> Bool # | |
| Ord ExitCode | |
Defined in GHC.Internal.IO.Exception | |
| Ord BufferMode | |
Defined in GHC.Internal.IO.Handle.Types | |
| Ord Newline | |
Defined in GHC.Internal.IO.Handle.Types | |
| Ord NewlineMode | |
Defined in GHC.Internal.IO.Handle.Types | |
| Ord IOMode | |
| Ord Int16 | |
| Ord Int32 | |
| Ord Int64 | |
| Ord Int8 | |
| Ord CBlkCnt | |
Defined in GHC.Internal.System.Posix.Types | |
| Ord CBlkSize | |
Defined in GHC.Internal.System.Posix.Types | |
| Ord CCc | |
| Ord CClockId | |
Defined in GHC.Internal.System.Posix.Types | |
| Ord CDev | |
| Ord CFsBlkCnt | |
| Ord CFsFilCnt | |
| Ord CGid | |
| Ord CId | |
| Ord CIno | |
| Ord CKey | |
| Ord CMode | |
| Ord CNfds | |
| Ord CNlink | |
| Ord COff | |
| Ord CPid | |
| Ord CRLim | |
| Ord CSocklen | |
Defined in GHC.Internal.System.Posix.Types | |
| Ord CSpeed | |
| Ord CSsize | |
| Ord CTcflag | |
Defined in GHC.Internal.System.Posix.Types | |
| Ord CTimer | |
| Ord CUid | |
| Ord Fd | |
| Ord SomeNat | |
Defined in GHC.Internal.TypeNats | |
| Ord GeneralCategory | |
Defined in GHC.Internal.Unicode Methods compare :: GeneralCategory -> GeneralCategory -> Ordering # (<) :: GeneralCategory -> GeneralCategory -> Bool # (<=) :: GeneralCategory -> GeneralCategory -> Bool # (>) :: GeneralCategory -> GeneralCategory -> Bool # (>=) :: GeneralCategory -> GeneralCategory -> Bool # max :: GeneralCategory -> GeneralCategory -> GeneralCategory # min :: GeneralCategory -> GeneralCategory -> GeneralCategory # | |
| Ord Word16 | |
| Ord Word32 | |
| Ord Word64 | |
| Ord Word8 | |
| Ord Ordering | |
Defined in GHC.Classes | |
| Ord TyCon | |
| Ord Integer | |
| Ord Natural | |
| Ord () | |
| Ord Bool | |
| Ord Char | |
| Ord Double | |
| Ord Float | |
| Ord Int | |
| Ord Word | |
| Ord a => Ord (First a) | |
| Ord a => Ord (Last a) | |
| Ord a => Ord (Max a) | |
| Ord a => Ord (Min a) | |
| Ord m => Ord (WrappedMonoid m) | |
Defined in Data.Semigroup Methods compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering # (<) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # | |
| Ord (Bits n) | |
| (PrimType ty, Ord ty) => Ord (Block ty) | |
Defined in Basement.Block.Base | |
| Ord (Zn n) | |
| Ord (Zn64 n) | |
| Ord a => Ord (Array a) | |
| (ByteSwap a, Ord a) => Ord (BE a) | |
| (ByteSwap a, Ord a) => Ord (LE a) | |
| Ord (FinalPtr a) | |
| Ord (CountOf ty) | |
Defined in Basement.Types.OffsetSize | |
| Ord (Offset ty) | |
| (PrimType ty, Ord ty) => Ord (UArray ty) | |
| (PrimType ty, Ord ty) => Ord (ChunkedUArray ty) Source # | |
Defined in Foundation.Array.Chunked.Unboxed Methods compare :: ChunkedUArray ty -> ChunkedUArray ty -> Ordering # (<) :: ChunkedUArray ty -> ChunkedUArray ty -> Bool # (<=) :: ChunkedUArray ty -> ChunkedUArray ty -> Bool # (>) :: ChunkedUArray ty -> ChunkedUArray ty -> Bool # (>=) :: ChunkedUArray ty -> ChunkedUArray ty -> Bool # max :: ChunkedUArray ty -> ChunkedUArray ty -> ChunkedUArray ty # min :: ChunkedUArray ty -> ChunkedUArray ty -> ChunkedUArray ty # | |
| Ord a => Ord (DList a) Source # | |
Defined in Foundation.List.DList | |
| Ord a => Ord (NonEmpty a) | |
| Ord a => Ord (Identity a) | |
Defined in GHC.Internal.Data.Functor.Identity | |
| Ord a => Ord (First a) | |
Defined in GHC.Internal.Data.Monoid | |
| Ord a => Ord (Last a) | |
| Ord a => Ord (Dual a) | |
Defined in GHC.Internal.Data.Semigroup.Internal | |
| Ord a => Ord (Product a) | |
Defined in GHC.Internal.Data.Semigroup.Internal | |
| Ord a => Ord (Sum a) | |
| Ord (ForeignPtr a) | |
Defined in GHC.Internal.ForeignPtr | |
| Ord a => Ord (ZipList a) | |
| Ord p => Ord (Par1 p) | |
| Ord (FunPtr a) | |
Defined in GHC.Internal.Ptr | |
| Ord (Ptr a) | |
| Integral a => Ord (Ratio a) | |
| Ord (SNat n) | |
| Ord a => Ord (Maybe a) | |
| Ord a => Ord (Solo a) | |
| Ord a => Ord [a] | |
| Ord (Fixed a) | |
| Ord a => Ord (Arg a b) | |
| (PrimType a, Ord a) => Ord (BlockN n a) | |
Defined in Basement.Sized.Block | |
| Ord a => Ord (ListN n a) | |
| (Ord a, Ord b) => Ord (These a b) | |
| (Ord a, Ord b) => Ord (Tuple2 a b) Source # | |
| (Ord a, Ord b) => Ord (Either a b) | |
Defined in GHC.Internal.Data.Either | |
| Ord (Proxy s) | |
Defined in GHC.Internal.Data.Proxy | |
| Ord (TypeRep a) | |
Defined in GHC.Internal.Data.Typeable.Internal | |
| Ord (U1 p) | |
| Ord (V1 p) | |
| (Ord a, Ord b) => Ord (a, b) | |
| (Ord a, Ord b, Ord c) => Ord (Tuple3 a b c) Source # | |
Defined in Foundation.Tuple | |
| Ord a => Ord (Const a b) | |
| Ord (f a) => Ord (Ap f a) | |
| Ord (f a) => Ord (Alt f a) | |
Defined in GHC.Internal.Data.Semigroup.Internal | |
| (Generic1 f, Ord (Rep1 f a)) => Ord (Generically1 f a) | |
Defined in GHC.Internal.Generics Methods compare :: Generically1 f a -> Generically1 f a -> Ordering # (<) :: Generically1 f a -> Generically1 f a -> Bool # (<=) :: Generically1 f a -> Generically1 f a -> Bool # (>) :: Generically1 f a -> Generically1 f a -> Bool # (>=) :: Generically1 f a -> Generically1 f a -> Bool # max :: Generically1 f a -> Generically1 f a -> Generically1 f a # min :: Generically1 f a -> Generically1 f a -> Generically1 f a # | |
| Ord (f p) => Ord (Rec1 f p) | |
Defined in GHC.Internal.Generics | |
| Ord (URec (Ptr ()) p) | |
Defined in GHC.Internal.Generics Methods compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering # (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # | |
| Ord (URec Char p) | |
Defined in GHC.Internal.Generics | |
| Ord (URec Double p) | |
Defined in GHC.Internal.Generics Methods compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # | |
| Ord (URec Float p) | |
Defined in GHC.Internal.Generics | |
| Ord (URec Int p) | |
Defined in GHC.Internal.Generics | |
| Ord (URec Word p) | |
Defined in GHC.Internal.Generics | |
| (Ord a, Ord b, Ord c) => Ord (a, b, c) | |
| (Ord (f a), Ord (g a)) => Ord (Product f g a) | |
Defined in Data.Functor.Product Methods compare :: Product f g a -> Product f g a -> Ordering # (<) :: Product f g a -> Product f g a -> Bool # (<=) :: Product f g a -> Product f g a -> Bool # (>) :: Product f g a -> Product f g a -> Bool # (>=) :: Product f g a -> Product f g a -> Bool # | |
| (Ord (f a), Ord (g a)) => Ord (Sum f g a) | |
| (Ord a, Ord b, Ord c, Ord d) => Ord (Tuple4 a b c d) Source # | |
Defined in Foundation.Tuple Methods compare :: Tuple4 a b c d -> Tuple4 a b c d -> Ordering # (<) :: Tuple4 a b c d -> Tuple4 a b c d -> Bool # (<=) :: Tuple4 a b c d -> Tuple4 a b c d -> Bool # (>) :: Tuple4 a b c d -> Tuple4 a b c d -> Bool # (>=) :: Tuple4 a b c d -> Tuple4 a b c d -> Bool # | |
| (Ord (f p), Ord (g p)) => Ord ((f :*: g) p) | |
Defined in GHC.Internal.Generics | |
| (Ord (f p), Ord (g p)) => Ord ((f :+: g) p) | |
Defined in GHC.Internal.Generics | |
| Ord c => Ord (K1 i c p) | |
Defined in GHC.Internal.Generics | |
| (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) | |
Defined in GHC.Classes | |
| Ord (f (g a)) => Ord (Compose f g a) | |
Defined in Data.Functor.Compose Methods compare :: Compose f g a -> Compose f g a -> Ordering # (<) :: Compose f g a -> Compose f g a -> Bool # (<=) :: Compose f g a -> Compose f g a -> Bool # (>) :: Compose f g a -> Compose f g a -> Bool # (>=) :: Compose f g a -> Compose f g a -> Bool # | |
| Ord (f (g p)) => Ord ((f :.: g) p) | |
Defined in GHC.Internal.Generics | |
| Ord (f p) => Ord (M1 i c f p) | |
Defined in GHC.Internal.Generics | |
| (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e) -> (a, b, c, d, e) -> Ordering # (<) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (<=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (>=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # max :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # min :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # | |
| (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Ordering # (<) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (<=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (>) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (>=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # max :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # min :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # | |
| (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Ordering # (<) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (<=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (>) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (>=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # max :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # min :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # | |
| (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Ordering # (<) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (<=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (>) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (>=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # max :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # min :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # | |
| (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # max :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # min :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # | |
| (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # min :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # | |
| (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # min :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # | |
| (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # min :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # | |
| (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) # | |
| (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # | |
| (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # | |
Instances
| Eq ByteArray | |
| Eq Timeout | |
| Eq PinnedStatus | |
| Eq Endianness | |
Defined in Basement.Endianness | |
| Eq OutOfBoundOperation | |
| Eq RecastDestinationSize | |
| Eq RecastSourceSize | |
| Eq Encoding | |
| Eq ASCII7_Invalid | |
| Eq ISO_8859_1_Invalid | |
| Eq UTF16_Invalid | |
| Eq UTF32_Invalid | |
| Eq AsciiString | |
Defined in Basement.Types.AsciiString | |
| Eq Char7 | |
| Eq FileSize | |
| Eq Addr | |
| Eq Word128 | |
| Eq Word256 | |
| Eq String | |
| Eq CM | |
| Eq ValidationFailure | |
Defined in Basement.UTF8.Types Methods (==) :: ValidationFailure -> ValidationFailure -> Bool # (/=) :: ValidationFailure -> ValidationFailure -> Bool # | |
| Eq Bitmap Source # | |
| Eq CSV Source # | |
| Eq Escaping Source # | |
| Eq Field Source # | |
| Eq Row Source # | |
| Eq IPv4 Source # | |
| Eq IPv6 Source # | |
| Eq Sign Source # | |
| Eq And Source # | |
| Eq Condition Source # | |
| Eq PartialError Source # | |
Defined in Foundation.Partial | |
| Eq Arch Source # | |
| Eq OS Source # | |
| Eq NanoSeconds Source # | |
Defined in Foundation.Time.Types | |
| Eq Seconds Source # | |
| Eq UUID Source # | |
| Eq FileName Source # | |
| Eq FilePath Source # | |
| Eq Relativity Source # | |
Defined in Foundation.VFS.FilePath | |
| Eq BigNat | |
| Eq Void | |
| Eq BlockReason | |
| Eq ThreadId | |
| Eq ThreadStatus | |
| Eq Constr | |
| Eq ConstrRep | |
| Eq DataRep | |
| Eq Fixity | |
| Eq All | |
| Eq Any | |
| Eq SomeTypeRep | |
| Eq Version | |
| Eq ErrorCall | |
| Eq ArithException | |
| Eq Errno | |
| Eq CBool | |
| Eq CChar | |
| Eq CClock | |
| Eq CDouble | |
| Eq CFloat | |
| Eq CInt | |
| Eq CIntMax | |
| Eq CIntPtr | |
| Eq CLLong | |
| Eq CLong | |
| Eq CPtrdiff | |
| Eq CSChar | |
| Eq CSUSeconds | |
Defined in GHC.Internal.Foreign.C.Types | |
| Eq CShort | |
| Eq CSigAtomic | |
Defined in GHC.Internal.Foreign.C.Types | |
| Eq CSize | |
| Eq CTime | |
| Eq CUChar | |
| Eq CUInt | |
| Eq CUIntMax | |
| Eq CUIntPtr | |
| Eq CULLong | |
| Eq CULong | |
| Eq CUSeconds | |
| Eq CUShort | |
| Eq CWchar | |
| Eq Associativity | |
| Eq DecidedStrictness | |
| Eq Fixity | |
| Eq SourceStrictness | |
| Eq SourceUnpackedness | |
| Eq MaskingState | |
| Eq IODeviceType | |
| Eq SeekMode | |
| Eq ArrayException | |
| Eq AsyncException | |
| Eq ExitCode | |
| Eq IOErrorType | |
| Eq IOException | |
Defined in GHC.Internal.IO.Exception | |
| Eq HandlePosn | |
| Eq BufferMode | |
| Eq Handle | |
| Eq Newline | |
| Eq NewlineMode | |
| Eq IOMode | |
| Eq Int16 | |
| Eq Int32 | |
| Eq Int64 | |
| Eq Int8 | |
| Eq IoSubSystem | |
| Eq SrcLoc | |
| Eq CBlkCnt | |
| Eq CBlkSize | |
| Eq CCc | |
| Eq CClockId | |
| Eq CDev | |
| Eq CFsBlkCnt | |
| Eq CFsFilCnt | |
| Eq CGid | |
| Eq CId | |
| Eq CIno | |
| Eq CKey | |
| Eq CMode | |
| Eq CNfds | |
| Eq CNlink | |
| Eq COff | |
| Eq CPid | |
| Eq CRLim | |
| Eq CSocklen | |
| Eq CSpeed | |
| Eq CSsize | |
| Eq CTcflag | |
| Eq CTimer | |
| Eq CUid | |
| Eq Fd | |
| Eq SomeNat | |
| Eq GeneralCategory | |
| Eq Word16 | |
| Eq Word32 | |
| Eq Word64 | |
| Eq Word8 | |
| Eq Module | |
| Eq Ordering | |
| Eq TrName | |
| Eq TyCon | |
| Eq Integer | |
| Eq Natural | |
| Eq () | |
| Eq Bool | |
| Eq Char | |
| Eq Double | |
| Eq Float | |
| Eq Int | |
| Eq Word | |
| Eq (Chan a) | |
| Eq (MutableByteArray s) | |
| Eq a => Eq (Complex a) | |
| Eq a => Eq (First a) | |
| Eq a => Eq (Last a) | |
| Eq a => Eq (Max a) | |
| Eq a => Eq (Min a) | |
| Eq m => Eq (WrappedMonoid m) | |
| Eq (Bits n) | |
| (PrimType ty, Eq ty) => Eq (Block ty) | |
| Eq (Zn n) | |
| Eq (Zn64 n) | |
| Eq a => Eq (Array a) | |
| Eq a => Eq (BE a) | |
| Eq a => Eq (LE a) | |
| Eq (FinalPtr a) | |
| Eq a => Eq (NonEmpty a) | |
| Eq (CountOf ty) | |
| Eq (Offset ty) | |
| (PrimType ty, Eq ty) => Eq (UArray ty) | |
| PrimType ty => Eq (ChunkedUArray ty) Source # | |
Defined in Foundation.Array.Chunked.Unboxed Methods (==) :: ChunkedUArray ty -> ChunkedUArray ty -> Bool # (/=) :: ChunkedUArray ty -> ChunkedUArray ty -> Bool # | |
| Eq a => Eq (DList a) Source # | |
| Eq a => Eq (NonEmpty a) | |
| Eq (TVar a) | |
| Eq a => Eq (Identity a) | |
| Eq a => Eq (First a) | |
| Eq a => Eq (Last a) | |
| Eq a => Eq (Dual a) | |
| Eq a => Eq (Product a) | |
| Eq a => Eq (Sum a) | |
| Eq (ForeignPtr a) | |
| Eq a => Eq (ZipList a) | |
| Eq p => Eq (Par1 p) | |
| Eq (IORef a) | |
| Eq (FunPtr a) | |
| Eq (Ptr a) | |
| Eq a => Eq (Ratio a) | |
| Eq (SNat n) | |
| Eq a => Eq (Maybe a) | |
| Eq a => Eq (Solo a) | |
| Eq a => Eq [a] | |
| Eq (Fixed a) | |
| Eq a => Eq (Arg a b) | |
| PrimType a => Eq (BlockN n a) | |
| Eq a => Eq (ListN n a) | |
| PrimType a => Eq (UVect n a) | |
| Eq a => Eq (Vect n a) | |
| (Eq a, Eq b) => Eq (These a b) | |
| (Eq a, Eq b) => Eq (Tuple2 a b) Source # | |
| (Eq a, Eq b) => Eq (Either a b) | |
| Eq (Proxy s) | |
| Eq (TypeRep a) | |
| Eq (U1 p) | |
| Eq (V1 p) | |
| (Eq a, Eq b) => Eq (a, b) | |
| (Eq a, Eq b, Eq c) => Eq (Tuple3 a b c) Source # | |
| Eq a => Eq (Const a b) | |
| Eq (f a) => Eq (Ap f a) | |
| Eq (f a) => Eq (Alt f a) | |
| Eq (OrderingI a b) | |
| (Generic1 f, Eq (Rep1 f a)) => Eq (Generically1 f a) | |
| Eq (f p) => Eq (Rec1 f p) | |
| Eq (URec (Ptr ()) p) | |
| Eq (URec Char p) | |
| Eq (URec Double p) | |
| Eq (URec Float p) | |
| Eq (URec Int p) | |
| Eq (URec Word p) | |
| (Eq a, Eq b, Eq c) => Eq (a, b, c) | |
| (Eq (f a), Eq (g a)) => Eq (Product f g a) | |
| (Eq (f a), Eq (g a)) => Eq (Sum f g a) | |
| (Eq a, Eq b, Eq c, Eq d) => Eq (Tuple4 a b c d) Source # | |
| (Eq (f p), Eq (g p)) => Eq ((f :*: g) p) | |
| (Eq (f p), Eq (g p)) => Eq ((f :+: g) p) | |
| Eq c => Eq (K1 i c p) | |
| (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) | |
| Eq (f (g a)) => Eq (Compose f g a) | |
| Eq (f (g p)) => Eq ((f :.: g) p) | |
| Eq (f p) => Eq (M1 i c f p) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Instances
Methods
enumFromThen :: a -> a -> [a] #
enumFromTo :: a -> a -> [a] #
enumFromThenTo :: a -> a -> a -> [a] #
Instances
| Enum Encoding | |
| Enum UTF32_Invalid | |
Defined in Basement.String.Encoding.UTF32 Methods succ :: UTF32_Invalid -> UTF32_Invalid # pred :: UTF32_Invalid -> UTF32_Invalid # toEnum :: Int -> UTF32_Invalid # fromEnum :: UTF32_Invalid -> Int # enumFrom :: UTF32_Invalid -> [UTF32_Invalid] # enumFromThen :: UTF32_Invalid -> UTF32_Invalid -> [UTF32_Invalid] # enumFromTo :: UTF32_Invalid -> UTF32_Invalid -> [UTF32_Invalid] # enumFromThenTo :: UTF32_Invalid -> UTF32_Invalid -> UTF32_Invalid -> [UTF32_Invalid] # | |
| Enum Word128 | |
| Enum Word256 | |
| Enum Escaping Source # | |
Defined in Foundation.Format.CSV.Types | |
| Enum Arch Source # | |
| Enum OS Source # | |
| Enum NanoSeconds Source # | |
Defined in Foundation.Time.Types Methods succ :: NanoSeconds -> NanoSeconds # pred :: NanoSeconds -> NanoSeconds # toEnum :: Int -> NanoSeconds # fromEnum :: NanoSeconds -> Int # enumFrom :: NanoSeconds -> [NanoSeconds] # enumFromThen :: NanoSeconds -> NanoSeconds -> [NanoSeconds] # enumFromTo :: NanoSeconds -> NanoSeconds -> [NanoSeconds] # enumFromThenTo :: NanoSeconds -> NanoSeconds -> NanoSeconds -> [NanoSeconds] # | |
| Enum Seconds Source # | |
| Enum CBool | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CChar | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CClock | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CDouble | |
| Enum CFloat | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CInt | |
| Enum CIntMax | |
| Enum CIntPtr | |
| Enum CLLong | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CLong | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CPtrdiff | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CSChar | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CSUSeconds | |
Defined in GHC.Internal.Foreign.C.Types Methods succ :: CSUSeconds -> CSUSeconds # pred :: CSUSeconds -> CSUSeconds # toEnum :: Int -> CSUSeconds # fromEnum :: CSUSeconds -> Int # enumFrom :: CSUSeconds -> [CSUSeconds] # enumFromThen :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromTo :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromThenTo :: CSUSeconds -> CSUSeconds -> CSUSeconds -> [CSUSeconds] # | |
| Enum CShort | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CSigAtomic | |
Defined in GHC.Internal.Foreign.C.Types Methods succ :: CSigAtomic -> CSigAtomic # pred :: CSigAtomic -> CSigAtomic # toEnum :: Int -> CSigAtomic # fromEnum :: CSigAtomic -> Int # enumFrom :: CSigAtomic -> [CSigAtomic] # enumFromThen :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromTo :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromThenTo :: CSigAtomic -> CSigAtomic -> CSigAtomic -> [CSigAtomic] # | |
| Enum CSize | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CTime | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CUChar | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CUInt | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CUIntMax | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CUIntPtr | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CULLong | |
| Enum CULong | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CUSeconds | |
Defined in GHC.Internal.Foreign.C.Types Methods succ :: CUSeconds -> CUSeconds # pred :: CUSeconds -> CUSeconds # fromEnum :: CUSeconds -> Int # enumFrom :: CUSeconds -> [CUSeconds] # enumFromThen :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromTo :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromThenTo :: CUSeconds -> CUSeconds -> CUSeconds -> [CUSeconds] # | |
| Enum CUShort | |
| Enum CWchar | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum Associativity | |
Defined in GHC.Internal.Generics Methods succ :: Associativity -> Associativity # pred :: Associativity -> Associativity # toEnum :: Int -> Associativity # fromEnum :: Associativity -> Int # enumFrom :: Associativity -> [Associativity] # enumFromThen :: Associativity -> Associativity -> [Associativity] # enumFromTo :: Associativity -> Associativity -> [Associativity] # enumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity] # | |
| Enum DecidedStrictness | |
Defined in GHC.Internal.Generics Methods succ :: DecidedStrictness -> DecidedStrictness # pred :: DecidedStrictness -> DecidedStrictness # toEnum :: Int -> DecidedStrictness # fromEnum :: DecidedStrictness -> Int # enumFrom :: DecidedStrictness -> [DecidedStrictness] # enumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromThenTo :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # | |
| Enum SourceStrictness | |
Defined in GHC.Internal.Generics Methods succ :: SourceStrictness -> SourceStrictness # pred :: SourceStrictness -> SourceStrictness # toEnum :: Int -> SourceStrictness # fromEnum :: SourceStrictness -> Int # enumFrom :: SourceStrictness -> [SourceStrictness] # enumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromThenTo :: SourceStrictness -> SourceStrictness -> SourceStrictness -> [SourceStrictness] # | |
| Enum SourceUnpackedness | |
Defined in GHC.Internal.Generics Methods succ :: SourceUnpackedness -> SourceUnpackedness # pred :: SourceUnpackedness -> SourceUnpackedness # toEnum :: Int -> SourceUnpackedness # fromEnum :: SourceUnpackedness -> Int # enumFrom :: SourceUnpackedness -> [SourceUnpackedness] # enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromThenTo :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # | |
| Enum SeekMode | |
Defined in GHC.Internal.IO.Device Methods succ :: SeekMode -> SeekMode # pred :: SeekMode -> SeekMode # enumFrom :: SeekMode -> [SeekMode] # enumFromThen :: SeekMode -> SeekMode -> [SeekMode] # enumFromTo :: SeekMode -> SeekMode -> [SeekMode] # enumFromThenTo :: SeekMode -> SeekMode -> SeekMode -> [SeekMode] # | |
| Enum IOMode | |
Defined in GHC.Internal.IO.IOMode | |
| Enum Int16 | |
Defined in GHC.Internal.Int | |
| Enum Int32 | |
Defined in GHC.Internal.Int | |
| Enum Int64 | |
Defined in GHC.Internal.Int | |
| Enum Int8 | |
| Enum DoCostCentres | |
Defined in GHC.Internal.RTS.Flags Methods succ :: DoCostCentres -> DoCostCentres # pred :: DoCostCentres -> DoCostCentres # toEnum :: Int -> DoCostCentres # fromEnum :: DoCostCentres -> Int # enumFrom :: DoCostCentres -> [DoCostCentres] # enumFromThen :: DoCostCentres -> DoCostCentres -> [DoCostCentres] # enumFromTo :: DoCostCentres -> DoCostCentres -> [DoCostCentres] # enumFromThenTo :: DoCostCentres -> DoCostCentres -> DoCostCentres -> [DoCostCentres] # | |
| Enum DoHeapProfile | |
Defined in GHC.Internal.RTS.Flags Methods succ :: DoHeapProfile -> DoHeapProfile # pred :: DoHeapProfile -> DoHeapProfile # toEnum :: Int -> DoHeapProfile # fromEnum :: DoHeapProfile -> Int # enumFrom :: DoHeapProfile -> [DoHeapProfile] # enumFromThen :: DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] # enumFromTo :: DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] # enumFromThenTo :: DoHeapProfile -> DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] # | |
| Enum DoTrace | |
Defined in GHC.Internal.RTS.Flags Methods enumFrom :: DoTrace -> [DoTrace] # enumFromThen :: DoTrace -> DoTrace -> [DoTrace] # enumFromTo :: DoTrace -> DoTrace -> [DoTrace] # enumFromThenTo :: DoTrace -> DoTrace -> DoTrace -> [DoTrace] # | |
| Enum GiveGCStats | |
Defined in GHC.Internal.RTS.Flags Methods succ :: GiveGCStats -> GiveGCStats # pred :: GiveGCStats -> GiveGCStats # toEnum :: Int -> GiveGCStats # fromEnum :: GiveGCStats -> Int # enumFrom :: GiveGCStats -> [GiveGCStats] # enumFromThen :: GiveGCStats -> GiveGCStats -> [GiveGCStats] # enumFromTo :: GiveGCStats -> GiveGCStats -> [GiveGCStats] # enumFromThenTo :: GiveGCStats -> GiveGCStats -> GiveGCStats -> [GiveGCStats] # | |
| Enum IoSubSystem | |
Defined in GHC.Internal.RTS.Flags Methods succ :: IoSubSystem -> IoSubSystem # pred :: IoSubSystem -> IoSubSystem # toEnum :: Int -> IoSubSystem # fromEnum :: IoSubSystem -> Int # enumFrom :: IoSubSystem -> [IoSubSystem] # enumFromThen :: IoSubSystem -> IoSubSystem -> [IoSubSystem] # enumFromTo :: IoSubSystem -> IoSubSystem -> [IoSubSystem] # enumFromThenTo :: IoSubSystem -> IoSubSystem -> IoSubSystem -> [IoSubSystem] # | |
| Enum CBlkCnt | |
Defined in GHC.Internal.System.Posix.Types Methods enumFrom :: CBlkCnt -> [CBlkCnt] # enumFromThen :: CBlkCnt -> CBlkCnt -> [CBlkCnt] # enumFromTo :: CBlkCnt -> CBlkCnt -> [CBlkCnt] # enumFromThenTo :: CBlkCnt -> CBlkCnt -> CBlkCnt -> [CBlkCnt] # | |
| Enum CBlkSize | |
Defined in GHC.Internal.System.Posix.Types Methods succ :: CBlkSize -> CBlkSize # pred :: CBlkSize -> CBlkSize # enumFrom :: CBlkSize -> [CBlkSize] # enumFromThen :: CBlkSize -> CBlkSize -> [CBlkSize] # enumFromTo :: CBlkSize -> CBlkSize -> [CBlkSize] # enumFromThenTo :: CBlkSize -> CBlkSize -> CBlkSize -> [CBlkSize] # | |
| Enum CCc | |
Defined in GHC.Internal.System.Posix.Types | |
| Enum CClockId | |
Defined in GHC.Internal.System.Posix.Types Methods succ :: CClockId -> CClockId # pred :: CClockId -> CClockId # enumFrom :: CClockId -> [CClockId] # enumFromThen :: CClockId -> CClockId -> [CClockId] # enumFromTo :: CClockId -> CClockId -> [CClockId] # enumFromThenTo :: CClockId -> CClockId -> CClockId -> [CClockId] # | |
| Enum CDev | |
Defined in GHC.Internal.System.Posix.Types | |
| Enum CFsBlkCnt | |
Defined in GHC.Internal.System.Posix.Types Methods succ :: CFsBlkCnt -> CFsBlkCnt # pred :: CFsBlkCnt -> CFsBlkCnt # fromEnum :: CFsBlkCnt -> Int # enumFrom :: CFsBlkCnt -> [CFsBlkCnt] # enumFromThen :: CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt] # enumFromTo :: CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt] # enumFromThenTo :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt] # | |
| Enum CFsFilCnt | |
Defined in GHC.Internal.System.Posix.Types Methods succ :: CFsFilCnt -> CFsFilCnt # pred :: CFsFilCnt -> CFsFilCnt # fromEnum :: CFsFilCnt -> Int # enumFrom :: CFsFilCnt -> [CFsFilCnt] # enumFromThen :: CFsFilCnt -> CFsFilCnt -> [CFsFilCnt] # enumFromTo :: CFsFilCnt -> CFsFilCnt -> [CFsFilCnt] # enumFromThenTo :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt -> [CFsFilCnt] # | |
| Enum CGid | |
Defined in GHC.Internal.System.Posix.Types | |
| Enum CId | |
Defined in GHC.Internal.System.Posix.Types | |
| Enum CIno | |
Defined in GHC.Internal.System.Posix.Types | |
| Enum CKey | |
Defined in GHC.Internal.System.Posix.Types | |
| Enum CMode | |
Defined in GHC.Internal.System.Posix.Types | |
| Enum CNfds | |
Defined in GHC.Internal.System.Posix.Types | |
| Enum CNlink | |
Defined in GHC.Internal.System.Posix.Types | |
| Enum COff | |
| Enum CPid | |
Defined in GHC.Internal.System.Posix.Types | |
| Enum CRLim | |
Defined in GHC.Internal.System.Posix.Types | |
| Enum CSocklen | |
Defined in GHC.Internal.System.Posix.Types Methods succ :: CSocklen -> CSocklen # pred :: CSocklen -> CSocklen # enumFrom :: CSocklen -> [CSocklen] # enumFromThen :: CSocklen -> CSocklen -> [CSocklen] # enumFromTo :: CSocklen -> CSocklen -> [CSocklen] # enumFromThenTo :: CSocklen -> CSocklen -> CSocklen -> [CSocklen] # | |
| Enum CSpeed | |
Defined in GHC.Internal.System.Posix.Types | |
| Enum CSsize | |
Defined in GHC.Internal.System.Posix.Types | |
| Enum CTcflag | |
Defined in GHC.Internal.System.Posix.Types Methods enumFrom :: CTcflag -> [CTcflag] # enumFromThen :: CTcflag -> CTcflag -> [CTcflag] # enumFromTo :: CTcflag -> CTcflag -> [CTcflag] # enumFromThenTo :: CTcflag -> CTcflag -> CTcflag -> [CTcflag] # | |
| Enum CUid | |
Defined in GHC.Internal.System.Posix.Types | |
| Enum Fd | |
Defined in GHC.Internal.System.Posix.Types | |
| Enum GeneralCategory | |
Defined in GHC.Internal.Unicode Methods succ :: GeneralCategory -> GeneralCategory # pred :: GeneralCategory -> GeneralCategory # toEnum :: Int -> GeneralCategory # fromEnum :: GeneralCategory -> Int # enumFrom :: GeneralCategory -> [GeneralCategory] # enumFromThen :: GeneralCategory -> GeneralCategory -> [GeneralCategory] # enumFromTo :: GeneralCategory -> GeneralCategory -> [GeneralCategory] # enumFromThenTo :: GeneralCategory -> GeneralCategory -> GeneralCategory -> [GeneralCategory] # | |
| Enum Word16 | |
Defined in GHC.Internal.Word | |
| Enum Word32 | |
Defined in GHC.Internal.Word | |
| Enum Word64 | |
Defined in GHC.Internal.Word | |
| Enum Word8 | |
Defined in GHC.Internal.Word | |
| Enum Ordering | |
Defined in GHC.Internal.Enum | |
| Enum Integer | |
| Enum Natural | |
| Enum () | |
Defined in GHC.Internal.Enum | |
| Enum Bool | |
| Enum Char | |
| Enum Double | |
Defined in GHC.Internal.Float | |
| Enum Float | |
Defined in GHC.Internal.Float | |
| Enum Int | |
| Enum Levity | |
Defined in GHC.Internal.Enum | |
| Enum VecCount | |
Defined in GHC.Internal.Enum Methods succ :: VecCount -> VecCount # pred :: VecCount -> VecCount # enumFrom :: VecCount -> [VecCount] # enumFromThen :: VecCount -> VecCount -> [VecCount] # enumFromTo :: VecCount -> VecCount -> [VecCount] # enumFromThenTo :: VecCount -> VecCount -> VecCount -> [VecCount] # | |
| Enum VecElem | |
Defined in GHC.Internal.Enum Methods enumFrom :: VecElem -> [VecElem] # enumFromThen :: VecElem -> VecElem -> [VecElem] # enumFromTo :: VecElem -> VecElem -> [VecElem] # enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem] # | |
| Enum Word | |
| Enum a => Enum (First a) | |
Defined in Data.Semigroup Methods enumFrom :: First a -> [First a] # enumFromThen :: First a -> First a -> [First a] # enumFromTo :: First a -> First a -> [First a] # enumFromThenTo :: First a -> First a -> First a -> [First a] # | |
| Enum a => Enum (Last a) | |
Defined in Data.Semigroup | |
| Enum a => Enum (Max a) | |
Defined in Data.Semigroup | |
| Enum a => Enum (Min a) | |
Defined in Data.Semigroup | |
| Enum a => Enum (WrappedMonoid a) | |
Defined in Data.Semigroup Methods succ :: WrappedMonoid a -> WrappedMonoid a # pred :: WrappedMonoid a -> WrappedMonoid a # toEnum :: Int -> WrappedMonoid a # fromEnum :: WrappedMonoid a -> Int # enumFrom :: WrappedMonoid a -> [WrappedMonoid a] # enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # | |
| SizeValid n => Enum (Bits n) | |
Defined in Basement.Bits | |
| Enum (CountOf ty) | |
Defined in Basement.Types.OffsetSize Methods succ :: CountOf ty -> CountOf ty # pred :: CountOf ty -> CountOf ty # fromEnum :: CountOf ty -> Int # enumFrom :: CountOf ty -> [CountOf ty] # enumFromThen :: CountOf ty -> CountOf ty -> [CountOf ty] # enumFromTo :: CountOf ty -> CountOf ty -> [CountOf ty] # enumFromThenTo :: CountOf ty -> CountOf ty -> CountOf ty -> [CountOf ty] # | |
| Enum (Offset ty) | |
Defined in Basement.Types.OffsetSize Methods succ :: Offset ty -> Offset ty # pred :: Offset ty -> Offset ty # fromEnum :: Offset ty -> Int # enumFrom :: Offset ty -> [Offset ty] # enumFromThen :: Offset ty -> Offset ty -> [Offset ty] # enumFromTo :: Offset ty -> Offset ty -> [Offset ty] # enumFromThenTo :: Offset ty -> Offset ty -> Offset ty -> [Offset ty] # | |
| Enum a => Enum (Identity a) | |
Defined in GHC.Internal.Data.Functor.Identity Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] # | |
| Integral a => Enum (Ratio a) | |
Defined in GHC.Internal.Real Methods enumFrom :: Ratio a -> [Ratio a] # enumFromThen :: Ratio a -> Ratio a -> [Ratio a] # enumFromTo :: Ratio a -> Ratio a -> [Ratio a] # enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a] # | |
| Enum a => Enum (Solo a) | |
Defined in GHC.Internal.Enum | |
| Enum (Fixed a) | |
Defined in Data.Fixed Methods enumFrom :: Fixed a -> [Fixed a] # enumFromThen :: Fixed a -> Fixed a -> [Fixed a] # enumFromTo :: Fixed a -> Fixed a -> [Fixed a] # enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a] # | |
| Enum (Proxy s) | |
| Enum a => Enum (Const a b) | |
Defined in GHC.Internal.Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> Const a b # fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] # | |
| Enum (f a) => Enum (Ap f a) | |
Defined in GHC.Internal.Data.Monoid | |
| Enum (f a) => Enum (Alt f a) | |
Defined in GHC.Internal.Data.Semigroup.Internal Methods enumFrom :: Alt f a -> [Alt f a] # enumFromThen :: Alt f a -> Alt f a -> [Alt f a] # enumFromTo :: Alt f a -> Alt f a -> [Alt f a] # enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [Alt f a] # | |
| Enum (f (g a)) => Enum (Compose f g a) | |
Defined in Data.Functor.Compose Methods succ :: Compose f g a -> Compose f g a # pred :: Compose f g a -> Compose f g a # toEnum :: Int -> Compose f g a # fromEnum :: Compose f g a -> Int # enumFrom :: Compose f g a -> [Compose f g a] # enumFromThen :: Compose f g a -> Compose f g a -> [Compose f g a] # enumFromTo :: Compose f g a -> Compose f g a -> [Compose f g a] # enumFromThenTo :: Compose f g a -> Compose f g a -> Compose f g a -> [Compose f g a] # | |
class Functor (f :: Type -> Type) where #
Minimal complete definition
Instances
Methods
fromInteger :: Integer -> a #
Instances
class Fractional a where #
Methods
fromRational :: Rational -> a #
Instances
| Fractional CDouble | |
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> CDouble # | |
| Fractional CFloat | |
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> CFloat # | |
| Fractional Rational | |
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> Rational # | |
| Fractional Double | |
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> Double # | |
| Fractional Float | |
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> Float # | |
class HasNegation a where #
Instances
class (forall a. Functor (p a)) => Bifunctor (p :: Type -> Type -> Type) where #
class Functor f => Applicative (f :: Type -> Type) where #
Instances
| Applicative Complex | |
| Applicative First | |
| Applicative Last | |
| Applicative Max | |
| Applicative Min | |
| Applicative Gen Source # | |
| Applicative Check Source # | |
| Applicative DList Source # | |
| Applicative Partial Source # | |
| Applicative NonEmpty | |
| Applicative STM | |
| Applicative Identity | |
| Applicative First | |
| Applicative Last | |
| Applicative Dual | |
| Applicative Product | |
| Applicative Sum | |
| Applicative ZipList | |
| Applicative Par1 | |
| Applicative P | |
| Applicative ReadP | |
| Applicative IO | |
| Applicative Maybe | |
| Applicative Solo | |
| Applicative [] | |
| Monad m => Applicative (WrappedMonad m) | |
Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c # (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a # | |
| Applicative m => Applicative (ResourceT m) Source # | |
Defined in Foundation.Conduit.Internal | |
| ParserSource input => Applicative (Parser input) Source # | |
Defined in Foundation.Parser | |
| Applicative (MonadRandomState gen) Source # | |
Defined in Foundation.Random.DRG Methods pure :: a -> MonadRandomState gen a # (<*>) :: MonadRandomState gen (a -> b) -> MonadRandomState gen a -> MonadRandomState gen b # liftA2 :: (a -> b -> c) -> MonadRandomState gen a -> MonadRandomState gen b -> MonadRandomState gen c # (*>) :: MonadRandomState gen a -> MonadRandomState gen b -> MonadRandomState gen b # (<*) :: MonadRandomState gen a -> MonadRandomState gen b -> MonadRandomState gen a # | |
| Arrow a => Applicative (ArrowMonad a) | |
Defined in GHC.Internal.Control.Arrow Methods pure :: a0 -> ArrowMonad a a0 # (<*>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c # (*>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 # | |
| Applicative (Either e) | |
| Applicative (Proxy :: Type -> Type) | |
| Applicative (U1 :: Type -> Type) | |
| Applicative (ST s) | |
| Monoid a => Applicative ((,) a) | |
| Arrow a => Applicative (WrappedArrow a b) | |
Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c # (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # | |
| Monad m => Applicative (Reader r m) | |
Defined in Basement.Compat.MonadTrans | |
| Monad m => Applicative (State s m) | |
Defined in Basement.Compat.MonadTrans | |
| Monad m => Applicative (ZipSink i m) Source # | |
Defined in Foundation.Conduit.Internal | |
| Monad m => Applicative (ExceptT e m) Source # | |
Defined in Foundation.Monad.Except | |
| Applicative m => Applicative (ReaderT r m) Source # | |
Defined in Foundation.Monad.Reader | |
| (Applicative m, Monad m) => Applicative (StateT s m) Source # | |
Defined in Foundation.Monad.State | |
| Applicative m => Applicative (Kleisli m a) | |
Defined in GHC.Internal.Control.Arrow | |
| Monoid m => Applicative (Const m :: Type -> Type) | |
| Applicative f => Applicative (Ap f) | |
| Applicative f => Applicative (Alt f) | |
| (Generic1 f, Applicative (Rep1 f)) => Applicative (Generically1 f) | |
Defined in GHC.Internal.Generics Methods pure :: a -> Generically1 f a # (<*>) :: Generically1 f (a -> b) -> Generically1 f a -> Generically1 f b # liftA2 :: (a -> b -> c) -> Generically1 f a -> Generically1 f b -> Generically1 f c # (*>) :: Generically1 f a -> Generically1 f b -> Generically1 f b # (<*) :: Generically1 f a -> Generically1 f b -> Generically1 f a # | |
| Applicative f => Applicative (Rec1 f) | |
| (Monoid a, Monoid b) => Applicative ((,,) a b) | |
| (Applicative f, Applicative g) => Applicative (Product f g) | |
Defined in Data.Functor.Product | |
| Applicative (Conduit i o m) Source # | |
Defined in Foundation.Conduit.Internal Methods pure :: a -> Conduit i o m a # (<*>) :: Conduit i o m (a -> b) -> Conduit i o m a -> Conduit i o m b # liftA2 :: (a -> b -> c) -> Conduit i o m a -> Conduit i o m b -> Conduit i o m c # (*>) :: Conduit i o m a -> Conduit i o m b -> Conduit i o m b # (<*) :: Conduit i o m a -> Conduit i o m b -> Conduit i o m a # | |
| (Applicative f, Applicative g) => Applicative (f :*: g) | |
| Monoid c => Applicative (K1 i c :: Type -> Type) | |
| (Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) | |
Defined in GHC.Internal.Base | |
| Applicative ((->) r) | |
| (Applicative f, Applicative g) => Applicative (Compose f g) | |
Defined in Data.Functor.Compose | |
| (Applicative f, Applicative g) => Applicative (f :.: g) | |
| Applicative f => Applicative (M1 i c f) | |
| Monad state => Applicative (Builder collection mutCollection step state err) | |
Defined in Basement.MutableBuilder Methods pure :: a -> Builder collection mutCollection step state err a # (<*>) :: Builder collection mutCollection step state err (a -> b) -> Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b # liftA2 :: (a -> b -> c) -> Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err c # (*>) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err b # (<*) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err a # | |
class Applicative m => Monad (m :: Type -> Type) where #
Minimal complete definition
Instances
| Monad Complex | |
| Monad First | |
| Monad Last | |
| Monad Max | |
| Monad Min | |
| Monad Gen Source # | |
| Monad Check Source # | |
| Monad DList Source # | |
| Monad Partial Source # | |
| Monad NonEmpty | |
| Monad STM | |
| Monad Identity | |
| Monad First | |
| Monad Last | |
| Monad Dual | |
| Monad Product | |
| Monad Sum | |
| Monad Par1 | |
| Monad P | |
| Monad ReadP | |
| Monad IO | |
| Monad Maybe | |
| Monad Solo | |
| Monad [] | |
| Monad m => Monad (WrappedMonad m) | |
| Monad m => Monad (ResourceT m) Source # | |
| ParserSource input => Monad (Parser input) Source # | |
| Monad (MonadRandomState gen) Source # | |
Defined in Foundation.Random.DRG Methods (>>=) :: MonadRandomState gen a -> (a -> MonadRandomState gen b) -> MonadRandomState gen b # (>>) :: MonadRandomState gen a -> MonadRandomState gen b -> MonadRandomState gen b # return :: a -> MonadRandomState gen a # | |
| ArrowApply a => Monad (ArrowMonad a) | |
| Monad (Either e) | |
| Monad (Proxy :: Type -> Type) | |
| Monad (U1 :: Type -> Type) | |
| Monad (ST s) | |
| Monoid a => Monad ((,) a) | |
| Monad m => Monad (Reader r m) | |
| Monad m => Monad (State r m) | |
| Monad m => Monad (ExceptT e m) Source # | |
| Monad m => Monad (ReaderT r m) Source # | |
| (Functor m, Monad m) => Monad (StateT s m) Source # | |
| Monad m => Monad (Kleisli m a) | |
| Monad f => Monad (Ap f) | |
| Monad f => Monad (Alt f) | |
| Monad f => Monad (Rec1 f) | |
| (Monoid a, Monoid b) => Monad ((,,) a b) | |
| (Monad f, Monad g) => Monad (Product f g) | |
| Monad (Conduit i o m) Source # | |
| (Monad f, Monad g) => Monad (f :*: g) | |
| (Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | |
| Monad ((->) r) | |
| Monad f => Monad (M1 i c f) | |
| Monad state => Monad (Builder collection mutCollection step state err) | |
Defined in Basement.MutableBuilder Methods (>>=) :: Builder collection mutCollection step state err a -> (a -> Builder collection mutCollection step state err b) -> Builder collection mutCollection step state err b # (>>) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err b # return :: a -> Builder collection mutCollection step state err a # | |
Methods
fromString :: String -> a #
Instances
| IsString AsciiString | |
Defined in Basement.Types.AsciiString Methods fromString :: String -> AsciiString # | |
| IsString String | |
Defined in Basement.UTF8.Base Methods fromString :: String -> String # | |
| IsString IPv4 Source # | |
Defined in Foundation.Network.IPv4 Methods fromString :: String -> IPv4 # | |
| IsString IPv6 Source # | |
Defined in Foundation.Network.IPv6 Methods fromString :: String -> IPv6 # | |
| IsString FileName Source # | |
Defined in Foundation.VFS.FilePath Methods fromString :: String -> FileName # | |
| IsString FilePath Source # | |
Defined in Foundation.VFS.FilePath Methods fromString :: String -> FilePath # | |
| IsString a => IsString (Identity a) | |
Defined in GHC.Internal.Data.String Methods fromString :: String -> Identity a # | |
| a ~ Char => IsString [a] | |
Defined in GHC.Internal.Data.String Methods fromString :: String -> [a] # | |
| IsString a => IsString (Const a b) | |
Defined in GHC.Internal.Data.String Methods fromString :: String -> Const a b # | |
Instances
| IsList ByteArray | |||||
| IsList AsciiString | |||||
Defined in Basement.Types.AsciiString Associated Types
Methods fromList :: [Item AsciiString] -> AsciiString # fromListN :: Int -> [Item AsciiString] -> AsciiString # toList :: AsciiString -> [Item AsciiString] # | |||||
| IsList String | |||||
| IsList Bitmap Source # | |||||
| IsList CSV Source # | |||||
| IsList Row Source # | |||||
| IsList Version | |||||
| IsList CallStack | |||||
| PrimType ty => IsList (Block ty) | |||||
| IsList (Array ty) | |||||
| IsList c => IsList (NonEmpty c) | |||||
| PrimType ty => IsList (UArray ty) | |||||
| PrimType ty => IsList (ChunkedUArray ty) Source # | |||||
Defined in Foundation.Array.Chunked.Unboxed Associated Types
Methods fromList :: [Item (ChunkedUArray ty)] -> ChunkedUArray ty # fromListN :: Int -> [Item (ChunkedUArray ty)] -> ChunkedUArray ty # toList :: ChunkedUArray ty -> [Item (ChunkedUArray ty)] # | |||||
| IsList (DList a) Source # | |||||
| IsList (NonEmpty a) | |||||
| IsList (ZipList a) | |||||
| IsList [a] | |||||
Numeric type classes
class (Integral a, Eq a, Ord a) => IsIntegral a where #
Instances
class IsIntegral a => IsNatural a where #
Instances
types that have sign and can be made absolute
Instances
class Subtractive a where #
Associated Types
type Difference a #
Methods
(-) :: a -> a -> Difference a #
Instances
class Multiplicative a where #
Methods
(^) :: (IsNatural n, Enum n, IDivisible n) => a -> n -> a #
Instances
| Multiplicative Word128 | |
| Multiplicative Word256 | |
| Multiplicative CChar | |
| Multiplicative CClock | |
| Multiplicative CDouble | |
| Multiplicative CFloat | |
| Multiplicative CInt | |
| Multiplicative CIntMax | |
| Multiplicative CIntPtr | |
| Multiplicative CLLong | |
| Multiplicative CLong | |
| Multiplicative CPtrdiff | |
| Multiplicative CSChar | |
| Multiplicative CSUSeconds | |
Defined in Basement.Numerical.Multiplicative Methods midentity :: CSUSeconds # (*) :: CSUSeconds -> CSUSeconds -> CSUSeconds # (^) :: (IsNatural n, Enum n, IDivisible n) => CSUSeconds -> n -> CSUSeconds # | |
| Multiplicative CShort | |
| Multiplicative CSigAtomic | |
Defined in Basement.Numerical.Multiplicative Methods midentity :: CSigAtomic # (*) :: CSigAtomic -> CSigAtomic -> CSigAtomic # (^) :: (IsNatural n, Enum n, IDivisible n) => CSigAtomic -> n -> CSigAtomic # | |
| Multiplicative CSize | |
| Multiplicative CTime | |
| Multiplicative CUChar | |
| Multiplicative CUInt | |
| Multiplicative CUIntMax | |
| Multiplicative CUIntPtr | |
| Multiplicative CULLong | |
| Multiplicative CULong | |
| Multiplicative CUSeconds | |
| Multiplicative CUShort | |
| Multiplicative CWchar | |
| Multiplicative Int16 | |
| Multiplicative Int32 | |
| Multiplicative Int64 | |
| Multiplicative Int8 | |
| Multiplicative Rational | |
| Multiplicative COff | |
| Multiplicative Word16 | |
| Multiplicative Word32 | |
| Multiplicative Word64 | |
| Multiplicative Word8 | |
| Multiplicative Integer | |
| Multiplicative Natural | |
| Multiplicative Double | |
| Multiplicative Float | |
| Multiplicative Int | |
| Multiplicative Word | |
| SizeValid n => Multiplicative (Bits n) | |
Defined in Basement.Bits | |
class (Additive a, Multiplicative a) => IDivisible a where #
Instances
| IDivisible Word128 | |
| IDivisible Word256 | |
| IDivisible CChar | |
| IDivisible CInt | |
| IDivisible CIntMax | |
| IDivisible CIntPtr | |
| IDivisible CLLong | |
| IDivisible CLong | |
| IDivisible CPtrdiff | |
| IDivisible CSChar | |
| IDivisible CShort | |
| IDivisible CSigAtomic | |
Defined in Basement.Numerical.Multiplicative Methods div :: CSigAtomic -> CSigAtomic -> CSigAtomic # mod :: CSigAtomic -> CSigAtomic -> CSigAtomic # divMod :: CSigAtomic -> CSigAtomic -> (CSigAtomic, CSigAtomic) # | |
| IDivisible CSize | |
| IDivisible CUChar | |
| IDivisible CUInt | |
| IDivisible CUIntMax | |
| IDivisible CUIntPtr | |
| IDivisible CULLong | |
| IDivisible CULong | |
| IDivisible CUShort | |
| IDivisible CWchar | |
| IDivisible Int16 | |
| IDivisible Int32 | |
| IDivisible Int64 | |
| IDivisible Int8 | |
| IDivisible Word16 | |
| IDivisible Word32 | |
| IDivisible Word64 | |
| IDivisible Word8 | |
| IDivisible Integer | |
| IDivisible Natural | |
| IDivisible Int | |
| IDivisible Word | |
| SizeValid n => IDivisible (Bits n) | |
class Multiplicative a => Divisible a where #
Data types
Instances
| MonadZip Maybe | |||||
| Eq1 Maybe | |||||
| Ord1 Maybe | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering | |||||
| Read1 Maybe | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Maybe a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Maybe a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Maybe a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Maybe a] | |||||
| Show1 Maybe | |||||
Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Maybe a -> ShowS liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Maybe a] -> ShowS | |||||
| MonadFailure Maybe | |||||
| 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 Methods fold :: Monoid m => Maybe m -> m foldMap :: Monoid m => (a -> m) -> Maybe a -> m foldMap' :: Monoid m => (a -> m) -> Maybe a -> m foldr :: (a -> b -> b) -> b -> Maybe a -> b foldr' :: (a -> b -> b) -> b -> Maybe a -> b foldl :: (b -> a -> b) -> b -> Maybe a -> b foldl' :: (b -> a -> b) -> b -> Maybe a -> b foldr1 :: (a -> a -> a) -> Maybe a -> a foldl1 :: (a -> a -> a) -> Maybe a -> a elem :: Eq a => a -> Maybe a -> Bool maximum :: Ord a => Maybe a -> a | |||||
| Traversable Maybe | |||||
| Generic1 Maybe | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| NormalForm a => NormalForm (Maybe a) | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Maybe a -> () # | |||||
| Arbitrary a => Arbitrary (Maybe a) Source # | |||||
| IsField a => IsField (Maybe a) Source # | |||||
| Semigroup a => Monoid (Maybe a) | |||||
| Semigroup a => Semigroup (Maybe a) | |||||
| Data a => Data (Maybe a) | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) dataTypeOf :: Maybe a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) | |||||
| Generic (Maybe a) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| SingKind a => SingKind (Maybe a) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Read a => Read (Maybe a) | |||||
Defined in GHC.Internal.Read | |||||
| Show a => Show (Maybe a) | |||||
| Eq a => Eq (Maybe a) | |||||
| Ord a => Ord (Maybe a) | |||||
| SingI ('Nothing :: Maybe a) | |||||
Defined in GHC.Internal.Generics | |||||
| From (Maybe a) (Either () a) | |||||
Defined in Basement.From | |||||
| SingI a2 => SingI ('Just a2 :: Maybe a1) | |||||
Defined in GHC.Internal.Generics | |||||
| type Failure Maybe | |||||
Defined in Basement.Monad | |||||
| type Rep1 Maybe | |||||
Defined in GHC.Internal.Generics | |||||
| type DemoteRep (Maybe a) | |||||
Defined in GHC.Internal.Generics | |||||
| type Rep (Maybe a) | |||||
Defined in GHC.Internal.Generics | |||||
| data Sing (b :: Maybe a) | |||||
Instances
| Monoid Ordering | |||||
| Semigroup Ordering | |||||
| Data Ordering | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering toConstr :: Ordering -> Constr dataTypeOf :: Ordering -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering | |||||
| Bounded Ordering | |||||
| Enum Ordering | |||||
Defined in GHC.Internal.Enum | |||||
| Generic Ordering | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Read Ordering | |||||
Defined in GHC.Internal.Read | |||||
| Show Ordering | |||||
| Eq Ordering | |||||
| Ord Ordering | |||||
Defined in GHC.Classes | |||||
| type Rep Ordering | |||||
Instances
| BitOps Bool | |||||
| FiniteBitsOps Bool | |||||
| NormalForm Bool | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Bool -> () # | |||||
| Arbitrary Bool Source # | |||||
| IsProperty Bool Source # | |||||
| IsField Bool Source # | |||||
| Bits Bool | |||||
Defined in GHC.Internal.Bits Methods (.&.) :: Bool -> Bool -> Bool # (.|.) :: Bool -> Bool -> Bool # complement :: Bool -> Bool # shift :: Bool -> Int -> Bool # rotate :: Bool -> Int -> Bool # setBit :: Bool -> Int -> Bool # clearBit :: Bool -> Int -> Bool # complementBit :: Bool -> Int -> Bool # testBit :: Bool -> Int -> Bool # bitSizeMaybe :: Bool -> Maybe Int # shiftL :: Bool -> Int -> Bool # unsafeShiftL :: Bool -> Int -> Bool # shiftR :: Bool -> Int -> Bool # unsafeShiftR :: Bool -> Int -> Bool # rotateL :: Bool -> Int -> Bool # | |||||
| FiniteBits Bool | |||||
Defined in GHC.Internal.Bits Methods finiteBitSize :: Bool -> Int countLeadingZeros :: Bool -> Int countTrailingZeros :: Bool -> Int | |||||
| Data Bool | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool dataTypeOf :: Bool -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bool) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bool) gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool | |||||
| Bounded Bool | |||||
| Enum Bool | |||||
| Storable Bool | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
| Generic Bool | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| SingKind Bool | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Read Bool | |||||
Defined in GHC.Internal.Read | |||||
| Show Bool | |||||
| Eq Bool | |||||
| Ord Bool | |||||
| SingI 'False | |||||
Defined in GHC.Internal.Generics | |||||
| SingI 'True | |||||
Defined in GHC.Internal.Generics | |||||
| IsProperty (String, Bool) Source # | |||||
| type DemoteRep Bool | |||||
Defined in GHC.Internal.Generics | |||||
| type Rep Bool | |||||
Defined in GHC.Internal.Generics | |||||
| data Sing (a :: Bool) | |||||
Instances
| IsChar Char | |||||
| PrintfArg Char | |||||
Defined in Text.Printf | |||||
| NormalForm Char | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Char -> () # | |||||
| Subtractive Char | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| PrimMemoryComparable Char | |||||
Defined in Basement.PrimType | |||||
| PrimType Char | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Char -> CountOf Word8 # primShiftToBytes :: Proxy Char -> Int # primBaUIndex :: ByteArray# -> Offset Char -> Char # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> prim Char # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> Char -> prim () # primAddrIndex :: Addr# -> Offset Char -> Char # primAddrRead :: PrimMonad prim => Addr# -> Offset Char -> prim Char # primAddrWrite :: PrimMonad prim => Addr# -> Offset Char -> Char -> prim () # | |||||
| Arbitrary Char Source # | |||||
| Storable Char Source # | |||||
| StorableFixed Char Source # | |||||
| IsField Char Source # | |||||
| Data Char | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char dataTypeOf :: Char -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) gmapT :: (forall b. Data b => b -> b) -> Char -> Char gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char | |||||
| Bounded Char | |||||
| Enum Char | |||||
| Storable Char | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
| Read Char | |||||
Defined in GHC.Internal.Read | |||||
| Show Char | |||||
| Eq Char | |||||
| Ord Char | |||||
| Generic1 (URec Char :: k -> Type) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| IsField [Char] Source # | |||||
| Foldable (UChar :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => UChar m -> m foldMap :: Monoid m => (a -> m) -> UChar a -> m foldMap' :: Monoid m => (a -> m) -> UChar a -> m foldr :: (a -> b -> b) -> b -> UChar a -> b foldr' :: (a -> b -> b) -> b -> UChar a -> b foldl :: (b -> a -> b) -> b -> UChar a -> b foldl' :: (b -> a -> b) -> b -> UChar a -> b foldr1 :: (a -> a -> a) -> UChar a -> a foldl1 :: (a -> a -> a) -> UChar a -> a toList :: UChar a -> [a] elem :: Eq a => a -> UChar a -> Bool maximum :: Ord a => UChar a -> a minimum :: Ord a => UChar a -> a sum :: Num a => UChar a -> a product :: Num a => UChar a -> a | |||||
| Traversable (UChar :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UChar a -> f (UChar b) sequenceA :: Applicative f => UChar (f a) -> f (UChar a) | |||||
| Functor (URec Char :: Type -> Type) | |||||
| Generic (URec Char p) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Show (URec Char p) | |||||
| Eq (URec Char p) | |||||
| Ord (URec Char p) | |||||
Defined in GHC.Internal.Generics | |||||
| type NatNumMaxBound Char | |||||
Defined in Basement.Nat type NatNumMaxBound Char = 1114111 | |||||
| type Difference Char | |||||
Defined in Basement.Numerical.Subtractive | |||||
| type PrimSize Char | |||||
Defined in Basement.PrimType | |||||
| data URec Char (p :: k) | |||||
Defined in GHC.Internal.Generics | |||||
| type Compare (a :: Char) (b :: Char) | |||||
Defined in GHC.Internal.Data.Type.Ord | |||||
| type Rep1 (URec Char :: k -> Type) | |||||
Defined in GHC.Internal.Generics | |||||
| type Rep (URec Char p) | |||||
Defined in GHC.Internal.Generics | |||||
Instances
| NormalForm Char7 | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Char7 -> () # | |||||
| PrimType Char7 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Char7 -> CountOf Word8 # primShiftToBytes :: Proxy Char7 -> Int # primBaUIndex :: ByteArray# -> Offset Char7 -> Char7 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char7 -> prim Char7 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char7 -> Char7 -> prim () # primAddrIndex :: Addr# -> Offset Char7 -> Char7 # primAddrRead :: PrimMonad prim => Addr# -> Offset Char7 -> prim Char7 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Char7 -> Char7 -> prim () # | |||||
| Arbitrary Char7 Source # | |||||
| Show Char7 | |||||
| Eq Char7 | |||||
| Ord Char7 | |||||
| type NatNumMaxBound Char7 | |||||
Defined in Basement.Nat type NatNumMaxBound Char7 = 127 | |||||
| type PrimSize Char7 | |||||
Defined in Basement.PrimType | |||||
Instances
| MonadIO IO | |||||||||
Defined in Control.Monad.IO.Class | |||||||||
| PrimMonad IO | |||||||||
Defined in Basement.Monad Associated Types
Methods primitive :: (State# (PrimState IO) -> (# State# (PrimState IO), a #)) -> IO a # primThrow :: Exception e => e -> IO a # unPrimMonad :: IO a -> State# (PrimState IO) -> (# State# (PrimState IO), a #) # primVarNew :: a -> IO (PrimVar IO a) # primVarRead :: PrimVar IO a -> IO a # primVarWrite :: PrimVar IO a -> a -> IO () # | |||||||||
| MonadBracket IO Source # | |||||||||
Defined in Foundation.Monad.Exception Methods generalBracket :: IO a -> (a -> b -> IO ignored1) -> (a -> SomeException -> IO ignored2) -> (a -> IO b) -> IO b Source # | |||||||||
| MonadCatch IO Source # | |||||||||
| MonadThrow IO Source # | |||||||||
| MonadRandom IO Source # | |||||||||
Defined in Foundation.Random.Class | |||||||||
| Alternative IO | |||||||||
| Applicative IO | |||||||||
| Functor IO | |||||||||
| Monad IO | |||||||||
| MonadPlus IO | |||||||||
| MonadFail IO | |||||||||
Defined in GHC.Internal.Control.Monad.Fail | |||||||||
| MonadFix IO | |||||||||
Defined in GHC.Internal.Control.Monad.Fix | |||||||||
| a ~ () => HPrintfType (IO a) | |||||||||
Defined in Text.Printf | |||||||||
| a ~ () => PrintfType (IO a) | |||||||||
Defined in Text.Printf | |||||||||
| Monoid a => Monoid (IO a) | |||||||||
| Semigroup a => Semigroup (IO a) | |||||||||
| type PrimState IO | |||||||||
Defined in Basement.Monad | |||||||||
| type PrimVar IO | |||||||||
Defined in Basement.Monad | |||||||||
Instances
| Bifoldable Either | |||||
| Bifoldable1 Either | |||||
Defined in Data.Bifoldable1 | |||||
| Bifunctor Either | |||||
| Bitraversable Either | |||||
Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d) | |||||
| Eq2 Either | |||||
| Ord2 Either | |||||
Defined in Data.Functor.Classes | |||||
| Read2 Either | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Either a b) liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Either a b] liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Either a b) liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Either a b] | |||||
| Show2 Either | |||||
Defined in Data.Functor.Classes Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Either a b -> ShowS liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Either a b] -> ShowS | |||||
| Generic1 (Either a :: Type -> Type) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Eq a => Eq1 (Either a) | |||||
| Ord a => Ord1 (Either a) | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b -> Ordering) -> Either a a0 -> Either a b -> Ordering | |||||
| Read a => Read1 (Either a) | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Either a a0) liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Either a a0] liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Either a a0) liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Either a a0] | |||||
| Show a => Show1 (Either a) | |||||
Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Either a a0 -> ShowS liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Either a a0] -> ShowS | |||||
| MonadFailure (Either a) | |||||
| 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 Methods fold :: Monoid m => Either a m -> m foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 elem :: Eq a0 => a0 -> Either a a0 -> Bool maximum :: Ord a0 => Either a a0 -> a0 minimum :: Ord a0 => Either a a0 -> a0 | |||||
| Traversable (Either a) | |||||
Defined in GHC.Internal.Data.Traversable | |||||
| From (Maybe a) (Either () a) | |||||
Defined in Basement.From | |||||
| (NormalForm l, NormalForm r) => NormalForm (Either l r) | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Either l r -> () # | |||||
| (Arbitrary l, Arbitrary r) => Arbitrary (Either l r) Source # | |||||
| Semigroup (Either a b) | |||||
| (Data a, Data b) => Data (Either a b) | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Either a b -> c (Either a b) gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b) toConstr :: Either a b -> Constr dataTypeOf :: Either a b -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Either a b)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Either a b)) gmapT :: (forall b0. Data b0 => b0 -> b0) -> Either a b -> Either a b gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) | |||||
| Generic (Either a b) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| (Read a, Read b) => Read (Either a b) | |||||
Defined in GHC.Internal.Data.Either | |||||
| (Show a, Show b) => Show (Either a b) | |||||
| (Eq a, Eq b) => Eq (Either a b) | |||||
| (Ord a, Ord b) => Ord (Either a b) | |||||
Defined in GHC.Internal.Data.Either | |||||
| From (Either a b) (These a b) | |||||
Defined in Basement.From | |||||
| type Rep1 (Either a :: Type -> Type) | |||||
Defined in GHC.Internal.Generics type Rep1 (Either a :: Type -> Type) = D1 ('MetaData "Either" "GHC.Internal.Data.Either" "ghc-internal" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1)) | |||||
| type Failure (Either a) | |||||
Defined in Basement.Monad | |||||
| type Rep (Either a b) | |||||
Defined in GHC.Internal.Generics type Rep (Either a b) = D1 ('MetaData "Either" "GHC.Internal.Data.Either" "ghc-internal" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 b))) | |||||
Numbers
Instances
| PrintfArg Int8 | |||||
Defined in Text.Printf | |||||
| BitOps Int8 | |||||
| FiniteBitsOps Int8 | |||||
| HasNegation Int8 | |||||
Defined in Basement.Compat.NumLiteral | |||||
| Integral Int8 | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Int8 # | |||||
| NormalForm Int8 | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Int8 -> () # | |||||
| Additive Int8 | |||||
| IDivisible Int8 | |||||
| Multiplicative Int8 | |||||
| IsIntegral Int8 | |||||
Defined in Basement.Numerical.Number | |||||
| Subtractive Int8 | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| PrimMemoryComparable Int8 | |||||
Defined in Basement.PrimType | |||||
| PrimType Int8 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Int8 -> CountOf Word8 # primShiftToBytes :: Proxy Int8 -> Int # primBaUIndex :: ByteArray# -> Offset Int8 -> Int8 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int8 -> prim Int8 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int8 -> Int8 -> prim () # primAddrIndex :: Addr# -> Offset Int8 -> Int8 # primAddrRead :: PrimMonad prim => Addr# -> Offset Int8 -> prim Int8 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int8 -> Int8 -> prim () # | |||||
| Arbitrary Int8 Source # | |||||
| Storable Int8 Source # | |||||
| StorableFixed Int8 Source # | |||||
| IsField Int8 Source # | |||||
| Hashable Int8 Source # | |||||
| Signed Int8 Source # | |||||
| Bits Int8 | |||||
Defined in GHC.Internal.Int Methods (.&.) :: Int8 -> Int8 -> Int8 # (.|.) :: Int8 -> Int8 -> Int8 # complement :: Int8 -> Int8 # shift :: Int8 -> Int -> Int8 # rotate :: Int8 -> Int -> Int8 # setBit :: Int8 -> Int -> Int8 # clearBit :: Int8 -> Int -> Int8 # complementBit :: Int8 -> Int -> Int8 # testBit :: Int8 -> Int -> Bool # bitSizeMaybe :: Int8 -> Maybe Int # shiftL :: Int8 -> Int -> Int8 # unsafeShiftL :: Int8 -> Int -> Int8 # shiftR :: Int8 -> Int -> Int8 # unsafeShiftR :: Int8 -> Int -> Int8 # rotateL :: Int8 -> Int -> Int8 # | |||||
| FiniteBits Int8 | |||||
Defined in GHC.Internal.Int Methods finiteBitSize :: Int8 -> Int countLeadingZeros :: Int8 -> Int countTrailingZeros :: Int8 -> Int | |||||
| Data Int8 | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int8 -> c Int8 gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int8 dataTypeOf :: Int8 -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int8) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int8) gmapT :: (forall b. Data b => b -> b) -> Int8 -> Int8 gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r gmapQ :: (forall d. Data d => d -> u) -> Int8 -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Int8 -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 | |||||
| Bounded Int8 | |||||
| Enum Int8 | |||||
| Storable Int8 | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
| Ix Int8 | |||||
| Num Int8 | |||||
| Read Int8 | |||||
Defined in GHC.Internal.Int | |||||
| Integral Int8 | |||||
| Real Int8 | |||||
Defined in GHC.Internal.Int Methods toRational :: Int8 -> Rational | |||||
| Show Int8 | |||||
| Eq Int8 | |||||
| Ord Int8 | |||||
| Cast Int8 Word8 | |||||
Defined in Basement.Cast | |||||
| Cast Word8 Int8 | |||||
Defined in Basement.Cast | |||||
| From Int8 Int16 | |||||
Defined in Basement.From | |||||
| From Int8 Int32 | |||||
Defined in Basement.From | |||||
| From Int8 Int64 | |||||
Defined in Basement.From | |||||
| From Int8 Int | |||||
Defined in Basement.From | |||||
| IntegralDownsize Int64 Int8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Integer Int8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Int Int8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralUpsize Int8 Int16 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int8 -> Int16 # | |||||
| IntegralUpsize Int8 Int32 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int8 -> Int32 # | |||||
| IntegralUpsize Int8 Int64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int8 -> Int64 # | |||||
| IntegralUpsize Int8 Int | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int8 -> Int # | |||||
| type NatNumMaxBound Int8 | |||||
Defined in Basement.Nat type NatNumMaxBound Int8 = 127 | |||||
| type Difference Int8 | |||||
Defined in Basement.Numerical.Subtractive | |||||
| type PrimSize Int8 | |||||
Defined in Basement.PrimType | |||||
Instances
| PrintfArg Int16 | |||||
Defined in Text.Printf | |||||
| BitOps Int16 | |||||
| FiniteBitsOps Int16 | |||||
| HasNegation Int16 | |||||
Defined in Basement.Compat.NumLiteral | |||||
| Integral Int16 | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Int16 # | |||||
| NormalForm Int16 | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Int16 -> () # | |||||
| Additive Int16 | |||||
| IDivisible Int16 | |||||
| Multiplicative Int16 | |||||
| IsIntegral Int16 | |||||
Defined in Basement.Numerical.Number | |||||
| Subtractive Int16 | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| PrimMemoryComparable Int16 | |||||
Defined in Basement.PrimType | |||||
| PrimType Int16 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Int16 -> CountOf Word8 # primShiftToBytes :: Proxy Int16 -> Int # primBaUIndex :: ByteArray# -> Offset Int16 -> Int16 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int16 -> prim Int16 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int16 -> Int16 -> prim () # primAddrIndex :: Addr# -> Offset Int16 -> Int16 # primAddrRead :: PrimMonad prim => Addr# -> Offset Int16 -> prim Int16 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int16 -> Int16 -> prim () # | |||||
| Arbitrary Int16 Source # | |||||
| Storable Int16 Source # | |||||
| StorableFixed Int16 Source # | |||||
| IsField Int16 Source # | |||||
| Hashable Int16 Source # | |||||
| Signed Int16 Source # | |||||
| Bits Int16 | |||||
Defined in GHC.Internal.Int Methods (.&.) :: Int16 -> Int16 -> Int16 # (.|.) :: Int16 -> Int16 -> Int16 # xor :: Int16 -> Int16 -> Int16 # complement :: Int16 -> Int16 # shift :: Int16 -> Int -> Int16 # rotate :: Int16 -> Int -> Int16 # setBit :: Int16 -> Int -> Int16 # clearBit :: Int16 -> Int -> Int16 # complementBit :: Int16 -> Int -> Int16 # testBit :: Int16 -> Int -> Bool # bitSizeMaybe :: Int16 -> Maybe Int # shiftL :: Int16 -> Int -> Int16 # unsafeShiftL :: Int16 -> Int -> Int16 # shiftR :: Int16 -> Int -> Int16 # unsafeShiftR :: Int16 -> Int -> Int16 # rotateL :: Int16 -> Int -> Int16 # | |||||
| FiniteBits Int16 | |||||
Defined in GHC.Internal.Int Methods finiteBitSize :: Int16 -> Int countLeadingZeros :: Int16 -> Int countTrailingZeros :: Int16 -> Int | |||||
| Data Int16 | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int16 -> c Int16 gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int16 dataTypeOf :: Int16 -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int16) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int16) gmapT :: (forall b. Data b => b -> b) -> Int16 -> Int16 gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r gmapQ :: (forall d. Data d => d -> u) -> Int16 -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Int16 -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 | |||||
| Bounded Int16 | |||||
| Enum Int16 | |||||
Defined in GHC.Internal.Int | |||||
| Storable Int16 | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
| Ix Int16 | |||||
| Num Int16 | |||||
| Read Int16 | |||||
Defined in GHC.Internal.Int | |||||
| Integral Int16 | |||||
| Real Int16 | |||||
Defined in GHC.Internal.Int Methods toRational :: Int16 -> Rational | |||||
| Show Int16 | |||||
| Eq Int16 | |||||
| Ord Int16 | |||||
| Cast Int16 Word16 | |||||
Defined in Basement.Cast | |||||
| Cast Word16 Int16 | |||||
Defined in Basement.Cast | |||||
| From Int16 Int32 | |||||
Defined in Basement.From | |||||
| From Int16 Int64 | |||||
Defined in Basement.From | |||||
| From Int16 Int | |||||
Defined in Basement.From | |||||
| From Int8 Int16 | |||||
Defined in Basement.From | |||||
| From Word8 Int16 | |||||
Defined in Basement.From | |||||
| IntegralDownsize Int64 Int16 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Integer Int16 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Int Int16 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralUpsize Int16 Int32 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int16 -> Int32 # | |||||
| IntegralUpsize Int16 Int64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int16 -> Int64 # | |||||
| IntegralUpsize Int16 Int | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int16 -> Int # | |||||
| IntegralUpsize Int8 Int16 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int8 -> Int16 # | |||||
| IntegralUpsize Word8 Int16 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Int16 # | |||||
| type NatNumMaxBound Int16 | |||||
Defined in Basement.Nat type NatNumMaxBound Int16 = 32767 | |||||
| type Difference Int16 | |||||
Defined in Basement.Numerical.Subtractive | |||||
| type PrimSize Int16 | |||||
Defined in Basement.PrimType | |||||
Instances
| PrintfArg Int32 | |||||
Defined in Text.Printf | |||||
| BitOps Int32 | |||||
| FiniteBitsOps Int32 | |||||
| HasNegation Int32 | |||||
Defined in Basement.Compat.NumLiteral | |||||
| Integral Int32 | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Int32 # | |||||
| NormalForm Int32 | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Int32 -> () # | |||||
| Additive Int32 | |||||
| IDivisible Int32 | |||||
| Multiplicative Int32 | |||||
| IsIntegral Int32 | |||||
Defined in Basement.Numerical.Number | |||||
| Subtractive Int32 | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| PrimMemoryComparable Int32 | |||||
Defined in Basement.PrimType | |||||
| PrimType Int32 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Int32 -> CountOf Word8 # primShiftToBytes :: Proxy Int32 -> Int # primBaUIndex :: ByteArray# -> Offset Int32 -> Int32 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int32 -> prim Int32 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int32 -> Int32 -> prim () # primAddrIndex :: Addr# -> Offset Int32 -> Int32 # primAddrRead :: PrimMonad prim => Addr# -> Offset Int32 -> prim Int32 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int32 -> Int32 -> prim () # | |||||
| Arbitrary Int32 Source # | |||||
| Storable Int32 Source # | |||||
| StorableFixed Int32 Source # | |||||
| IsField Int32 Source # | |||||
| Hashable Int32 Source # | |||||
| Signed Int32 Source # | |||||
| Bits Int32 | |||||
Defined in GHC.Internal.Int Methods (.&.) :: Int32 -> Int32 -> Int32 # (.|.) :: Int32 -> Int32 -> Int32 # xor :: Int32 -> Int32 -> Int32 # complement :: Int32 -> Int32 # shift :: Int32 -> Int -> Int32 # rotate :: Int32 -> Int -> Int32 # setBit :: Int32 -> Int -> Int32 # clearBit :: Int32 -> Int -> Int32 # complementBit :: Int32 -> Int -> Int32 # testBit :: Int32 -> Int -> Bool # bitSizeMaybe :: Int32 -> Maybe Int # shiftL :: Int32 -> Int -> Int32 # unsafeShiftL :: Int32 -> Int -> Int32 # shiftR :: Int32 -> Int -> Int32 # unsafeShiftR :: Int32 -> Int -> Int32 # rotateL :: Int32 -> Int -> Int32 # | |||||
| FiniteBits Int32 | |||||
Defined in GHC.Internal.Int Methods finiteBitSize :: Int32 -> Int countLeadingZeros :: Int32 -> Int countTrailingZeros :: Int32 -> Int | |||||
| Data Int32 | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int32 -> c Int32 gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int32 dataTypeOf :: Int32 -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int32) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int32) gmapT :: (forall b. Data b => b -> b) -> Int32 -> Int32 gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r gmapQ :: (forall d. Data d => d -> u) -> Int32 -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Int32 -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 | |||||
| Bounded Int32 | |||||
| Enum Int32 | |||||
Defined in GHC.Internal.Int | |||||
| Storable Int32 | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
| Ix Int32 | |||||
| Num Int32 | |||||
| Read Int32 | |||||
Defined in GHC.Internal.Int | |||||
| Integral Int32 | |||||
| Real Int32 | |||||
Defined in GHC.Internal.Int Methods toRational :: Int32 -> Rational | |||||
| Show Int32 | |||||
| Eq Int32 | |||||
| Ord Int32 | |||||
| Cast Int32 Word32 | |||||
Defined in Basement.Cast | |||||
| Cast Int32 Int | |||||
Defined in Basement.Cast | |||||
| Cast Int32 Word | |||||
Defined in Basement.Cast | |||||
| Cast Word32 Int32 | |||||
Defined in Basement.Cast | |||||
| Cast Int Int32 | |||||
Defined in Basement.Cast | |||||
| Cast Word Int32 | |||||
Defined in Basement.Cast | |||||
| From Int16 Int32 | |||||
Defined in Basement.From | |||||
| From Int32 Int64 | |||||
Defined in Basement.From | |||||
| From Int32 Int | |||||
Defined in Basement.From | |||||
| From Int8 Int32 | |||||
Defined in Basement.From | |||||
| From Word16 Int32 | |||||
Defined in Basement.From | |||||
| From Word8 Int32 | |||||
Defined in Basement.From | |||||
| IntegralDownsize Int64 Int32 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Integer Int32 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Int Int32 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralUpsize Int16 Int32 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int16 -> Int32 # | |||||
| IntegralUpsize Int32 Int64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int32 -> Int64 # | |||||
| IntegralUpsize Int32 Int | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int32 -> Int # | |||||
| IntegralUpsize Int8 Int32 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int8 -> Int32 # | |||||
| IntegralUpsize Word8 Int32 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Int32 # | |||||
| type NatNumMaxBound Int32 | |||||
Defined in Basement.Nat type NatNumMaxBound Int32 = 2147483647 | |||||
| type Difference Int32 | |||||
Defined in Basement.Numerical.Subtractive | |||||
| type PrimSize Int32 | |||||
Defined in Basement.PrimType | |||||
Instances
| PrintfArg Int64 | |||||
Defined in Text.Printf | |||||
| BitOps Int64 | |||||
| FiniteBitsOps Int64 | |||||
| HasNegation Int64 | |||||
Defined in Basement.Compat.NumLiteral | |||||
| Integral Int64 | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Int64 # | |||||
| NormalForm Int64 | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Int64 -> () # | |||||
| Additive Int64 | |||||
| IDivisible Int64 | |||||
| Multiplicative Int64 | |||||
| IsIntegral Int64 | |||||
Defined in Basement.Numerical.Number | |||||
| Subtractive Int64 | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| PrimMemoryComparable Int64 | |||||
Defined in Basement.PrimType | |||||
| PrimType Int64 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Int64 -> CountOf Word8 # primShiftToBytes :: Proxy Int64 -> Int # primBaUIndex :: ByteArray# -> Offset Int64 -> Int64 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int64 -> prim Int64 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int64 -> Int64 -> prim () # primAddrIndex :: Addr# -> Offset Int64 -> Int64 # primAddrRead :: PrimMonad prim => Addr# -> Offset Int64 -> prim Int64 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int64 -> Int64 -> prim () # | |||||
| Arbitrary Int64 Source # | |||||
| Storable Int64 Source # | |||||
| StorableFixed Int64 Source # | |||||
| IsField Int64 Source # | |||||
| Hashable Int64 Source # | |||||
| Signed Int64 Source # | |||||
| Bits Int64 | |||||
Defined in GHC.Internal.Int Methods (.&.) :: Int64 -> Int64 -> Int64 # (.|.) :: Int64 -> Int64 -> Int64 # xor :: Int64 -> Int64 -> Int64 # complement :: Int64 -> Int64 # shift :: Int64 -> Int -> Int64 # rotate :: Int64 -> Int -> Int64 # setBit :: Int64 -> Int -> Int64 # clearBit :: Int64 -> Int -> Int64 # complementBit :: Int64 -> Int -> Int64 # testBit :: Int64 -> Int -> Bool # bitSizeMaybe :: Int64 -> Maybe Int # shiftL :: Int64 -> Int -> Int64 # unsafeShiftL :: Int64 -> Int -> Int64 # shiftR :: Int64 -> Int -> Int64 # unsafeShiftR :: Int64 -> Int -> Int64 # rotateL :: Int64 -> Int -> Int64 # | |||||
| FiniteBits Int64 | |||||
Defined in GHC.Internal.Int Methods finiteBitSize :: Int64 -> Int countLeadingZeros :: Int64 -> Int countTrailingZeros :: Int64 -> Int | |||||
| Data Int64 | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int64 -> c Int64 gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int64 dataTypeOf :: Int64 -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int64) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int64) gmapT :: (forall b. Data b => b -> b) -> Int64 -> Int64 gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r gmapQ :: (forall d. Data d => d -> u) -> Int64 -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Int64 -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 | |||||
| Bounded Int64 | |||||
| Enum Int64 | |||||
Defined in GHC.Internal.Int | |||||
| Storable Int64 | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
| Ix Int64 | |||||
| Num Int64 | |||||
| Read Int64 | |||||
Defined in GHC.Internal.Int | |||||
| Integral Int64 | |||||
| Real Int64 | |||||
Defined in GHC.Internal.Int Methods toRational :: Int64 -> Rational | |||||
| Show Int64 | |||||
| Eq Int64 | |||||
| Ord Int64 | |||||
| Cast Int64 Word64 | |||||
Defined in Basement.Cast | |||||
| Cast Word64 Int64 | |||||
Defined in Basement.Cast | |||||
| From Int16 Int64 | |||||
Defined in Basement.From | |||||
| From Int32 Int64 | |||||
Defined in Basement.From | |||||
| From Int8 Int64 | |||||
Defined in Basement.From | |||||
| From Word16 Int64 | |||||
Defined in Basement.From | |||||
| From Word32 Int64 | |||||
Defined in Basement.From | |||||
| From Word8 Int64 | |||||
Defined in Basement.From | |||||
| From Int Int64 | |||||
Defined in Basement.From | |||||
| IntegralDownsize Int64 Int16 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Int64 Int32 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Int64 Int8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Int64 Int | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Integer Int64 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralUpsize Int16 Int64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int16 -> Int64 # | |||||
| IntegralUpsize Int32 Int64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int32 -> Int64 # | |||||
| IntegralUpsize Int8 Int64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int8 -> Int64 # | |||||
| IntegralUpsize Word8 Int64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Int64 # | |||||
| IntegralUpsize Int Int64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int -> Int64 # | |||||
| type NatNumMaxBound Int64 | |||||
Defined in Basement.Nat type NatNumMaxBound Int64 = 9223372036854775807 | |||||
| type Difference Int64 | |||||
Defined in Basement.Numerical.Subtractive | |||||
| type PrimSize Int64 | |||||
Defined in Basement.PrimType | |||||
Instances
| PrintfArg Word8 | |||||
Defined in Text.Printf | |||||
| BitOps Word8 | |||||
| FiniteBitsOps Word8 | |||||
| HasNegation Word8 | |||||
Defined in Basement.Compat.NumLiteral | |||||
| Integral Word8 | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Word8 # | |||||
| NormalForm Word8 | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Word8 -> () # | |||||
| Additive Word8 | |||||
| IDivisible Word8 | |||||
| Multiplicative Word8 | |||||
| IsIntegral Word8 | |||||
Defined in Basement.Numerical.Number | |||||
| IsNatural Word8 | |||||
Defined in Basement.Numerical.Number | |||||
| Subtractive Word8 | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| PrimMemoryComparable Word8 | |||||
Defined in Basement.PrimType | |||||
| PrimType Word8 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word8 -> CountOf Word8 # primShiftToBytes :: Proxy Word8 -> Int # primBaUIndex :: ByteArray# -> Offset Word8 -> Word8 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word8 -> prim Word8 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word8 -> Word8 -> prim () # primAddrIndex :: Addr# -> Offset Word8 -> Word8 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word8 -> prim Word8 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word8 -> Word8 -> prim () # | |||||
| Arbitrary Word8 Source # | |||||
| Storable Word8 Source # | |||||
| StorableFixed Word8 Source # | |||||
| IsField Word8 Source # | |||||
| Hashable Word8 Source # | |||||
| Bits Word8 | |||||
Defined in GHC.Internal.Word Methods (.&.) :: Word8 -> Word8 -> Word8 # (.|.) :: Word8 -> Word8 -> Word8 # xor :: Word8 -> Word8 -> Word8 # complement :: Word8 -> Word8 # shift :: Word8 -> Int -> Word8 # rotate :: Word8 -> Int -> Word8 # setBit :: Word8 -> Int -> Word8 # clearBit :: Word8 -> Int -> Word8 # complementBit :: Word8 -> Int -> Word8 # testBit :: Word8 -> Int -> Bool # bitSizeMaybe :: Word8 -> Maybe Int # shiftL :: Word8 -> Int -> Word8 # unsafeShiftL :: Word8 -> Int -> Word8 # shiftR :: Word8 -> Int -> Word8 # unsafeShiftR :: Word8 -> Int -> Word8 # rotateL :: Word8 -> Int -> Word8 # | |||||
| FiniteBits Word8 | |||||
Defined in GHC.Internal.Word Methods finiteBitSize :: Word8 -> Int countLeadingZeros :: Word8 -> Int countTrailingZeros :: Word8 -> Int | |||||
| Data Word8 | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word8 -> c Word8 gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word8 dataTypeOf :: Word8 -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word8) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word8) gmapT :: (forall b. Data b => b -> b) -> Word8 -> Word8 gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r gmapQ :: (forall d. Data d => d -> u) -> Word8 -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Word8 -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 | |||||
| Bounded Word8 | |||||
| Enum Word8 | |||||
Defined in GHC.Internal.Word | |||||
| Storable Word8 | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
| Ix Word8 | |||||
| Num Word8 | |||||
| Read Word8 | |||||
Defined in GHC.Internal.Read | |||||
| Integral Word8 | |||||
| Real Word8 | |||||
Defined in GHC.Internal.Word Methods toRational :: Word8 -> Rational | |||||
| Show Word8 | |||||
| Eq Word8 | |||||
| Ord Word8 | |||||
| Cast Int8 Word8 | |||||
Defined in Basement.Cast | |||||
| Cast Word8 Int8 | |||||
Defined in Basement.Cast | |||||
| From Word8 Word128 | |||||
Defined in Basement.From | |||||
| From Word8 Word256 | |||||
Defined in Basement.From | |||||
| From Word8 Int16 | |||||
Defined in Basement.From | |||||
| From Word8 Int32 | |||||
Defined in Basement.From | |||||
| From Word8 Int64 | |||||
Defined in Basement.From | |||||
| From Word8 Word16 | |||||
Defined in Basement.From | |||||
| From Word8 Word32 | |||||
Defined in Basement.From | |||||
| From Word8 Word64 | |||||
Defined in Basement.From | |||||
| From Word8 Int | |||||
Defined in Basement.From | |||||
| From Word8 Word | |||||
Defined in Basement.From | |||||
| IntegralDownsize Word16 Word8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Word32 Word8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Word64 Word8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Integer Word8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Natural Word8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Word Word8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralUpsize Word8 Int16 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Int16 # | |||||
| IntegralUpsize Word8 Int32 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Int32 # | |||||
| IntegralUpsize Word8 Int64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Int64 # | |||||
| IntegralUpsize Word8 Word16 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Word16 # | |||||
| IntegralUpsize Word8 Word32 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Word32 # | |||||
| IntegralUpsize Word8 Word64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Word64 # | |||||
| IntegralUpsize Word8 Int | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Int # | |||||
| IntegralUpsize Word8 Word | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Word # | |||||
| From AsciiString (UArray Word8) | |||||
Defined in Basement.From Methods from :: AsciiString -> UArray Word8 | |||||
| From String (UArray Word8) | |||||
Defined in Basement.From | |||||
| Indexable (Block Word8) Word64 | |||||
| Indexable (Ptr Word8) Word64 | |||||
| (KnownNat n, NatWithinBound Word8 n) => From (Zn n) Word8 | |||||
Defined in Basement.From | |||||
| (KnownNat n, NatWithinBound Word8 n) => From (Zn64 n) Word8 | |||||
Defined in Basement.From | |||||
| TryFrom (UArray Word8) String | |||||
| Cast (Block a) (Block Word8) | |||||
Defined in Basement.Cast | |||||
| type NatNumMaxBound Word8 | |||||
Defined in Basement.Nat type NatNumMaxBound Word8 = 255 | |||||
| type Difference Word8 | |||||
Defined in Basement.Numerical.Subtractive | |||||
| type PrimSize Word8 | |||||
Defined in Basement.PrimType | |||||
Instances
| PrintfArg Word16 | |||||
Defined in Text.Printf | |||||
| BitOps Word16 | |||||
Defined in Basement.Bits | |||||
| FiniteBitsOps Word16 | |||||
Defined in Basement.Bits | |||||
| HasNegation Word16 | |||||
Defined in Basement.Compat.NumLiteral | |||||
| Integral Word16 | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Word16 # | |||||
| ByteSwap Word16 | |||||
Defined in Basement.Endianness | |||||
| NormalForm Word16 | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Word16 -> () # | |||||
| Additive Word16 | |||||
| IDivisible Word16 | |||||
| Multiplicative Word16 | |||||
| IsIntegral Word16 | |||||
Defined in Basement.Numerical.Number | |||||
| IsNatural Word16 | |||||
Defined in Basement.Numerical.Number | |||||
| Subtractive Word16 | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| PrimMemoryComparable Word16 | |||||
Defined in Basement.PrimType | |||||
| PrimType Word16 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word16 -> CountOf Word8 # primShiftToBytes :: Proxy Word16 -> Int # primBaUIndex :: ByteArray# -> Offset Word16 -> Word16 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word16 -> prim Word16 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word16 -> Word16 -> prim () # primAddrIndex :: Addr# -> Offset Word16 -> Word16 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word16 -> prim Word16 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word16 -> Word16 -> prim () # | |||||
| Arbitrary Word16 Source # | |||||
| Storable Word16 Source # | |||||
| StorableFixed Word16 Source # | |||||
| IsField Word16 Source # | |||||
| Hashable Word16 Source # | |||||
| Bits Word16 | |||||
Defined in GHC.Internal.Word Methods (.&.) :: Word16 -> Word16 -> Word16 # (.|.) :: Word16 -> Word16 -> Word16 # xor :: Word16 -> Word16 -> Word16 # complement :: Word16 -> Word16 # shift :: Word16 -> Int -> Word16 # rotate :: Word16 -> Int -> Word16 # setBit :: Word16 -> Int -> Word16 # clearBit :: Word16 -> Int -> Word16 # complementBit :: Word16 -> Int -> Word16 # testBit :: Word16 -> Int -> Bool # bitSizeMaybe :: Word16 -> Maybe Int # shiftL :: Word16 -> Int -> Word16 # unsafeShiftL :: Word16 -> Int -> Word16 # shiftR :: Word16 -> Int -> Word16 # unsafeShiftR :: Word16 -> Int -> Word16 # rotateL :: Word16 -> Int -> Word16 # | |||||
| FiniteBits Word16 | |||||
Defined in GHC.Internal.Word Methods finiteBitSize :: Word16 -> Int countLeadingZeros :: Word16 -> Int countTrailingZeros :: Word16 -> Int | |||||
| Data Word16 | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word16 -> c Word16 gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word16 dataTypeOf :: Word16 -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word16) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word16) gmapT :: (forall b. Data b => b -> b) -> Word16 -> Word16 gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r gmapQ :: (forall d. Data d => d -> u) -> Word16 -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Word16 -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 | |||||
| Bounded Word16 | |||||
| Enum Word16 | |||||
Defined in GHC.Internal.Word | |||||
| Storable Word16 | |||||
| Ix Word16 | |||||
| Num Word16 | |||||
| Read Word16 | |||||
Defined in GHC.Internal.Read | |||||
| Integral Word16 | |||||
| Real Word16 | |||||
Defined in GHC.Internal.Word Methods toRational :: Word16 -> Rational | |||||
| Show Word16 | |||||
| Eq Word16 | |||||
| Ord Word16 | |||||
| Cast Int16 Word16 | |||||
Defined in Basement.Cast | |||||
| Cast Word16 Int16 | |||||
Defined in Basement.Cast | |||||
| From Word16 Word128 | |||||
Defined in Basement.From | |||||
| From Word16 Word256 | |||||
Defined in Basement.From | |||||
| From Word16 Int32 | |||||
Defined in Basement.From | |||||
| From Word16 Int64 | |||||
Defined in Basement.From | |||||
| From Word16 Word32 | |||||
Defined in Basement.From | |||||
| From Word16 Word64 | |||||
Defined in Basement.From | |||||
| From Word16 Int | |||||
Defined in Basement.From | |||||
| From Word16 Word | |||||
Defined in Basement.From | |||||
| From Word8 Word16 | |||||
Defined in Basement.From | |||||
| IntegralDownsize Word16 Word8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Word32 Word16 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Word64 Word16 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Integer Word16 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Natural Word16 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Word Word16 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralUpsize Word16 Word32 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word16 -> Word32 # | |||||
| IntegralUpsize Word16 Word64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word16 -> Word64 # | |||||
| IntegralUpsize Word16 Word | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word16 -> Word # | |||||
| IntegralUpsize Word8 Word16 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Word16 # | |||||
| Storable (BE Word16) Source # | |||||
| Storable (LE Word16) Source # | |||||
| StorableFixed (BE Word16) Source # | |||||
| StorableFixed (LE Word16) Source # | |||||
| (KnownNat n, NatWithinBound Word16 n) => From (Zn n) Word16 | |||||
Defined in Basement.From | |||||
| (KnownNat n, NatWithinBound Word16 n) => From (Zn64 n) Word16 | |||||
Defined in Basement.From | |||||
| type NatNumMaxBound Word16 | |||||
Defined in Basement.Nat type NatNumMaxBound Word16 = 65535 | |||||
| type Difference Word16 | |||||
Defined in Basement.Numerical.Subtractive | |||||
| type PrimSize Word16 | |||||
Defined in Basement.PrimType | |||||
Instances
| PrintfArg Word32 | |||||
Defined in Text.Printf | |||||
| BitOps Word32 | |||||
Defined in Basement.Bits | |||||
| FiniteBitsOps Word32 | |||||
Defined in Basement.Bits | |||||
| HasNegation Word32 | |||||
Defined in Basement.Compat.NumLiteral | |||||
| Integral Word32 | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Word32 # | |||||
| ByteSwap Word32 | |||||
Defined in Basement.Endianness | |||||
| NormalForm Word32 | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Word32 -> () # | |||||
| Additive Word32 | |||||
| IDivisible Word32 | |||||
| Multiplicative Word32 | |||||
| IsIntegral Word32 | |||||
Defined in Basement.Numerical.Number | |||||
| IsNatural Word32 | |||||
Defined in Basement.Numerical.Number | |||||
| Subtractive Word32 | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| PrimMemoryComparable Word32 | |||||
Defined in Basement.PrimType | |||||
| PrimType Word32 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word32 -> CountOf Word8 # primShiftToBytes :: Proxy Word32 -> Int # primBaUIndex :: ByteArray# -> Offset Word32 -> Word32 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word32 -> prim Word32 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word32 -> Word32 -> prim () # primAddrIndex :: Addr# -> Offset Word32 -> Word32 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word32 -> prim Word32 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word32 -> Word32 -> prim () # | |||||
| Arbitrary Word32 Source # | |||||
| Storable Word32 Source # | |||||
| StorableFixed Word32 Source # | |||||
| IsField Word32 Source # | |||||
| Hashable Word32 Source # | |||||
| Bits Word32 | |||||
Defined in GHC.Internal.Word Methods (.&.) :: Word32 -> Word32 -> Word32 # (.|.) :: Word32 -> Word32 -> Word32 # xor :: Word32 -> Word32 -> Word32 # complement :: Word32 -> Word32 # shift :: Word32 -> Int -> Word32 # rotate :: Word32 -> Int -> Word32 # setBit :: Word32 -> Int -> Word32 # clearBit :: Word32 -> Int -> Word32 # complementBit :: Word32 -> Int -> Word32 # testBit :: Word32 -> Int -> Bool # bitSizeMaybe :: Word32 -> Maybe Int # shiftL :: Word32 -> Int -> Word32 # unsafeShiftL :: Word32 -> Int -> Word32 # shiftR :: Word32 -> Int -> Word32 # unsafeShiftR :: Word32 -> Int -> Word32 # rotateL :: Word32 -> Int -> Word32 # | |||||
| FiniteBits Word32 | |||||
Defined in GHC.Internal.Word Methods finiteBitSize :: Word32 -> Int countLeadingZeros :: Word32 -> Int countTrailingZeros :: Word32 -> Int | |||||
| Data Word32 | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word32 -> c Word32 gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word32 dataTypeOf :: Word32 -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word32) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word32) gmapT :: (forall b. Data b => b -> b) -> Word32 -> Word32 gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r gmapQ :: (forall d. Data d => d -> u) -> Word32 -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Word32 -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 | |||||
| Bounded Word32 | |||||
| Enum Word32 | |||||
Defined in GHC.Internal.Word | |||||
| Storable Word32 | |||||
| Ix Word32 | |||||
| Num Word32 | |||||
| Read Word32 | |||||
Defined in GHC.Internal.Read | |||||
| Integral Word32 | |||||
| Real Word32 | |||||
Defined in GHC.Internal.Word Methods toRational :: Word32 -> Rational | |||||
| Show Word32 | |||||
| Eq Word32 | |||||
| Ord Word32 | |||||
| Cast Int32 Word32 | |||||
Defined in Basement.Cast | |||||
| Cast Word32 Int32 | |||||
Defined in Basement.Cast | |||||
| Cast Word32 Int | |||||
Defined in Basement.Cast | |||||
| Cast Word32 Word | |||||
Defined in Basement.Cast | |||||
| Cast Int Word32 | |||||
Defined in Basement.Cast | |||||
| Cast Word Word32 | |||||
Defined in Basement.Cast | |||||
| From Word16 Word32 | |||||
Defined in Basement.From | |||||
| From Word32 Word128 | |||||
Defined in Basement.From | |||||
| From Word32 Word256 | |||||
Defined in Basement.From | |||||
| From Word32 Int64 | |||||
Defined in Basement.From | |||||
| From Word32 Word64 | |||||
Defined in Basement.From | |||||
| From Word32 Int | |||||
Defined in Basement.From | |||||
| From Word32 Word | |||||
Defined in Basement.From | |||||
| From Word8 Word32 | |||||
Defined in Basement.From | |||||
| IntegralDownsize Word32 Word16 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Word32 Word8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Word64 Word32 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Integer Word32 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Natural Word32 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Word Word32 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralUpsize Word16 Word32 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word16 -> Word32 # | |||||
| IntegralUpsize Word32 Word64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word32 -> Word64 # | |||||
| IntegralUpsize Word32 Word | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word32 -> Word # | |||||
| IntegralUpsize Word8 Word32 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Word32 # | |||||
| Storable (BE Word32) Source # | |||||
| Storable (LE Word32) Source # | |||||
| StorableFixed (BE Word32) Source # | |||||
| StorableFixed (LE Word32) Source # | |||||
| (KnownNat n, NatWithinBound Word32 n) => From (Zn n) Word32 | |||||
Defined in Basement.From | |||||
| (KnownNat n, NatWithinBound Word32 n) => From (Zn64 n) Word32 | |||||
Defined in Basement.From | |||||
| type NatNumMaxBound Word32 | |||||
Defined in Basement.Nat type NatNumMaxBound Word32 = 4294967295 | |||||
| type Difference Word32 | |||||
Defined in Basement.Numerical.Subtractive | |||||
| type PrimSize Word32 | |||||
Defined in Basement.PrimType | |||||
Instances
| PrintfArg Word64 | |||||
Defined in Text.Printf | |||||
| BitOps Word64 | |||||
Defined in Basement.Bits | |||||
| FiniteBitsOps Word64 | |||||
Defined in Basement.Bits | |||||
| HasNegation Word64 | |||||
Defined in Basement.Compat.NumLiteral | |||||
| Integral Word64 | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Word64 # | |||||
| ByteSwap Word64 | |||||
Defined in Basement.Endianness | |||||
| NormalForm Word64 | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Word64 -> () # | |||||
| Additive Word64 | |||||
| IDivisible Word64 | |||||
| Multiplicative Word64 | |||||
| IsIntegral Word64 | |||||
Defined in Basement.Numerical.Number | |||||
| IsNatural Word64 | |||||
Defined in Basement.Numerical.Number | |||||
| Subtractive Word64 | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| PrimMemoryComparable Word64 | |||||
Defined in Basement.PrimType | |||||
| PrimType Word64 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word64 -> CountOf Word8 # primShiftToBytes :: Proxy Word64 -> Int # primBaUIndex :: ByteArray# -> Offset Word64 -> Word64 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word64 -> prim Word64 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word64 -> Word64 -> prim () # primAddrIndex :: Addr# -> Offset Word64 -> Word64 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word64 -> prim Word64 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word64 -> Word64 -> prim () # | |||||
| Arbitrary Word64 Source # | |||||
| Storable Word64 Source # | |||||
| StorableFixed Word64 Source # | |||||
| IsField Word64 Source # | |||||
| Hashable Word64 Source # | |||||
| Bits Word64 | |||||
Defined in GHC.Internal.Word Methods (.&.) :: Word64 -> Word64 -> Word64 # (.|.) :: Word64 -> Word64 -> Word64 # xor :: Word64 -> Word64 -> Word64 # complement :: Word64 -> Word64 # shift :: Word64 -> Int -> Word64 # rotate :: Word64 -> Int -> Word64 # setBit :: Word64 -> Int -> Word64 # clearBit :: Word64 -> Int -> Word64 # complementBit :: Word64 -> Int -> Word64 # testBit :: Word64 -> Int -> Bool # bitSizeMaybe :: Word64 -> Maybe Int # shiftL :: Word64 -> Int -> Word64 # unsafeShiftL :: Word64 -> Int -> Word64 # shiftR :: Word64 -> Int -> Word64 # unsafeShiftR :: Word64 -> Int -> Word64 # rotateL :: Word64 -> Int -> Word64 # | |||||
| FiniteBits Word64 | |||||
Defined in GHC.Internal.Word Methods finiteBitSize :: Word64 -> Int countLeadingZeros :: Word64 -> Int countTrailingZeros :: Word64 -> Int | |||||
| Data Word64 | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word64 -> c Word64 gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word64 dataTypeOf :: Word64 -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word64) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word64) gmapT :: (forall b. Data b => b -> b) -> Word64 -> Word64 gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r gmapQ :: (forall d. Data d => d -> u) -> Word64 -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Word64 -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 | |||||
| Bounded Word64 | |||||
| Enum Word64 | |||||
Defined in GHC.Internal.Word | |||||
| Storable Word64 | |||||
| Ix Word64 | |||||
| Num Word64 | |||||
| Read Word64 | |||||
Defined in GHC.Internal.Read | |||||
| Integral Word64 | |||||
| Real Word64 | |||||
Defined in GHC.Internal.Word Methods toRational :: Word64 -> Rational | |||||
| Show Word64 | |||||
| Eq Word64 | |||||
| Ord Word64 | |||||
| Cast Int64 Word64 | |||||
Defined in Basement.Cast | |||||
| Cast Word64 Int64 | |||||
Defined in Basement.Cast | |||||
| From Word16 Word64 | |||||
Defined in Basement.From | |||||
| From Word32 Word64 | |||||
Defined in Basement.From | |||||
| From Word64 Word128 | |||||
Defined in Basement.From | |||||
| From Word64 Word256 | |||||
Defined in Basement.From | |||||
| From Word8 Word64 | |||||
Defined in Basement.From | |||||
| From Word Word64 | |||||
Defined in Basement.From | |||||
| IntegralDownsize Word64 Word16 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Word64 Word32 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Word64 Word8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Integer Word64 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Natural Word64 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralUpsize Word16 Word64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word16 -> Word64 # | |||||
| IntegralUpsize Word32 Word64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word32 -> Word64 # | |||||
| IntegralUpsize Word8 Word64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Word64 # | |||||
| IntegralUpsize Word Word64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word -> Word64 # | |||||
| Storable (BE Word64) Source # | |||||
| Storable (LE Word64) Source # | |||||
| StorableFixed (BE Word64) Source # | |||||
| StorableFixed (LE Word64) Source # | |||||
| Indexable (Block Word8) Word64 | |||||
| Indexable (Ptr Word8) Word64 | |||||
| (KnownNat n, NatWithinBound Word64 n) => From (Zn n) Word64 | |||||
Defined in Basement.From | |||||
| From (Zn64 n) Word64 | |||||
Defined in Basement.From | |||||
| type NatNumMaxBound Word64 | |||||
Defined in Basement.Nat type NatNumMaxBound Word64 = 18446744073709551615 | |||||
| type Difference Word64 | |||||
Defined in Basement.Numerical.Subtractive | |||||
| type PrimSize Word64 | |||||
Defined in Basement.PrimType | |||||
Instances
| PrintfArg Word | |||||
Defined in Text.Printf | |||||
| BitOps Word | |||||
| FiniteBitsOps Word | |||||
| HasNegation Word | |||||
Defined in Basement.Compat.NumLiteral | |||||
| Integral Word | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Word # | |||||
| NormalForm Word | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Word -> () # | |||||
| Additive Word | |||||
| IDivisible Word | |||||
| Multiplicative Word | |||||
| IsIntegral Word | |||||
Defined in Basement.Numerical.Number | |||||
| IsNatural Word | |||||
Defined in Basement.Numerical.Number | |||||
| Subtractive Word | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| PrimMemoryComparable Word | |||||
Defined in Basement.PrimType | |||||
| PrimType Word | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word -> CountOf Word8 # primShiftToBytes :: Proxy Word -> Int # primBaUIndex :: ByteArray# -> Offset Word -> Word # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word -> prim Word # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word -> Word -> prim () # primAddrIndex :: Addr# -> Offset Word -> Word # primAddrRead :: PrimMonad prim => Addr# -> Offset Word -> prim Word # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word -> Word -> prim () # | |||||
| Arbitrary Word Source # | |||||
| IsField Word Source # | |||||
| Bits Word | |||||
Defined in GHC.Internal.Bits Methods (.&.) :: Word -> Word -> Word # (.|.) :: Word -> Word -> Word # complement :: Word -> Word # shift :: Word -> Int -> Word # rotate :: Word -> Int -> Word # setBit :: Word -> Int -> Word # clearBit :: Word -> Int -> Word # complementBit :: Word -> Int -> Word # testBit :: Word -> Int -> Bool # bitSizeMaybe :: Word -> Maybe Int # shiftL :: Word -> Int -> Word # unsafeShiftL :: Word -> Int -> Word # shiftR :: Word -> Int -> Word # unsafeShiftR :: Word -> Int -> Word # rotateL :: Word -> Int -> Word # | |||||
| FiniteBits Word | |||||
Defined in GHC.Internal.Bits Methods finiteBitSize :: Word -> Int countLeadingZeros :: Word -> Int countTrailingZeros :: Word -> Int | |||||
| Data Word | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word dataTypeOf :: Word -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) gmapT :: (forall b. Data b => b -> b) -> Word -> Word gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word | |||||
| Bounded Word | |||||
| Enum Word | |||||
| Storable Word | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
| Num Word | |||||
| Read Word | |||||
Defined in GHC.Internal.Read | |||||
| Integral Word | |||||
| Real Word | |||||
Defined in GHC.Internal.Real Methods toRational :: Word -> Rational | |||||
| Show Word | |||||
| Eq Word | |||||
| Ord Word | |||||
| Cast Int32 Word | |||||
Defined in Basement.Cast | |||||
| Cast Word32 Word | |||||
Defined in Basement.Cast | |||||
| Cast Int Word | |||||
Defined in Basement.Cast | |||||
| Cast Word Int32 | |||||
Defined in Basement.Cast | |||||
| Cast Word Word32 | |||||
Defined in Basement.Cast | |||||
| Cast Word Int | |||||
Defined in Basement.Cast | |||||
| From Word16 Word | |||||
Defined in Basement.From | |||||
| From Word32 Word | |||||
Defined in Basement.From | |||||
| From Word8 Word | |||||
Defined in Basement.From | |||||
| From Word Word64 | |||||
Defined in Basement.From | |||||
| IntegralDownsize Word Word16 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Word Word32 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Word Word8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralUpsize Word16 Word | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word16 -> Word # | |||||
| IntegralUpsize Word32 Word | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word32 -> Word # | |||||
| IntegralUpsize Word8 Word | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Word # | |||||
| IntegralUpsize Word Word64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word -> Word64 # | |||||
| From Word (CountOf ty) | |||||
Defined in Basement.From | |||||
| From Word (Offset ty) | |||||
Defined in Basement.From | |||||
| Generic1 (URec Word :: k -> Type) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Foldable (UWord :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => UWord m -> m foldMap :: Monoid m => (a -> m) -> UWord a -> m foldMap' :: Monoid m => (a -> m) -> UWord a -> m foldr :: (a -> b -> b) -> b -> UWord a -> b foldr' :: (a -> b -> b) -> b -> UWord a -> b foldl :: (b -> a -> b) -> b -> UWord a -> b foldl' :: (b -> a -> b) -> b -> UWord a -> b foldr1 :: (a -> a -> a) -> UWord a -> a foldl1 :: (a -> a -> a) -> UWord a -> a toList :: UWord a -> [a] elem :: Eq a => a -> UWord a -> Bool maximum :: Ord a => UWord a -> a minimum :: Ord a => UWord a -> a sum :: Num a => UWord a -> a product :: Num a => UWord a -> a | |||||
| Traversable (UWord :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UWord a -> f (UWord b) sequenceA :: Applicative f => UWord (f a) -> f (UWord a) | |||||
| From (CountOf ty) Word | |||||
Defined in Basement.From | |||||
| Functor (URec Word :: Type -> Type) | |||||
| Generic (URec Word p) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Show (URec Word p) | |||||
| Eq (URec Word p) | |||||
| Ord (URec Word p) | |||||
Defined in GHC.Internal.Generics | |||||
| type NatNumMaxBound Word | |||||
Defined in Basement.Nat | |||||
| type Difference Word | |||||
Defined in Basement.Numerical.Subtractive | |||||
| type PrimSize Word | |||||
Defined in Basement.PrimType | |||||
| data URec Word (p :: k) | |||||
Defined in GHC.Internal.Generics | |||||
| type Rep1 (URec Word :: k -> Type) | |||||
Defined in GHC.Internal.Generics | |||||
| type Rep (URec Word p) | |||||
Defined in GHC.Internal.Generics | |||||
Instances
| BitOps Word128 | |||||
Defined in Basement.Bits | |||||
| FiniteBitsOps Word128 | |||||
Defined in Basement.Bits | |||||
| HasNegation Word128 | |||||
Defined in Basement.Types.Word128 | |||||
| Integral Word128 | |||||
Defined in Basement.Types.Word128 Methods fromInteger :: Integer -> Word128 # | |||||
| NormalForm Word128 | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Word128 -> () # | |||||
| Additive Word128 | |||||
| IDivisible Word128 | |||||
| Multiplicative Word128 | |||||
| IsIntegral Word128 | |||||
Defined in Basement.Types.Word128 | |||||
| IsNatural Word128 | |||||
Defined in Basement.Types.Word128 | |||||
| Subtractive Word128 | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| PrimMemoryComparable Word128 | |||||
Defined in Basement.PrimType | |||||
| PrimType Word128 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word128 -> CountOf Word8 # primShiftToBytes :: Proxy Word128 -> Int # primBaUIndex :: ByteArray# -> Offset Word128 -> Word128 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word128 -> prim Word128 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word128 -> Word128 -> prim () # primAddrIndex :: Addr# -> Offset Word128 -> Word128 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word128 -> prim Word128 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word128 -> Word128 -> prim () # | |||||
| Arbitrary Word128 Source # | |||||
| Storable Word128 Source # | |||||
| StorableFixed Word128 Source # | |||||
| IsField Word128 Source # | |||||
| Hashable Word128 Source # | |||||
| Bits Word128 | |||||
Defined in Basement.Types.Word128 Methods (.&.) :: Word128 -> Word128 -> Word128 # (.|.) :: Word128 -> Word128 -> Word128 # xor :: Word128 -> Word128 -> Word128 # complement :: Word128 -> Word128 # shift :: Word128 -> Int -> Word128 # rotate :: Word128 -> Int -> Word128 # setBit :: Word128 -> Int -> Word128 # clearBit :: Word128 -> Int -> Word128 # complementBit :: Word128 -> Int -> Word128 # testBit :: Word128 -> Int -> Bool # bitSizeMaybe :: Word128 -> Maybe Int # shiftL :: Word128 -> Int -> Word128 # unsafeShiftL :: Word128 -> Int -> Word128 # shiftR :: Word128 -> Int -> Word128 # unsafeShiftR :: Word128 -> Int -> Word128 # rotateL :: Word128 -> Int -> Word128 # | |||||
| Bounded Word128 | |||||
| Enum Word128 | |||||
| Storable Word128 | |||||
| Num Word128 | |||||
| Show Word128 | |||||
| Eq Word128 | |||||
| Ord Word128 | |||||
Defined in Basement.Types.Word128 | |||||
| From Word128 Word256 | |||||
Defined in Basement.From | |||||
| From Word16 Word128 | |||||
Defined in Basement.From | |||||
| From Word32 Word128 | |||||
Defined in Basement.From | |||||
| From Word64 Word128 | |||||
Defined in Basement.From | |||||
| From Word8 Word128 | |||||
Defined in Basement.From | |||||
| Storable (BE Word128) Source # | |||||
| Storable (LE Word128) Source # | |||||
| StorableFixed (BE Word128) Source # | |||||
| StorableFixed (LE Word128) Source # | |||||
| (KnownNat n, NatWithinBound Word128 n) => From (Zn n) Word128 | |||||
Defined in Basement.From | |||||
| From (Zn64 n) Word128 | |||||
Defined in Basement.From | |||||
| type NatNumMaxBound Word128 | |||||
Defined in Basement.Nat type NatNumMaxBound Word128 = 340282366920938463463374607431768211455 | |||||
| type Difference Word128 | |||||
Defined in Basement.Numerical.Subtractive | |||||
| type PrimSize Word128 | |||||
Defined in Basement.PrimType | |||||
Instances
| BitOps Word256 | |||||
Defined in Basement.Bits | |||||
| FiniteBitsOps Word256 | |||||
Defined in Basement.Bits | |||||
| HasNegation Word256 | |||||
Defined in Basement.Types.Word256 | |||||
| Integral Word256 | |||||
Defined in Basement.Types.Word256 Methods fromInteger :: Integer -> Word256 # | |||||
| NormalForm Word256 | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Word256 -> () # | |||||
| Additive Word256 | |||||
| IDivisible Word256 | |||||
| Multiplicative Word256 | |||||
| IsIntegral Word256 | |||||
Defined in Basement.Types.Word256 | |||||
| IsNatural Word256 | |||||
Defined in Basement.Types.Word256 | |||||
| Subtractive Word256 | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| PrimMemoryComparable Word256 | |||||
Defined in Basement.PrimType | |||||
| PrimType Word256 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word256 -> CountOf Word8 # primShiftToBytes :: Proxy Word256 -> Int # primBaUIndex :: ByteArray# -> Offset Word256 -> Word256 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word256 -> prim Word256 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word256 -> Word256 -> prim () # primAddrIndex :: Addr# -> Offset Word256 -> Word256 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word256 -> prim Word256 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word256 -> Word256 -> prim () # | |||||
| Arbitrary Word256 Source # | |||||
| Storable Word256 Source # | |||||
| StorableFixed Word256 Source # | |||||
| IsField Word256 Source # | |||||
| Hashable Word256 Source # | |||||
| Bits Word256 | |||||
Defined in Basement.Types.Word256 Methods (.&.) :: Word256 -> Word256 -> Word256 # (.|.) :: Word256 -> Word256 -> Word256 # xor :: Word256 -> Word256 -> Word256 # complement :: Word256 -> Word256 # shift :: Word256 -> Int -> Word256 # rotate :: Word256 -> Int -> Word256 # setBit :: Word256 -> Int -> Word256 # clearBit :: Word256 -> Int -> Word256 # complementBit :: Word256 -> Int -> Word256 # testBit :: Word256 -> Int -> Bool # bitSizeMaybe :: Word256 -> Maybe Int # shiftL :: Word256 -> Int -> Word256 # unsafeShiftL :: Word256 -> Int -> Word256 # shiftR :: Word256 -> Int -> Word256 # unsafeShiftR :: Word256 -> Int -> Word256 # rotateL :: Word256 -> Int -> Word256 # | |||||
| Bounded Word256 | |||||
| Enum Word256 | |||||
| Storable Word256 | |||||
| Num Word256 | |||||
| Show Word256 | |||||
| Eq Word256 | |||||
| Ord Word256 | |||||
Defined in Basement.Types.Word256 | |||||
| From Word128 Word256 | |||||
Defined in Basement.From | |||||
| From Word16 Word256 | |||||
Defined in Basement.From | |||||
| From Word32 Word256 | |||||
Defined in Basement.From | |||||
| From Word64 Word256 | |||||
Defined in Basement.From | |||||
| From Word8 Word256 | |||||
Defined in Basement.From | |||||
| Storable (BE Word256) Source # | |||||
| Storable (LE Word256) Source # | |||||
| StorableFixed (BE Word256) Source # | |||||
| StorableFixed (LE Word256) Source # | |||||
| (KnownNat n, NatWithinBound Word256 n) => From (Zn n) Word256 | |||||
Defined in Basement.From | |||||
| From (Zn64 n) Word256 | |||||
Defined in Basement.From | |||||
| type NatNumMaxBound Word256 | |||||
Defined in Basement.Nat type NatNumMaxBound Word256 = 115792089237316195423570985008687907853269984665640564039457584007913129639935 | |||||
| type Difference Word256 | |||||
Defined in Basement.Numerical.Subtractive | |||||
| type PrimSize Word256 | |||||
Defined in Basement.PrimType | |||||
Instances
| PrintfArg Int | |||||
Defined in Text.Printf | |||||
| HasNegation Int | |||||
Defined in Basement.Compat.NumLiteral | |||||
| Integral Int | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Int # | |||||
| NormalForm Int | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Int -> () # | |||||
| Additive Int | |||||
| IDivisible Int | |||||
| Multiplicative Int | |||||
| IsIntegral Int | |||||
Defined in Basement.Numerical.Number | |||||
| Subtractive Int | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| PrimMemoryComparable Int | |||||
Defined in Basement.PrimType | |||||
| PrimType Int | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Int -> CountOf Word8 # primShiftToBytes :: Proxy Int -> Int # primBaUIndex :: ByteArray# -> Offset Int -> Int # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int -> prim Int # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int -> Int -> prim () # primAddrIndex :: Addr# -> Offset Int -> Int # primAddrRead :: PrimMonad prim => Addr# -> Offset Int -> prim Int # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int -> Int -> prim () # | |||||
| Arbitrary Int Source # | |||||
| IsField Int Source # | |||||
| Signed Int Source # | |||||
| Bits Int | |||||
Defined in GHC.Internal.Bits | |||||
| FiniteBits Int | |||||
Defined in GHC.Internal.Bits | |||||
| Data Int | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int dataTypeOf :: Int -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) gmapT :: (forall b. Data b => b -> b) -> Int -> Int gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int | |||||
| Bounded Int | |||||
| Enum Int | |||||
| Storable Int | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
| Num Int | |||||
| Read Int | |||||
Defined in GHC.Internal.Read | |||||
| Integral Int | |||||
| Real Int | |||||
Defined in GHC.Internal.Real Methods toRational :: Int -> Rational | |||||
| Show Int | |||||
| Eq Int | |||||
| Ord Int | |||||
| Cast Int32 Int | |||||
Defined in Basement.Cast | |||||
| Cast Word32 Int | |||||
Defined in Basement.Cast | |||||
| Cast Int Int32 | |||||
Defined in Basement.Cast | |||||
| Cast Int Word32 | |||||
Defined in Basement.Cast | |||||
| Cast Int Word | |||||
Defined in Basement.Cast | |||||
| Cast Word Int | |||||
Defined in Basement.Cast | |||||
| From Int16 Int | |||||
Defined in Basement.From | |||||
| From Int32 Int | |||||
Defined in Basement.From | |||||
| From Int8 Int | |||||
Defined in Basement.From | |||||
| From Word16 Int | |||||
Defined in Basement.From | |||||
| From Word32 Int | |||||
Defined in Basement.From | |||||
| From Word8 Int | |||||
Defined in Basement.From | |||||
| From Int Int64 | |||||
Defined in Basement.From | |||||
| IntegralDownsize Int64 Int | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Int Int16 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Int Int32 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Int Int8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralUpsize Int16 Int | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int16 -> Int # | |||||
| IntegralUpsize Int32 Int | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int32 -> Int # | |||||
| IntegralUpsize Int8 Int | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int8 -> Int # | |||||
| IntegralUpsize Word8 Int | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Word8 -> Int # | |||||
| IntegralUpsize Int Int64 | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: Int -> Int64 # | |||||
| TryFrom Int (CountOf ty) | |||||
Defined in Basement.From | |||||
| TryFrom Int (Offset ty) | |||||
Defined in Basement.From | |||||
| Generic1 (URec Int :: k -> Type) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Foldable (UInt :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Foldable Methods 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 toList :: UInt a -> [a] elem :: Eq a => a -> UInt a -> Bool maximum :: Ord a => UInt a -> a minimum :: Ord a => UInt a -> a sum :: Num a => UInt a -> a product :: Num a => UInt a -> a | |||||
| Traversable (UInt :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UInt a -> f (UInt b) sequenceA :: Applicative f => UInt (f a) -> f (UInt a) | |||||
| From (CountOf ty) Int | |||||
Defined in Basement.From | |||||
| Functor (URec Int :: Type -> Type) | |||||
| Generic (URec Int p) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Show (URec Int p) | |||||
| Eq (URec Int p) | |||||
| Ord (URec Int p) | |||||
Defined in GHC.Internal.Generics | |||||
| type NatNumMaxBound Int | |||||
Defined in Basement.Nat | |||||
| type Difference Int | |||||
Defined in Basement.Numerical.Subtractive | |||||
| type PrimSize Int | |||||
Defined in Basement.PrimType | |||||
| data URec Int (p :: k) | |||||
Defined in GHC.Internal.Generics | |||||
| type Rep1 (URec Int :: k -> Type) | |||||
Defined in GHC.Internal.Generics | |||||
| type Rep (URec Int p) | |||||
Defined in GHC.Internal.Generics | |||||
Instances
| PrintfArg Integer | |||||
Defined in Text.Printf | |||||
| Fractional Rational | |||||
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> Rational # | |||||
| HasNegation Integer | |||||
Defined in Basement.Compat.NumLiteral | |||||
| Integral Integer | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Integer # | |||||
| NormalForm Integer | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Integer -> () # | |||||
| Additive Rational | |||||
| Additive Integer | |||||
| Divisible Rational | |||||
| IDivisible Integer | |||||
| Multiplicative Rational | |||||
| Multiplicative Integer | |||||
| IsIntegral Integer | |||||
Defined in Basement.Numerical.Number | |||||
| Subtractive Integer | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| Arbitrary Integer Source # | |||||
| IsField Integer Source # | |||||
| Hashable Integer Source # | |||||
| IntegralRounding Rational Source # | |||||
| Signed Integer Source # | |||||
| Bits Integer | |||||
Defined in GHC.Internal.Bits Methods (.&.) :: Integer -> Integer -> Integer # (.|.) :: Integer -> Integer -> Integer # xor :: Integer -> Integer -> Integer # complement :: Integer -> Integer # shift :: Integer -> Int -> Integer # rotate :: Integer -> Int -> Integer # setBit :: Integer -> Int -> Integer # clearBit :: Integer -> Int -> Integer # complementBit :: Integer -> Int -> Integer # testBit :: Integer -> Int -> Bool # bitSizeMaybe :: Integer -> Maybe Int # shiftL :: Integer -> Int -> Integer # unsafeShiftL :: Integer -> Int -> Integer # shiftR :: Integer -> Int -> Integer # unsafeShiftR :: Integer -> Int -> Integer # rotateL :: Integer -> Int -> Integer # | |||||
| Data Integer | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Integer -> c Integer gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Integer dataTypeOf :: Integer -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Integer) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Integer) gmapT :: (forall b. Data b => b -> b) -> Integer -> Integer gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r gmapQ :: (forall d. Data d => d -> u) -> Integer -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Integer -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Integer -> m Integer gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer | |||||
| Enum Integer | |||||
| Num Integer | |||||
| Read Integer | |||||
Defined in GHC.Internal.Read | |||||
| Integral Integer | |||||
Defined in GHC.Internal.Real | |||||
| Real Integer | |||||
Defined in GHC.Internal.Real Methods toRational :: Integer -> Rational | |||||
| Show Integer | |||||
| Eq Integer | |||||
| Ord Integer | |||||
| IsIntegral n => From n Integer | |||||
Defined in Basement.From | |||||
| IntegralDownsize Integer Int16 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Integer Int32 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Integer Int64 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Integer Int8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Integer Word16 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Integer Word32 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Integer Word64 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Integer Word8 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Integer Natural | |||||
Defined in Basement.IntegralConv | |||||
| IsIntegral a => IntegralUpsize a Integer | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: a -> Integer # | |||||
| type Difference Integer | |||||
Defined in Basement.Numerical.Subtractive | |||||
Instances
| PrintfArg Natural | |||||
Defined in Text.Printf | |||||
| Integral Natural | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Natural # | |||||
| NormalForm Natural | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Natural -> () # | |||||
| Additive Natural | |||||
| IDivisible Natural | |||||
| Multiplicative Natural | |||||
| IsIntegral Natural | |||||
Defined in Basement.Numerical.Number | |||||
| IsNatural Natural | |||||
Defined in Basement.Numerical.Number | |||||
| Subtractive Natural | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| Arbitrary Natural Source # | |||||
| IsField Natural Source # | |||||
| Hashable Natural Source # | |||||
| Bits Natural | |||||
Defined in GHC.Internal.Bits Methods (.&.) :: Natural -> Natural -> Natural # (.|.) :: Natural -> Natural -> Natural # xor :: Natural -> Natural -> Natural # complement :: Natural -> Natural # shift :: Natural -> Int -> Natural # rotate :: Natural -> Int -> Natural # setBit :: Natural -> Int -> Natural # clearBit :: Natural -> Int -> Natural # complementBit :: Natural -> Int -> Natural # testBit :: Natural -> Int -> Bool # bitSizeMaybe :: Natural -> Maybe Int # shiftL :: Natural -> Int -> Natural # unsafeShiftL :: Natural -> Int -> Natural # shiftR :: Natural -> Int -> Natural # unsafeShiftR :: Natural -> Int -> Natural # rotateL :: Natural -> Int -> Natural # | |||||
| Data Natural | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Natural -> c Natural gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Natural dataTypeOf :: Natural -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Natural) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Natural) gmapT :: (forall b. Data b => b -> b) -> Natural -> Natural gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r gmapQ :: (forall d. Data d => d -> u) -> Natural -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Natural -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Natural -> m Natural gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural | |||||
| Enum Natural | |||||
| Num Natural | |||||
| Read Natural | |||||
Defined in GHC.Internal.Read | |||||
| Integral Natural | |||||
Defined in GHC.Internal.Real | |||||
| Real Natural | |||||
Defined in GHC.Internal.Real Methods toRational :: Natural -> Rational | |||||
| Show Natural | |||||
| Eq Natural | |||||
| Ord Natural | |||||
| KnownNat n => HasResolution (n :: Nat) | |||||
Defined in Data.Fixed Methods resolution :: p n -> Integer | |||||
| IsNatural n => From n Natural | |||||
Defined in Basement.From | |||||
| IntegralDownsize Integer Natural | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Natural Word16 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Natural Word32 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Natural Word64 | |||||
Defined in Basement.IntegralConv | |||||
| IntegralDownsize Natural Word8 | |||||
Defined in Basement.IntegralConv | |||||
| IsNatural a => IntegralUpsize a Natural | |||||
Defined in Basement.IntegralConv Methods integralUpsize :: a -> Natural # | |||||
| TestCoercion SNat | |||||
Defined in GHC.Internal.TypeNats Methods testCoercion :: forall (a :: Nat) (b :: Nat). SNat a -> SNat b -> Maybe (Coercion a b) | |||||
| TestEquality SNat | |||||
Defined in GHC.Internal.TypeNats Methods testEquality :: forall (a :: Nat) (b :: Nat). SNat a -> SNat b -> Maybe (a :~: b) | |||||
| type Difference Natural | |||||
Defined in Basement.Numerical.Subtractive | |||||
| type Compare (a :: Natural) (b :: Natural) | |||||
Defined in GHC.Internal.Data.Type.Ord | |||||
Instances
| PrintfArg Float | |||||
Defined in Text.Printf | |||||
| Fractional Float | |||||
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> Float # | |||||
| HasNegation Float | |||||
Defined in Basement.Compat.NumLiteral | |||||
| Integral Float | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Float # | |||||
| NormalForm Float | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Float -> () # | |||||
| Additive Float | |||||
| Divisible Float | |||||
| Multiplicative Float | |||||
| Subtractive Float | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| PrimType Float | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Float -> CountOf Word8 # primShiftToBytes :: Proxy Float -> Int # primBaUIndex :: ByteArray# -> Offset Float -> Float # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Float -> prim Float # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Float -> Float -> prim () # primAddrIndex :: Addr# -> Offset Float -> Float # primAddrRead :: PrimMonad prim => Addr# -> Offset Float -> prim Float # primAddrWrite :: PrimMonad prim => Addr# -> Offset Float -> Float -> prim () # | |||||
| Arbitrary Float Source # | |||||
| Storable Float Source # | |||||
| StorableFixed Float Source # | |||||
| Trigonometry Float Source # | |||||
Defined in Foundation.Math.Trigonometry Methods sin :: Float -> Float Source # cos :: Float -> Float Source # tan :: Float -> Float Source # asin :: Float -> Float Source # acos :: Float -> Float Source # atan :: Float -> Float Source # sinh :: Float -> Float Source # cosh :: Float -> Float Source # tanh :: Float -> Float Source # asinh :: Float -> Float Source # | |||||
| IntegralRounding Float Source # | |||||
| Signed Float Source # | |||||
| FloatingPoint Float Source # | |||||
| Data Float | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float dataTypeOf :: Float -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) gmapT :: (forall b. Data b => b -> b) -> Float -> Float gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float | |||||
| Enum Float | |||||
Defined in GHC.Internal.Float | |||||
| Floating Float | |||||
| RealFloat Float | |||||
Defined in GHC.Internal.Float Methods floatRadix :: Float -> Integer floatDigits :: Float -> Int floatRange :: Float -> (Int, Int) decodeFloat :: Float -> (Integer, Int) encodeFloat :: Integer -> Int -> Float significand :: Float -> Float scaleFloat :: Int -> Float -> Float isInfinite :: Float -> Bool isDenormalized :: Float -> Bool isNegativeZero :: Float -> Bool | |||||
| Storable Float | |||||
Defined in GHC.Internal.Foreign.Storable | |||||
| Num Float | |||||
| Read Float | |||||
Defined in GHC.Internal.Read | |||||
| Fractional Float | |||||
| Real Float | |||||
Defined in GHC.Internal.Float Methods toRational :: Float -> Rational | |||||
| RealFrac Float | |||||
| Show Float | |||||
| Eq Float | |||||
| Ord Float | |||||
| Generic1 (URec Float :: k -> Type) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Foldable (UFloat :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => UFloat m -> m foldMap :: Monoid m => (a -> m) -> UFloat a -> m foldMap' :: Monoid m => (a -> m) -> UFloat a -> m foldr :: (a -> b -> b) -> b -> UFloat a -> b foldr' :: (a -> b -> b) -> b -> UFloat a -> b foldl :: (b -> a -> b) -> b -> UFloat a -> b foldl' :: (b -> a -> b) -> b -> UFloat a -> b foldr1 :: (a -> a -> a) -> UFloat a -> a foldl1 :: (a -> a -> a) -> UFloat a -> a toList :: UFloat a -> [a] elem :: Eq a => a -> UFloat a -> Bool maximum :: Ord a => UFloat a -> a minimum :: Ord a => UFloat a -> a sum :: Num a => UFloat a -> a product :: Num a => UFloat a -> a | |||||
| Traversable (UFloat :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UFloat a -> f (UFloat b) sequenceA :: Applicative f => UFloat (f a) -> f (UFloat a) | |||||
| Functor (URec Float :: Type -> Type) | |||||
| Generic (URec Float p) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Show (URec Float p) | |||||
| Eq (URec Float p) | |||||
| Ord (URec Float p) | |||||
Defined in GHC.Internal.Generics | |||||
| type Difference Float | |||||
Defined in Basement.Numerical.Subtractive | |||||
| type PrimSize Float | |||||
Defined in Basement.PrimType | |||||
| data URec Float (p :: k) | |||||
Defined in GHC.Internal.Generics | |||||
| type Rep1 (URec Float :: k -> Type) | |||||
Defined in GHC.Internal.Generics | |||||
| type Rep (URec Float p) | |||||
Defined in GHC.Internal.Generics | |||||
Instances
| PrintfArg Double | |||||
Defined in Text.Printf | |||||
| Fractional Double | |||||
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> Double # | |||||
| HasNegation Double | |||||
Defined in Basement.Compat.NumLiteral | |||||
| Integral Double | |||||
Defined in Basement.Compat.NumLiteral Methods fromInteger :: Integer -> Double # | |||||
| NormalForm Double | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Double -> () # | |||||
| Additive Double | |||||
| Divisible Double | |||||
| Multiplicative Double | |||||
| Subtractive Double | |||||
Defined in Basement.Numerical.Subtractive Associated Types
| |||||
| PrimType Double | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Double -> CountOf Word8 # primShiftToBytes :: Proxy Double -> Int # primBaUIndex :: ByteArray# -> Offset Double -> Double # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Double -> prim Double # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Double -> Double -> prim () # primAddrIndex :: Addr# -> Offset Double -> Double # primAddrRead :: PrimMonad prim => Addr# -> Offset Double -> prim Double # primAddrWrite :: PrimMonad prim => Addr# -> Offset Double -> Double -> prim () # | |||||
| Arbitrary Double Source # | |||||
| Storable Double Source # | |||||
| StorableFixed Double Source # | |||||
| IsField Double Source # | |||||
| Trigonometry Double Source # | |||||
Defined in Foundation.Math.Trigonometry Methods sin :: Double -> Double Source # cos :: Double -> Double Source # tan :: Double -> Double Source # asin :: Double -> Double Source # acos :: Double -> Double Source # atan :: Double -> Double Source # sinh :: Double -> Double Source # cosh :: Double -> Double Source # tanh :: Double -> Double Source # asinh :: Double -> Double Source # | |||||
| IntegralRounding Double Source # | |||||
| Signed Double Source # | |||||
| FloatingPoint Double Source # | |||||
| Data Double | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double 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 | |||||
| Enum Double | |||||
Defined in GHC.Internal.Float | |||||
| Floating Double | |||||
| RealFloat Double | |||||
Defined in GHC.Internal.Float Methods floatRadix :: Double -> Integer floatDigits :: Double -> Int floatRange :: Double -> (Int, Int) decodeFloat :: Double -> (Integer, Int) encodeFloat :: Integer -> Int -> Double significand :: Double -> Double scaleFloat :: Int -> Double -> Double isInfinite :: Double -> Bool isDenormalized :: Double -> Bool isNegativeZero :: Double -> Bool | |||||
| Storable Double | |||||
| Num Double | |||||
| Read Double | |||||
Defined in GHC.Internal.Read | |||||
| Fractional Double | |||||
| Real Double | |||||
Defined in GHC.Internal.Float Methods toRational :: Double -> Rational | |||||
| RealFrac Double | |||||
| Show Double | |||||
| Eq Double | |||||
| Ord Double | |||||
| Generic1 (URec Double :: k -> Type) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Foldable (UDouble :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => UDouble m -> m foldMap :: Monoid m => (a -> m) -> UDouble a -> m foldMap' :: Monoid m => (a -> m) -> UDouble a -> m foldr :: (a -> b -> b) -> b -> UDouble a -> b foldr' :: (a -> b -> b) -> b -> UDouble a -> b foldl :: (b -> a -> b) -> b -> UDouble a -> b foldl' :: (b -> a -> b) -> b -> UDouble a -> b foldr1 :: (a -> a -> a) -> UDouble a -> a foldl1 :: (a -> a -> a) -> UDouble a -> a toList :: UDouble a -> [a] elem :: Eq a => a -> UDouble a -> Bool maximum :: Ord a => UDouble a -> a minimum :: Ord a => UDouble a -> a sum :: Num a => UDouble a -> a product :: Num a => UDouble a -> a | |||||
| Traversable (UDouble :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UDouble a -> f (UDouble b) sequenceA :: Applicative f => UDouble (f a) -> f (UDouble a) | |||||
| Functor (URec Double :: Type -> Type) | |||||
| Generic (URec Double p) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Show (URec Double p) | |||||
| Eq (URec Double p) | |||||
| Ord (URec Double p) | |||||
Defined in GHC.Internal.Generics Methods compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # | |||||
| type Difference Double | |||||
Defined in Basement.Numerical.Subtractive | |||||
| type PrimSize Double | |||||
Defined in Basement.PrimType | |||||
| data URec Double (p :: k) | |||||
Defined in GHC.Internal.Generics | |||||
| type Rep1 (URec Double :: k -> Type) | |||||
Defined in GHC.Internal.Generics | |||||
| type Rep (URec Double p) | |||||
Defined in GHC.Internal.Generics | |||||
Instances
| From Word (CountOf ty) | |||||
Defined in Basement.From | |||||
| TryFrom Int (CountOf ty) | |||||
Defined in Basement.From | |||||
| Integral (CountOf ty) | |||||
Defined in Basement.Types.OffsetSize Methods fromInteger :: Integer -> CountOf ty # | |||||
| NormalForm (CountOf a) | |||||
Defined in Basement.NormalForm Methods toNormalForm :: CountOf a -> () # | |||||
| Additive (CountOf ty) | |||||
| IsIntegral (CountOf ty) | |||||
Defined in Basement.Types.OffsetSize | |||||
| IsNatural (CountOf ty) | |||||
Defined in Basement.Types.OffsetSize | |||||
| Subtractive (CountOf ty) | |||||
Defined in Basement.Types.OffsetSize Associated Types
| |||||
| Arbitrary (CountOf ty) Source # | |||||
| IsField (CountOf a) Source # | |||||
| Monoid (CountOf ty) | |||||
| Semigroup (CountOf ty) | |||||
| Enum (CountOf ty) | |||||
Defined in Basement.Types.OffsetSize Methods succ :: CountOf ty -> CountOf ty # pred :: CountOf ty -> CountOf ty # fromEnum :: CountOf ty -> Int # enumFrom :: CountOf ty -> [CountOf ty] # enumFromThen :: CountOf ty -> CountOf ty -> [CountOf ty] # enumFromTo :: CountOf ty -> CountOf ty -> [CountOf ty] # enumFromThenTo :: CountOf ty -> CountOf ty -> CountOf ty -> [CountOf ty] # | |||||
| Num (CountOf ty) | |||||
Defined in Basement.Types.OffsetSize | |||||
| Show (CountOf ty) | |||||
| Eq (CountOf ty) | |||||
| Ord (CountOf ty) | |||||
Defined in Basement.Types.OffsetSize | |||||
| From (CountOf ty) Int | |||||
Defined in Basement.From | |||||
| From (CountOf ty) Word | |||||
Defined in Basement.From | |||||
| type NatNumMaxBound (CountOf x) | |||||
Defined in Basement.Types.OffsetSize | |||||
| type Difference (CountOf ty) | |||||
Defined in Basement.Types.OffsetSize | |||||
Instances
| From Word (Offset ty) | |||||
Defined in Basement.From | |||||
| TryFrom Int (Offset ty) | |||||
Defined in Basement.From | |||||
| Integral (Offset ty) | |||||
Defined in Basement.Types.OffsetSize Methods fromInteger :: Integer -> Offset ty # | |||||
| NormalForm (Offset a) | |||||
Defined in Basement.NormalForm Methods toNormalForm :: Offset a -> () # | |||||
| Additive (Offset ty) | |||||
| IsIntegral (Offset ty) | |||||
Defined in Basement.Types.OffsetSize | |||||
| IsNatural (Offset ty) | |||||
Defined in Basement.Types.OffsetSize | |||||
| Subtractive (Offset ty) | |||||
Defined in Basement.Types.OffsetSize Associated Types
| |||||
| IsField (Offset a) Source # | |||||
| Enum (Offset ty) | |||||
Defined in Basement.Types.OffsetSize Methods succ :: Offset ty -> Offset ty # pred :: Offset ty -> Offset ty # fromEnum :: Offset ty -> Int # enumFrom :: Offset ty -> [Offset ty] # enumFromThen :: Offset ty -> Offset ty -> [Offset ty] # enumFromTo :: Offset ty -> Offset ty -> [Offset ty] # enumFromThenTo :: Offset ty -> Offset ty -> Offset ty -> [Offset ty] # | |||||
| Num (Offset ty) | |||||
| Show (Offset ty) | |||||
| Eq (Offset ty) | |||||
| Ord (Offset ty) | |||||
| type NatNumMaxBound (Offset x) | |||||
Defined in Basement.Types.OffsetSize | |||||
| type Difference (Offset ty) | |||||
Defined in Basement.Types.OffsetSize | |||||
Collection types
Instances
| From AsciiString (UArray Word8) | |||||||||
Defined in Basement.From Methods from :: AsciiString -> UArray Word8 | |||||||||
| From String (UArray Word8) | |||||||||
Defined in Basement.From | |||||||||
| NormalForm (UArray ty) | |||||||||
Defined in Basement.UArray.Base Methods toNormalForm :: UArray ty -> () # | |||||||||
| PrimType ty => Buildable (UArray ty) Source # | |||||||||
Defined in Foundation.Collection.Buildable Associated Types
Methods append :: forall (prim :: Type -> Type) err. PrimMonad prim => Element (UArray ty) -> Builder (UArray ty) (Mutable (UArray ty)) (Step (UArray ty)) prim err () Source # build :: PrimMonad prim => Int -> Builder (UArray ty) (Mutable (UArray ty)) (Step (UArray ty)) prim err () -> prim (Either err (UArray ty)) Source # | |||||||||
| PrimType ty => Collection (UArray ty) Source # | |||||||||
Defined in Foundation.Collection.Collection Methods null :: UArray ty -> Bool Source # length :: UArray ty -> CountOf (Element (UArray ty)) Source # elem :: (Eq a, a ~ Element (UArray ty)) => Element (UArray ty) -> UArray ty -> Bool Source # notElem :: (Eq a, a ~ Element (UArray ty)) => Element (UArray ty) -> UArray ty -> Bool Source # maximum :: (Ord a, a ~ Element (UArray ty)) => NonEmpty (UArray ty) -> Element (UArray ty) Source # minimum :: (Ord a, a ~ Element (UArray ty)) => NonEmpty (UArray ty) -> Element (UArray ty) Source # any :: (Element (UArray ty) -> Bool) -> UArray ty -> Bool Source # all :: (Element (UArray ty) -> Bool) -> UArray ty -> Bool Source # | |||||||||
| PrimType ty => Copy (UArray ty) Source # | |||||||||
| PrimType ty => Fold1able (UArray ty) Source # | |||||||||
Defined in Foundation.Collection.Foldable | |||||||||
| PrimType ty => Foldable (UArray ty) Source # | |||||||||
| PrimType ty => IndexedCollection (UArray ty) Source # | |||||||||
| PrimType ty => InnerFunctor (UArray ty) Source # | |||||||||
| PrimType ty => Sequential (UArray ty) Source # | |||||||||
Defined in Foundation.Collection.Sequential Methods take :: CountOf (Element (UArray ty)) -> UArray ty -> UArray ty Source # revTake :: CountOf (Element (UArray ty)) -> UArray ty -> UArray ty Source # drop :: CountOf (Element (UArray ty)) -> UArray ty -> UArray ty Source # revDrop :: CountOf (Element (UArray ty)) -> UArray ty -> UArray ty Source # splitAt :: CountOf (Element (UArray ty)) -> UArray ty -> (UArray ty, UArray ty) Source # revSplitAt :: CountOf (Element (UArray ty)) -> UArray ty -> (UArray ty, UArray ty) Source # splitOn :: (Element (UArray ty) -> Bool) -> UArray ty -> [UArray ty] Source # break :: (Element (UArray ty) -> Bool) -> UArray ty -> (UArray ty, UArray ty) Source # breakEnd :: (Element (UArray ty) -> Bool) -> UArray ty -> (UArray ty, UArray ty) Source # breakElem :: Element (UArray ty) -> UArray ty -> (UArray ty, UArray ty) Source # takeWhile :: (Element (UArray ty) -> Bool) -> UArray ty -> UArray ty Source # dropWhile :: (Element (UArray ty) -> Bool) -> UArray ty -> UArray ty Source # intersperse :: Element (UArray ty) -> UArray ty -> UArray ty Source # intercalate :: Element (UArray ty) -> UArray ty -> Element (UArray ty) Source # span :: (Element (UArray ty) -> Bool) -> UArray ty -> (UArray ty, UArray ty) Source # spanEnd :: (Element (UArray ty) -> Bool) -> UArray ty -> (UArray ty, UArray ty) Source # filter :: (Element (UArray ty) -> Bool) -> UArray ty -> UArray ty Source # partition :: (Element (UArray ty) -> Bool) -> UArray ty -> (UArray ty, UArray ty) Source # reverse :: UArray ty -> UArray ty Source # uncons :: UArray ty -> Maybe (Element (UArray ty), UArray ty) Source # unsnoc :: UArray ty -> Maybe (UArray ty, Element (UArray ty)) Source # snoc :: UArray ty -> Element (UArray ty) -> UArray ty Source # cons :: Element (UArray ty) -> UArray ty -> UArray ty Source # find :: (Element (UArray ty) -> Bool) -> UArray ty -> Maybe (Element (UArray ty)) Source # sortBy :: (Element (UArray ty) -> Element (UArray ty) -> Ordering) -> UArray ty -> UArray ty Source # singleton :: Element (UArray ty) -> UArray ty Source # head :: NonEmpty (UArray ty) -> Element (UArray ty) Source # last :: NonEmpty (UArray ty) -> Element (UArray ty) Source # tail :: NonEmpty (UArray ty) -> UArray ty Source # init :: NonEmpty (UArray ty) -> UArray ty Source # replicate :: CountOf (Element (UArray ty)) -> Element (UArray ty) -> UArray ty Source # isPrefixOf :: UArray ty -> UArray ty -> Bool Source # isSuffixOf :: UArray ty -> UArray ty -> Bool Source # isInfixOf :: UArray ty -> UArray ty -> Bool Source # stripPrefix :: UArray ty -> UArray ty -> Maybe (UArray ty) Source # stripSuffix :: UArray ty -> UArray ty -> Maybe (UArray ty) Source # | |||||||||
| PrimType ty => Zippable (UArray ty) Source # | |||||||||
Defined in Foundation.Collection.Zippable Methods zipWith :: (Sequential a, Sequential b) => (Element a -> Element b -> Element (UArray ty)) -> a -> b -> UArray ty Source # zipWith3 :: (Sequential a, Sequential b, Sequential c) => (Element a -> Element b -> Element c -> Element (UArray ty)) -> a -> b -> c -> UArray ty Source # zipWith4 :: (Sequential a, Sequential b, Sequential c, Sequential d) => (Element a -> Element b -> Element c -> Element d -> Element (UArray ty)) -> a -> b -> c -> d -> UArray ty Source # zipWith5 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element (UArray ty)) -> a -> b -> c -> d -> e -> UArray ty Source # zipWith6 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element f -> Element (UArray ty)) -> a -> b -> c -> d -> e -> f -> UArray ty Source # zipWith7 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Sequential g) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element f -> Element g -> Element (UArray ty)) -> a -> b -> c -> d -> e -> f -> g -> UArray ty Source # | |||||||||
| PrimType a => Hashable (UArray a) Source # | |||||||||
| PrimType ty => Monoid (UArray ty) | |||||||||
| PrimType ty => Semigroup (UArray ty) | |||||||||
| Data ty => Data (UArray ty) | |||||||||
Defined in Basement.UArray.Base Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UArray ty -> c (UArray ty) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UArray ty) toConstr :: UArray ty -> Constr dataTypeOf :: UArray ty -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UArray ty)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UArray ty)) gmapT :: (forall b. Data b => b -> b) -> UArray ty -> UArray ty gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UArray ty -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UArray ty -> r gmapQ :: (forall d. Data d => d -> u) -> UArray ty -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> UArray ty -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> UArray ty -> m (UArray ty) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UArray ty -> m (UArray ty) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UArray ty -> m (UArray ty) | |||||||||
| PrimType ty => IsList (UArray ty) | |||||||||
| (PrimType ty, Show ty) => Show (UArray ty) | |||||||||
| (PrimType ty, Eq ty) => Eq (UArray ty) | |||||||||
| (PrimType ty, Ord ty) => Ord (UArray ty) | |||||||||
| TryFrom (UArray Word8) String | |||||||||
| PrimType ty => From (Block ty) (UArray ty) | |||||||||
Defined in Basement.From | |||||||||
| PrimType ty => From (Array ty) (UArray ty) | |||||||||
Defined in Basement.From | |||||||||
| PrimType ty => From (UArray ty) (Block ty) | |||||||||
Defined in Basement.From | |||||||||
| PrimType ty => From (UArray ty) (Array ty) | |||||||||
Defined in Basement.From | |||||||||
| (NatWithinBound (CountOf ty) n, KnownNat n, PrimType ty) => TryFrom (UArray ty) (BlockN n ty) | |||||||||
Defined in Basement.From | |||||||||
| (NatWithinBound Int n, PrimType ty) => From (BlockN n ty) (UArray ty) | |||||||||
Defined in Basement.From | |||||||||
| type Mutable (UArray ty) Source # | |||||||||
Defined in Foundation.Collection.Buildable | |||||||||
| type Step (UArray ty) Source # | |||||||||
Defined in Foundation.Collection.Buildable | |||||||||
| type Element (UArray ty) Source # | |||||||||
Defined in Foundation.Collection.Element | |||||||||
| type Item (UArray ty) | |||||||||
Defined in Basement.UArray.Base | |||||||||
Minimal complete definition
primSizeInBytes, primShiftToBytes, primBaUIndex, primMbaURead, primMbaUWrite, primAddrIndex, primAddrRead, primAddrWrite
Instances
| PrimType Char7 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Char7 -> CountOf Word8 # primShiftToBytes :: Proxy Char7 -> Int # primBaUIndex :: ByteArray# -> Offset Char7 -> Char7 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char7 -> prim Char7 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char7 -> Char7 -> prim () # primAddrIndex :: Addr# -> Offset Char7 -> Char7 # primAddrRead :: PrimMonad prim => Addr# -> Offset Char7 -> prim Char7 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Char7 -> Char7 -> prim () # | |||||
| PrimType Word128 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word128 -> CountOf Word8 # primShiftToBytes :: Proxy Word128 -> Int # primBaUIndex :: ByteArray# -> Offset Word128 -> Word128 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word128 -> prim Word128 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word128 -> Word128 -> prim () # primAddrIndex :: Addr# -> Offset Word128 -> Word128 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word128 -> prim Word128 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word128 -> Word128 -> prim () # | |||||
| PrimType Word256 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word256 -> CountOf Word8 # primShiftToBytes :: Proxy Word256 -> Int # primBaUIndex :: ByteArray# -> Offset Word256 -> Word256 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word256 -> prim Word256 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word256 -> Word256 -> prim () # primAddrIndex :: Addr# -> Offset Word256 -> Word256 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word256 -> prim Word256 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word256 -> Word256 -> prim () # | |||||
| PrimType NanoSeconds Source # | |||||
Defined in Foundation.Time.Types Associated Types
Methods primSizeInBytes :: Proxy NanoSeconds -> CountOf Word8 # primShiftToBytes :: Proxy NanoSeconds -> Int # primBaUIndex :: ByteArray# -> Offset NanoSeconds -> NanoSeconds # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset NanoSeconds -> prim NanoSeconds # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset NanoSeconds -> NanoSeconds -> prim () # primAddrIndex :: Addr# -> Offset NanoSeconds -> NanoSeconds # primAddrRead :: PrimMonad prim => Addr# -> Offset NanoSeconds -> prim NanoSeconds # primAddrWrite :: PrimMonad prim => Addr# -> Offset NanoSeconds -> NanoSeconds -> prim () # | |||||
| PrimType Seconds Source # | |||||
Defined in Foundation.Time.Types Associated Types
Methods primSizeInBytes :: Proxy Seconds -> CountOf Word8 # primShiftToBytes :: Proxy Seconds -> Int # primBaUIndex :: ByteArray# -> Offset Seconds -> Seconds # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Seconds -> prim Seconds # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Seconds -> Seconds -> prim () # primAddrIndex :: Addr# -> Offset Seconds -> Seconds # primAddrRead :: PrimMonad prim => Addr# -> Offset Seconds -> prim Seconds # primAddrWrite :: PrimMonad prim => Addr# -> Offset Seconds -> Seconds -> prim () # | |||||
| PrimType CChar | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy CChar -> CountOf Word8 # primShiftToBytes :: Proxy CChar -> Int # primBaUIndex :: ByteArray# -> Offset CChar -> CChar # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CChar -> prim CChar # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CChar -> CChar -> prim () # primAddrIndex :: Addr# -> Offset CChar -> CChar # primAddrRead :: PrimMonad prim => Addr# -> Offset CChar -> prim CChar # primAddrWrite :: PrimMonad prim => Addr# -> Offset CChar -> CChar -> prim () # | |||||
| PrimType CUChar | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy CUChar -> CountOf Word8 # primShiftToBytes :: Proxy CUChar -> Int # primBaUIndex :: ByteArray# -> Offset CUChar -> CUChar # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CUChar -> prim CUChar # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CUChar -> CUChar -> prim () # primAddrIndex :: Addr# -> Offset CUChar -> CUChar # primAddrRead :: PrimMonad prim => Addr# -> Offset CUChar -> prim CUChar # primAddrWrite :: PrimMonad prim => Addr# -> Offset CUChar -> CUChar -> prim () # | |||||
| PrimType Int16 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Int16 -> CountOf Word8 # primShiftToBytes :: Proxy Int16 -> Int # primBaUIndex :: ByteArray# -> Offset Int16 -> Int16 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int16 -> prim Int16 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int16 -> Int16 -> prim () # primAddrIndex :: Addr# -> Offset Int16 -> Int16 # primAddrRead :: PrimMonad prim => Addr# -> Offset Int16 -> prim Int16 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int16 -> Int16 -> prim () # | |||||
| PrimType Int32 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Int32 -> CountOf Word8 # primShiftToBytes :: Proxy Int32 -> Int # primBaUIndex :: ByteArray# -> Offset Int32 -> Int32 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int32 -> prim Int32 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int32 -> Int32 -> prim () # primAddrIndex :: Addr# -> Offset Int32 -> Int32 # primAddrRead :: PrimMonad prim => Addr# -> Offset Int32 -> prim Int32 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int32 -> Int32 -> prim () # | |||||
| PrimType Int64 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Int64 -> CountOf Word8 # primShiftToBytes :: Proxy Int64 -> Int # primBaUIndex :: ByteArray# -> Offset Int64 -> Int64 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int64 -> prim Int64 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int64 -> Int64 -> prim () # primAddrIndex :: Addr# -> Offset Int64 -> Int64 # primAddrRead :: PrimMonad prim => Addr# -> Offset Int64 -> prim Int64 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int64 -> Int64 -> prim () # | |||||
| PrimType Int8 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Int8 -> CountOf Word8 # primShiftToBytes :: Proxy Int8 -> Int # primBaUIndex :: ByteArray# -> Offset Int8 -> Int8 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int8 -> prim Int8 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int8 -> Int8 -> prim () # primAddrIndex :: Addr# -> Offset Int8 -> Int8 # primAddrRead :: PrimMonad prim => Addr# -> Offset Int8 -> prim Int8 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int8 -> Int8 -> prim () # | |||||
| PrimType Word16 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word16 -> CountOf Word8 # primShiftToBytes :: Proxy Word16 -> Int # primBaUIndex :: ByteArray# -> Offset Word16 -> Word16 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word16 -> prim Word16 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word16 -> Word16 -> prim () # primAddrIndex :: Addr# -> Offset Word16 -> Word16 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word16 -> prim Word16 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word16 -> Word16 -> prim () # | |||||
| PrimType Word32 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word32 -> CountOf Word8 # primShiftToBytes :: Proxy Word32 -> Int # primBaUIndex :: ByteArray# -> Offset Word32 -> Word32 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word32 -> prim Word32 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word32 -> Word32 -> prim () # primAddrIndex :: Addr# -> Offset Word32 -> Word32 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word32 -> prim Word32 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word32 -> Word32 -> prim () # | |||||
| PrimType Word64 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word64 -> CountOf Word8 # primShiftToBytes :: Proxy Word64 -> Int # primBaUIndex :: ByteArray# -> Offset Word64 -> Word64 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word64 -> prim Word64 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word64 -> Word64 -> prim () # primAddrIndex :: Addr# -> Offset Word64 -> Word64 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word64 -> prim Word64 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word64 -> Word64 -> prim () # | |||||
| PrimType Word8 | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word8 -> CountOf Word8 # primShiftToBytes :: Proxy Word8 -> Int # primBaUIndex :: ByteArray# -> Offset Word8 -> Word8 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word8 -> prim Word8 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word8 -> Word8 -> prim () # primAddrIndex :: Addr# -> Offset Word8 -> Word8 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word8 -> prim Word8 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word8 -> Word8 -> prim () # | |||||
| PrimType Char | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Char -> CountOf Word8 # primShiftToBytes :: Proxy Char -> Int # primBaUIndex :: ByteArray# -> Offset Char -> Char # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> prim Char # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> Char -> prim () # primAddrIndex :: Addr# -> Offset Char -> Char # primAddrRead :: PrimMonad prim => Addr# -> Offset Char -> prim Char # primAddrWrite :: PrimMonad prim => Addr# -> Offset Char -> Char -> prim () # | |||||
| PrimType Double | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Double -> CountOf Word8 # primShiftToBytes :: Proxy Double -> Int # primBaUIndex :: ByteArray# -> Offset Double -> Double # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Double -> prim Double # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Double -> Double -> prim () # primAddrIndex :: Addr# -> Offset Double -> Double # primAddrRead :: PrimMonad prim => Addr# -> Offset Double -> prim Double # primAddrWrite :: PrimMonad prim => Addr# -> Offset Double -> Double -> prim () # | |||||
| PrimType Float | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Float -> CountOf Word8 # primShiftToBytes :: Proxy Float -> Int # primBaUIndex :: ByteArray# -> Offset Float -> Float # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Float -> prim Float # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Float -> Float -> prim () # primAddrIndex :: Addr# -> Offset Float -> Float # primAddrRead :: PrimMonad prim => Addr# -> Offset Float -> prim Float # primAddrWrite :: PrimMonad prim => Addr# -> Offset Float -> Float -> prim () # | |||||
| PrimType Int | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Int -> CountOf Word8 # primShiftToBytes :: Proxy Int -> Int # primBaUIndex :: ByteArray# -> Offset Int -> Int # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int -> prim Int # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int -> Int -> prim () # primAddrIndex :: Addr# -> Offset Int -> Int # primAddrRead :: PrimMonad prim => Addr# -> Offset Int -> prim Int # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int -> Int -> prim () # | |||||
| PrimType Word | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy Word -> CountOf Word8 # primShiftToBytes :: Proxy Word -> Int # primBaUIndex :: ByteArray# -> Offset Word -> Word # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word -> prim Word # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word -> Word -> prim () # primAddrIndex :: Addr# -> Offset Word -> Word # primAddrRead :: PrimMonad prim => Addr# -> Offset Word -> prim Word # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word -> Word -> prim () # | |||||
| PrimType a => PrimType (BE a) | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy (BE a) -> CountOf Word8 # primShiftToBytes :: Proxy (BE a) -> Int # primBaUIndex :: ByteArray# -> Offset (BE a) -> BE a # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset (BE a) -> prim (BE a) # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset (BE a) -> BE a -> prim () # primAddrIndex :: Addr# -> Offset (BE a) -> BE a # primAddrRead :: PrimMonad prim => Addr# -> Offset (BE a) -> prim (BE a) # primAddrWrite :: PrimMonad prim => Addr# -> Offset (BE a) -> BE a -> prim () # | |||||
| PrimType a => PrimType (LE a) | |||||
Defined in Basement.PrimType Associated Types
Methods primSizeInBytes :: Proxy (LE a) -> CountOf Word8 # primShiftToBytes :: Proxy (LE a) -> Int # primBaUIndex :: ByteArray# -> Offset (LE a) -> LE a # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset (LE a) -> prim (LE a) # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset (LE a) -> LE a -> prim () # primAddrIndex :: Addr# -> Offset (LE a) -> LE a # primAddrRead :: PrimMonad prim => Addr# -> Offset (LE a) -> prim (LE a) # primAddrWrite :: PrimMonad prim => Addr# -> Offset (LE a) -> LE a -> prim () # | |||||
Instances
| Mappable Array Source # | |||||||||
Defined in Foundation.Collection.Mappable Methods traverse :: Applicative f => (a -> f b) -> Array a -> f (Array b) Source # sequenceA :: Applicative f => Array (f a) -> f (Array a) Source # mapM :: (Applicative m, Monad m) => (a -> m b) -> Array a -> m (Array b) Source # sequence :: (Applicative m, Monad m) => Array (m a) -> m (Array a) Source # | |||||||||
| Functor Array | |||||||||
| NormalForm a => NormalForm (Array a) | |||||||||
Defined in Basement.BoxedArray Methods toNormalForm :: Array a -> () # | |||||||||
| Buildable (Array ty) Source # | |||||||||
Defined in Foundation.Collection.Buildable Associated Types
Methods append :: forall (prim :: Type -> Type) err. PrimMonad prim => Element (Array ty) -> Builder (Array ty) (Mutable (Array ty)) (Step (Array ty)) prim err () Source # build :: PrimMonad prim => Int -> Builder (Array ty) (Mutable (Array ty)) (Step (Array ty)) prim err () -> prim (Either err (Array ty)) Source # | |||||||||
| Collection (Array ty) Source # | |||||||||
Defined in Foundation.Collection.Collection Methods null :: Array ty -> Bool Source # length :: Array ty -> CountOf (Element (Array ty)) Source # elem :: (Eq a, a ~ Element (Array ty)) => Element (Array ty) -> Array ty -> Bool Source # notElem :: (Eq a, a ~ Element (Array ty)) => Element (Array ty) -> Array ty -> Bool Source # maximum :: (Ord a, a ~ Element (Array ty)) => NonEmpty (Array ty) -> Element (Array ty) Source # minimum :: (Ord a, a ~ Element (Array ty)) => NonEmpty (Array ty) -> Element (Array ty) Source # any :: (Element (Array ty) -> Bool) -> Array ty -> Bool Source # all :: (Element (Array ty) -> Bool) -> Array ty -> Bool Source # | |||||||||
| Copy (Array ty) Source # | |||||||||
| Fold1able (Array ty) Source # | |||||||||
Defined in Foundation.Collection.Foldable | |||||||||
| Foldable (Array ty) Source # | |||||||||
| IndexedCollection (Array ty) Source # | |||||||||
| InnerFunctor (Array ty) Source # | |||||||||
| Sequential (Array ty) Source # | |||||||||
Defined in Foundation.Collection.Sequential Methods take :: CountOf (Element (Array ty)) -> Array ty -> Array ty Source # revTake :: CountOf (Element (Array ty)) -> Array ty -> Array ty Source # drop :: CountOf (Element (Array ty)) -> Array ty -> Array ty Source # revDrop :: CountOf (Element (Array ty)) -> Array ty -> Array ty Source # splitAt :: CountOf (Element (Array ty)) -> Array ty -> (Array ty, Array ty) Source # revSplitAt :: CountOf (Element (Array ty)) -> Array ty -> (Array ty, Array ty) Source # splitOn :: (Element (Array ty) -> Bool) -> Array ty -> [Array ty] Source # break :: (Element (Array ty) -> Bool) -> Array ty -> (Array ty, Array ty) Source # breakEnd :: (Element (Array ty) -> Bool) -> Array ty -> (Array ty, Array ty) Source # breakElem :: Element (Array ty) -> Array ty -> (Array ty, Array ty) Source # takeWhile :: (Element (Array ty) -> Bool) -> Array ty -> Array ty Source # dropWhile :: (Element (Array ty) -> Bool) -> Array ty -> Array ty Source # intersperse :: Element (Array ty) -> Array ty -> Array ty Source # intercalate :: Element (Array ty) -> Array ty -> Element (Array ty) Source # span :: (Element (Array ty) -> Bool) -> Array ty -> (Array ty, Array ty) Source # spanEnd :: (Element (Array ty) -> Bool) -> Array ty -> (Array ty, Array ty) Source # filter :: (Element (Array ty) -> Bool) -> Array ty -> Array ty Source # partition :: (Element (Array ty) -> Bool) -> Array ty -> (Array ty, Array ty) Source # reverse :: Array ty -> Array ty Source # uncons :: Array ty -> Maybe (Element (Array ty), Array ty) Source # unsnoc :: Array ty -> Maybe (Array ty, Element (Array ty)) Source # snoc :: Array ty -> Element (Array ty) -> Array ty Source # cons :: Element (Array ty) -> Array ty -> Array ty Source # find :: (Element (Array ty) -> Bool) -> Array ty -> Maybe (Element (Array ty)) Source # sortBy :: (Element (Array ty) -> Element (Array ty) -> Ordering) -> Array ty -> Array ty Source # singleton :: Element (Array ty) -> Array ty Source # head :: NonEmpty (Array ty) -> Element (Array ty) Source # last :: NonEmpty (Array ty) -> Element (Array ty) Source # tail :: NonEmpty (Array ty) -> Array ty Source # init :: NonEmpty (Array ty) -> Array ty Source # replicate :: CountOf (Element (Array ty)) -> Element (Array ty) -> Array ty Source # isPrefixOf :: Array ty -> Array ty -> Bool Source # isSuffixOf :: Array ty -> Array ty -> Bool Source # isInfixOf :: Array ty -> Array ty -> Bool Source # stripPrefix :: Array ty -> Array ty -> Maybe (Array ty) Source # stripSuffix :: Array ty -> Array ty -> Maybe (Array ty) Source # | |||||||||
| BoxedZippable (Array ty) Source # | |||||||||
Defined in Foundation.Collection.Zippable Methods zip :: (Sequential a, Sequential b, Element (Array ty) ~ (Element a, Element b)) => a -> b -> Array ty Source # zip3 :: (Sequential a, Sequential b, Sequential c, Element (Array ty) ~ (Element a, Element b, Element c)) => a -> b -> c -> Array ty Source # zip4 :: (Sequential a, Sequential b, Sequential c, Sequential d, Element (Array ty) ~ (Element a, Element b, Element c, Element d)) => a -> b -> c -> d -> Array ty Source # zip5 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Element (Array ty) ~ (Element a, Element b, Element c, Element d, Element e)) => a -> b -> c -> d -> e -> Array ty Source # zip6 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Element (Array ty) ~ (Element a, Element b, Element c, Element d, Element e, Element f)) => a -> b -> c -> d -> e -> f -> Array ty Source # zip7 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Sequential g, Element (Array ty) ~ (Element a, Element b, Element c, Element d, Element e, Element f, Element g)) => a -> b -> c -> d -> e -> f -> g -> Array ty Source # unzip :: (Sequential a, Sequential b, Element (Array ty) ~ (Element a, Element b)) => Array ty -> (a, b) Source # unzip3 :: (Sequential a, Sequential b, Sequential c, Element (Array ty) ~ (Element a, Element b, Element c)) => Array ty -> (a, b, c) Source # unzip4 :: (Sequential a, Sequential b, Sequential c, Sequential d, Element (Array ty) ~ (Element a, Element b, Element c, Element d)) => Array ty -> (a, b, c, d) Source # unzip5 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Element (Array ty) ~ (Element a, Element b, Element c, Element d, Element e)) => Array ty -> (a, b, c, d, e) Source # unzip6 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Element (Array ty) ~ (Element a, Element b, Element c, Element d, Element e, Element f)) => Array ty -> (a, b, c, d, e, f) Source # unzip7 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Sequential g, Element (Array ty) ~ (Element a, Element b, Element c, Element d, Element e, Element f, Element g)) => Array ty -> (a, b, c, d, e, f, g) Source # | |||||||||
| Zippable (Array ty) Source # | |||||||||
Defined in Foundation.Collection.Zippable Methods zipWith :: (Sequential a, Sequential b) => (Element a -> Element b -> Element (Array ty)) -> a -> b -> Array ty Source # zipWith3 :: (Sequential a, Sequential b, Sequential c) => (Element a -> Element b -> Element c -> Element (Array ty)) -> a -> b -> c -> Array ty Source # zipWith4 :: (Sequential a, Sequential b, Sequential c, Sequential d) => (Element a -> Element b -> Element c -> Element d -> Element (Array ty)) -> a -> b -> c -> d -> Array ty Source # zipWith5 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element (Array ty)) -> a -> b -> c -> d -> e -> Array ty Source # zipWith6 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element f -> Element (Array ty)) -> a -> b -> c -> d -> e -> f -> Array ty Source # zipWith7 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Sequential g) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element f -> Element g -> Element (Array ty)) -> a -> b -> c -> d -> e -> f -> g -> Array ty Source # | |||||||||
| Hashable a => Hashable (Array a) Source # | |||||||||
| Monoid (Array a) | |||||||||
| Semigroup (Array a) | |||||||||
| Data ty => Data (Array ty) | |||||||||
Defined in Basement.BoxedArray Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Array ty -> c (Array ty) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Array ty) toConstr :: Array ty -> Constr dataTypeOf :: Array ty -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Array ty)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array ty)) gmapT :: (forall b. Data b => b -> b) -> Array ty -> Array ty gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Array ty -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Array ty -> r gmapQ :: (forall d. Data d => d -> u) -> Array ty -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Array ty -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Array ty -> m (Array ty) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Array ty -> m (Array ty) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Array ty -> m (Array ty) | |||||||||
| IsList (Array ty) | |||||||||
| Show a => Show (Array a) | |||||||||
| Eq a => Eq (Array a) | |||||||||
| Ord a => Ord (Array a) | |||||||||
| PrimType ty => From (Array ty) (Block ty) | |||||||||
Defined in Basement.From | |||||||||
| PrimType ty => From (Array ty) (UArray ty) | |||||||||
Defined in Basement.From | |||||||||
| PrimType ty => From (UArray ty) (Array ty) | |||||||||
Defined in Basement.From | |||||||||
| (NatWithinBound (CountOf ty) n, KnownNat n, PrimType ty) => TryFrom (Array ty) (BlockN n ty) | |||||||||
Defined in Basement.From | |||||||||
| (NatWithinBound Int n, PrimType ty) => From (BlockN n ty) (Array ty) | |||||||||
Defined in Basement.From | |||||||||
| type Mutable (Array ty) Source # | |||||||||
Defined in Foundation.Collection.Buildable | |||||||||
| type Step (Array ty) Source # | |||||||||
Defined in Foundation.Collection.Buildable | |||||||||
| type Element (Array ty) Source # | |||||||||
Defined in Foundation.Collection.Element | |||||||||
| type Item (Array ty) | |||||||||
Defined in Basement.BoxedArray | |||||||||
Instances
| NormalForm String | |||||||||
Defined in Basement.UTF8.Base Methods toNormalForm :: String -> () # | |||||||||
| Arbitrary String Source # | |||||||||
| Buildable String Source # | |||||||||
Defined in Foundation.Collection.Buildable Associated Types
| |||||||||
| Collection String Source # | |||||||||
Defined in Foundation.Collection.Collection Methods null :: String -> Bool Source # length :: String -> CountOf (Element String) Source # elem :: (Eq a, a ~ Element String) => Element String -> String -> Bool Source # notElem :: (Eq a, a ~ Element String) => Element String -> String -> Bool Source # maximum :: (Ord a, a ~ Element String) => NonEmpty String -> Element String Source # minimum :: (Ord a, a ~ Element String) => NonEmpty String -> Element String Source # | |||||||||
| Copy String Source # | |||||||||
| IndexedCollection String Source # | |||||||||
| InnerFunctor String Source # | |||||||||
| Sequential String Source # | |||||||||
Defined in Foundation.Collection.Sequential Methods take :: CountOf (Element String) -> String -> String Source # revTake :: CountOf (Element String) -> String -> String Source # drop :: CountOf (Element String) -> String -> String Source # revDrop :: CountOf (Element String) -> String -> String Source # splitAt :: CountOf (Element String) -> String -> (String, String) Source # revSplitAt :: CountOf (Element String) -> String -> (String, String) Source # splitOn :: (Element String -> Bool) -> String -> [String] Source # break :: (Element String -> Bool) -> String -> (String, String) Source # breakEnd :: (Element String -> Bool) -> String -> (String, String) Source # breakElem :: Element String -> String -> (String, String) Source # takeWhile :: (Element String -> Bool) -> String -> String Source # dropWhile :: (Element String -> Bool) -> String -> String Source # intersperse :: Element String -> String -> String Source # intercalate :: Element String -> String -> Element String Source # span :: (Element String -> Bool) -> String -> (String, String) Source # spanEnd :: (Element String -> Bool) -> String -> (String, String) Source # filter :: (Element String -> Bool) -> String -> String Source # partition :: (Element String -> Bool) -> String -> (String, String) Source # reverse :: String -> String Source # uncons :: String -> Maybe (Element String, String) Source # unsnoc :: String -> Maybe (String, Element String) Source # snoc :: String -> Element String -> String Source # cons :: Element String -> String -> String Source # find :: (Element String -> Bool) -> String -> Maybe (Element String) Source # sortBy :: (Element String -> Element String -> Ordering) -> String -> String Source # singleton :: Element String -> String Source # head :: NonEmpty String -> Element String Source # last :: NonEmpty String -> Element String Source # tail :: NonEmpty String -> String Source # init :: NonEmpty String -> String Source # replicate :: CountOf (Element String) -> Element String -> String Source # isPrefixOf :: String -> String -> Bool Source # isSuffixOf :: String -> String -> Bool Source # isInfixOf :: String -> String -> Bool Source # | |||||||||
| Zippable String Source # | |||||||||
Defined in Foundation.Collection.Zippable Methods zipWith :: (Sequential a, Sequential b) => (Element a -> Element b -> Element String) -> a -> b -> String Source # zipWith3 :: (Sequential a, Sequential b, Sequential c) => (Element a -> Element b -> Element c -> Element String) -> a -> b -> c -> String Source # zipWith4 :: (Sequential a, Sequential b, Sequential c, Sequential d) => (Element a -> Element b -> Element c -> Element d -> Element String) -> a -> b -> c -> d -> String Source # zipWith5 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element String) -> a -> b -> c -> d -> e -> String Source # zipWith6 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element f -> Element String) -> a -> b -> c -> d -> e -> f -> String Source # zipWith7 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Sequential g) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element f -> Element g -> Element String) -> a -> b -> c -> d -> e -> f -> g -> String Source # | |||||||||
| IsField String Source # | |||||||||
| Hashable String Source # | |||||||||
| ParserSource String Source # | |||||||||
Defined in Foundation.Parser Methods nullChunk :: String -> Chunk String -> Bool Source # appendChunk :: String -> Chunk String -> String Source # subChunk :: String -> Offset (Element String) -> CountOf (Element String) -> Chunk String Source # spanChunk :: String -> Offset (Element String) -> (Element String -> Bool) -> (Chunk String, Offset (Element String)) Source # | |||||||||
| Monoid String | |||||||||
| Semigroup String | |||||||||
| Data String | |||||||||
Defined in Basement.UTF8.Base Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> String -> c String gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c String dataTypeOf :: String -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c String) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c String) gmapT :: (forall b. Data b => b -> b) -> String -> String gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> String -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> String -> r gmapQ :: (forall d. Data d => d -> u) -> String -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> String -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> String -> m String gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> String -> m String gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> String -> m String | |||||||||
| IsString String | |||||||||
Defined in Basement.UTF8.Base Methods fromString :: String -> String # | |||||||||
| IsList String | |||||||||
| Show String | |||||||||
| Eq String | |||||||||
| Ord String | |||||||||
| From AsciiString String | |||||||||
Defined in Basement.From Methods from :: AsciiString -> String | |||||||||
| From String (UArray Word8) | |||||||||
Defined in Basement.From | |||||||||
| Show (ParseError String) Source # | |||||||||
Defined in Foundation.Parser Methods showsPrec :: Int -> ParseError String -> ShowS show :: ParseError String -> String showList :: [ParseError String] -> ShowS | |||||||||
| TryFrom (UArray Word8) String | |||||||||
| IsProperty (String, Bool) Source # | |||||||||
| type Mutable String Source # | |||||||||
Defined in Foundation.Collection.Buildable | |||||||||
| type Step String Source # | |||||||||
Defined in Foundation.Collection.Buildable | |||||||||
| type Element String Source # | |||||||||
Defined in Foundation.Collection.Element | |||||||||
| type Chunk String Source # | |||||||||
Defined in Foundation.Parser | |||||||||
| type Item String | |||||||||
Defined in Basement.UTF8.Base | |||||||||
Numeric functions
fromIntegral :: (Integral a, Num b) => a -> b #
realToFrac :: (Real a, Fractional b) => a -> b #
Monoids
Minimal complete definition
(<>) | sconcat
Instances
| Semigroup ByteArray | |
Defined in Data.Array.Byte | |
| Semigroup Builder | |
Defined in Basement.Block.Builder | |
| Semigroup Builder | |
| Semigroup AsciiString | |
Defined in Basement.Types.AsciiString Methods (<>) :: AsciiString -> AsciiString -> AsciiString # sconcat :: NonEmpty AsciiString -> AsciiString stimes :: Integral b => b -> AsciiString -> AsciiString | |
| Semigroup String | |
| Semigroup Bitmap Source # | |
| Semigroup CSV Source # | |
| Semigroup Row Source # | |
| Semigroup FileName Source # | |
| Semigroup Void | |
Defined in GHC.Internal.Base | |
| Semigroup All | |
Defined in GHC.Internal.Data.Semigroup.Internal | |
| Semigroup Any | |
Defined in GHC.Internal.Data.Semigroup.Internal | |
| Semigroup ExceptionContext | |
Defined in GHC.Internal.Exception.Context | |
| Semigroup Ordering | |
| Semigroup () | |
Defined in GHC.Internal.Base | |
| Semigroup (FromMaybe b) | |
Defined in Data.Foldable1 | |
| Semigroup a => Semigroup (JoinWith a) | |
Defined in Data.Foldable1 | |
| Semigroup (NonEmptyDList a) | |
Defined in Data.Foldable1 | |
| Semigroup (Comparison a) | |
Defined in Data.Functor.Contravariant | |
| Semigroup (Equivalence a) | |
Defined in Data.Functor.Contravariant | |
| Semigroup (Predicate a) | |
Defined in Data.Functor.Contravariant | |
| Semigroup (First a) | |
Defined in Data.Semigroup | |
| Semigroup (Last a) | |
Defined in Data.Semigroup | |
| Ord a => Semigroup (Max a) | |
Defined in Data.Semigroup | |
| Ord a => Semigroup (Min a) | |
Defined in Data.Semigroup | |
| Monoid m => Semigroup (WrappedMonoid m) | |
Defined in Data.Semigroup | |
| PrimType ty => Semigroup (Block ty) | |
| Semigroup (Array a) | |
| Semigroup (CountOf ty) | |
| PrimType ty => Semigroup (UArray ty) | |
| Semigroup (ChunkedUArray a) Source # | |
Defined in Foundation.Array.Chunked.Unboxed Methods (<>) :: ChunkedUArray a -> ChunkedUArray a -> ChunkedUArray a # sconcat :: NonEmpty (ChunkedUArray a) -> ChunkedUArray a stimes :: Integral b => b -> ChunkedUArray a -> ChunkedUArray a | |
| Semigroup (DList a) Source # | |
| Semigroup (NonEmpty a) | |
Defined in GHC.Internal.Base | |
| Semigroup a => Semigroup (STM a) | |
Defined in GHC.Internal.Conc.Sync | |
| Semigroup a => Semigroup (Identity a) | |
| Semigroup (First a) | |
Defined in GHC.Internal.Data.Monoid | |
| Semigroup (Last a) | |
Defined in GHC.Internal.Data.Monoid | |
| Semigroup a => Semigroup (Dual a) | |
Defined in GHC.Internal.Data.Semigroup.Internal | |
| Semigroup (Endo a) | |
Defined in GHC.Internal.Data.Semigroup.Internal | |
| Num a => Semigroup (Product a) | |
Defined in GHC.Internal.Data.Semigroup.Internal | |
| Num a => Semigroup (Sum a) | |
Defined in GHC.Internal.Data.Semigroup.Internal | |
| (Generic a, Semigroup (Rep a ())) => Semigroup (Generically a) | |
Defined in GHC.Internal.Generics | |
| Semigroup p => Semigroup (Par1 p) | |
Defined in GHC.Internal.Generics | |
| Semigroup a => Semigroup (IO a) | |
| Semigroup a => Semigroup (Maybe a) | |
| Semigroup a => Semigroup (Solo a) | |
Defined in GHC.Internal.Base | |
| Semigroup [a] | |
Defined in GHC.Internal.Base | |
| Semigroup a => Semigroup (Op a b) | |
Defined in Data.Functor.Contravariant | |
| Semigroup (Either a b) | |
| Semigroup (Proxy s) | |
| Semigroup (U1 p) | |
Defined in GHC.Internal.Generics | |
| Semigroup (V1 p) | |
Defined in GHC.Internal.Generics | |
| Semigroup a => Semigroup (ST s a) | |
Defined in GHC.Internal.ST | |
| (Semigroup a, Semigroup b) => Semigroup (a, b) | |
Defined in GHC.Internal.Base | |
| Semigroup b => Semigroup (a -> b) | |
Defined in GHC.Internal.Base | |
| Semigroup a => Semigroup (Const a b) | |
Defined in GHC.Internal.Data.Functor.Const | |
| (Applicative f, Semigroup a) => Semigroup (Ap f a) | |
Defined in GHC.Internal.Data.Monoid | |
| Alternative f => Semigroup (Alt f a) | |
Defined in GHC.Internal.Data.Semigroup.Internal | |
| Semigroup (f p) => Semigroup (Rec1 f p) | |
Defined in GHC.Internal.Generics | |
| (Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c) | |
Defined in GHC.Internal.Base | |
| (Semigroup (f a), Semigroup (g a)) => Semigroup (Product f g a) | |
Defined in Data.Functor.Product | |
| (Semigroup (f p), Semigroup (g p)) => Semigroup ((f :*: g) p) | |
Defined in GHC.Internal.Generics | |
| Semigroup c => Semigroup (K1 i c p) | |
Defined in GHC.Internal.Generics | |
| (Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d) | |
Defined in GHC.Internal.Base | |
| Semigroup (f (g a)) => Semigroup (Compose f g a) | |
Defined in Data.Functor.Compose | |
| Semigroup (f (g p)) => Semigroup ((f :.: g) p) | |
Defined in GHC.Internal.Generics | |
| Semigroup (f p) => Semigroup (M1 i c f p) | |
Defined in GHC.Internal.Generics | |
| (Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e) | |
Defined in GHC.Internal.Base | |
class Semigroup a => Monoid a where #
Instances
| Monoid ByteArray | |
| Monoid Builder | |
| Monoid Builder | |
| Monoid AsciiString | |
Defined in Basement.Types.AsciiString Methods mempty :: AsciiString # mappend :: AsciiString -> AsciiString -> AsciiString # mconcat :: [AsciiString] -> AsciiString # | |
| Monoid String | |
| Monoid Bitmap Source # | |
| Monoid CSV Source # | |
| Monoid Row Source # | |
| Monoid FileName Source # | |
| Monoid All | |
| Monoid Any | |
| Monoid ExceptionContext | |
| Monoid Ordering | |
| Monoid () | |
| Monoid (Comparison a) | |
| Monoid (Equivalence a) | |
| Monoid (Predicate a) | |
| (Ord a, Bounded a) => Monoid (Max a) | |
| (Ord a, Bounded a) => Monoid (Min a) | |
| Monoid m => Monoid (WrappedMonoid m) | |
| PrimType ty => Monoid (Block ty) | |
| Monoid (Array a) | |
| Monoid (CountOf ty) | |
| PrimType ty => Monoid (UArray ty) | |
| Monoid (ChunkedUArray a) Source # | |
Defined in Foundation.Array.Chunked.Unboxed Methods mempty :: ChunkedUArray a # mappend :: ChunkedUArray a -> ChunkedUArray a -> ChunkedUArray a # mconcat :: [ChunkedUArray a] -> ChunkedUArray a # | |
| Monoid (DList a) Source # | |
| Monoid a => Monoid (STM a) | |
| Monoid a => Monoid (Identity a) | |
| Monoid (First a) | |
| Monoid (Last a) | |
| Monoid a => Monoid (Dual a) | |
| Monoid (Endo a) | |
| Num a => Monoid (Product a) | |
| Num a => Monoid (Sum a) | |
| (Generic a, Monoid (Rep a ())) => Monoid (Generically a) | |
| Monoid p => Monoid (Par1 p) | |
| Monoid a => Monoid (IO a) | |
| Semigroup a => Monoid (Maybe a) | |
| Monoid a => Monoid (Solo a) | |
| Monoid [a] | |
| Monoid a => Monoid (Op a b) | |
| Monoid (Proxy s) | |
| Monoid (U1 p) | |
| Monoid a => Monoid (ST s a) | |
| (Monoid a, Monoid b) => Monoid (a, b) | |
| Monoid b => Monoid (a -> b) | |
| Monoid a => Monoid (Const a b) | |
| (Applicative f, Monoid a) => Monoid (Ap f a) | |
| Alternative f => Monoid (Alt f a) | |
| Monoid (f p) => Monoid (Rec1 f p) | |
| (Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) | |
| (Monoid (f a), Monoid (g a)) => Monoid (Product f g a) | |
| (Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) | |
| Monoid c => Monoid (K1 i c p) | |
| (Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) | |
| Monoid (f (g a)) => Monoid (Compose f g a) | |
| Monoid (f (g p)) => Monoid ((f :.: g) p) | |
| Monoid (f p) => Monoid (M1 i c f p) | |
| (Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) | |
Collection
class (IsList c, Item c ~ Element c) => Collection c where Source #
A set of methods for ordered colection
Methods
Check if a collection is empty
length :: c -> CountOf (Element c) Source #
Length of a collection (number of Element c)
elem :: (Eq a, a ~ Element c) => Element c -> c -> Bool Source #
Check if a collection contains a specific element
This is the inverse of notElem.
notElem :: (Eq a, a ~ Element c) => Element c -> c -> Bool Source #
Check if a collection does *not* contain a specific element
This is the inverse of elem.
maximum :: (Ord a, a ~ Element c) => NonEmpty c -> Element c Source #
Get the maximum element of a collection
minimum :: (Ord a, a ~ Element c) => NonEmpty c -> Element c Source #
Get the minimum element of a collection
any :: (Element c -> Bool) -> c -> Bool Source #
Determine is any elements of the collection satisfy the predicate
all :: (Element c -> Bool) -> c -> Bool Source #
Determine is all elements of the collection satisfy the predicate
Instances
| Collection AsciiString Source # | |
Defined in Foundation.Collection.Collection Methods null :: AsciiString -> Bool Source # length :: AsciiString -> CountOf (Element AsciiString) Source # elem :: (Eq a, a ~ Element AsciiString) => Element AsciiString -> AsciiString -> Bool Source # notElem :: (Eq a, a ~ Element AsciiString) => Element AsciiString -> AsciiString -> Bool Source # maximum :: (Ord a, a ~ Element AsciiString) => NonEmpty AsciiString -> Element AsciiString Source # minimum :: (Ord a, a ~ Element AsciiString) => NonEmpty AsciiString -> Element AsciiString Source # any :: (Element AsciiString -> Bool) -> AsciiString -> Bool Source # all :: (Element AsciiString -> Bool) -> AsciiString -> Bool Source # | |
| Collection String Source # | |
Defined in Foundation.Collection.Collection Methods null :: String -> Bool Source # length :: String -> CountOf (Element String) Source # elem :: (Eq a, a ~ Element String) => Element String -> String -> Bool Source # notElem :: (Eq a, a ~ Element String) => Element String -> String -> Bool Source # maximum :: (Ord a, a ~ Element String) => NonEmpty String -> Element String Source # minimum :: (Ord a, a ~ Element String) => NonEmpty String -> Element String Source # | |
| Collection Bitmap Source # | |
Defined in Foundation.Array.Bitmap Methods null :: Bitmap -> Bool Source # length :: Bitmap -> CountOf (Element Bitmap) Source # elem :: (Eq a, a ~ Element Bitmap) => Element Bitmap -> Bitmap -> Bool Source # notElem :: (Eq a, a ~ Element Bitmap) => Element Bitmap -> Bitmap -> Bool Source # maximum :: (Ord a, a ~ Element Bitmap) => NonEmpty Bitmap -> Element Bitmap Source # minimum :: (Ord a, a ~ Element Bitmap) => NonEmpty Bitmap -> Element Bitmap Source # | |
| Collection CSV Source # | |
Defined in Foundation.Format.CSV.Types Methods length :: CSV -> CountOf (Element CSV) Source # elem :: (Eq a, a ~ Element CSV) => Element CSV -> CSV -> Bool Source # notElem :: (Eq a, a ~ Element CSV) => Element CSV -> CSV -> Bool Source # maximum :: (Ord a, a ~ Element CSV) => NonEmpty CSV -> Element CSV Source # minimum :: (Ord a, a ~ Element CSV) => NonEmpty CSV -> Element CSV Source # | |
| Collection Row Source # | |
Defined in Foundation.Format.CSV.Types Methods length :: Row -> CountOf (Element Row) Source # elem :: (Eq a, a ~ Element Row) => Element Row -> Row -> Bool Source # notElem :: (Eq a, a ~ Element Row) => Element Row -> Row -> Bool Source # maximum :: (Ord a, a ~ Element Row) => NonEmpty Row -> Element Row Source # minimum :: (Ord a, a ~ Element Row) => NonEmpty Row -> Element Row Source # | |
| PrimType ty => Collection (Block ty) Source # | |
Defined in Foundation.Collection.Collection Methods null :: Block ty -> Bool Source # length :: Block ty -> CountOf (Element (Block ty)) Source # elem :: (Eq a, a ~ Element (Block ty)) => Element (Block ty) -> Block ty -> Bool Source # notElem :: (Eq a, a ~ Element (Block ty)) => Element (Block ty) -> Block ty -> Bool Source # maximum :: (Ord a, a ~ Element (Block ty)) => NonEmpty (Block ty) -> Element (Block ty) Source # minimum :: (Ord a, a ~ Element (Block ty)) => NonEmpty (Block ty) -> Element (Block ty) Source # any :: (Element (Block ty) -> Bool) -> Block ty -> Bool Source # all :: (Element (Block ty) -> Bool) -> Block ty -> Bool Source # | |
| Collection (Array ty) Source # | |
Defined in Foundation.Collection.Collection Methods null :: Array ty -> Bool Source # length :: Array ty -> CountOf (Element (Array ty)) Source # elem :: (Eq a, a ~ Element (Array ty)) => Element (Array ty) -> Array ty -> Bool Source # notElem :: (Eq a, a ~ Element (Array ty)) => Element (Array ty) -> Array ty -> Bool Source # maximum :: (Ord a, a ~ Element (Array ty)) => NonEmpty (Array ty) -> Element (Array ty) Source # minimum :: (Ord a, a ~ Element (Array ty)) => NonEmpty (Array ty) -> Element (Array ty) Source # any :: (Element (Array ty) -> Bool) -> Array ty -> Bool Source # all :: (Element (Array ty) -> Bool) -> Array ty -> Bool Source # | |
| Collection c => Collection (NonEmpty c) Source # | |
Defined in Foundation.Collection.Collection Methods null :: NonEmpty c -> Bool Source # length :: NonEmpty c -> CountOf (Element (NonEmpty c)) Source # elem :: (Eq a, a ~ Element (NonEmpty c)) => Element (NonEmpty c) -> NonEmpty c -> Bool Source # notElem :: (Eq a, a ~ Element (NonEmpty c)) => Element (NonEmpty c) -> NonEmpty c -> Bool Source # maximum :: (Ord a, a ~ Element (NonEmpty c)) => NonEmpty (NonEmpty c) -> Element (NonEmpty c) Source # minimum :: (Ord a, a ~ Element (NonEmpty c)) => NonEmpty (NonEmpty c) -> Element (NonEmpty c) Source # any :: (Element (NonEmpty c) -> Bool) -> NonEmpty c -> Bool Source # all :: (Element (NonEmpty c) -> Bool) -> NonEmpty c -> Bool Source # | |
| PrimType ty => Collection (UArray ty) Source # | |
Defined in Foundation.Collection.Collection Methods null :: UArray ty -> Bool Source # length :: UArray ty -> CountOf (Element (UArray ty)) Source # elem :: (Eq a, a ~ Element (UArray ty)) => Element (UArray ty) -> UArray ty -> Bool Source # notElem :: (Eq a, a ~ Element (UArray ty)) => Element (UArray ty) -> UArray ty -> Bool Source # maximum :: (Ord a, a ~ Element (UArray ty)) => NonEmpty (UArray ty) -> Element (UArray ty) Source # minimum :: (Ord a, a ~ Element (UArray ty)) => NonEmpty (UArray ty) -> Element (UArray ty) Source # any :: (Element (UArray ty) -> Bool) -> UArray ty -> Bool Source # all :: (Element (UArray ty) -> Bool) -> UArray ty -> Bool Source # | |
| PrimType ty => Collection (ChunkedUArray ty) Source # | |
Defined in Foundation.Array.Chunked.Unboxed Methods null :: ChunkedUArray ty -> Bool Source # length :: ChunkedUArray ty -> CountOf (Element (ChunkedUArray ty)) Source # elem :: (Eq a, a ~ Element (ChunkedUArray ty)) => Element (ChunkedUArray ty) -> ChunkedUArray ty -> Bool Source # notElem :: (Eq a, a ~ Element (ChunkedUArray ty)) => Element (ChunkedUArray ty) -> ChunkedUArray ty -> Bool Source # maximum :: (Ord a, a ~ Element (ChunkedUArray ty)) => NonEmpty (ChunkedUArray ty) -> Element (ChunkedUArray ty) Source # minimum :: (Ord a, a ~ Element (ChunkedUArray ty)) => NonEmpty (ChunkedUArray ty) -> Element (ChunkedUArray ty) Source # any :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> Bool Source # all :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> Bool Source # | |
| Collection (DList a) Source # | |
Defined in Foundation.List.DList Methods null :: DList a -> Bool Source # length :: DList a -> CountOf (Element (DList a)) Source # elem :: (Eq a0, a0 ~ Element (DList a)) => Element (DList a) -> DList a -> Bool Source # notElem :: (Eq a0, a0 ~ Element (DList a)) => Element (DList a) -> DList a -> Bool Source # maximum :: (Ord a0, a0 ~ Element (DList a)) => NonEmpty (DList a) -> Element (DList a) Source # minimum :: (Ord a0, a0 ~ Element (DList a)) => NonEmpty (DList a) -> Element (DList a) Source # any :: (Element (DList a) -> Bool) -> DList a -> Bool Source # all :: (Element (DList a) -> Bool) -> DList a -> Bool Source # | |
| Collection [a] Source # | |
Defined in Foundation.Collection.Collection Methods length :: [a] -> CountOf (Element [a]) Source # elem :: (Eq a0, a0 ~ Element [a]) => Element [a] -> [a] -> Bool Source # notElem :: (Eq a0, a0 ~ Element [a]) => Element [a] -> [a] -> Bool Source # maximum :: (Ord a0, a0 ~ Element [a]) => NonEmpty [a] -> Element [a] Source # minimum :: (Ord a0, a0 ~ Element [a]) => NonEmpty [a] -> Element [a] Source # | |
and :: (Collection col, Element col ~ Bool) => col -> Bool Source #
Return True if all the elements in the collection are True
or :: (Collection col, Element col ~ Bool) => col -> Bool Source #
Return True if at least one element in the collection is True
class (IsList c, Item c ~ Element c, Monoid c, Collection c) => Sequential c where Source #
A set of methods for ordered colection
Minimal complete definition
(take, drop | splitAt), (revTake, revDrop | revSplitAt), splitOn, (break | span), (breakEnd | spanEnd), intersperse, filter, reverse, uncons, unsnoc, snoc, cons, find, sortBy, singleton, replicate
Methods
take :: CountOf (Element c) -> c -> c Source #
Take the first @n elements of a collection
revTake :: CountOf (Element c) -> c -> c Source #
Take the last @n elements of a collection
drop :: CountOf (Element c) -> c -> c Source #
Drop the first @n elements of a collection
revDrop :: CountOf (Element c) -> c -> c Source #
Drop the last @n elements of a collection
splitAt :: CountOf (Element c) -> c -> (c, c) Source #
Split the collection at the @n'th elements
revSplitAt :: CountOf (Element c) -> c -> (c, c) Source #
Split the collection at the @n'th elements from the end
splitOn :: (Element c -> Bool) -> c -> [c] Source #
Split on a specific elements returning a list of colletion
break :: (Element c -> Bool) -> c -> (c, c) Source #
Split a collection when the predicate return true
breakEnd :: (Element c -> Bool) -> c -> (c, c) Source #
Split a collection when the predicate return true starting from the end of the collection
breakElem :: Element c -> c -> (c, c) Source #
Split a collection at the given element
takeWhile :: (Element c -> Bool) -> c -> c Source #
Return the longest prefix in the collection that satisfy the predicate
dropWhile :: (Element c -> Bool) -> c -> c Source #
Return the longest prefix in the collection that satisfy the predicate
intersperse :: Element c -> c -> c Source #
The intersperse function takes an element and a list and
`intersperses' that element between the elements of the list.
For example,
intersperse ',' "abcde" == "a,b,c,d,e"
intercalate :: Element c -> c -> Element c Source #
intercalate xs xss is equivalent to (.
It inserts the list mconcat (intersperse xs xss))xs in between the lists in xss and concatenates the
result.
span :: (Element c -> Bool) -> c -> (c, c) Source #
Split a collection while the predicate return true
spanEnd :: (Element c -> Bool) -> c -> (c, c) Source #
Split a collection while the predicate return true starting from the end of the collection
filter :: (Element c -> Bool) -> c -> c Source #
Filter all the elements that satisfy the predicate
partition :: (Element c -> Bool) -> c -> (c, c) Source #
Partition the elements that satisfy the predicate and those that don't
Reverse a collection
uncons :: c -> Maybe (Element c, c) Source #
Decompose a collection into its first element and the remaining collection. If the collection is empty, returns Nothing.
unsnoc :: c -> Maybe (c, Element c) Source #
Decompose a collection into a collection without its last element, and the last element If the collection is empty, returns Nothing.
snoc :: c -> Element c -> c Source #
Prepend an element to an ordered collection
cons :: Element c -> c -> c Source #
Append an element to an ordered collection
find :: (Element c -> Bool) -> c -> Maybe (Element c) Source #
Find an element in an ordered collection
sortBy :: (Element c -> Element c -> Ordering) -> c -> c Source #
Sort an ordered collection using the specified order function
singleton :: Element c -> c Source #
Create a collection with a single element
head :: NonEmpty c -> Element c Source #
get the first element of a non-empty collection
last :: NonEmpty c -> Element c Source #
get the last element of a non-empty collection
tail :: NonEmpty c -> c Source #
Extract the elements after the first element of a non-empty collection.
init :: NonEmpty c -> c Source #
Extract the elements before the last element of a non-empty collection.
replicate :: CountOf (Element c) -> Element c -> c Source #
Create a collection where the element in parameter is repeated N time
isPrefixOf :: c -> c -> Bool Source #
Takes two collections and returns True iff the first collection is a prefix of the second.
default isPrefixOf :: Eq c => c -> c -> Bool Source #
isSuffixOf :: c -> c -> Bool Source #
Takes two collections and returns True iff the first collection is a suffix of the second.
default isSuffixOf :: Eq c => c -> c -> Bool Source #
isInfixOf :: c -> c -> Bool Source #
Takes two collections and returns True iff the first collection is an infix of the second.
stripPrefix :: c -> c -> Maybe c Source #
Try to strip a prefix from a collection
stripSuffix :: c -> c -> Maybe c Source #
Try to strip a suffix from a collection
Instances
| Sequential AsciiString Source # | |
Defined in Foundation.Collection.Sequential Methods take :: CountOf (Element AsciiString) -> AsciiString -> AsciiString Source # revTake :: CountOf (Element AsciiString) -> AsciiString -> AsciiString Source # drop :: CountOf (Element AsciiString) -> AsciiString -> AsciiString Source # revDrop :: CountOf (Element AsciiString) -> AsciiString -> AsciiString Source # splitAt :: CountOf (Element AsciiString) -> AsciiString -> (AsciiString, AsciiString) Source # revSplitAt :: CountOf (Element AsciiString) -> AsciiString -> (AsciiString, AsciiString) Source # splitOn :: (Element AsciiString -> Bool) -> AsciiString -> [AsciiString] Source # break :: (Element AsciiString -> Bool) -> AsciiString -> (AsciiString, AsciiString) Source # breakEnd :: (Element AsciiString -> Bool) -> AsciiString -> (AsciiString, AsciiString) Source # breakElem :: Element AsciiString -> AsciiString -> (AsciiString, AsciiString) Source # takeWhile :: (Element AsciiString -> Bool) -> AsciiString -> AsciiString Source # dropWhile :: (Element AsciiString -> Bool) -> AsciiString -> AsciiString Source # intersperse :: Element AsciiString -> AsciiString -> AsciiString Source # intercalate :: Element AsciiString -> AsciiString -> Element AsciiString Source # span :: (Element AsciiString -> Bool) -> AsciiString -> (AsciiString, AsciiString) Source # spanEnd :: (Element AsciiString -> Bool) -> AsciiString -> (AsciiString, AsciiString) Source # filter :: (Element AsciiString -> Bool) -> AsciiString -> AsciiString Source # partition :: (Element AsciiString -> Bool) -> AsciiString -> (AsciiString, AsciiString) Source # reverse :: AsciiString -> AsciiString Source # uncons :: AsciiString -> Maybe (Element AsciiString, AsciiString) Source # unsnoc :: AsciiString -> Maybe (AsciiString, Element AsciiString) Source # snoc :: AsciiString -> Element AsciiString -> AsciiString Source # cons :: Element AsciiString -> AsciiString -> AsciiString Source # find :: (Element AsciiString -> Bool) -> AsciiString -> Maybe (Element AsciiString) Source # sortBy :: (Element AsciiString -> Element AsciiString -> Ordering) -> AsciiString -> AsciiString Source # singleton :: Element AsciiString -> AsciiString Source # head :: NonEmpty AsciiString -> Element AsciiString Source # last :: NonEmpty AsciiString -> Element AsciiString Source # tail :: NonEmpty AsciiString -> AsciiString Source # init :: NonEmpty AsciiString -> AsciiString Source # replicate :: CountOf (Element AsciiString) -> Element AsciiString -> AsciiString Source # isPrefixOf :: AsciiString -> AsciiString -> Bool Source # isSuffixOf :: AsciiString -> AsciiString -> Bool Source # isInfixOf :: AsciiString -> AsciiString -> Bool Source # stripPrefix :: AsciiString -> AsciiString -> Maybe AsciiString Source # stripSuffix :: AsciiString -> AsciiString -> Maybe AsciiString Source # | |
| Sequential String Source # | |
Defined in Foundation.Collection.Sequential Methods take :: CountOf (Element String) -> String -> String Source # revTake :: CountOf (Element String) -> String -> String Source # drop :: CountOf (Element String) -> String -> String Source # revDrop :: CountOf (Element String) -> String -> String Source # splitAt :: CountOf (Element String) -> String -> (String, String) Source # revSplitAt :: CountOf (Element String) -> String -> (String, String) Source # splitOn :: (Element String -> Bool) -> String -> [String] Source # break :: (Element String -> Bool) -> String -> (String, String) Source # breakEnd :: (Element String -> Bool) -> String -> (String, String) Source # breakElem :: Element String -> String -> (String, String) Source # takeWhile :: (Element String -> Bool) -> String -> String Source # dropWhile :: (Element String -> Bool) -> String -> String Source # intersperse :: Element String -> String -> String Source # intercalate :: Element String -> String -> Element String Source # span :: (Element String -> Bool) -> String -> (String, String) Source # spanEnd :: (Element String -> Bool) -> String -> (String, String) Source # filter :: (Element String -> Bool) -> String -> String Source # partition :: (Element String -> Bool) -> String -> (String, String) Source # reverse :: String -> String Source # uncons :: String -> Maybe (Element String, String) Source # unsnoc :: String -> Maybe (String, Element String) Source # snoc :: String -> Element String -> String Source # cons :: Element String -> String -> String Source # find :: (Element String -> Bool) -> String -> Maybe (Element String) Source # sortBy :: (Element String -> Element String -> Ordering) -> String -> String Source # singleton :: Element String -> String Source # head :: NonEmpty String -> Element String Source # last :: NonEmpty String -> Element String Source # tail :: NonEmpty String -> String Source # init :: NonEmpty String -> String Source # replicate :: CountOf (Element String) -> Element String -> String Source # isPrefixOf :: String -> String -> Bool Source # isSuffixOf :: String -> String -> Bool Source # isInfixOf :: String -> String -> Bool Source # | |
| Sequential Bitmap Source # | |
Defined in Foundation.Array.Bitmap Methods take :: CountOf (Element Bitmap) -> Bitmap -> Bitmap Source # revTake :: CountOf (Element Bitmap) -> Bitmap -> Bitmap Source # drop :: CountOf (Element Bitmap) -> Bitmap -> Bitmap Source # revDrop :: CountOf (Element Bitmap) -> Bitmap -> Bitmap Source # splitAt :: CountOf (Element Bitmap) -> Bitmap -> (Bitmap, Bitmap) Source # revSplitAt :: CountOf (Element Bitmap) -> Bitmap -> (Bitmap, Bitmap) Source # splitOn :: (Element Bitmap -> Bool) -> Bitmap -> [Bitmap] Source # break :: (Element Bitmap -> Bool) -> Bitmap -> (Bitmap, Bitmap) Source # breakEnd :: (Element Bitmap -> Bool) -> Bitmap -> (Bitmap, Bitmap) Source # breakElem :: Element Bitmap -> Bitmap -> (Bitmap, Bitmap) Source # takeWhile :: (Element Bitmap -> Bool) -> Bitmap -> Bitmap Source # dropWhile :: (Element Bitmap -> Bool) -> Bitmap -> Bitmap Source # intersperse :: Element Bitmap -> Bitmap -> Bitmap Source # intercalate :: Element Bitmap -> Bitmap -> Element Bitmap Source # span :: (Element Bitmap -> Bool) -> Bitmap -> (Bitmap, Bitmap) Source # spanEnd :: (Element Bitmap -> Bool) -> Bitmap -> (Bitmap, Bitmap) Source # filter :: (Element Bitmap -> Bool) -> Bitmap -> Bitmap Source # partition :: (Element Bitmap -> Bool) -> Bitmap -> (Bitmap, Bitmap) Source # reverse :: Bitmap -> Bitmap Source # uncons :: Bitmap -> Maybe (Element Bitmap, Bitmap) Source # unsnoc :: Bitmap -> Maybe (Bitmap, Element Bitmap) Source # snoc :: Bitmap -> Element Bitmap -> Bitmap Source # cons :: Element Bitmap -> Bitmap -> Bitmap Source # find :: (Element Bitmap -> Bool) -> Bitmap -> Maybe (Element Bitmap) Source # sortBy :: (Element Bitmap -> Element Bitmap -> Ordering) -> Bitmap -> Bitmap Source # singleton :: Element Bitmap -> Bitmap Source # head :: NonEmpty Bitmap -> Element Bitmap Source # last :: NonEmpty Bitmap -> Element Bitmap Source # tail :: NonEmpty Bitmap -> Bitmap Source # init :: NonEmpty Bitmap -> Bitmap Source # replicate :: CountOf (Element Bitmap) -> Element Bitmap -> Bitmap Source # isPrefixOf :: Bitmap -> Bitmap -> Bool Source # isSuffixOf :: Bitmap -> Bitmap -> Bool Source # isInfixOf :: Bitmap -> Bitmap -> Bool Source # | |
| Sequential CSV Source # | |
Defined in Foundation.Format.CSV.Types Methods take :: CountOf (Element CSV) -> CSV -> CSV Source # revTake :: CountOf (Element CSV) -> CSV -> CSV Source # drop :: CountOf (Element CSV) -> CSV -> CSV Source # revDrop :: CountOf (Element CSV) -> CSV -> CSV Source # splitAt :: CountOf (Element CSV) -> CSV -> (CSV, CSV) Source # revSplitAt :: CountOf (Element CSV) -> CSV -> (CSV, CSV) Source # splitOn :: (Element CSV -> Bool) -> CSV -> [CSV] Source # break :: (Element CSV -> Bool) -> CSV -> (CSV, CSV) Source # breakEnd :: (Element CSV -> Bool) -> CSV -> (CSV, CSV) Source # breakElem :: Element CSV -> CSV -> (CSV, CSV) Source # takeWhile :: (Element CSV -> Bool) -> CSV -> CSV Source # dropWhile :: (Element CSV -> Bool) -> CSV -> CSV Source # intersperse :: Element CSV -> CSV -> CSV Source # intercalate :: Element CSV -> CSV -> Element CSV Source # span :: (Element CSV -> Bool) -> CSV -> (CSV, CSV) Source # spanEnd :: (Element CSV -> Bool) -> CSV -> (CSV, CSV) Source # filter :: (Element CSV -> Bool) -> CSV -> CSV Source # partition :: (Element CSV -> Bool) -> CSV -> (CSV, CSV) Source # reverse :: CSV -> CSV Source # uncons :: CSV -> Maybe (Element CSV, CSV) Source # unsnoc :: CSV -> Maybe (CSV, Element CSV) Source # snoc :: CSV -> Element CSV -> CSV Source # cons :: Element CSV -> CSV -> CSV Source # find :: (Element CSV -> Bool) -> CSV -> Maybe (Element CSV) Source # sortBy :: (Element CSV -> Element CSV -> Ordering) -> CSV -> CSV Source # singleton :: Element CSV -> CSV Source # head :: NonEmpty CSV -> Element CSV Source # last :: NonEmpty CSV -> Element CSV Source # tail :: NonEmpty CSV -> CSV Source # init :: NonEmpty CSV -> CSV Source # replicate :: CountOf (Element CSV) -> Element CSV -> CSV Source # isPrefixOf :: CSV -> CSV -> Bool Source # isSuffixOf :: CSV -> CSV -> Bool Source # isInfixOf :: CSV -> CSV -> Bool Source # | |
| Sequential Row Source # | |
Defined in Foundation.Format.CSV.Types Methods take :: CountOf (Element Row) -> Row -> Row Source # revTake :: CountOf (Element Row) -> Row -> Row Source # drop :: CountOf (Element Row) -> Row -> Row Source # revDrop :: CountOf (Element Row) -> Row -> Row Source # splitAt :: CountOf (Element Row) -> Row -> (Row, Row) Source # revSplitAt :: CountOf (Element Row) -> Row -> (Row, Row) Source # splitOn :: (Element Row -> Bool) -> Row -> [Row] Source # break :: (Element Row -> Bool) -> Row -> (Row, Row) Source # breakEnd :: (Element Row -> Bool) -> Row -> (Row, Row) Source # breakElem :: Element Row -> Row -> (Row, Row) Source # takeWhile :: (Element Row -> Bool) -> Row -> Row Source # dropWhile :: (Element Row -> Bool) -> Row -> Row Source # intersperse :: Element Row -> Row -> Row Source # intercalate :: Element Row -> Row -> Element Row Source # span :: (Element Row -> Bool) -> Row -> (Row, Row) Source # spanEnd :: (Element Row -> Bool) -> Row -> (Row, Row) Source # filter :: (Element Row -> Bool) -> Row -> Row Source # partition :: (Element Row -> Bool) -> Row -> (Row, Row) Source # reverse :: Row -> Row Source # uncons :: Row -> Maybe (Element Row, Row) Source # unsnoc :: Row -> Maybe (Row, Element Row) Source # snoc :: Row -> Element Row -> Row Source # cons :: Element Row -> Row -> Row Source # find :: (Element Row -> Bool) -> Row -> Maybe (Element Row) Source # sortBy :: (Element Row -> Element Row -> Ordering) -> Row -> Row Source # singleton :: Element Row -> Row Source # head :: NonEmpty Row -> Element Row Source # last :: NonEmpty Row -> Element Row Source # tail :: NonEmpty Row -> Row Source # init :: NonEmpty Row -> Row Source # replicate :: CountOf (Element Row) -> Element Row -> Row Source # isPrefixOf :: Row -> Row -> Bool Source # isSuffixOf :: Row -> Row -> Bool Source # isInfixOf :: Row -> Row -> Bool Source # | |
| PrimType ty => Sequential (Block ty) Source # | |
Defined in Foundation.Collection.Sequential Methods take :: CountOf (Element (Block ty)) -> Block ty -> Block ty Source # revTake :: CountOf (Element (Block ty)) -> Block ty -> Block ty Source # drop :: CountOf (Element (Block ty)) -> Block ty -> Block ty Source # revDrop :: CountOf (Element (Block ty)) -> Block ty -> Block ty Source # splitAt :: CountOf (Element (Block ty)) -> Block ty -> (Block ty, Block ty) Source # revSplitAt :: CountOf (Element (Block ty)) -> Block ty -> (Block ty, Block ty) Source # splitOn :: (Element (Block ty) -> Bool) -> Block ty -> [Block ty] Source # break :: (Element (Block ty) -> Bool) -> Block ty -> (Block ty, Block ty) Source # breakEnd :: (Element (Block ty) -> Bool) -> Block ty -> (Block ty, Block ty) Source # breakElem :: Element (Block ty) -> Block ty -> (Block ty, Block ty) Source # takeWhile :: (Element (Block ty) -> Bool) -> Block ty -> Block ty Source # dropWhile :: (Element (Block ty) -> Bool) -> Block ty -> Block ty Source # intersperse :: Element (Block ty) -> Block ty -> Block ty Source # intercalate :: Element (Block ty) -> Block ty -> Element (Block ty) Source # span :: (Element (Block ty) -> Bool) -> Block ty -> (Block ty, Block ty) Source # spanEnd :: (Element (Block ty) -> Bool) -> Block ty -> (Block ty, Block ty) Source # filter :: (Element (Block ty) -> Bool) -> Block ty -> Block ty Source # partition :: (Element (Block ty) -> Bool) -> Block ty -> (Block ty, Block ty) Source # reverse :: Block ty -> Block ty Source # uncons :: Block ty -> Maybe (Element (Block ty), Block ty) Source # unsnoc :: Block ty -> Maybe (Block ty, Element (Block ty)) Source # snoc :: Block ty -> Element (Block ty) -> Block ty Source # cons :: Element (Block ty) -> Block ty -> Block ty Source # find :: (Element (Block ty) -> Bool) -> Block ty -> Maybe (Element (Block ty)) Source # sortBy :: (Element (Block ty) -> Element (Block ty) -> Ordering) -> Block ty -> Block ty Source # singleton :: Element (Block ty) -> Block ty Source # head :: NonEmpty (Block ty) -> Element (Block ty) Source # last :: NonEmpty (Block ty) -> Element (Block ty) Source # tail :: NonEmpty (Block ty) -> Block ty Source # init :: NonEmpty (Block ty) -> Block ty Source # replicate :: CountOf (Element (Block ty)) -> Element (Block ty) -> Block ty Source # isPrefixOf :: Block ty -> Block ty -> Bool Source # isSuffixOf :: Block ty -> Block ty -> Bool Source # isInfixOf :: Block ty -> Block ty -> Bool Source # stripPrefix :: Block ty -> Block ty -> Maybe (Block ty) Source # stripSuffix :: Block ty -> Block ty -> Maybe (Block ty) Source # | |
| Sequential (Array ty) Source # | |
Defined in Foundation.Collection.Sequential Methods take :: CountOf (Element (Array ty)) -> Array ty -> Array ty Source # revTake :: CountOf (Element (Array ty)) -> Array ty -> Array ty Source # drop :: CountOf (Element (Array ty)) -> Array ty -> Array ty Source # revDrop :: CountOf (Element (Array ty)) -> Array ty -> Array ty Source # splitAt :: CountOf (Element (Array ty)) -> Array ty -> (Array ty, Array ty) Source # revSplitAt :: CountOf (Element (Array ty)) -> Array ty -> (Array ty, Array ty) Source # splitOn :: (Element (Array ty) -> Bool) -> Array ty -> [Array ty] Source # break :: (Element (Array ty) -> Bool) -> Array ty -> (Array ty, Array ty) Source # breakEnd :: (Element (Array ty) -> Bool) -> Array ty -> (Array ty, Array ty) Source # breakElem :: Element (Array ty) -> Array ty -> (Array ty, Array ty) Source # takeWhile :: (Element (Array ty) -> Bool) -> Array ty -> Array ty Source # dropWhile :: (Element (Array ty) -> Bool) -> Array ty -> Array ty Source # intersperse :: Element (Array ty) -> Array ty -> Array ty Source # intercalate :: Element (Array ty) -> Array ty -> Element (Array ty) Source # span :: (Element (Array ty) -> Bool) -> Array ty -> (Array ty, Array ty) Source # spanEnd :: (Element (Array ty) -> Bool) -> Array ty -> (Array ty, Array ty) Source # filter :: (Element (Array ty) -> Bool) -> Array ty -> Array ty Source # partition :: (Element (Array ty) -> Bool) -> Array ty -> (Array ty, Array ty) Source # reverse :: Array ty -> Array ty Source # uncons :: Array ty -> Maybe (Element (Array ty), Array ty) Source # unsnoc :: Array ty -> Maybe (Array ty, Element (Array ty)) Source # snoc :: Array ty -> Element (Array ty) -> Array ty Source # cons :: Element (Array ty) -> Array ty -> Array ty Source # find :: (Element (Array ty) -> Bool) -> Array ty -> Maybe (Element (Array ty)) Source # sortBy :: (Element (Array ty) -> Element (Array ty) -> Ordering) -> Array ty -> Array ty Source # singleton :: Element (Array ty) -> Array ty Source # head :: NonEmpty (Array ty) -> Element (Array ty) Source # last :: NonEmpty (Array ty) -> Element (Array ty) Source # tail :: NonEmpty (Array ty) -> Array ty Source # init :: NonEmpty (Array ty) -> Array ty Source # replicate :: CountOf (Element (Array ty)) -> Element (Array ty) -> Array ty Source # isPrefixOf :: Array ty -> Array ty -> Bool Source # isSuffixOf :: Array ty -> Array ty -> Bool Source # isInfixOf :: Array ty -> Array ty -> Bool Source # stripPrefix :: Array ty -> Array ty -> Maybe (Array ty) Source # stripSuffix :: Array ty -> Array ty -> Maybe (Array ty) Source # | |
| PrimType ty => Sequential (UArray ty) Source # | |
Defined in Foundation.Collection.Sequential Methods take :: CountOf (Element (UArray ty)) -> UArray ty -> UArray ty Source # revTake :: CountOf (Element (UArray ty)) -> UArray ty -> UArray ty Source # drop :: CountOf (Element (UArray ty)) -> UArray ty -> UArray ty Source # revDrop :: CountOf (Element (UArray ty)) -> UArray ty -> UArray ty Source # splitAt :: CountOf (Element (UArray ty)) -> UArray ty -> (UArray ty, UArray ty) Source # revSplitAt :: CountOf (Element (UArray ty)) -> UArray ty -> (UArray ty, UArray ty) Source # splitOn :: (Element (UArray ty) -> Bool) -> UArray ty -> [UArray ty] Source # break :: (Element (UArray ty) -> Bool) -> UArray ty -> (UArray ty, UArray ty) Source # breakEnd :: (Element (UArray ty) -> Bool) -> UArray ty -> (UArray ty, UArray ty) Source # breakElem :: Element (UArray ty) -> UArray ty -> (UArray ty, UArray ty) Source # takeWhile :: (Element (UArray ty) -> Bool) -> UArray ty -> UArray ty Source # dropWhile :: (Element (UArray ty) -> Bool) -> UArray ty -> UArray ty Source # intersperse :: Element (UArray ty) -> UArray ty -> UArray ty Source # intercalate :: Element (UArray ty) -> UArray ty -> Element (UArray ty) Source # span :: (Element (UArray ty) -> Bool) -> UArray ty -> (UArray ty, UArray ty) Source # spanEnd :: (Element (UArray ty) -> Bool) -> UArray ty -> (UArray ty, UArray ty) Source # filter :: (Element (UArray ty) -> Bool) -> UArray ty -> UArray ty Source # partition :: (Element (UArray ty) -> Bool) -> UArray ty -> (UArray ty, UArray ty) Source # reverse :: UArray ty -> UArray ty Source # uncons :: UArray ty -> Maybe (Element (UArray ty), UArray ty) Source # unsnoc :: UArray ty -> Maybe (UArray ty, Element (UArray ty)) Source # snoc :: UArray ty -> Element (UArray ty) -> UArray ty Source # cons :: Element (UArray ty) -> UArray ty -> UArray ty Source # find :: (Element (UArray ty) -> Bool) -> UArray ty -> Maybe (Element (UArray ty)) Source # sortBy :: (Element (UArray ty) -> Element (UArray ty) -> Ordering) -> UArray ty -> UArray ty Source # singleton :: Element (UArray ty) -> UArray ty Source # head :: NonEmpty (UArray ty) -> Element (UArray ty) Source # last :: NonEmpty (UArray ty) -> Element (UArray ty) Source # tail :: NonEmpty (UArray ty) -> UArray ty Source # init :: NonEmpty (UArray ty) -> UArray ty Source # replicate :: CountOf (Element (UArray ty)) -> Element (UArray ty) -> UArray ty Source # isPrefixOf :: UArray ty -> UArray ty -> Bool Source # isSuffixOf :: UArray ty -> UArray ty -> Bool Source # isInfixOf :: UArray ty -> UArray ty -> Bool Source # stripPrefix :: UArray ty -> UArray ty -> Maybe (UArray ty) Source # stripSuffix :: UArray ty -> UArray ty -> Maybe (UArray ty) Source # | |
| PrimType ty => Sequential (ChunkedUArray ty) Source # | |
Defined in Foundation.Array.Chunked.Unboxed Methods take :: CountOf (Element (ChunkedUArray ty)) -> ChunkedUArray ty -> ChunkedUArray ty Source # revTake :: CountOf (Element (ChunkedUArray ty)) -> ChunkedUArray ty -> ChunkedUArray ty Source # drop :: CountOf (Element (ChunkedUArray ty)) -> ChunkedUArray ty -> ChunkedUArray ty Source # revDrop :: CountOf (Element (ChunkedUArray ty)) -> ChunkedUArray ty -> ChunkedUArray ty Source # splitAt :: CountOf (Element (ChunkedUArray ty)) -> ChunkedUArray ty -> (ChunkedUArray ty, ChunkedUArray ty) Source # revSplitAt :: CountOf (Element (ChunkedUArray ty)) -> ChunkedUArray ty -> (ChunkedUArray ty, ChunkedUArray ty) Source # splitOn :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> [ChunkedUArray ty] Source # break :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> (ChunkedUArray ty, ChunkedUArray ty) Source # breakEnd :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> (ChunkedUArray ty, ChunkedUArray ty) Source # breakElem :: Element (ChunkedUArray ty) -> ChunkedUArray ty -> (ChunkedUArray ty, ChunkedUArray ty) Source # takeWhile :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> ChunkedUArray ty Source # dropWhile :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> ChunkedUArray ty Source # intersperse :: Element (ChunkedUArray ty) -> ChunkedUArray ty -> ChunkedUArray ty Source # intercalate :: Element (ChunkedUArray ty) -> ChunkedUArray ty -> Element (ChunkedUArray ty) Source # span :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> (ChunkedUArray ty, ChunkedUArray ty) Source # spanEnd :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> (ChunkedUArray ty, ChunkedUArray ty) Source # filter :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> ChunkedUArray ty Source # partition :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> (ChunkedUArray ty, ChunkedUArray ty) Source # reverse :: ChunkedUArray ty -> ChunkedUArray ty Source # uncons :: ChunkedUArray ty -> Maybe (Element (ChunkedUArray ty), ChunkedUArray ty) Source # unsnoc :: ChunkedUArray ty -> Maybe (ChunkedUArray ty, Element (ChunkedUArray ty)) Source # snoc :: ChunkedUArray ty -> Element (ChunkedUArray ty) -> ChunkedUArray ty Source # cons :: Element (ChunkedUArray ty) -> ChunkedUArray ty -> ChunkedUArray ty Source # find :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> Maybe (Element (ChunkedUArray ty)) Source # sortBy :: (Element (ChunkedUArray ty) -> Element (ChunkedUArray ty) -> Ordering) -> ChunkedUArray ty -> ChunkedUArray ty Source # singleton :: Element (ChunkedUArray ty) -> ChunkedUArray ty Source # head :: NonEmpty (ChunkedUArray ty) -> Element (ChunkedUArray ty) Source # last :: NonEmpty (ChunkedUArray ty) -> Element (ChunkedUArray ty) Source # tail :: NonEmpty (ChunkedUArray ty) -> ChunkedUArray ty Source # init :: NonEmpty (ChunkedUArray ty) -> ChunkedUArray ty Source # replicate :: CountOf (Element (ChunkedUArray ty)) -> Element (ChunkedUArray ty) -> ChunkedUArray ty Source # isPrefixOf :: ChunkedUArray ty -> ChunkedUArray ty -> Bool Source # isSuffixOf :: ChunkedUArray ty -> ChunkedUArray ty -> Bool Source # isInfixOf :: ChunkedUArray ty -> ChunkedUArray ty -> Bool Source # stripPrefix :: ChunkedUArray ty -> ChunkedUArray ty -> Maybe (ChunkedUArray ty) Source # stripSuffix :: ChunkedUArray ty -> ChunkedUArray ty -> Maybe (ChunkedUArray ty) Source # | |
| Sequential (DList a) Source # | |
Defined in Foundation.List.DList Methods take :: CountOf (Element (DList a)) -> DList a -> DList a Source # revTake :: CountOf (Element (DList a)) -> DList a -> DList a Source # drop :: CountOf (Element (DList a)) -> DList a -> DList a Source # revDrop :: CountOf (Element (DList a)) -> DList a -> DList a Source # splitAt :: CountOf (Element (DList a)) -> DList a -> (DList a, DList a) Source # revSplitAt :: CountOf (Element (DList a)) -> DList a -> (DList a, DList a) Source # splitOn :: (Element (DList a) -> Bool) -> DList a -> [DList a] Source # break :: (Element (DList a) -> Bool) -> DList a -> (DList a, DList a) Source # breakEnd :: (Element (DList a) -> Bool) -> DList a -> (DList a, DList a) Source # breakElem :: Element (DList a) -> DList a -> (DList a, DList a) Source # takeWhile :: (Element (DList a) -> Bool) -> DList a -> DList a Source # dropWhile :: (Element (DList a) -> Bool) -> DList a -> DList a Source # intersperse :: Element (DList a) -> DList a -> DList a Source # intercalate :: Element (DList a) -> DList a -> Element (DList a) Source # span :: (Element (DList a) -> Bool) -> DList a -> (DList a, DList a) Source # spanEnd :: (Element (DList a) -> Bool) -> DList a -> (DList a, DList a) Source # filter :: (Element (DList a) -> Bool) -> DList a -> DList a Source # partition :: (Element (DList a) -> Bool) -> DList a -> (DList a, DList a) Source # reverse :: DList a -> DList a Source # uncons :: DList a -> Maybe (Element (DList a), DList a) Source # unsnoc :: DList a -> Maybe (DList a, Element (DList a)) Source # snoc :: DList a -> Element (DList a) -> DList a Source # cons :: Element (DList a) -> DList a -> DList a Source # find :: (Element (DList a) -> Bool) -> DList a -> Maybe (Element (DList a)) Source # sortBy :: (Element (DList a) -> Element (DList a) -> Ordering) -> DList a -> DList a Source # singleton :: Element (DList a) -> DList a Source # head :: NonEmpty (DList a) -> Element (DList a) Source # last :: NonEmpty (DList a) -> Element (DList a) Source # tail :: NonEmpty (DList a) -> DList a Source # init :: NonEmpty (DList a) -> DList a Source # replicate :: CountOf (Element (DList a)) -> Element (DList a) -> DList a Source # isPrefixOf :: DList a -> DList a -> Bool Source # isSuffixOf :: DList a -> DList a -> Bool Source # isInfixOf :: DList a -> DList a -> Bool Source # stripPrefix :: DList a -> DList a -> Maybe (DList a) Source # stripSuffix :: DList a -> DList a -> Maybe (DList a) Source # | |
| Sequential [a] Source # | |
Defined in Foundation.Collection.Sequential Methods take :: CountOf (Element [a]) -> [a] -> [a] Source # revTake :: CountOf (Element [a]) -> [a] -> [a] Source # drop :: CountOf (Element [a]) -> [a] -> [a] Source # revDrop :: CountOf (Element [a]) -> [a] -> [a] Source # splitAt :: CountOf (Element [a]) -> [a] -> ([a], [a]) Source # revSplitAt :: CountOf (Element [a]) -> [a] -> ([a], [a]) Source # splitOn :: (Element [a] -> Bool) -> [a] -> [[a]] Source # break :: (Element [a] -> Bool) -> [a] -> ([a], [a]) Source # breakEnd :: (Element [a] -> Bool) -> [a] -> ([a], [a]) Source # breakElem :: Element [a] -> [a] -> ([a], [a]) Source # takeWhile :: (Element [a] -> Bool) -> [a] -> [a] Source # dropWhile :: (Element [a] -> Bool) -> [a] -> [a] Source # intersperse :: Element [a] -> [a] -> [a] Source # intercalate :: Element [a] -> [a] -> Element [a] Source # span :: (Element [a] -> Bool) -> [a] -> ([a], [a]) Source # spanEnd :: (Element [a] -> Bool) -> [a] -> ([a], [a]) Source # filter :: (Element [a] -> Bool) -> [a] -> [a] Source # partition :: (Element [a] -> Bool) -> [a] -> ([a], [a]) Source # reverse :: [a] -> [a] Source # uncons :: [a] -> Maybe (Element [a], [a]) Source # unsnoc :: [a] -> Maybe ([a], Element [a]) Source # snoc :: [a] -> Element [a] -> [a] Source # cons :: Element [a] -> [a] -> [a] Source # find :: (Element [a] -> Bool) -> [a] -> Maybe (Element [a]) Source # sortBy :: (Element [a] -> Element [a] -> Ordering) -> [a] -> [a] Source # singleton :: Element [a] -> [a] Source # head :: NonEmpty [a] -> Element [a] Source # last :: NonEmpty [a] -> Element [a] Source # tail :: NonEmpty [a] -> [a] Source # init :: NonEmpty [a] -> [a] Source # replicate :: CountOf (Element [a]) -> Element [a] -> [a] Source # isPrefixOf :: [a] -> [a] -> Bool Source # isSuffixOf :: [a] -> [a] -> Bool Source # isInfixOf :: [a] -> [a] -> Bool Source # stripPrefix :: [a] -> [a] -> Maybe [a] Source # stripSuffix :: [a] -> [a] -> Maybe [a] Source # | |
Instances
| Collection c => Collection (NonEmpty c) Source # | |
Defined in Foundation.Collection.Collection Methods null :: NonEmpty c -> Bool Source # length :: NonEmpty c -> CountOf (Element (NonEmpty c)) Source # elem :: (Eq a, a ~ Element (NonEmpty c)) => Element (NonEmpty c) -> NonEmpty c -> Bool Source # notElem :: (Eq a, a ~ Element (NonEmpty c)) => Element (NonEmpty c) -> NonEmpty c -> Bool Source # maximum :: (Ord a, a ~ Element (NonEmpty c)) => NonEmpty (NonEmpty c) -> Element (NonEmpty c) Source # minimum :: (Ord a, a ~ Element (NonEmpty c)) => NonEmpty (NonEmpty c) -> Element (NonEmpty c) Source # any :: (Element (NonEmpty c) -> Bool) -> NonEmpty c -> Bool Source # all :: (Element (NonEmpty c) -> Bool) -> NonEmpty c -> Bool Source # | |
| IsList c => IsList (NonEmpty c) | |
| Show a => Show (NonEmpty a) | |
| Eq a => Eq (NonEmpty a) | |
| type Element (NonEmpty a) Source # | |
Defined in Foundation.Collection.Element | |
| type Item (NonEmpty c) | |
Defined in Basement.NonEmpty | |
nonEmpty :: Collection c => c -> Maybe (NonEmpty c) Source #
Smart constructor to create a NonEmpty collection
If the collection is empty, then Nothing is returned Otherwise, the collection is wrapped in the NonEmpty property
Folds
class Foldable collection where Source #
Give the ability to fold a collection on itself
Methods
foldl' :: (a -> Element collection -> a) -> a -> collection -> a Source #
Left-associative fold of a structure.
In the case of lists, foldl, when applied to a binary operator, a starting value (typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right:
foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn
Note that to produce the outermost application of the operator the entire input list must be traversed. This means that foldl' will diverge if given an infinite list.
Note that Foundation only provides foldl', a strict version of foldl because
the lazy version is seldom useful.
Left-associative fold of a structure with strict application of the operator.
foldr :: (Element collection -> a -> a) -> a -> collection -> a Source #
Right-associative fold of a structure.
foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)
foldr' :: (Element collection -> a -> a) -> a -> collection -> a Source #
Right-associative fold of a structure, but with strict application of the operator.
Instances
| Foldable Bitmap Source # | |
| PrimType ty => Foldable (Block ty) Source # | |
| Foldable (Array ty) Source # | |
| PrimType ty => Foldable (UArray ty) Source # | |
| PrimType ty => Foldable (ChunkedUArray ty) Source # | |
Defined in Foundation.Array.Chunked.Unboxed Methods foldl' :: (a -> Element (ChunkedUArray ty) -> a) -> a -> ChunkedUArray ty -> a Source # foldr :: (Element (ChunkedUArray ty) -> a -> a) -> a -> ChunkedUArray ty -> a Source # foldr' :: (Element (ChunkedUArray ty) -> a -> a) -> a -> ChunkedUArray ty -> a Source # | |
| Foldable (DList a) Source # | |
| Foldable [a] Source # | |
| PrimType ty => Foldable (BlockN n ty) Source # | |
| Foldable (ListN n a) Source # | |
Maybe
listToMaybe :: [a] -> Maybe a #
maybeToList :: Maybe a -> [a] #
Either
partitionEithers :: [Either a b] -> ([a], [b]) #
Function
Applicative
Monad
Exceptions
class (Typeable e, Show e) => Exception e where #
Minimal complete definition
Nothing
Methods
toException :: e -> SomeException #
fromException :: SomeException -> Maybe e #
displayException :: e -> String #
backtraceDesired :: e -> Bool #
Instances
| Exception Timeout | |
Defined in System.Timeout Methods toException :: Timeout -> SomeException # fromException :: SomeException -> Maybe Timeout # displayException :: Timeout -> String # backtraceDesired :: Timeout -> Bool # | |
| Exception InvalidRecast | |
Defined in Basement.Exception Methods toException :: InvalidRecast -> SomeException # fromException :: SomeException -> Maybe InvalidRecast # displayException :: InvalidRecast -> String # backtraceDesired :: InvalidRecast -> Bool # | |
| Exception NonEmptyCollectionIsEmpty | |
Defined in Basement.Exception Methods toException :: NonEmptyCollectionIsEmpty -> SomeException # fromException :: SomeException -> Maybe NonEmptyCollectionIsEmpty # displayException :: NonEmptyCollectionIsEmpty -> String # backtraceDesired :: NonEmptyCollectionIsEmpty -> Bool # | |
| Exception OutOfBound | |
Defined in Basement.Exception Methods toException :: OutOfBound -> SomeException # fromException :: SomeException -> Maybe OutOfBound # displayException :: OutOfBound -> String # backtraceDesired :: OutOfBound -> Bool # | |
| Exception ASCII7_Invalid | |
Defined in Basement.String.Encoding.ASCII7 Methods toException :: ASCII7_Invalid -> SomeException # fromException :: SomeException -> Maybe ASCII7_Invalid # displayException :: ASCII7_Invalid -> String # backtraceDesired :: ASCII7_Invalid -> Bool # | |
| Exception ISO_8859_1_Invalid | |
Defined in Basement.String.Encoding.ISO_8859_1 Methods toException :: ISO_8859_1_Invalid -> SomeException # fromException :: SomeException -> Maybe ISO_8859_1_Invalid # displayException :: ISO_8859_1_Invalid -> String # backtraceDesired :: ISO_8859_1_Invalid -> Bool # | |
| Exception UTF16_Invalid | |
Defined in Basement.String.Encoding.UTF16 Methods toException :: UTF16_Invalid -> SomeException # fromException :: SomeException -> Maybe UTF16_Invalid # displayException :: UTF16_Invalid -> String # backtraceDesired :: UTF16_Invalid -> Bool # | |
| Exception UTF32_Invalid | |
Defined in Basement.String.Encoding.UTF32 Methods toException :: UTF32_Invalid -> SomeException # fromException :: SomeException -> Maybe UTF32_Invalid # displayException :: UTF32_Invalid -> String # backtraceDesired :: UTF32_Invalid -> Bool # | |
| Exception ValidationFailure | |
Defined in Basement.UTF8.Types Methods toException :: ValidationFailure -> SomeException # fromException :: SomeException -> Maybe ValidationFailure # displayException :: ValidationFailure -> String # | |
| Exception PartialError Source # | |
Defined in Foundation.Partial Methods toException :: PartialError -> SomeException # fromException :: SomeException -> Maybe PartialError # displayException :: PartialError -> String # backtraceDesired :: PartialError -> Bool # | |
| Exception Void | |
Defined in GHC.Internal.Exception.Type Methods toException :: Void -> SomeException # fromException :: SomeException -> Maybe Void # displayException :: Void -> String # backtraceDesired :: Void -> Bool # | |
| Exception NestedAtomically | |
Defined in GHC.Internal.Control.Exception.Base Methods toException :: NestedAtomically -> SomeException # fromException :: SomeException -> Maybe NestedAtomically # displayException :: NestedAtomically -> String # backtraceDesired :: NestedAtomically -> Bool # | |
| Exception NoMatchingContinuationPrompt | |
Defined in GHC.Internal.Control.Exception.Base Methods toException :: NoMatchingContinuationPrompt -> SomeException # fromException :: SomeException -> Maybe NoMatchingContinuationPrompt # displayException :: NoMatchingContinuationPrompt -> String # backtraceDesired :: NoMatchingContinuationPrompt -> Bool # | |
| Exception NoMethodError | |
Defined in GHC.Internal.Control.Exception.Base Methods toException :: NoMethodError -> SomeException # fromException :: SomeException -> Maybe NoMethodError # displayException :: NoMethodError -> String # backtraceDesired :: NoMethodError -> Bool # | |
| Exception NonTermination | |
Defined in GHC.Internal.Control.Exception.Base Methods toException :: NonTermination -> SomeException # fromException :: SomeException -> Maybe NonTermination # displayException :: NonTermination -> String # backtraceDesired :: NonTermination -> Bool # | |
| Exception PatternMatchFail | |
Defined in GHC.Internal.Control.Exception.Base Methods toException :: PatternMatchFail -> SomeException # fromException :: SomeException -> Maybe PatternMatchFail # displayException :: PatternMatchFail -> String # backtraceDesired :: PatternMatchFail -> Bool # | |
| Exception RecConError | |
Defined in GHC.Internal.Control.Exception.Base Methods toException :: RecConError -> SomeException # fromException :: SomeException -> Maybe RecConError # displayException :: RecConError -> String # backtraceDesired :: RecConError -> Bool # | |
| Exception RecSelError | |
Defined in GHC.Internal.Control.Exception.Base Methods toException :: RecSelError -> SomeException # fromException :: SomeException -> Maybe RecSelError # displayException :: RecSelError -> String # backtraceDesired :: RecSelError -> Bool # | |
| Exception RecUpdError | |
Defined in GHC.Internal.Control.Exception.Base Methods toException :: RecUpdError -> SomeException # fromException :: SomeException -> Maybe RecUpdError # displayException :: RecUpdError -> String # backtraceDesired :: RecUpdError -> Bool # | |
| Exception TypeError | |
Defined in GHC.Internal.Control.Exception.Base Methods toException :: TypeError -> SomeException # fromException :: SomeException -> Maybe TypeError # displayException :: TypeError -> String # backtraceDesired :: TypeError -> Bool # | |
| Exception ErrorCall | |
Defined in GHC.Internal.Exception Methods toException :: ErrorCall -> SomeException # fromException :: SomeException -> Maybe ErrorCall # displayException :: ErrorCall -> String # backtraceDesired :: ErrorCall -> Bool # | |
| Exception ArithException | |
Defined in GHC.Internal.Exception.Type Methods toException :: ArithException -> SomeException # fromException :: SomeException -> Maybe ArithException # displayException :: ArithException -> String # backtraceDesired :: ArithException -> Bool # | |
| Exception SomeException | |
Defined in GHC.Internal.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String # backtraceDesired :: SomeException -> Bool # | |
| Exception AllocationLimitExceeded | |
Defined in GHC.Internal.IO.Exception Methods toException :: AllocationLimitExceeded -> SomeException # fromException :: SomeException -> Maybe AllocationLimitExceeded # displayException :: AllocationLimitExceeded -> String # backtraceDesired :: AllocationLimitExceeded -> Bool # | |
| Exception ArrayException | |
Defined in GHC.Internal.IO.Exception Methods toException :: ArrayException -> SomeException # fromException :: SomeException -> Maybe ArrayException # displayException :: ArrayException -> String # backtraceDesired :: ArrayException -> Bool # | |
| Exception AssertionFailed | |
Defined in GHC.Internal.IO.Exception Methods toException :: AssertionFailed -> SomeException # fromException :: SomeException -> Maybe AssertionFailed # displayException :: AssertionFailed -> String # backtraceDesired :: AssertionFailed -> Bool # | |
| Exception AsyncException | |
Defined in GHC.Internal.IO.Exception Methods toException :: AsyncException -> SomeException # fromException :: SomeException -> Maybe AsyncException # displayException :: AsyncException -> String # backtraceDesired :: AsyncException -> Bool # | |
| Exception BlockedIndefinitelyOnMVar | |
Defined in GHC.Internal.IO.Exception Methods toException :: BlockedIndefinitelyOnMVar -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar # displayException :: BlockedIndefinitelyOnMVar -> String # backtraceDesired :: BlockedIndefinitelyOnMVar -> Bool # | |
| Exception BlockedIndefinitelyOnSTM | |
Defined in GHC.Internal.IO.Exception Methods toException :: BlockedIndefinitelyOnSTM -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM # displayException :: BlockedIndefinitelyOnSTM -> String # backtraceDesired :: BlockedIndefinitelyOnSTM -> Bool # | |
| Exception CompactionFailed | |
Defined in GHC.Internal.IO.Exception Methods toException :: CompactionFailed -> SomeException # fromException :: SomeException -> Maybe CompactionFailed # displayException :: CompactionFailed -> String # backtraceDesired :: CompactionFailed -> Bool # | |
| Exception Deadlock | |
Defined in GHC.Internal.IO.Exception Methods toException :: Deadlock -> SomeException # fromException :: SomeException -> Maybe Deadlock # displayException :: Deadlock -> String # backtraceDesired :: Deadlock -> Bool # | |
| Exception ExitCode | |
Defined in GHC.Internal.IO.Exception Methods toException :: ExitCode -> SomeException # fromException :: SomeException -> Maybe ExitCode # displayException :: ExitCode -> String # backtraceDesired :: ExitCode -> Bool # | |
| Exception FixIOException | |
Defined in GHC.Internal.IO.Exception Methods toException :: FixIOException -> SomeException # fromException :: SomeException -> Maybe FixIOException # displayException :: FixIOException -> String # backtraceDesired :: FixIOException -> Bool # | |
| Exception IOException | |
Defined in GHC.Internal.IO.Exception Methods toException :: IOException -> SomeException # fromException :: SomeException -> Maybe IOException # displayException :: IOException -> String # backtraceDesired :: IOException -> Bool # | |
| Exception SomeAsyncException | |
Defined in GHC.Internal.IO.Exception Methods toException :: SomeAsyncException -> SomeException # fromException :: SomeException -> Maybe SomeAsyncException # displayException :: SomeAsyncException -> String # backtraceDesired :: SomeAsyncException -> Bool # | |
| (Typeable input, Show input) => Exception (ParseError input) Source # | |
Defined in Foundation.Parser Methods toException :: ParseError input -> SomeException # fromException :: SomeException -> Maybe (ParseError input) # displayException :: ParseError input -> String # backtraceDesired :: ParseError input -> Bool # | |
| Exception a => Exception (ExceptionWithContext a) | |
Defined in GHC.Internal.Exception.Type Methods toException :: ExceptionWithContext a -> SomeException # fromException :: SomeException -> Maybe (ExceptionWithContext a) # displayException :: ExceptionWithContext a -> String # backtraceDesired :: ExceptionWithContext a -> Bool # | |
| Exception e => Exception (NoBacktrace e) | |
Defined in GHC.Internal.Exception.Type Methods toException :: NoBacktrace e -> SomeException # fromException :: SomeException -> Maybe (NoBacktrace e) # displayException :: NoBacktrace e -> String # backtraceDesired :: NoBacktrace e -> Bool # | |
data SomeException #
Instances
| Exception SomeException | |
Defined in GHC.Internal.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String # backtraceDesired :: SomeException -> Bool # | |
| Show SomeException | |
Defined in GHC.Internal.Exception.Type Methods showsPrec :: Int -> SomeException -> ShowS show :: SomeException -> String showList :: [SomeException] -> ShowS | |
data IOException #
Instances
| Exception IOException | |
Defined in GHC.Internal.IO.Exception Methods toException :: IOException -> SomeException # fromException :: SomeException -> Maybe IOException # displayException :: IOException -> String # backtraceDesired :: IOException -> Bool # | |
| Show IOException | |
Defined in GHC.Internal.IO.Exception Methods showsPrec :: Int -> IOException -> ShowS show :: IOException -> String showList :: [IOException] -> ShowS | |
| Eq IOException | |
Defined in GHC.Internal.IO.Exception | |
Proxy
Constructors
| Proxy |
Instances
| Generic1 (Proxy :: k -> Type) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| MonadZip (Proxy :: Type -> Type) | |||||
| Eq1 (Proxy :: Type -> Type) | |||||
| Ord1 (Proxy :: Type -> Type) | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Proxy a -> Proxy b -> Ordering | |||||
| Read1 (Proxy :: Type -> Type) | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Proxy a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Proxy a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Proxy a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Proxy a] | |||||
| Show1 (Proxy :: Type -> Type) | |||||
Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Proxy a -> ShowS liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Proxy a] -> ShowS | |||||
| Contravariant (Proxy :: Type -> Type) | |||||
| Alternative (Proxy :: Type -> Type) | |||||
| Applicative (Proxy :: Type -> Type) | |||||
| Functor (Proxy :: Type -> Type) | |||||
| Monad (Proxy :: Type -> Type) | |||||
| MonadPlus (Proxy :: Type -> Type) | |||||
| Foldable (Proxy :: Type -> Type) | |||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => Proxy m -> m foldMap :: Monoid m => (a -> m) -> Proxy a -> m foldMap' :: Monoid m => (a -> m) -> Proxy a -> m foldr :: (a -> b -> b) -> b -> Proxy a -> b foldr' :: (a -> b -> b) -> b -> Proxy a -> b foldl :: (b -> a -> b) -> b -> Proxy a -> b foldl' :: (b -> a -> b) -> b -> Proxy a -> b foldr1 :: (a -> a -> a) -> Proxy a -> a foldl1 :: (a -> a -> a) -> Proxy a -> a elem :: Eq a => a -> Proxy a -> Bool maximum :: Ord a => Proxy a -> a | |||||
| Traversable (Proxy :: Type -> Type) | |||||
| Monoid (Proxy s) | |||||
| Semigroup (Proxy s) | |||||
| Data t => Data (Proxy t) | |||||
Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Proxy t -> c (Proxy t) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Proxy t) dataTypeOf :: Proxy t -> DataType dataCast1 :: Typeable t0 => (forall d. Data d => c (t0 d)) -> Maybe (c (Proxy t)) dataCast2 :: Typeable t0 => (forall d e. (Data d, Data e) => c (t0 d e)) -> Maybe (c (Proxy t)) gmapT :: (forall b. Data b => b -> b) -> Proxy t -> Proxy t gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Proxy t -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Proxy t -> r gmapQ :: (forall d. Data d => d -> u) -> Proxy t -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Proxy t -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) | |||||
| Bounded (Proxy t) | |||||
| Enum (Proxy s) | |||||
| Generic (Proxy t) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Ix (Proxy s) | |||||
Defined in GHC.Internal.Data.Proxy | |||||
| Read (Proxy t) | |||||
Defined in GHC.Internal.Data.Proxy | |||||
| Show (Proxy s) | |||||
| Eq (Proxy s) | |||||
| Ord (Proxy s) | |||||
Defined in GHC.Internal.Data.Proxy | |||||
| type Rep1 (Proxy :: k -> Type) | |||||
Defined in GHC.Internal.Generics | |||||
| type Rep (Proxy t) | |||||
Defined in GHC.Internal.Generics | |||||
asProxyTypeOf :: a -> proxy a -> a #
Partial
Partialiality wrapper.
partial :: a -> Partial a Source #
Create a value that is partial. this can only be
unwrap using the fromPartial function
data PartialError Source #
An error related to the evaluation of a Partial value that failed.
it contains the name of the function and the reason for failure
Instances
| Exception PartialError Source # | |
Defined in Foundation.Partial Methods toException :: PartialError -> SomeException # fromException :: SomeException -> Maybe PartialError # displayException :: PartialError -> String # backtraceDesired :: PartialError -> Bool # | |
| Show PartialError Source # | |
Defined in Foundation.Partial Methods showsPrec :: Int -> PartialError -> ShowS show :: PartialError -> String showList :: [PartialError] -> ShowS | |
| Eq PartialError Source # | |
Defined in Foundation.Partial | |
fromPartial :: Partial a -> a Source #
Dewrap a possible partial value
ifThenElse :: Bool -> a -> a -> a #