foundation-0.0.17: Alternative prelude with batteries and no dependencies

License | BSD-style
Maintainer | Vincent Hanquez <vincent@snarc.org>
Stability | experimental
Portability | portable
Safe Haskell | None
Language | Haskell2010

Foundation

Contents

- Standard
  - Operators
  - Functions
  - Type classes
  - Numeric type classes
  - Data types
  - Numbers
  - Collection types
  - Numeric functions
  - Monoids
  - Collection
  - Folds
  - Maybe
  - Either
  - Function
  - Applicative
  - Monad
  - Exceptions
  - Proxy
  - Partial
  - Old Prelude Strings as [Char] with bridge back and forth

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
- (.) :: Category k cat => forall b c a. 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
- class Sndable a where
  - type ProductSecond a
- class Thdable a where
  - type ProductThird a
- id :: Category k cat => forall a. 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
- class Functor f where
- class Integral a where
- class Fractional a where
- class HasNegation a where
- class Bifunctor p where
- class Functor f => Applicative f where
- class Applicative m => Monad m where
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- class IsString a where
- class IsList l where
  - type Item l :: *
- class (Enum a, Eq a, Ord a, Integral a) => IsIntegral a where
- class (Enum a, Eq a, Ord a, Integral a, IsIntegral a) => IsNatural a where
- class Signed a where
- class Additive a where
- class Subtractive a where
  - type Difference a :: *
- class Multiplicative a where
- class (Additive a, Multiplicative a) => IDivisible a where
- class Multiplicative a => Divisible a where
- data Maybe a :: * -> *
  - = Nothing
  - | Just a
- data Ordering :: *
  - = LT
  - | EQ
  - | GT
- data Bool :: *
  - = False
  - | True
- data Char :: *
- data Char7 :: *
- data IO a :: * -> *
- data Either a b :: * -> * -> *
  - = Left a
  - | Right 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 Monoid a where
- (<>) :: Monoid m => m -> m -> m
- class (IsList c, Item c ~ Element c) => Collection c where
- 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
- 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 => forall a. 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
- class Typeable k a
- data SomeException :: *
- data IOException :: *
- data Proxy k t :: forall k. 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

($) :: (a -> b) -> a -> b infixr 0 #

Application operator. This operator is redundant, since ordinary application `(f x)` means the same as `(f `$` x)`. However, `$` has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example:

        f $ g $ h x  =  f (g (h x))

It is also useful in higher-order situations, such as ``map` (`$` 0) xs`, or ``zipWith` (`$`) fs xs`.

($!) :: (a -> b) -> a -> b infixr 0 #

Strict (call-by-value) application operator. It takes a function and an argument, evaluates the argument to weak head normal form (WHNF), then calls the function with that value.

(&&) :: Bool -> Bool -> Bool infixr 3 #

Boolean "and"

(||) :: Bool -> Bool -> Bool infixr 2 #

Boolean "or"

(.) :: Category k cat => forall b c a. cat b c -> cat a b -> cat a c #

morphism composition

## Functions

not :: Bool -> Bool #

Boolean "not"

otherwise :: Bool #

`otherwise` is defined as the value `True`. It helps to make guards more readable. eg.

     f x | x < 0     = ...
         | otherwise = ...

data Tuple2 a b Source #

Strict tuple (a,b)

Constructors

Tuple2 !a !b |

Instances

Bifunctor Tuple2 Source # |
Methods bimap :: (a -> b) -> (c -> d) -> Tuple2 a c -> Tuple2 b d # first :: (a -> b) -> Tuple2 a c -> Tuple2 b c # second :: (b -> c) -> Tuple2 a b -> Tuple2 a c #
Nthable 1 (Tuple2 a b) Source # |
Associated Types type NthTy (1 :: Nat) (Tuple2 a b) :: * Source # Methods nth :: proxy 1 -> Tuple2 a b -> NthTy 1 (Tuple2 a b) Source #
Nthable 2 (Tuple2 a b) Source # |
Associated Types type NthTy (2 :: Nat) (Tuple2 a b) :: * Source # Methods nth :: proxy 2 -> Tuple2 a b -> NthTy 2 (Tuple2 a b) Source #
(Eq b, Eq a) => Eq (Tuple2 a b) Source # |
Methods (==) :: Tuple2 a b -> Tuple2 a b -> Bool # (/=) :: Tuple2 a b -> Tuple2 a b -> Bool #
(Data b, Data a) => Data (Tuple2 a b) Source # |

Methods

gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> Tuple2 a b -> c (Tuple2 a b) #

gunfold :: (forall c r. Data c => c (c -> 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 c. Data c => c -> c) -> Tuple2 a b -> Tuple2 a b #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tuple2 a b -> r #

gmapQr :: (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) #

(Ord b, Ord a) => Ord (Tuple2 a b) Source # |
Methods compare :: Tuple2 a b -> Tuple2 a b -> Ordering # (<) :: Tuple2 a b -> Tuple2 a b -> Bool # (<=) :: Tuple2 a b -> Tuple2 a b -> Bool # (>) :: Tuple2 a b -> Tuple2 a b -> Bool # (>=) :: Tuple2 a b -> Tuple2 a b -> Bool # max :: Tuple2 a b -> Tuple2 a b -> Tuple2 a b # min :: Tuple2 a b -> Tuple2 a b -> Tuple2 a b #
(Show b, Show a) => Show (Tuple2 a b) Source # |
Methods showsPrec :: Int -> Tuple2 a b -> ShowS # show :: Tuple2 a b -> String # showList :: [Tuple2 a b] -> ShowS #
Generic (Tuple2 a b) Source # |
Associated Types type Rep (Tuple2 a b) :: * -> * # Methods from :: Tuple2 a b -> Rep (Tuple2 a b) x # to :: Rep (Tuple2 a b) x -> Tuple2 a b #
(NormalForm a, NormalForm b) => NormalForm (Tuple2 a b) Source # |
Methods toNormalForm :: Tuple2 a b -> () #
Sndable (Tuple2 a b) Source # |
Associated Types type ProductSecond (Tuple2 a b) :: * Source # Methods snd :: Tuple2 a b -> ProductSecond (Tuple2 a b) Source #
Fstable (Tuple2 a b) Source # |
Associated Types type ProductFirst (Tuple2 a b) :: * Source # Methods fst :: Tuple2 a b -> ProductFirst (Tuple2 a b) Source #
(Hashable a, Hashable b) => Hashable (Tuple2 a b) Source # |
Methods hashMix :: Hasher st => Tuple2 a b -> st -> st Source #
type NthTy 1 (Tuple2 a b) Source # |
type NthTy 1 (Tuple2 a b) = a
type NthTy 2 (Tuple2 a b) Source # |
type NthTy 2 (Tuple2 a b) = b
type Rep (Tuple2 a b) Source # |
type Rep (Tuple2 a b) = D1 (MetaData "Tuple2" "Foundation.Tuple" "foundation-0.0.17-CL5hY2f92B7EywaUc6v2Lf" False) (C1 (MetaCons "Tuple2" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 b))))
type ProductSecond (Tuple2 a b) Source # |
type ProductSecond (Tuple2 a b) = b
type ProductFirst (Tuple2 a b) Source # |
type ProductFirst (Tuple2 a b) = a

data Tuple3 a b c Source #

Strict tuple (a,b,c)

Constructors

Tuple3 !a !b !c |

Instances

Nthable 1 (Tuple3 a b c) Source # |
Associated Types type NthTy (1 :: Nat) (Tuple3 a b c) :: * Source # Methods nth :: proxy 1 -> Tuple3 a b c -> NthTy 1 (Tuple3 a b c) Source #
Nthable 2 (Tuple3 a b c) Source # |
Associated Types type NthTy (2 :: Nat) (Tuple3 a b c) :: * Source # Methods nth :: proxy 2 -> Tuple3 a b c -> NthTy 2 (Tuple3 a b c) Source #
Nthable 3 (Tuple3 a b c) Source # |
Associated Types type NthTy (3 :: Nat) (Tuple3 a b c) :: * Source # Methods nth :: proxy 3 -> Tuple3 a b c -> NthTy 3 (Tuple3 a b c) Source #
(Eq c, Eq b, Eq a) => Eq (Tuple3 a b c) Source # |
Methods (==) :: Tuple3 a b c -> Tuple3 a b c -> Bool # (/=) :: Tuple3 a b c -> Tuple3 a b c -> Bool #
(Data c, Data b, Data a) => Data (Tuple3 a b c) Source # |

Methods

gfoldl :: (forall d e. Data d => c (d -> e) -> d -> c e) -> (forall g. g -> c g) -> Tuple3 a b c -> c (Tuple3 a b c) #

gunfold :: (forall d r. Data d => c (d -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Tuple3 a b c) #

toConstr :: Tuple3 a b c -> Constr #

dataTypeOf :: Tuple3 a b c -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Tuple3 a b c)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Tuple3 a b c)) #

gmapT :: (forall d. Data d => d -> d) -> 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 :: (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) #

(Ord c, Ord b, Ord a) => Ord (Tuple3 a b c) Source # |
Methods compare :: Tuple3 a b c -> Tuple3 a b c -> Ordering # (<) :: Tuple3 a b c -> Tuple3 a b c -> Bool # (<=) :: Tuple3 a b c -> Tuple3 a b c -> Bool # (>) :: Tuple3 a b c -> Tuple3 a b c -> Bool # (>=) :: Tuple3 a b c -> Tuple3 a b c -> Bool # max :: Tuple3 a b c -> Tuple3 a b c -> Tuple3 a b c # min :: Tuple3 a b c -> Tuple3 a b c -> Tuple3 a b c #
(Show c, Show b, Show a) => Show (Tuple3 a b c) Source # |
Methods showsPrec :: Int -> Tuple3 a b c -> ShowS # show :: Tuple3 a b c -> String # showList :: [Tuple3 a b c] -> ShowS #
Generic (Tuple3 a b c) Source # |
Associated Types type Rep (Tuple3 a b c) :: * -> * # Methods from :: Tuple3 a b c -> Rep (Tuple3 a b c) x # to :: Rep (Tuple3 a b c) x -> Tuple3 a b c #
(NormalForm a, NormalForm b, NormalForm c) => NormalForm (Tuple3 a b c) Source # |
Methods toNormalForm :: Tuple3 a b c -> () #
Thdable (Tuple3 a b c) Source # |
Associated Types type ProductThird (Tuple3 a b c) :: * Source # Methods thd :: Tuple3 a b c -> ProductThird (Tuple3 a b c) Source #
Sndable (Tuple3 a b c) Source # |
Associated Types type ProductSecond (Tuple3 a b c) :: * Source # Methods snd :: Tuple3 a b c -> ProductSecond (Tuple3 a b c) Source #
Fstable (Tuple3 a b c) Source # |
Associated Types type ProductFirst (Tuple3 a b c) :: * Source # Methods fst :: Tuple3 a b c -> ProductFirst (Tuple3 a b c) Source #
(Hashable a, Hashable b, Hashable c) => Hashable (Tuple3 a b c) Source # |
Methods hashMix :: Hasher st => Tuple3 a b c -> st -> st Source #
type NthTy 1 (Tuple3 a b c) Source # |
type NthTy 1 (Tuple3 a b c) = a
type NthTy 2 (Tuple3 a b c) Source # |
type NthTy 2 (Tuple3 a b c) = b
type NthTy 3 (Tuple3 a b c) Source # |
type NthTy 3 (Tuple3 a b c) = c
type Rep (Tuple3 a b c) Source # |

type Rep (Tuple3 a b c) = D1 (MetaData "Tuple3" "Foundation.Tuple" "foundation-0.0.17-CL5hY2f92B7EywaUc6v2Lf" False) (C1 (MetaCons "Tuple3" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 b)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 c)))))

type ProductThird (Tuple3 a b c) Source # |
type ProductThird (Tuple3 a b c) = c
type ProductSecond (Tuple3 a b c) Source # |
type ProductSecond (Tuple3 a b c) = b
type ProductFirst (Tuple3 a b c) Source # |
type ProductFirst (Tuple3 a b c) = a

data Tuple4 a b c d Source #

Strict tuple (a,b,c,d)

Constructors

Tuple4 !a !b !c !d |

Instances

Nthable 1 (Tuple4 a b c d) Source # |
Associated Types type NthTy (1 :: Nat) (Tuple4 a b c d) :: * Source # Methods nth :: proxy 1 -> Tuple4 a b c d -> NthTy 1 (Tuple4 a b c d) Source #
Nthable 2 (Tuple4 a b c d) Source # |
Associated Types type NthTy (2 :: Nat) (Tuple4 a b c d) :: * Source # Methods nth :: proxy 2 -> Tuple4 a b c d -> NthTy 2 (Tuple4 a b c d) Source #
Nthable 3 (Tuple4 a b c d) Source # |
Associated Types type NthTy (3 :: Nat) (Tuple4 a b c d) :: * Source # Methods nth :: proxy 3 -> Tuple4 a b c d -> NthTy 3 (Tuple4 a b c d) Source #
Nthable 4 (Tuple4 a b c d) Source # |
Associated Types type NthTy (4 :: Nat) (Tuple4 a b c d) :: * Source # Methods nth :: proxy 4 -> Tuple4 a b c d -> NthTy 4 (Tuple4 a b c d) Source #
(Eq d, Eq c, Eq b, Eq a) => Eq (Tuple4 a b c d) Source # |
Methods (==) :: Tuple4 a b c d -> Tuple4 a b c d -> Bool # (/=) :: Tuple4 a b c d -> Tuple4 a b c d -> Bool #
(Data d, Data c, Data b, Data a) => Data (Tuple4 a b c d) Source # |

Methods

gfoldl :: (forall e f. Data e => c (e -> f) -> e -> c f) -> (forall g. g -> c g) -> Tuple4 a b c d -> c (Tuple4 a b c d) #

gunfold :: (forall e r. Data e => c (e -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Tuple4 a b c d) #

toConstr :: Tuple4 a b c d -> Constr #

dataTypeOf :: Tuple4 a b c d -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall e. Data e => c (t e)) -> Maybe (c (Tuple4 a b c d)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall e f. (Data e, Data f) => c (t e f)) -> Maybe (c (Tuple4 a b c d)) #

gmapT :: (forall e. Data e => e -> e) -> Tuple4 a b c d -> Tuple4 a b c d #

gmapQl :: (r -> r' -> r) -> r -> (forall e. Data e => e -> r') -> Tuple4 a b c d -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall e. Data e => e -> r') -> Tuple4 a b c d -> r #

gmapQ :: (forall e. Data e => e -> u) -> Tuple4 a b c d -> [u] #

gmapQi :: Int -> (forall e. Data e => e -> u) -> Tuple4 a b c d -> u #

gmapM :: Monad m => (forall e. Data e => e -> m e) -> Tuple4 a b c d -> m (Tuple4 a b c d) #

gmapMp :: MonadPlus m => (forall e. Data e => e -> m e) -> Tuple4 a b c d -> m (Tuple4 a b c d) #

gmapMo :: MonadPlus m => (forall e. Data e => e -> m e) -> Tuple4 a b c d -> m (Tuple4 a b c d) #

(Ord d, Ord c, Ord b, Ord a) => Ord (Tuple4 a b c d) Source # |
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 # max :: Tuple4 a b c d -> Tuple4 a b c d -> Tuple4 a b c d # min :: Tuple4 a b c d -> Tuple4 a b c d -> Tuple4 a b c d #
(Show d, Show c, Show b, Show a) => Show (Tuple4 a b c d) Source # |
Methods showsPrec :: Int -> Tuple4 a b c d -> ShowS # show :: Tuple4 a b c d -> String # showList :: [Tuple4 a b c d] -> ShowS #
Generic (Tuple4 a b c d) Source # |
Associated Types type Rep (Tuple4 a b c d) :: * -> * # Methods from :: Tuple4 a b c d -> Rep (Tuple4 a b c d) x # to :: Rep (Tuple4 a b c d) x -> Tuple4 a b c d #
(NormalForm a, NormalForm b, NormalForm c, NormalForm d) => NormalForm (Tuple4 a b c d) Source # |
Methods toNormalForm :: Tuple4 a b c d -> () #
Thdable (Tuple4 a b c d) Source # |
Associated Types type ProductThird (Tuple4 a b c d) :: * Source # Methods thd :: Tuple4 a b c d -> ProductThird (Tuple4 a b c d) Source #
Sndable (Tuple4 a b c d) Source # |
Associated Types type ProductSecond (Tuple4 a b c d) :: * Source # Methods snd :: Tuple4 a b c d -> ProductSecond (Tuple4 a b c d) Source #
Fstable (Tuple4 a b c d) Source # |
Associated Types type ProductFirst (Tuple4 a b c d) :: * Source # Methods fst :: Tuple4 a b c d -> ProductFirst (Tuple4 a b c d) Source #
(Hashable a, Hashable b, Hashable c, Hashable d) => Hashable (Tuple4 a b c d) Source # |
Methods hashMix :: Hasher st => Tuple4 a b c d -> st -> st Source #
type NthTy 1 (Tuple4 a b c d) Source # |
type NthTy 1 (Tuple4 a b c d) = a
type NthTy 2 (Tuple4 a b c d) Source # |
type NthTy 2 (Tuple4 a b c d) = b
type NthTy 3 (Tuple4 a b c d) Source # |
type NthTy 3 (Tuple4 a b c d) = c
type NthTy 4 (Tuple4 a b c d) Source # |
type NthTy 4 (Tuple4 a b c d) = d
type Rep (Tuple4 a b c d) Source # |

type Rep (Tuple4 a b c d) = D1 (MetaData "Tuple4" "Foundation.Tuple" "foundation-0.0.17-CL5hY2f92B7EywaUc6v2Lf" False) (C1 (MetaCons "Tuple4" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 b))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 c)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 d)))))

type ProductThird (Tuple4 a b c d) Source # |
type ProductThird (Tuple4 a b c d) = c
type ProductSecond (Tuple4 a b c d) Source # |
type ProductSecond (Tuple4 a b c d) = b
type ProductFirst (Tuple4 a b c d) Source # |
type ProductFirst (Tuple4 a b c d) = a

class Fstable a where Source #

Class of product types that have a first element

Minimal complete definition

fst

Associated Types

type ProductFirst a Source #

Methods

fst :: a -> ProductFirst a Source #

Instances

Fstable (a, b) Source # |
Associated Types type ProductFirst (a, b) :: * Source # Methods fst :: (a, b) -> ProductFirst (a, b) Source #
Fstable (Tuple2 a b) Source # |
Associated Types type ProductFirst (Tuple2 a b) :: * Source # Methods fst :: Tuple2 a b -> ProductFirst (Tuple2 a b) Source #
Fstable (a, b, c) Source # |
Associated Types type ProductFirst (a, b, c) :: * Source # Methods fst :: (a, b, c) -> ProductFirst (a, b, c) Source #
Fstable (Tuple3 a b c) Source # |
Associated Types type ProductFirst (Tuple3 a b c) :: * Source # Methods fst :: Tuple3 a b c -> ProductFirst (Tuple3 a b c) Source #
Fstable (a, b, c, d) Source # |
Associated Types type ProductFirst (a, b, c, d) :: * Source # Methods fst :: (a, b, c, d) -> ProductFirst (a, b, c, d) Source #
Fstable (Tuple4 a b c d) Source # |
Associated Types type ProductFirst (Tuple4 a b c d) :: * Source # Methods fst :: Tuple4 a b c d -> ProductFirst (Tuple4 a b c d) Source #

class Sndable a where Source #

Class of product types that have a second element

Minimal complete definition

snd

Associated Types

type ProductSecond a Source #

Methods

snd :: a -> ProductSecond a Source #

Instances

Sndable (a, b) Source # |
Associated Types type ProductSecond (a, b) :: * Source # Methods snd :: (a, b) -> ProductSecond (a, b) Source #
Sndable (Tuple2 a b) Source # |
Associated Types type ProductSecond (Tuple2 a b) :: * Source # Methods snd :: Tuple2 a b -> ProductSecond (Tuple2 a b) Source #
Sndable (a, b, c) Source # |
Associated Types type ProductSecond (a, b, c) :: * Source # Methods snd :: (a, b, c) -> ProductSecond (a, b, c) Source #
Sndable (Tuple3 a b c) Source # |
Associated Types type ProductSecond (Tuple3 a b c) :: * Source # Methods snd :: Tuple3 a b c -> ProductSecond (Tuple3 a b c) Source #
Sndable (a, b, c, d) Source # |
Associated Types type ProductSecond (a, b, c, d) :: * Source # Methods snd :: (a, b, c, d) -> ProductSecond (a, b, c, d) Source #
Sndable (Tuple4 a b c d) Source # |
Associated Types type ProductSecond (Tuple4 a b c d) :: * Source # Methods snd :: Tuple4 a b c d -> ProductSecond (Tuple4 a b c d) Source #

class Thdable a where Source #

Class of product types that have a third element

Minimal complete definition

thd

Associated Types

type ProductThird a Source #

Methods

thd :: a -> ProductThird a Source #

Instances

Thdable (a, b, c) Source # |
Associated Types type ProductThird (a, b, c) :: * Source # Methods thd :: (a, b, c) -> ProductThird (a, b, c) Source #
Thdable (Tuple3 a b c) Source # |
Associated Types type ProductThird (Tuple3 a b c) :: * Source # Methods thd :: Tuple3 a b c -> ProductThird (Tuple3 a b c) Source #
Thdable (a, b, c, d) Source # |
Associated Types type ProductThird (a, b, c, d) :: * Source # Methods thd :: (a, b, c, d) -> ProductThird (a, b, c, d) Source #
Thdable (Tuple4 a b c d) Source # |
Associated Types type ProductThird (Tuple4 a b c d) :: * Source # Methods thd :: Tuple4 a b c d -> ProductThird (Tuple4 a b c d) Source #

id :: Category k cat => forall a. cat a a #

the identity morphism

maybe :: b -> (a -> b) -> Maybe a -> b #

The `maybe` function takes a default value, a function, and a `Maybe` value. If the `Maybe` value is `Nothing`, the function returns the default value. Otherwise, it applies the function to the value inside the `Just` and returns the result.

#### Examples

Basic usage:

    >>> maybe False odd (Just 3)
    True

    >>> maybe False odd Nothing
    False

Read an integer from a string using `readMaybe`. If we succeed, return twice the integer; that is, apply `(*2)` to it. If instead we fail to parse an integer, return `0` by default:

    >>> import Text.Read ( readMaybe )
    >>> maybe 0 (*2) (readMaybe "5")
    10
    >>> maybe 0 (*2) (readMaybe "")
    0

Apply `show` to a `Maybe Int`. If we have `Just n`, we want to show the underlying `Int` `n`. But if we have `Nothing`, we return the empty string instead of (for example) "Nothing":

    >>> maybe "" show (Just 5)
    "5"
    >>> maybe "" show Nothing
    ""

either :: (a -> c) -> (b -> c) -> Either a b -> c #

Case analysis for the `Either` type. If the value is ``Left` a`, apply the first function to `a`; if it is ``Right` b`, apply the second function to `b`.

#### Examples

We create two values of type ``Either` `String` `Int``, one using the `Left` constructor and another using the `Right` constructor. Then we apply "either" the `length` function (if we have a `String`) or the "times-two" function (if we have an `Int`):

    >>> let s = Left "foo" :: Either String Int
    >>> let n = Right 3 :: Either String Int
    >>> either length (*2) s
    3
    >>> either length (*2) n
    6

flip :: (a -> b -> c) -> b -> a -> c #

``flip` f` takes its (first) two arguments in the reverse order of `f`.

const :: a -> b -> a #

`const x` is a unary function which evaluates to `x` for all inputs.

For instance,

    >>> map (const 42) [0..3]
    [42,42,42,42]

error :: HasCallStack => String -> a #

stop execution and displays an error message

putStr :: String -> IO () Source #

Print a string to standard output

putStrLn :: String -> IO () Source #

Print a string with a newline to standard output

getArgs :: IO [String] #

Returns a list of the program's command line arguments (not including the program name).

uncurry :: (a -> b -> c) -> (a, b) -> c #

`uncurry` converts a curried function to a function on pairs.

curry :: ((a, b) -> c) -> a -> b -> c #

`curry` converts an uncurried function to a curried function.

swap :: (a, b) -> (b, a) #

Swap the components of a pair.

until :: (a -> Bool) -> (a -> a) -> a -> a #

``until` p f` yields the result of applying `f` until `p` holds.

asTypeOf :: a -> a -> a #

`asTypeOf` is a type-restricted version of `const`. It is usually used as an infix operator, and its typing forces its first argument (which is usually overloaded) to have the same type as the second.

undefined :: HasCallStack => a #

A special case of `error`. It is expected that compilers will recognize this and insert error messages which are more appropriate to the context in which `undefined` appears.

seq :: a -> b -> b #

The value of `seq a b` is bottom if `a` is bottom, and otherwise equal to `b`. `seq` is usually introduced to improve performance by avoiding unneeded laziness.

A note on evaluation order: the expression `seq a b` does not guarantee that `a` will be evaluated before `b`. The only guarantee given by `seq` is that the both `a` and `b` will be evaluated before `seq` returns a value. In particular, this means that `b` may be evaluated before `a`. If you need to guarantee a specific order of evaluation, you must use the function `pseq` from the "parallel" package.

class NormalForm a #

Data that can be fully evaluated in Normal Form

Minimal complete definition

toNormalForm

Instances

NormalForm Bool |
Methods toNormalForm :: Bool -> () #
NormalForm Char |
Methods toNormalForm :: Char -> () #
NormalForm Double |
Methods toNormalForm :: Double -> () #
NormalForm Float |
Methods toNormalForm :: Float -> () #
NormalForm Int |
Methods toNormalForm :: Int -> () #
NormalForm Int8 |
Methods toNormalForm :: Int8 -> () #
NormalForm Int16 |
Methods toNormalForm :: Int16 -> () #
NormalForm Int32 |
Methods toNormalForm :: Int32 -> () #
NormalForm Int64 |
Methods toNormalForm :: Int64 -> () #
NormalForm Integer |
Methods toNormalForm :: Integer -> () #
NormalForm Word |
Methods toNormalForm :: Word -> () #
NormalForm Word8 |
Methods toNormalForm :: Word8 -> () #
NormalForm Word16 |
Methods toNormalForm :: Word16 -> () #
NormalForm Word32 |
Methods toNormalForm :: Word32 -> () #
NormalForm Word64 |
Methods toNormalForm :: Word64 -> () #
NormalForm () |
Methods toNormalForm :: () -> () #
NormalForm Natural |
Methods toNormalForm :: Natural -> () #
NormalForm CChar |
Methods toNormalForm :: CChar -> () #
NormalForm CSChar |
Methods toNormalForm :: CSChar -> () #
NormalForm CUChar |
Methods toNormalForm :: CUChar -> () #
NormalForm CShort |
Methods toNormalForm :: CShort -> () #
NormalForm CUShort |
Methods toNormalForm :: CUShort -> () #
NormalForm CInt |
Methods toNormalForm :: CInt -> () #
NormalForm CUInt |
Methods toNormalForm :: CUInt -> () #
NormalForm CLong |
Methods toNormalForm :: CLong -> () #
NormalForm CULong |
Methods toNormalForm :: CULong -> () #
NormalForm CLLong |
Methods toNormalForm :: CLLong -> () #
NormalForm CULLong |
Methods toNormalForm :: CULLong -> () #
NormalForm CFloat |
Methods toNormalForm :: CFloat -> () #
NormalForm CDouble |
Methods toNormalForm :: CDouble -> () #
NormalForm String |
Methods toNormalForm :: String -> () #
NormalForm Word256 |
Methods toNormalForm :: Word256 -> () #
NormalForm Word128 |
Methods toNormalForm :: Word128 -> () #
NormalForm Char7 |
Methods toNormalForm :: Char7 -> () #
NormalForm IPv4 # |
Methods toNormalForm :: IPv4 -> () #
NormalForm IPv6 # |
Methods toNormalForm :: IPv6 -> () #
NormalForm UUID # |
Methods toNormalForm :: UUID -> () #
NormalForm a => NormalForm [a] |
Methods toNormalForm :: [a] -> () #
NormalForm a => NormalForm (Maybe a) |
Methods toNormalForm :: Maybe a -> () #
NormalForm (Ptr a) |
Methods toNormalForm :: Ptr a -> () #
NormalForm a => NormalForm (Array a) |
Methods toNormalForm :: Array a -> () #
NormalForm (UArray ty) |
Methods toNormalForm :: UArray ty -> () #
NormalForm (Block ty) |
Methods toNormalForm :: Block ty -> () #
NormalForm (Offset a) |
Methods toNormalForm :: Offset a -> () #
NormalForm (CountOf a) |
Methods toNormalForm :: CountOf a -> () #
NormalForm (Zn64 n) |
Methods toNormalForm :: Zn64 n -> () #
NormalForm (Zn n) |
Methods toNormalForm :: Zn n -> () #
NormalForm a => NormalForm (LE a) |
Methods toNormalForm :: LE a -> () #
NormalForm a => NormalForm (BE a) |
Methods toNormalForm :: BE a -> () #
NormalForm (ChunkedUArray ty) # |
Methods toNormalForm :: ChunkedUArray ty -> () #
(NormalForm l, NormalForm r) => NormalForm (Either l r) |
Methods toNormalForm :: Either l r -> () #
(NormalForm a, NormalForm b) => NormalForm (a, b) |
Methods toNormalForm :: (a, b) -> () #
NormalForm a => NormalForm (ListN n a) |
Methods toNormalForm :: ListN n a -> () #
(NormalForm a, NormalForm b) => NormalForm (These a b) |
Methods toNormalForm :: These a b -> () #
(NormalForm a, NormalForm b) => NormalForm (Tuple2 a b) # |
Methods toNormalForm :: Tuple2 a b -> () #
(NormalForm a, NormalForm b, NormalForm c) => NormalForm (a, b, c) |
Methods toNormalForm :: (a, b, c) -> () #
(NormalForm a, NormalForm b, NormalForm c) => NormalForm (Tuple3 a b c) # |
Methods toNormalForm :: Tuple3 a b c -> () #
(NormalForm a, NormalForm b, NormalForm c, NormalForm d) => NormalForm (a, b, c, d) |
Methods toNormalForm :: (a, b, c, d) -> () #
(NormalForm a, NormalForm b, NormalForm c, NormalForm d) => NormalForm (Tuple4 a b c d) # |
Methods toNormalForm :: Tuple4 a b c d -> () #
(NormalForm a, NormalForm b, NormalForm c, NormalForm d, NormalForm e) => NormalForm (a, b, c, d, e) |
Methods toNormalForm :: (a, b, c, d, e) -> () #
(NormalForm a, NormalForm b, NormalForm c, NormalForm d, NormalForm e, NormalForm f) => NormalForm (a, b, c, d, e, f) |
Methods toNormalForm :: (a, b, c, d, e, f) -> () #
(NormalForm a, NormalForm b, NormalForm c, NormalForm d, NormalForm e, NormalForm f, NormalForm g) => NormalForm (a, b, c, d, e, f, g) |
Methods toNormalForm :: (a, b, c, d, e, f, g) -> () #
(NormalForm a, NormalForm b, NormalForm c, NormalForm d, NormalForm e, NormalForm f, NormalForm g, NormalForm h) => NormalForm (a, b, c, d, e, f, g, h) |
Methods toNormalForm :: (a, b, c, d, e, f, g, h) -> () #

deepseq :: NormalForm a => a -> b -> b #

force :: NormalForm a => a -> a #

## Type classes

class Show a #

Conversion of values to readable `String`s.

Derived instances of `Show` have the following properties, which are compatible with derived instances of `Read`:

- The result of `show` is a syntactically correct Haskell expression containing only constants, given the fixity declarations in force at the point where the type is declared. It contains only the constructor names defined in the data type, parentheses, and spaces. When labelled constructor fields are used, braces, commas, field names, and equal signs are also used.
- If the constructor is defined to be an infix operator, then `showsPrec` will produce infix applications of the constructor.
- the representation will be enclosed in parentheses if the precedence of the top-level constructor in `x` is less than `d` (associativity is ignored). Thus, if `d` is `0` then the result is never surrounded in parentheses; if `d` is `11` it is always surrounded in parentheses, unless it is an atomic expression.
- If the constructor is defined using record syntax, then `show` will produce the record-syntax form, with the fields given in the same order as the original declaration.

For example, given the declarations

    infixr 5 :^:
    data Tree a =  Leaf a  |  Tree a :^: Tree a

the derived instance of `Show` is equivalent to

    instance (Show a) => Show (Tree a) where

           showsPrec d (Leaf m) = showParen (d > app_prec) $
                showString "Leaf " . showsPrec (app_prec+1) m
             where app_prec = 10

           showsPrec d (u :^: v) = showParen (d > up_prec) $
                showsPrec (up_prec+1) u .
                showString " :^: "      .
                showsPrec (up_prec+1) v
             where up_prec = 5

Note that right-associativity of `:^:` is ignored. For example,

- ``show` (Leaf 1 :^: Leaf 2 :^: Leaf 3)` produces the string `"Leaf 1 :^: (Leaf 2 :^: Leaf 3)"`.

Minimal complete definition

showsPrec | show

Instances

Show Bool |
Methods showsPrec :: Int -> Bool -> ShowS # show :: Bool -> String # showList :: [Bool] -> ShowS #
Show Char |
Methods showsPrec :: Int -> Char -> ShowS # show :: Char -> String # showList :: [Char] -> ShowS #
Show Int |
Methods showsPrec :: Int -> Int -> ShowS # show :: Int -> String # showList :: [Int] -> ShowS #
Show Int8 |
Methods showsPrec :: Int -> Int8 -> ShowS # show :: Int8 -> String # showList :: [Int8] -> ShowS #
Show Int16 |
Methods showsPrec :: Int -> Int16 -> ShowS # show :: Int16 -> String # showList :: [Int16] -> ShowS #
Show Int32 |
Methods showsPrec :: Int -> Int32 -> ShowS # show :: Int32 -> String # showList :: [Int32] -> ShowS #
Show Int64 |
Methods showsPrec :: Int -> Int64 -> ShowS # show :: Int64 -> String # showList :: [Int64] -> ShowS #
Show Integer |
Methods showsPrec :: Int -> Integer -> ShowS # show :: Integer -> String # showList :: [Integer] -> ShowS #
Show Ordering |
Methods showsPrec :: Int -> Ordering -> ShowS # show :: Ordering -> String # showList :: [Ordering] -> ShowS #
Show Word |
Methods showsPrec :: Int -> Word -> ShowS # show :: Word -> String # showList :: [Word] -> ShowS #
Show Word8 |
Methods showsPrec :: Int -> Word8 -> ShowS # show :: Word8 -> String # showList :: [Word8] -> ShowS #
Show Word16 |
Methods showsPrec :: Int -> Word16 -> ShowS # show :: Word16 -> String # showList :: [Word16] -> ShowS #
Show Word32 |
Methods showsPrec :: Int -> Word32 -> ShowS # show :: Word32 -> String # showList :: [Word32] -> ShowS #
Show Word64 |
Methods showsPrec :: Int -> Word64 -> ShowS # show :: Word64 -> String # showList :: [Word64] -> ShowS #
Show CallStack |
Methods showsPrec :: Int -> CallStack -> ShowS # show :: CallStack -> String # showList :: [CallStack] -> ShowS #
Show TypeRep |
Methods showsPrec :: Int -> TypeRep -> ShowS # show :: TypeRep -> String # showList :: [TypeRep] -> ShowS #
Show () |
Methods showsPrec :: Int -> () -> ShowS # show :: () -> String # showList :: [()] -> ShowS #
Show TyCon |
Methods showsPrec :: Int -> TyCon -> ShowS # show :: TyCon -> String # showList :: [TyCon] -> ShowS #
Show Module |
Methods showsPrec :: Int -> Module -> ShowS # show :: Module -> String # showList :: [Module] -> ShowS #
Show TrName |
Methods showsPrec :: Int -> TrName -> ShowS # show :: TrName -> String # showList :: [TrName] -> ShowS #
Show FD |
Methods showsPrec :: Int -> FD -> ShowS # show :: FD -> String # showList :: [FD] -> ShowS #
Show HandleType |
Methods showsPrec :: Int -> HandleType -> ShowS # show :: HandleType -> String # showList :: [HandleType] -> ShowS #
Show Natural |
Methods showsPrec :: Int -> Natural -> ShowS # show :: Natural -> String # showList :: [Natural] -> ShowS #
Show Void |
Methods showsPrec :: Int -> Void -> ShowS # show :: Void -> String # showList :: [Void] -> ShowS #
Show DataType |
Methods showsPrec :: Int -> DataType -> ShowS # show :: DataType -> String # showList :: [DataType] -> ShowS #
Show Constr |
Methods showsPrec :: Int -> Constr -> ShowS # show :: Constr -> String # showList :: [Constr] -> ShowS #
Show DataRep |
Methods showsPrec :: Int -> DataRep -> ShowS # show :: DataRep -> String # showList :: [DataRep] -> ShowS #
Show ConstrRep |
Methods showsPrec :: Int -> ConstrRep -> ShowS # show :: ConstrRep -> String # showList :: [ConstrRep] -> ShowS #
Show Fixity |
Methods showsPrec :: Int -> Fixity -> ShowS # show :: Fixity -> String # showList :: [Fixity] -> ShowS #
Show Version |
Methods showsPrec :: Int -> Version -> ShowS # show :: Version -> String # showList :: [Version] -> ShowS #
Show GCStats |
Methods showsPrec :: Int -> GCStats -> ShowS # show :: GCStats -> String # showList :: [GCStats] -> ShowS #
Show HandlePosn |
Methods showsPrec :: Int -> HandlePosn -> ShowS # show :: HandlePosn -> String # showList :: [HandlePosn] -> ShowS #
Show PatternMatchFail |
Methods showsPrec :: Int -> PatternMatchFail -> ShowS # show :: PatternMatchFail -> String # showList :: [PatternMatchFail] -> ShowS #
Show RecSelError |
Methods showsPrec :: Int -> RecSelError -> ShowS # show :: RecSelError -> String # showList :: [RecSelError] -> ShowS #
Show RecConError |
Methods showsPrec :: Int -> RecConError -> ShowS # show :: RecConError -> String # showList :: [RecConError] -> ShowS #
Show RecUpdError |
Methods showsPrec :: Int -> RecUpdError -> ShowS # show :: RecUpdError -> String # showList :: [RecUpdError] -> ShowS #
Show NoMethodError |
Methods showsPrec :: Int -> NoMethodError -> ShowS # show :: NoMethodError -> String # showList :: [NoMethodError] -> ShowS #
Show TypeError |
Methods showsPrec :: Int -> TypeError -> ShowS # show :: TypeError -> String # showList :: [TypeError] -> ShowS #
Show NonTermination |
Methods showsPrec :: Int -> NonTermination -> ShowS # show :: NonTermination -> String # showList :: [NonTermination] -> ShowS #
Show NestedAtomically |
Methods showsPrec :: Int -> NestedAtomically -> ShowS # show :: NestedAtomically -> String # showList :: [NestedAtomically] -> ShowS #
Show CDev |
Methods showsPrec :: Int -> CDev -> ShowS # show :: CDev -> String # showList :: [CDev] -> ShowS #
Show CIno |
Methods showsPrec :: Int -> CIno -> ShowS # show :: CIno -> String # showList :: [CIno] -> ShowS #
Show CMode |
Methods showsPrec :: Int -> CMode -> ShowS # show :: CMode -> String # showList :: [CMode] -> ShowS #
Show COff |
Methods showsPrec :: Int -> COff -> ShowS # show :: COff -> String # showList :: [COff] -> ShowS #
Show CPid |
Methods showsPrec :: Int -> CPid -> ShowS # show :: CPid -> String # showList :: [CPid] -> ShowS #
Show CSsize |
Methods showsPrec :: Int -> CSsize -> ShowS # show :: CSsize -> String # showList :: [CSsize] -> ShowS #
Show CGid |
Methods showsPrec :: Int -> CGid -> ShowS # show :: CGid -> String # showList :: [CGid] -> ShowS #
Show CNlink |
Methods showsPrec :: Int -> CNlink -> ShowS # show :: CNlink -> String # showList :: [CNlink] -> ShowS #
Show CUid |
Methods showsPrec :: Int -> CUid -> ShowS # show :: CUid -> String # showList :: [CUid] -> ShowS #
Show CCc |
Methods showsPrec :: Int -> CCc -> ShowS # show :: CCc -> String # showList :: [CCc] -> ShowS #
Show CSpeed |
Methods showsPrec :: Int -> CSpeed -> ShowS # show :: CSpeed -> String # showList :: [CSpeed] -> ShowS #
Show CTcflag |
Methods showsPrec :: Int -> CTcflag -> ShowS # show :: CTcflag -> String # showList :: [CTcflag] -> ShowS #
Show CRLim |
Methods showsPrec :: Int -> CRLim -> ShowS # show :: CRLim -> String # showList :: [CRLim] -> ShowS #
Show Fd |
Methods showsPrec :: Int -> Fd -> ShowS # show :: Fd -> String # showList :: [Fd] -> ShowS #
Show ThreadId |
Methods showsPrec :: Int -> ThreadId -> ShowS # show :: ThreadId -> String # showList :: [ThreadId] -> ShowS #
Show BlockReason |
Methods showsPrec :: Int -> BlockReason -> ShowS # show :: BlockReason -> String # showList :: [BlockReason] -> ShowS #
Show ThreadStatus |
Methods showsPrec :: Int -> ThreadStatus -> ShowS # show :: ThreadStatus -> String # showList :: [ThreadStatus] -> ShowS #
Show BlockedIndefinitelyOnMVar |
Methods showsPrec :: Int -> BlockedIndefinitelyOnMVar -> ShowS # show :: BlockedIndefinitelyOnMVar -> String # showList :: [BlockedIndefinitelyOnMVar] -> ShowS #
Show BlockedIndefinitelyOnSTM |
Methods showsPrec :: Int -> BlockedIndefinitelyOnSTM -> ShowS # show :: BlockedIndefinitelyOnSTM -> String # showList :: [BlockedIndefinitelyOnSTM] -> ShowS #
Show Deadlock |
Methods showsPrec :: Int -> Deadlock -> ShowS # show :: Deadlock -> String # showList :: [Deadlock] -> ShowS #
Show AllocationLimitExceeded |
Methods showsPrec :: Int -> AllocationLimitExceeded -> ShowS # show :: AllocationLimitExceeded -> String # showList :: [AllocationLimitExceeded] -> ShowS #
Show AssertionFailed |
Methods showsPrec :: Int -> AssertionFailed -> ShowS # show :: AssertionFailed -> String # showList :: [AssertionFailed] -> ShowS #
Show SomeAsyncException |
Methods showsPrec :: Int -> SomeAsyncException -> ShowS # show :: SomeAsyncException -> String # showList :: [SomeAsyncException] -> ShowS #
Show AsyncException |
Methods showsPrec :: Int -> AsyncException -> ShowS # show :: AsyncException -> String # showList :: [AsyncException] -> ShowS #
Show ArrayException |
Methods showsPrec :: Int -> ArrayException -> ShowS # show :: ArrayException -> String # showList :: [ArrayException] -> ShowS #
Show ExitCode |
Methods showsPrec :: Int -> ExitCode -> ShowS # show :: ExitCode -> String # showList :: [ExitCode] -> ShowS #
Show IOErrorType |
Methods showsPrec :: Int -> IOErrorType -> ShowS # show :: IOErrorType -> String # showList :: [IOErrorType] -> ShowS #
Show Handle |
Methods showsPrec :: Int -> Handle -> ShowS # show :: Handle -> String # showList :: [Handle] -> ShowS #
Show BufferMode |
Methods showsPrec :: Int -> BufferMode -> ShowS # show :: BufferMode -> String # showList :: [BufferMode] -> ShowS #
Show Newline |
Methods showsPrec :: Int -> Newline -> ShowS # show :: Newline -> String # showList :: [Newline] -> ShowS #
Show NewlineMode |
Methods showsPrec :: Int -> NewlineMode -> ShowS # show :: NewlineMode -> String # showList :: [NewlineMode] -> ShowS #
Show WordPtr |
Methods showsPrec :: Int -> WordPtr -> ShowS # show :: WordPtr -> String # showList :: [WordPtr] -> ShowS #
Show IntPtr |
Methods showsPrec :: Int -> IntPtr -> ShowS # show :: IntPtr -> String # showList :: [IntPtr] -> ShowS #
Show CChar |
Methods showsPrec :: Int -> CChar -> ShowS # show :: CChar -> String # showList :: [CChar] -> ShowS #
Show CSChar |
Methods showsPrec :: Int -> CSChar -> ShowS # show :: CSChar -> String # showList :: [CSChar] -> ShowS #
Show CUChar |
Methods showsPrec :: Int -> CUChar -> ShowS # show :: CUChar -> String # showList :: [CUChar] -> ShowS #
Show CShort |
Methods showsPrec :: Int -> CShort -> ShowS # show :: CShort -> String # showList :: [CShort] -> ShowS #
Show CUShort |
Methods showsPrec :: Int -> CUShort -> ShowS # show :: CUShort -> String # showList :: [CUShort] -> ShowS #
Show CInt |
Methods showsPrec :: Int -> CInt -> ShowS # show :: CInt -> String # showList :: [CInt] -> ShowS #
Show CUInt |
Methods showsPrec :: Int -> CUInt -> ShowS # show :: CUInt -> String # showList :: [CUInt] -> ShowS #
Show CLong |
Methods showsPrec :: Int -> CLong -> ShowS # show :: CLong -> String # showList :: [CLong] -> ShowS #
Show CULong |
Methods showsPrec :: Int -> CULong -> ShowS # show :: CULong -> String # showList :: [CULong] -> ShowS #
Show CLLong |
Methods showsPrec :: Int -> CLLong -> ShowS # show :: CLLong -> String # showList :: [CLLong] -> ShowS #
Show CULLong |
Methods showsPrec :: Int -> CULLong -> ShowS # show :: CULLong -> String # showList :: [CULLong] -> ShowS #
Show CFloat |
Methods showsPrec :: Int -> CFloat -> ShowS # show :: CFloat -> String # showList :: [CFloat] -> ShowS #
Show CDouble |
Methods showsPrec :: Int -> CDouble -> ShowS # show :: CDouble -> String # showList :: [CDouble] -> ShowS #
Show CPtrdiff |
Methods showsPrec :: Int -> CPtrdiff -> ShowS # show :: CPtrdiff -> String # showList :: [CPtrdiff] -> ShowS #
Show CSize |
Methods showsPrec :: Int -> CSize -> ShowS # show :: CSize -> String # showList :: [CSize] -> ShowS #
Show CWchar |
Methods showsPrec :: Int -> CWchar -> ShowS # show :: CWchar -> String # showList :: [CWchar] -> ShowS #
Show CSigAtomic |
Methods showsPrec :: Int -> CSigAtomic -> ShowS # show :: CSigAtomic -> String # showList :: [CSigAtomic] -> ShowS #
Show CClock |
Methods showsPrec :: Int -> CClock -> ShowS # show :: CClock -> String # showList :: [CClock] -> ShowS #
Show CTime |
Methods showsPrec :: Int -> CTime -> ShowS # show :: CTime -> String # showList :: [CTime] -> ShowS #
Show CUSeconds |
Methods showsPrec :: Int -> CUSeconds -> ShowS # show :: CUSeconds -> String # showList :: [CUSeconds] -> ShowS #
Show CSUSeconds |
Methods showsPrec :: Int -> CSUSeconds -> ShowS # show :: CSUSeconds -> String # showList :: [CSUSeconds] -> ShowS #
Show CIntPtr |
Methods showsPrec :: Int -> CIntPtr -> ShowS # show :: CIntPtr -> String # showList :: [CIntPtr] -> ShowS #
Show CUIntPtr |
Methods showsPrec :: Int -> CUIntPtr -> ShowS # show :: CUIntPtr -> String # showList :: [CUIntPtr] -> ShowS #
Show CIntMax |
Methods showsPrec :: Int -> CIntMax -> ShowS # show :: CIntMax -> String # showList :: [CIntMax] -> ShowS #
Show CUIntMax |
Methods showsPrec :: Int -> CUIntMax -> ShowS # show :: CUIntMax -> String # showList :: [CUIntMax] -> ShowS #
Show SeekMode |
Methods showsPrec :: Int -> SeekMode -> ShowS # show :: SeekMode -> String # showList :: [SeekMode] -> ShowS #
Show All |
Methods showsPrec :: Int -> All -> ShowS # show :: All -> String # showList :: [All] -> ShowS #
Show Any |
Methods showsPrec :: Int -> Any -> ShowS # show :: Any -> String # showList :: [Any] -> ShowS #
Show Fixity |
Methods showsPrec :: Int -> Fixity -> ShowS # show :: Fixity -> String # showList :: [Fixity] -> ShowS #
Show Associativity |
Methods showsPrec :: Int -> Associativity -> ShowS # show :: Associativity -> String # showList :: [Associativity] -> ShowS #
Show SourceUnpackedness |
Methods showsPrec :: Int -> SourceUnpackedness -> ShowS # show :: SourceUnpackedness -> String # showList :: [SourceUnpackedness] -> ShowS #
Show SourceStrictness |
Methods showsPrec :: Int -> SourceStrictness -> ShowS # show :: SourceStrictness -> String # showList :: [SourceStrictness] -> ShowS #
Show DecidedStrictness |
Methods showsPrec :: Int -> DecidedStrictness -> ShowS # show :: DecidedStrictness -> String # showList :: [DecidedStrictness] -> ShowS #
Show MaskingState |
Methods showsPrec :: Int -> MaskingState -> ShowS # show :: MaskingState -> String # showList :: [MaskingState] -> ShowS #
Show IOException |
Methods showsPrec :: Int -> IOException -> ShowS # show :: IOException -> String # showList :: [IOException] -> ShowS #
Show ErrorCall |
Methods showsPrec :: Int -> ErrorCall -> ShowS # show :: ErrorCall -> String # showList :: [ErrorCall] -> ShowS #
Show ArithException |
Methods showsPrec :: Int -> ArithException -> ShowS # show :: ArithException -> String # showList :: [ArithException] -> ShowS #
Show SomeNat |
Methods showsPrec :: Int -> SomeNat -> ShowS # show :: SomeNat -> String # showList :: [SomeNat] -> ShowS #
Show SomeSymbol |
Methods showsPrec :: Int -> SomeSymbol -> ShowS # show :: SomeSymbol -> String # showList :: [SomeSymbol] -> ShowS #
Show IOMode |
Methods showsPrec :: Int -> IOMode -> ShowS # show :: IOMode -> String # showList :: [IOMode] -> ShowS #
Show Lexeme |
Methods showsPrec :: Int -> Lexeme -> ShowS # show :: Lexeme -> String # showList :: [Lexeme] -> ShowS #
Show Number |
Methods showsPrec :: Int -> Number -> ShowS # show :: Number -> String # showList :: [Number] -> ShowS #
Show GeneralCategory |
Methods showsPrec :: Int -> GeneralCategory -> ShowS # show :: GeneralCategory -> String # showList :: [GeneralCategory] -> ShowS #
Show SomeException |
Methods showsPrec :: Int -> SomeException -> ShowS # show :: SomeException -> String # showList :: [SomeException] -> ShowS #
Show SrcLoc |
Methods showsPrec :: Int -> SrcLoc -> ShowS # show :: SrcLoc -> String # showList :: [SrcLoc] -> ShowS #
Show UTF32_Invalid |
Methods showsPrec :: Int -> UTF32_Invalid -> ShowS # show :: UTF32_Invalid -> String # showList :: [UTF32_Invalid] -> ShowS #
Show UTF16_Invalid |
Methods showsPrec :: Int -> UTF16_Invalid -> ShowS # show :: UTF16_Invalid -> String # showList :: [UTF16_Invalid] -> ShowS #
Show ISO_8859_1_Invalid |
Methods showsPrec :: Int -> ISO_8859_1_Invalid -> ShowS # show :: ISO_8859_1_Invalid -> String # showList :: [ISO_8859_1_Invalid] -> ShowS #
Show ASCII7_Invalid |
Methods showsPrec :: Int -> ASCII7_Invalid -> ShowS # show :: ASCII7_Invalid -> String # showList :: [ASCII7_Invalid] -> ShowS #
Show Encoding |
Methods showsPrec :: Int -> Encoding -> ShowS # show :: Encoding -> String # showList :: [Encoding] -> ShowS #
Show String |
Methods showsPrec :: Int -> String -> ShowS # show :: String -> String # showList :: [String] -> ShowS #
Show AsciiString |
Methods showsPrec :: Int -> AsciiString -> ShowS # show :: AsciiString -> String # showList :: [AsciiString] -> ShowS #
Show ValidationFailure |
Methods showsPrec :: Int -> ValidationFailure -> ShowS # show :: ValidationFailure -> String # showList :: [ValidationFailure] -> ShowS #
Show OutOfBoundOperation |
Methods showsPrec :: Int -> OutOfBoundOperation -> ShowS # show :: OutOfBoundOperation -> String # showList :: [OutOfBoundOperation] -> ShowS #
Show OutOfBound |
Methods showsPrec :: Int -> OutOfBound -> ShowS # show :: OutOfBound -> String # showList :: [OutOfBound] -> ShowS #
Show RecastSourceSize |
Methods showsPrec :: Int -> RecastSourceSize -> ShowS # show :: RecastSourceSize -> String # showList :: [RecastSourceSize] -> ShowS #
Show RecastDestinationSize |
Methods showsPrec :: Int -> RecastDestinationSize -> ShowS # show :: RecastDestinationSize -> String # showList :: [RecastDestinationSize] -> ShowS #
Show InvalidRecast |
Methods showsPrec :: Int -> InvalidRecast -> ShowS # show :: InvalidRecast -> String # showList :: [InvalidRecast] -> ShowS #
Show NonEmptyCollectionIsEmpty |
Methods showsPrec :: Int -> NonEmptyCollectionIsEmpty -> ShowS # show :: NonEmptyCollectionIsEmpty -> String # showList :: [NonEmptyCollectionIsEmpty] -> ShowS #
Show FileSize |
Methods showsPrec :: Int -> FileSize -> ShowS # show :: FileSize -> String # showList :: [FileSize] -> ShowS #
Show Word256 |
Methods showsPrec :: Int -> Word256 -> ShowS # show :: Word256 -> String # showList :: [Word256] -> ShowS #
Show Word128 |
Methods showsPrec :: Int -> Word128 -> ShowS # show :: Word128 -> String # showList :: [Word128] -> ShowS #
Show Char7 |
Methods showsPrec :: Int -> Char7 -> ShowS # show :: Char7 -> String # showList :: [Char7] -> ShowS #
Show Endianness |
Methods showsPrec :: Int -> Endianness -> ShowS # show :: Endianness -> String # showList :: [Endianness] -> ShowS #
Show Arch # |
Methods showsPrec :: Int -> Arch -> ShowS # show :: Arch -> String # showList :: [Arch] -> ShowS #
Show OS # |
Methods showsPrec :: Int -> OS -> ShowS # show :: OS -> String # showList :: [OS] -> ShowS #
Show PartialError # |
Methods showsPrec :: Int -> PartialError -> ShowS # show :: PartialError -> String # showList :: [PartialError] -> ShowS #
Show Seconds # |
Methods showsPrec :: Int -> Seconds -> ShowS # show :: Seconds -> String # showList :: [Seconds] -> ShowS #
Show NanoSeconds # |
Methods showsPrec :: Int -> NanoSeconds -> ShowS # show :: NanoSeconds -> String # showList :: [NanoSeconds] -> ShowS #
Show And # |
Methods showsPrec :: Int -> And -> ShowS # show :: And -> String # showList :: [And] -> ShowS #
Show Condition # |
Methods showsPrec :: Int -> Condition -> ShowS # show :: Condition -> String # showList :: [Condition] -> ShowS #
Show Bitmap # |
Methods showsPrec :: Int -> Bitmap -> ShowS # show :: Bitmap -> String # showList :: [Bitmap] -> ShowS #
Show IPv4 # |
Methods showsPrec :: Int -> IPv4 -> ShowS # show :: IPv4 -> String # showList :: [IPv4] -> ShowS #
Show IPv6 # |
Methods showsPrec :: Int -> IPv6 -> ShowS # show :: IPv6 -> String # showList :: [IPv6] -> ShowS #
Show UUID # |
Methods showsPrec :: Int -> UUID -> ShowS # show :: UUID -> String # showList :: [UUID] -> ShowS #
Show FileName # |
Methods showsPrec :: Int -> FileName -> ShowS # show :: FileName -> String # showList :: [FileName] -> ShowS #
Show FilePath # |
Methods showsPrec :: Int -> FilePath -> ShowS # show :: FilePath -> String # showList :: [FilePath] -> ShowS #
Show Relativity # |
Methods showsPrec :: Int -> Relativity -> ShowS # show :: Relativity -> String # showList :: [Relativity] -> ShowS #
Show a => Show [a] |
Methods showsPrec :: Int -> [a] -> ShowS # show :: [a] -> String # showList :: [[a]] -> ShowS #
Show a => Show (Maybe a) |
Methods showsPrec :: Int -> Maybe a -> ShowS # show :: Maybe a -> String # showList :: [Maybe a] -> ShowS #
Show a => Show (Ratio a) |
Methods showsPrec :: Int -> Ratio a -> ShowS # show :: Ratio a -> String # showList :: [Ratio a] -> ShowS #
Show (Ptr a) |
Methods showsPrec :: Int -> Ptr a -> ShowS # show :: Ptr a -> String # showList :: [Ptr a] -> ShowS #
Show (FunPtr a) |
Methods showsPrec :: Int -> FunPtr a -> ShowS # show :: FunPtr a -> String # showList :: [FunPtr a] -> ShowS #
Show (V1 p) |
Methods showsPrec :: Int -> V1 p -> ShowS # show :: V1 p -> String # showList :: [V1 p] -> ShowS #
Show (U1 p) |
Methods showsPrec :: Int -> U1 p -> ShowS # show :: U1 p -> String # showList :: [U1 p] -> ShowS #
Show p => Show (Par1 p) |
Methods showsPrec :: Int -> Par1 p -> ShowS # show :: Par1 p -> String # showList :: [Par1 p] -> ShowS #
Show a => Show (Identity a) | This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed
Methods showsPrec :: Int -> Identity a -> ShowS # show :: Identity a -> String # showList :: [Identity a] -> ShowS #
Show a => Show (Min a) |
Methods showsPrec :: Int -> Min a -> ShowS # show :: Min a -> String # showList :: [Min a] -> ShowS #
Show a => Show (Max a) |
Methods showsPrec :: Int -> Max a -> ShowS # show :: Max a -> String # showList :: [Max a] -> ShowS #
Show a => Show (First a) |
Methods showsPrec :: Int -> First a -> ShowS # show :: First a -> String # showList :: [First a] -> ShowS #
Show a => Show (Last a) |
Methods showsPrec :: Int -> Last a -> ShowS # show :: Last a -> String # showList :: [Last a] -> ShowS #
Show m => Show (WrappedMonoid m) |
Methods showsPrec :: Int -> WrappedMonoid m -> ShowS # show :: WrappedMonoid m -> String # showList :: [WrappedMonoid m] -> ShowS #
Show a => Show (Option a) |
Methods showsPrec :: Int -> Option a -> ShowS # show :: Option a -> String # showList :: [Option a] -> ShowS #
Show a => Show (NonEmpty a) |
Methods showsPrec :: Int -> NonEmpty a -> ShowS # show :: NonEmpty a -> String # showList :: [NonEmpty a] -> ShowS #
Show a => Show (ZipList a) |
Methods showsPrec :: Int -> ZipList a -> ShowS # show :: ZipList a -> String # showList :: [ZipList a] -> ShowS #
Show (ForeignPtr a) |
Methods showsPrec :: Int -> ForeignPtr a -> ShowS # show :: ForeignPtr a -> String # showList :: [ForeignPtr a] -> ShowS #
Show a => Show (Dual a) |
Methods showsPrec :: Int -> Dual a -> ShowS # show :: Dual a -> String # showList :: [Dual a] -> ShowS #
Show a => Show (Sum a) |
Methods showsPrec :: Int -> Sum a -> ShowS # show :: Sum a -> String # showList :: [Sum a] -> ShowS #
Show a => Show (Product a) |
Methods showsPrec :: Int -> Product a -> ShowS # show :: Product a -> String # showList :: [Product a] -> ShowS #
Show a => Show (First a) |
Methods showsPrec :: Int -> First a -> ShowS # show :: First a -> String # showList :: [First a] -> ShowS #
Show a => Show (Last a) |
Methods showsPrec :: Int -> Last a -> ShowS # show :: Last a -> String # showList :: [Last a] -> ShowS #
Show a => Show (Array a) |
Methods showsPrec :: Int -> Array a -> ShowS # show :: Array a -> String # showList :: [Array a] -> ShowS #
(PrimType ty, Show ty) => Show (UArray ty) |
Methods showsPrec :: Int -> UArray ty -> ShowS # show :: UArray ty -> String # showList :: [UArray ty] -> ShowS #
(PrimType ty, Show ty) => Show (Block ty) |
Methods showsPrec :: Int -> Block ty -> ShowS # show :: Block ty -> String # showList :: [Block ty] -> ShowS #
Show a => Show (NonEmpty a) |
Methods showsPrec :: Int -> NonEmpty a -> ShowS # show :: NonEmpty a -> String # showList :: [NonEmpty a] -> ShowS #
Show (Offset ty) |
Methods showsPrec :: Int -> Offset ty -> ShowS # show :: Offset ty -> String # showList :: [Offset ty] -> ShowS #
Show (CountOf ty) |
Methods showsPrec :: Int -> CountOf ty -> ShowS # show :: CountOf ty -> String # showList :: [CountOf ty] -> ShowS #
Show (Zn64 n) |
Methods showsPrec :: Int -> Zn64 n -> ShowS # show :: Zn64 n -> String # showList :: [Zn64 n] -> ShowS #
Show (Zn n) |
Methods showsPrec :: Int -> Zn n -> ShowS # show :: Zn n -> String # showList :: [Zn n] -> ShowS #
Show (FinalPtr a) |
Methods showsPrec :: Int -> FinalPtr a -> ShowS # show :: FinalPtr a -> String # showList :: [FinalPtr a] -> ShowS #
Show a => Show (LE a) |
Methods showsPrec :: Int -> LE a -> ShowS # show :: LE a -> String # showList :: [LE a] -> ShowS #
Show a => Show (BE a) |
Methods showsPrec :: Int -> BE a -> ShowS # show :: BE a -> String # showList :: [BE a] -> ShowS #
Show a => Show (DList a) # |
Methods showsPrec :: Int -> DList a -> ShowS # show :: DList a -> String # showList :: [DList a] -> ShowS #
Show (ParseError input) # |
Methods showsPrec :: Int -> ParseError input -> ShowS # show :: ParseError input -> String # showList :: [ParseError input] -> ShowS #
(Show ty, PrimType ty) => Show (ChunkedUArray ty) # |
Methods showsPrec :: Int -> ChunkedUArray ty -> ShowS # show :: ChunkedUArray ty -> String # showList :: [ChunkedUArray ty] -> ShowS #
(Show b, Show a) => Show (Either a b) |
Methods showsPrec :: Int -> Either a b -> ShowS # show :: Either a b -> String # showList :: [Either a b] -> ShowS #
Show (f p) => Show (Rec1 f p) |
Methods showsPrec :: Int -> Rec1 f p -> ShowS # show :: Rec1 f p -> String # showList :: [Rec1 f p] -> ShowS #
Show (URec Char p) |
Methods showsPrec :: Int -> URec Char p -> ShowS # show :: URec Char p -> String # showList :: [URec Char p] -> ShowS #
Show (URec Double p) |
Methods showsPrec :: Int -> URec Double p -> ShowS # show :: URec Double p -> String # showList :: [URec Double p] -> ShowS #
Show (URec Float p) |
Methods showsPrec :: Int -> URec Float p -> ShowS # show :: URec Float p -> String # showList :: [URec Float p] -> ShowS #
Show (URec Int p) |
Methods showsPrec :: Int -> URec Int p -> ShowS # show :: URec Int p -> String # showList :: [URec Int p] -> ShowS #
Show (URec Word p) |
Methods showsPrec :: Int -> URec Word p -> ShowS # show :: URec Word p -> String # showList :: [URec Word p] -> ShowS #
(Show a, Show b) => Show (a, b) |
Methods showsPrec :: Int -> (a, b) -> ShowS # show :: (a, b) -> String # showList :: [(a, b)] -> ShowS #
(Ix a, Show a, Show b) => Show (Array a b) |
Methods showsPrec :: Int -> Array a b -> ShowS # show :: Array a b -> String # showList :: [Array a b] -> ShowS #
(Show b, Show a) => Show (Arg a b) |
Methods showsPrec :: Int -> Arg a b -> ShowS # show :: Arg a b -> String # showList :: [Arg a b] -> ShowS #
Show (Proxy k s) |
Methods showsPrec :: Int -> Proxy k s -> ShowS # show :: Proxy k s -> String # showList :: [Proxy k s] -> ShowS #
Show (ST s a) |
Methods showsPrec :: Int -> ST s a -> ShowS # show :: ST s a -> String # showList :: [ST s a] -> ShowS #
Show a => Show (ListN n a) |
Methods showsPrec :: Int -> ListN n a -> ShowS # show :: ListN n a -> String # showList :: [ListN n a] -> ShowS #
(Show b, Show a) => Show (These a b) |
Methods showsPrec :: Int -> These a b -> ShowS # show :: These a b -> String # showList :: [These a b] -> ShowS #
(Show b, Show a) => Show (Tuple2 a b) # |
Methods showsPrec :: Int -> Tuple2 a b -> ShowS # show :: Tuple2 a b -> String # showList :: [Tuple2 a b] -> ShowS #
Show k => Show (Result input k) # |
Methods showsPrec :: Int -> Result input k -> ShowS # show :: Result input k -> String # showList :: [Result input k] -> ShowS #
Show c => Show (K1 i c p) |
Methods showsPrec :: Int -> K1 i c p -> ShowS # show :: K1 i c p -> String # showList :: [K1 i c p] -> ShowS #
(Show (g p), Show (f p)) => Show ((:+:) f g p) |
Methods showsPrec :: Int -> (f :+: g) p -> ShowS # show :: (f :+: g) p -> String # showList :: [(f :+: g) p] -> ShowS #
(Show (g p), Show (f p)) => Show ((:*:) f g p) |
Methods showsPrec :: Int -> (f :*: g) p -> ShowS # show :: (f :*: g) p -> String # showList :: [(f :*: g) p] -> ShowS #
Show (f (g p)) => Show ((:.:) f g p) |
Methods showsPrec :: Int -> (f :.: g) p -> ShowS # show :: (f :.: g) p -> String # showList :: [(f :.: g) p] -> ShowS #
(Show a, Show b, Show c) => Show (a, b, c) |
Methods showsPrec :: Int -> (a, b, c) -> ShowS # show :: (a, b, c) -> String # showList :: [(a, b, c)] -> ShowS #
Show a => Show (Const k a b) | This instance would be equivalent to the derived instances of the `Const` newtype if the `runConst` field were removed
Methods showsPrec :: Int -> Const k a b -> ShowS # show :: Const k a b -> String # showList :: [Const k a b] -> ShowS #
Show (f a) => Show (Alt k f a) |
Methods showsPrec :: Int -> Alt k f a -> ShowS # show :: Alt k f a -> String # showList :: [Alt k f a] -> ShowS #
Show (Coercion k a b) |
Methods showsPrec :: Int -> Coercion k a b -> ShowS # show :: Coercion k a b -> String # showList :: [Coercion k a b] -> ShowS #
Show ((:~:) k a b) |
Methods showsPrec :: Int -> (k :~: a) b -> ShowS # show :: (k :~: a) b -> String # showList :: [(k :~: a) b] -> ShowS #
(Show c, Show b, Show a) => Show (Tuple3 a b c) # |
Methods showsPrec :: Int -> Tuple3 a b c -> ShowS # show :: Tuple3 a b c -> String # showList :: [Tuple3 a b c] -> ShowS #
Show (f p) => Show (M1 i c f p) |
Methods showsPrec :: Int -> M1 i c f p -> ShowS # show :: M1 i c f p -> String # showList :: [M1 i c f p] -> ShowS #
(Show a, Show b, Show c, Show d) => Show (a, b, c, d) |
Methods showsPrec :: Int -> (a, b, c, d) -> ShowS # show :: (a, b, c, d) -> String # showList :: [(a, b, c, d)] -> ShowS #
(Show d, Show c, Show b, Show a) => Show (Tuple4 a b c d) # |
Methods showsPrec :: Int -> Tuple4 a b c d -> ShowS # show :: Tuple4 a b c d -> String # showList :: [Tuple4 a b c d] -> ShowS #
(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) |
Methods showsPrec :: Int -> (a, b, c, d, e) -> ShowS # show :: (a, b, c, d, e) -> String # showList :: [(a, b, c, d, e)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) |
Methods showsPrec :: Int -> (a, b, c, d, e, f) -> ShowS # show :: (a, b, c, d, e, f) -> String # showList :: [(a, b, c, d, e, f)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g) |
Methods showsPrec :: Int -> (a, b, c, d, e, f, g) -> ShowS # show :: (a, b, c, d, e, f, g) -> String # showList :: [(a, b, c, d, e, f, g)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h) |
Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h) -> ShowS # show :: (a, b, c, d, e, f, g, h) -> String # showList :: [(a, b, c, d, e, f, g, h)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i) |
Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i) -> ShowS # show :: (a, b, c, d, e, f, g, h, i) -> String # showList :: [(a, b, c, d, e, f, g, h, i)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j) |
Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k) |
Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l) |
Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m) |
Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n) |
Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) |
Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> ShowS #

show :: Show a => a -> String #

Use the Show class to create a String.

Note that this is not efficient, since an intermediate [Char] is going to be created before turning into a real String.

class Eq a => Ord a where #

The `Ord` class is used for totally ordered datatypes.

Instances of `Ord` can be derived for any user-defined datatype whose constituent types are in `Ord`. The declared order of the constructors in the data declaration determines the ordering in derived `Ord` instances. The `Ordering` datatype allows a single comparison to determine the precise ordering of two objects.

Minimal complete definition: either `compare` or `<=`. Using `compare` can be more efficient for complex types.

Minimal complete definition

compare | (<=)

Methods

compare :: a -> a -> Ordering #

(<) :: a -> a -> Bool infix 4 #

(<=) :: a -> a -> Bool infix 4 #

(>) :: a -> a -> Bool infix 4 #

(>=) :: a -> a -> Bool infix 4 #

max :: a -> a -> a #

min :: a -> a -> a #

Instances

Ord Bool |
Methods compare :: Bool -> Bool -> Ordering # (<) :: Bool -> Bool -> Bool # (<=) :: Bool -> Bool -> Bool # (>) :: Bool -> Bool -> Bool # (>=) :: Bool -> Bool -> Bool # max :: Bool -> Bool -> Bool # min :: Bool -> Bool -> Bool #
Ord Char |
Methods compare :: Char -> Char -> Ordering # (<) :: Char -> Char -> Bool # (<=) :: Char -> Char -> Bool # (>) :: Char -> Char -> Bool # (>=) :: Char -> Char -> Bool # max :: Char -> Char -> Char # min :: Char -> Char -> Char #
Ord Double |
Methods compare :: Double -> Double -> Ordering # (<) :: Double -> Double -> Bool # (<=) :: Double -> Double -> Bool # (>) :: Double -> Double -> Bool # (>=) :: Double -> Double -> Bool # max :: Double -> Double -> Double # min :: Double -> Double -> Double #
Ord Float |
Methods compare :: Float -> Float -> Ordering # (<) :: Float -> Float -> Bool # (<=) :: Float -> Float -> Bool # (>) :: Float -> Float -> Bool # (>=) :: Float -> Float -> Bool # max :: Float -> Float -> Float # min :: Float -> Float -> Float #
Ord Int |
Methods compare :: Int -> Int -> Ordering # (<) :: Int -> Int -> Bool # (<=) :: Int -> Int -> Bool # (>) :: Int -> Int -> Bool # (>=) :: Int -> Int -> Bool # max :: Int -> Int -> Int # min :: Int -> Int -> Int #
Ord Int8 |
Methods compare :: Int8 -> Int8 -> Ordering # (<) :: Int8 -> Int8 -> Bool # (<=) :: Int8 -> Int8 -> Bool # (>) :: Int8 -> Int8 -> Bool # (>=) :: Int8 -> Int8 -> Bool # max :: Int8 -> Int8 -> Int8 # min :: Int8 -> Int8 -> Int8 #
Ord Int16 |
Methods compare :: Int16 -> Int16 -> Ordering # (<) :: Int16 -> Int16 -> Bool # (<=) :: Int16 -> Int16 -> Bool # (>) :: Int16 -> Int16 -> Bool # (>=) :: Int16 -> Int16 -> Bool # max :: Int16 -> Int16 -> Int16 # min :: Int16 -> Int16 -> Int16 #
Ord Int32 |
Methods compare :: Int32 -> Int32 -> Ordering # (<) :: Int32 -> Int32 -> Bool # (<=) :: Int32 -> Int32 -> Bool # (>) :: Int32 -> Int32 -> Bool # (>=) :: Int32 -> Int32 -> Bool # max :: Int32 -> Int32 -> Int32 # min :: Int32 -> Int32 -> Int32 #
Ord Int64 |
Methods compare :: Int64 -> Int64 -> Ordering # (<) :: Int64 -> Int64 -> Bool # (<=) :: Int64 -> Int64 -> Bool # (>) :: Int64 -> Int64 -> Bool # (>=) :: Int64 -> Int64 -> Bool # max :: Int64 -> Int64 -> Int64 # min :: Int64 -> Int64 -> Int64 #
Ord Integer |
Methods compare :: Integer -> Integer -> Ordering # (<) :: Integer -> Integer -> Bool # (<=) :: Integer -> Integer -> Bool # (>) :: Integer -> Integer -> Bool # (>=) :: Integer -> Integer -> Bool # max :: Integer -> Integer -> Integer # min :: Integer -> Integer -> Integer #
Ord Ordering |
Methods compare :: Ordering -> Ordering -> Ordering # (<) :: Ordering -> Ordering -> Bool # (<=) :: Ordering -> Ordering -> Bool # (>) :: Ordering -> Ordering -> Bool # (>=) :: Ordering -> Ordering -> Bool # max :: Ordering -> Ordering -> Ordering # min :: Ordering -> Ordering -> Ordering #
Ord Word |
Methods compare :: Word -> Word -> Ordering # (<) :: Word -> Word -> Bool # (<=) :: Word -> Word -> Bool # (>) :: Word -> Word -> Bool # (>=) :: Word -> Word -> Bool # max :: Word -> Word -> Word # min :: Word -> Word -> Word #
Ord Word8 |
Methods compare :: Word8 -> Word8 -> Ordering # (<) :: Word8 -> Word8 -> Bool # (<=) :: Word8 -> Word8 -> Bool # (>) :: Word8 -> Word8 -> Bool # (>=) :: Word8 -> Word8 -> Bool # max :: Word8 -> Word8 -> Word8 # min :: Word8 -> Word8 -> Word8 #
Ord Word16 |
Methods compare :: Word16 -> Word16 -> Ordering # (<) :: Word16 -> Word16 -> Bool # (<=) :: Word16 -> Word16 -> Bool # (>) :: Word16 -> Word16 -> Bool # (>=) :: Word16 -> Word16 -> Bool # max :: Word16 -> Word16 -> Word16 # min :: Word16 -> Word16 -> Word16 #
Ord Word32 |
Methods compare :: Word32 -> Word32 -> Ordering # (<) :: Word32 -> Word32 -> Bool # (<=) :: Word32 -> Word32 -> Bool # (>) :: Word32 -> Word32 -> Bool # (>=) :: Word32 -> Word32 -> Bool # max :: Word32 -> Word32 -> Word32 # min :: Word32 -> Word32 -> Word32 #
Ord Word64 |
Methods compare :: Word64 -> Word64 -> Ordering # (<) :: Word64 -> Word64 -> Bool # (<=) :: Word64 -> Word64 -> Bool # (>) :: Word64 -> Word64 -> Bool # (>=) :: Word64 -> Word64 -> Bool # max :: Word64 -> Word64 -> Word64 # min :: Word64 -> Word64 -> Word64 #
Ord TypeRep |
Methods compare :: TypeRep -> TypeRep -> Ordering # (<) :: TypeRep -> TypeRep -> Bool # (<=) :: TypeRep -> TypeRep -> Bool # (>) :: TypeRep -> TypeRep -> Bool # (>=) :: TypeRep -> TypeRep -> Bool # max :: TypeRep -> TypeRep -> TypeRep # min :: TypeRep -> TypeRep -> TypeRep #
Ord () |
Methods compare :: () -> () -> Ordering # (<) :: () -> () -> Bool # (<=) :: () -> () -> Bool # (>) :: () -> () -> Bool # (>=) :: () -> () -> Bool # max :: () -> () -> () # min :: () -> () -> () #
Ord TyCon |
Methods compare :: TyCon -> TyCon -> Ordering # (<) :: TyCon -> TyCon -> Bool # (<=) :: TyCon -> TyCon -> Bool # (>) :: TyCon -> TyCon -> Bool # (>=) :: TyCon -> TyCon -> Bool # max :: TyCon -> TyCon -> TyCon # min :: TyCon -> TyCon -> TyCon #
Ord BigNat |
Methods compare :: BigNat -> BigNat -> Ordering # (<) :: BigNat -> BigNat -> Bool # (<=) :: BigNat -> BigNat -> Bool # (>) :: BigNat -> BigNat -> Bool # (>=) :: BigNat -> BigNat -> Bool # max :: BigNat -> BigNat -> BigNat # min :: BigNat -> BigNat -> BigNat #
Ord Natural |
Methods compare :: Natural -> Natural -> Ordering # (<) :: Natural -> Natural -> Bool # (<=) :: Natural -> Natural -> Bool # (>) :: Natural -> Natural -> Bool # (>=) :: Natural -> Natural -> Bool # max :: Natural -> Natural -> Natural # min :: Natural -> Natural -> Natural #
Ord Void |
Methods compare :: Void -> Void -> Ordering # (<) :: Void -> Void -> Bool # (<=) :: Void -> Void -> Bool # (>) :: Void -> Void -> Bool # (>=) :: Void -> Void -> Bool # max :: Void -> Void -> Void # min :: Void -> Void -> Void #
Ord Version |
Methods compare :: Version -> Version -> Ordering # (<) :: Version -> Version -> Bool # (<=) :: Version -> Version -> Bool # (>) :: Version -> Version -> Bool # (>=) :: Version -> Version -> Bool # max :: Version -> Version -> Version # min :: Version -> Version -> Version #
Ord CDev |
Methods compare :: CDev -> CDev -> Ordering # (<) :: CDev -> CDev -> Bool # (<=) :: CDev -> CDev -> Bool # (>) :: CDev -> CDev -> Bool # (>=) :: CDev -> CDev -> Bool # max :: CDev -> CDev -> CDev # min :: CDev -> CDev -> CDev #
Ord CIno |
Methods compare :: CIno -> CIno -> Ordering # (<) :: CIno -> CIno -> Bool # (<=) :: CIno -> CIno -> Bool # (>) :: CIno -> CIno -> Bool # (>=) :: CIno -> CIno -> Bool # max :: CIno -> CIno -> CIno # min :: CIno -> CIno -> CIno #
Ord CMode |
Methods compare :: CMode -> CMode -> Ordering # (<) :: CMode -> CMode -> Bool # (<=) :: CMode -> CMode -> Bool # (>) :: CMode -> CMode -> Bool # (>=) :: CMode -> CMode -> Bool # max :: CMode -> CMode -> CMode # min :: CMode -> CMode -> CMode #
Ord COff |
Methods compare :: COff -> COff -> Ordering # (<) :: COff -> COff -> Bool # (<=) :: COff -> COff -> Bool # (>) :: COff -> COff -> Bool # (>=) :: COff -> COff -> Bool # max :: COff -> COff -> COff # min :: COff -> COff -> COff #
Ord CPid |
Methods compare :: CPid -> CPid -> Ordering # (<) :: CPid -> CPid -> Bool # (<=) :: CPid -> CPid -> Bool # (>) :: CPid -> CPid -> Bool # (>=) :: CPid -> CPid -> Bool # max :: CPid -> CPid -> CPid # min :: CPid -> CPid -> CPid #
Ord CSsize |
Methods compare :: CSsize -> CSsize -> Ordering # (<) :: CSsize -> CSsize -> Bool # (<=) :: CSsize -> CSsize -> Bool # (>) :: CSsize -> CSsize -> Bool # (>=) :: CSsize -> CSsize -> Bool # max :: CSsize -> CSsize -> CSsize # min :: CSsize -> CSsize -> CSsize #
Ord CGid |
Methods compare :: CGid -> CGid -> Ordering # (<) :: CGid -> CGid -> Bool # (<=) :: CGid -> CGid -> Bool # (>) :: CGid -> CGid -> Bool # (>=) :: CGid -> CGid -> Bool # max :: CGid -> CGid -> CGid # min :: CGid -> CGid -> CGid #
Ord CNlink |
Methods compare :: CNlink -> CNlink -> Ordering # (<) :: CNlink -> CNlink -> Bool # (<=) :: CNlink -> CNlink -> Bool # (>) :: CNlink -> CNlink -> Bool # (>=) :: CNlink -> CNlink -> Bool # max :: CNlink -> CNlink -> CNlink # min :: CNlink -> CNlink -> CNlink #
Ord CUid |
Methods compare :: CUid -> CUid -> Ordering # (<) :: CUid -> CUid -> Bool # (<=) :: CUid -> CUid -> Bool # (>) :: CUid -> CUid -> Bool # (>=) :: CUid -> CUid -> Bool # max :: CUid -> CUid -> CUid # min :: CUid -> CUid -> CUid #
Ord CCc |
Methods compare :: CCc -> CCc -> Ordering # (<) :: CCc -> CCc -> Bool # (<=) :: CCc -> CCc -> Bool # (>) :: CCc -> CCc -> Bool # (>=) :: CCc -> CCc -> Bool # max :: CCc -> CCc -> CCc # min :: CCc -> CCc -> CCc #
Ord CSpeed |
Methods compare :: CSpeed -> CSpeed -> Ordering # (<) :: CSpeed -> CSpeed -> Bool # (<=) :: CSpeed -> CSpeed -> Bool # (>) :: CSpeed -> CSpeed -> Bool # (>=) :: CSpeed -> CSpeed -> Bool # max :: CSpeed -> CSpeed -> CSpeed # min :: CSpeed -> CSpeed -> CSpeed #
Ord CTcflag |
Methods compare :: CTcflag -> CTcflag -> Ordering # (<) :: CTcflag -> CTcflag -> Bool # (<=) :: CTcflag -> CTcflag -> Bool # (>) :: CTcflag -> CTcflag -> Bool # (>=) :: CTcflag -> CTcflag -> Bool # max :: CTcflag -> CTcflag -> CTcflag # min :: CTcflag -> CTcflag -> CTcflag #
Ord CRLim |
Methods compare :: CRLim -> CRLim -> Ordering # (<) :: CRLim -> CRLim -> Bool # (<=) :: CRLim -> CRLim -> Bool # (>) :: CRLim -> CRLim -> Bool # (>=) :: CRLim -> CRLim -> Bool # max :: CRLim -> CRLim -> CRLim # min :: CRLim -> CRLim -> CRLim #
Ord Fd |
Methods compare :: Fd -> Fd -> Ordering # (<) :: Fd -> Fd -> Bool # (<=) :: Fd -> Fd -> Bool # (>) :: Fd -> Fd -> Bool # (>=) :: Fd -> Fd -> Bool # max :: Fd -> Fd -> Fd # min :: Fd -> Fd -> Fd #
Ord ThreadId |
Methods compare :: ThreadId -> ThreadId -> Ordering # (<) :: ThreadId -> ThreadId -> Bool # (<=) :: ThreadId -> ThreadId -> Bool # (>) :: ThreadId -> ThreadId -> Bool # (>=) :: ThreadId -> ThreadId -> Bool # max :: ThreadId -> ThreadId -> ThreadId # min :: ThreadId -> ThreadId -> ThreadId #
Ord BlockReason |
Methods compare :: BlockReason -> BlockReason -> Ordering # (<) :: BlockReason -> BlockReason -> Bool # (<=) :: BlockReason -> BlockReason -> Bool # (>) :: BlockReason -> BlockReason -> Bool # (>=) :: BlockReason -> BlockReason -> Bool # max :: BlockReason -> BlockReason -> BlockReason # min :: BlockReason -> BlockReason -> BlockReason #
Ord ThreadStatus |
Methods compare :: ThreadStatus -> ThreadStatus -> Ordering # (<) :: ThreadStatus -> ThreadStatus -> Bool # (<=) :: ThreadStatus -> ThreadStatus -> Bool # (>) :: ThreadStatus -> ThreadStatus -> Bool # (>=) :: ThreadStatus -> ThreadStatus -> Bool # max :: ThreadStatus -> ThreadStatus -> ThreadStatus # min :: ThreadStatus -> ThreadStatus -> ThreadStatus #
Ord AsyncException |
Methods compare :: AsyncException -> AsyncException -> Ordering # (<) :: AsyncException -> AsyncException -> Bool # (<=) :: AsyncException -> AsyncException -> Bool # (>) :: AsyncException -> AsyncException -> Bool # (>=) :: AsyncException -> AsyncException -> Bool # max :: AsyncException -> AsyncException -> AsyncException # min :: AsyncException -> AsyncException -> AsyncException #
Ord ArrayException |
Methods compare :: ArrayException -> ArrayException -> Ordering # (<) :: ArrayException -> ArrayException -> Bool # (<=) :: ArrayException -> ArrayException -> Bool # (>) :: ArrayException -> ArrayException -> Bool # (>=) :: ArrayException -> ArrayException -> Bool # max :: ArrayException -> ArrayException -> ArrayException # min :: ArrayException -> ArrayException -> ArrayException #
Ord ExitCode |
Methods compare :: ExitCode -> ExitCode -> Ordering # (<) :: ExitCode -> ExitCode -> Bool # (<=) :: ExitCode -> ExitCode -> Bool # (>) :: ExitCode -> ExitCode -> Bool # (>=) :: ExitCode -> ExitCode -> Bool # max :: ExitCode -> ExitCode -> ExitCode # min :: ExitCode -> ExitCode -> ExitCode #
Ord BufferMode |
Methods compare :: BufferMode -> BufferMode -> Ordering # (<) :: BufferMode -> BufferMode -> Bool # (<=) :: BufferMode -> BufferMode -> Bool # (>) :: BufferMode -> BufferMode -> Bool # (>=) :: BufferMode -> BufferMode -> Bool # max :: BufferMode -> BufferMode -> BufferMode # min :: BufferMode -> BufferMode -> BufferMode #
Ord Newline |
Methods compare :: Newline -> Newline -> Ordering # (<) :: Newline -> Newline -> Bool # (<=) :: Newline -> Newline -> Bool # (>) :: Newline -> Newline -> Bool # (>=) :: Newline -> Newline -> Bool # max :: Newline -> Newline -> Newline # min :: Newline -> Newline -> Newline #
Ord NewlineMode |
Methods compare :: NewlineMode -> NewlineMode -> Ordering # (<) :: NewlineMode -> NewlineMode -> Bool # (<=) :: NewlineMode -> NewlineMode -> Bool # (>) :: NewlineMode -> NewlineMode -> Bool # (>=) :: NewlineMode -> NewlineMode -> Bool # max :: NewlineMode -> NewlineMode -> NewlineMode # min :: NewlineMode -> NewlineMode -> NewlineMode #
Ord WordPtr |
Methods compare :: WordPtr -> WordPtr -> Ordering # (<) :: WordPtr -> WordPtr -> Bool # (<=) :: WordPtr -> WordPtr -> Bool # (>) :: WordPtr -> WordPtr -> Bool # (>=) :: WordPtr -> WordPtr -> Bool # max :: WordPtr -> WordPtr -> WordPtr # min :: WordPtr -> WordPtr -> WordPtr #
Ord IntPtr |
Methods compare :: IntPtr -> IntPtr -> Ordering # (<) :: IntPtr -> IntPtr -> Bool # (<=) :: IntPtr -> IntPtr -> Bool # (>) :: IntPtr -> IntPtr -> Bool # (>=) :: IntPtr -> IntPtr -> Bool # max :: IntPtr -> IntPtr -> IntPtr # min :: IntPtr -> IntPtr -> IntPtr #
Ord CChar |
Methods compare :: CChar -> CChar -> Ordering # (<) :: CChar -> CChar -> Bool # (<=) :: CChar -> CChar -> Bool # (>) :: CChar -> CChar -> Bool # (>=) :: CChar -> CChar -> Bool # max :: CChar -> CChar -> CChar # min :: CChar -> CChar -> CChar #
Ord CSChar |
Methods compare :: CSChar -> CSChar -> Ordering # (<) :: CSChar -> CSChar -> Bool # (<=) :: CSChar -> CSChar -> Bool # (>) :: CSChar -> CSChar -> Bool # (>=) :: CSChar -> CSChar -> Bool # max :: CSChar -> CSChar -> CSChar # min :: CSChar -> CSChar -> CSChar #
Ord CUChar |
Methods compare :: CUChar -> CUChar -> Ordering # (<) :: CUChar -> CUChar -> Bool # (<=) :: CUChar -> CUChar -> Bool # (>) :: CUChar -> CUChar -> Bool # (>=) :: CUChar -> CUChar -> Bool # max :: CUChar -> CUChar -> CUChar # min :: CUChar -> CUChar -> CUChar #
Ord CShort |
Methods compare :: CShort -> CShort -> Ordering # (<) :: CShort -> CShort -> Bool # (<=) :: CShort -> CShort -> Bool # (>) :: CShort -> CShort -> Bool # (>=) :: CShort -> CShort -> Bool # max :: CShort -> CShort -> CShort # min :: CShort -> CShort -> CShort #
Ord CUShort |
Methods compare :: CUShort -> CUShort -> Ordering # (<) :: CUShort -> CUShort -> Bool # (<=) :: CUShort -> CUShort -> Bool # (>) :: CUShort -> CUShort -> Bool # (>=) :: CUShort -> CUShort -> Bool # max :: CUShort -> CUShort -> CUShort # min :: CUShort -> CUShort -> CUShort #
Ord CInt |
Methods compare :: CInt -> CInt -> Ordering # (<) :: CInt -> CInt -> Bool # (<=) :: CInt -> CInt -> Bool # (>) :: CInt -> CInt -> Bool # (>=) :: CInt -> CInt -> Bool # max :: CInt -> CInt -> CInt # min :: CInt -> CInt -> CInt #
Ord CUInt |
Methods compare :: CUInt -> CUInt -> Ordering # (<) :: CUInt -> CUInt -> Bool # (<=) :: CUInt -> CUInt -> Bool # (>) :: CUInt -> CUInt -> Bool # (>=) :: CUInt -> CUInt -> Bool # max :: CUInt -> CUInt -> CUInt # min :: CUInt -> CUInt -> CUInt #
Ord CLong |
Methods compare :: CLong -> CLong -> Ordering # (<) :: CLong -> CLong -> Bool # (<=) :: CLong -> CLong -> Bool # (>) :: CLong -> CLong -> Bool # (>=) :: CLong -> CLong -> Bool # max :: CLong -> CLong -> CLong # min :: CLong -> CLong -> CLong #
Ord CULong |
Methods compare :: CULong -> CULong -> Ordering # (<) :: CULong -> CULong -> Bool # (<=) :: CULong -> CULong -> Bool # (>) :: CULong -> CULong -> Bool # (>=) :: CULong -> CULong -> Bool # max :: CULong -> CULong -> CULong # min :: CULong -> CULong -> CULong #
Ord CLLong |
Methods compare :: CLLong -> CLLong -> Ordering # (<) :: CLLong -> CLLong -> Bool # (<=) :: CLLong -> CLLong -> Bool # (>) :: CLLong -> CLLong -> Bool # (>=) :: CLLong -> CLLong -> Bool # max :: CLLong -> CLLong -> CLLong # min :: CLLong -> CLLong -> CLLong #
Ord CULLong |
Methods compare :: CULLong -> CULLong -> Ordering # (<) :: CULLong -> CULLong -> Bool # (<=) :: CULLong -> CULLong -> Bool # (>) :: CULLong -> CULLong -> Bool # (>=) :: CULLong -> CULLong -> Bool # max :: CULLong -> CULLong -> CULLong # min :: CULLong -> CULLong -> CULLong #
Ord CFloat |
Methods compare :: CFloat -> CFloat -> Ordering # (<) :: CFloat -> CFloat -> Bool # (<=) :: CFloat -> CFloat -> Bool # (>) :: CFloat -> CFloat -> Bool # (>=) :: CFloat -> CFloat -> Bool # max :: CFloat -> CFloat -> CFloat # min :: CFloat -> CFloat -> CFloat #
Ord CDouble |
Methods compare :: CDouble -> CDouble -> Ordering # (<) :: CDouble -> CDouble -> Bool # (<=) :: CDouble -> CDouble -> Bool # (>) :: CDouble -> CDouble -> Bool # (>=) :: CDouble -> CDouble -> Bool # max :: CDouble -> CDouble -> CDouble # min :: CDouble -> CDouble -> CDouble #
Ord CPtrdiff |
Methods compare :: CPtrdiff -> CPtrdiff -> Ordering # (<) :: CPtrdiff -> CPtrdiff -> Bool # (<=) :: CPtrdiff -> CPtrdiff -> Bool # (>) :: CPtrdiff -> CPtrdiff -> Bool # (>=) :: CPtrdiff -> CPtrdiff -> Bool # max :: CPtrdiff -> CPtrdiff -> CPtrdiff # min :: CPtrdiff -> CPtrdiff -> CPtrdiff #
Ord CSize |
Methods compare :: CSize -> CSize -> Ordering # (<) :: CSize -> CSize -> Bool # (<=) :: CSize -> CSize -> Bool # (>) :: CSize -> CSize -> Bool # (>=) :: CSize -> CSize -> Bool # max :: CSize -> CSize -> CSize # min :: CSize -> CSize -> CSize #
Ord CWchar |
Methods compare :: CWchar -> CWchar -> Ordering # (<) :: CWchar -> CWchar -> Bool # (<=) :: CWchar -> CWchar -> Bool # (>) :: CWchar -> CWchar -> Bool # (>=) :: CWchar -> CWchar -> Bool # max :: CWchar -> CWchar -> CWchar # min :: CWchar -> CWchar -> CWchar #
Ord CSigAtomic |
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 CClock |
Methods compare :: CClock -> CClock -> Ordering # (<) :: CClock -> CClock -> Bool # (<=) :: CClock -> CClock -> Bool # (>) :: CClock -> CClock -> Bool # (>=) :: CClock -> CClock -> Bool # max :: CClock -> CClock -> CClock # min :: CClock -> CClock -> CClock #
Ord CTime |
Methods compare :: CTime -> CTime -> Ordering # (<) :: CTime -> CTime -> Bool # (<=) :: CTime -> CTime -> Bool # (>) :: CTime -> CTime -> Bool # (>=) :: CTime -> CTime -> Bool # max :: CTime -> CTime -> CTime # min :: CTime -> CTime -> CTime #
Ord CUSeconds |
Methods compare :: CUSeconds -> CUSeconds -> Ordering # (<) :: CUSeconds -> CUSeconds -> Bool # (<=) :: CUSeconds -> CUSeconds -> Bool # (>) :: CUSeconds -> CUSeconds -> Bool # (>=) :: CUSeconds -> CUSeconds -> Bool # max :: CUSeconds -> CUSeconds -> CUSeconds # min :: CUSeconds -> CUSeconds -> CUSeconds #
Ord CSUSeconds |
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 CIntPtr |
Methods compare :: CIntPtr -> CIntPtr -> Ordering # (<) :: CIntPtr -> CIntPtr -> Bool # (<=) :: CIntPtr -> CIntPtr -> Bool # (>) :: CIntPtr -> CIntPtr -> Bool # (>=) :: CIntPtr -> CIntPtr -> Bool # max :: CIntPtr -> CIntPtr -> CIntPtr # min :: CIntPtr -> CIntPtr -> CIntPtr #
Ord CUIntPtr |
Methods compare :: CUIntPtr -> CUIntPtr -> Ordering # (<) :: CUIntPtr -> CUIntPtr -> Bool # (<=) :: CUIntPtr -> CUIntPtr -> Bool # (>) :: CUIntPtr -> CUIntPtr -> Bool # (>=) :: CUIntPtr -> CUIntPtr -> Bool # max :: CUIntPtr -> CUIntPtr -> CUIntPtr # min :: CUIntPtr -> CUIntPtr -> CUIntPtr #
Ord CIntMax |
Methods compare :: CIntMax -> CIntMax -> Ordering # (<) :: CIntMax -> CIntMax -> Bool # (<=) :: CIntMax -> CIntMax -> Bool # (>) :: CIntMax -> CIntMax -> Bool # (>=) :: CIntMax -> CIntMax -> Bool # max :: CIntMax -> CIntMax -> CIntMax # min :: CIntMax -> CIntMax -> CIntMax #
Ord CUIntMax |
Methods compare :: CUIntMax -> CUIntMax -> Ordering # (<) :: CUIntMax -> CUIntMax -> Bool # (<=) :: CUIntMax -> CUIntMax -> Bool # (>) :: CUIntMax -> CUIntMax -> Bool # (>=) :: CUIntMax -> CUIntMax -> Bool # max :: CUIntMax -> CUIntMax -> CUIntMax # min :: CUIntMax -> CUIntMax -> CUIntMax #
Ord SeekMode |
Methods compare :: SeekMode -> SeekMode -> Ordering # (<) :: SeekMode -> SeekMode -> Bool # (<=) :: SeekMode -> SeekMode -> Bool # (>) :: SeekMode -> SeekMode -> Bool # (>=) :: SeekMode -> SeekMode -> Bool # max :: SeekMode -> SeekMode -> SeekMode # min :: SeekMode -> SeekMode -> SeekMode #
Ord All |
Methods compare :: All -> All -> Ordering # (<) :: All -> All -> Bool # (<=) :: All -> All -> Bool # (>) :: All -> All -> Bool # (>=) :: All -> All -> Bool # max :: All -> All -> All # min :: All -> All -> All #
Ord Any |
Methods compare :: Any -> Any -> Ordering # (<) :: Any -> Any -> Bool # (<=) :: Any -> Any -> Bool # (>) :: Any -> Any -> Bool # (>=) :: Any -> Any -> Bool # max :: Any -> Any -> Any # min :: Any -> Any -> Any #
Ord Fixity |
Methods compare :: Fixity -> Fixity -> Ordering # (<) :: Fixity -> Fixity -> Bool # (<=) :: Fixity -> Fixity -> Bool # (>) :: Fixity -> Fixity -> Bool # (>=) :: Fixity -> Fixity -> Bool # max :: Fixity -> Fixity -> Fixity # min :: Fixity -> Fixity -> Fixity #
Ord Associativity |
Methods compare :: Associativity -> Associativity -> Ordering # (<) :: Associativity -> Associativity -> Bool # (<=) :: Associativity -> Associativity -> Bool # (>) :: Associativity -> Associativity -> Bool # (>=) :: Associativity -> Associativity -> Bool # max :: Associativity -> Associativity -> Associativity # min :: Associativity -> Associativity -> Associativity #
Ord SourceUnpackedness |

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 SourceStrictness |

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 DecidedStrictness |

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 ErrorCall |
Methods compare :: ErrorCall -> ErrorCall -> Ordering # (<) :: ErrorCall -> ErrorCall -> Bool # (<=) :: ErrorCall -> ErrorCall -> Bool # (>) :: ErrorCall -> ErrorCall -> Bool # (>=) :: ErrorCall -> ErrorCall -> Bool # max :: ErrorCall -> ErrorCall -> ErrorCall # min :: ErrorCall -> ErrorCall -> ErrorCall #
Ord ArithException |
Methods compare :: ArithException -> ArithException -> Ordering # (<) :: ArithException -> ArithException -> Bool # (<=) :: ArithException -> ArithException -> Bool # (>) :: ArithException -> ArithException -> Bool # (>=) :: ArithException -> ArithException -> Bool # max :: ArithException -> ArithException -> ArithException # min :: ArithException -> ArithException -> ArithException #
Ord SomeNat |
Methods compare :: SomeNat -> SomeNat -> Ordering # (<) :: SomeNat -> SomeNat -> Bool # (<=) :: SomeNat -> SomeNat -> Bool # (>) :: SomeNat -> SomeNat -> Bool # (>=) :: SomeNat -> SomeNat -> Bool # max :: SomeNat -> SomeNat -> SomeNat # min :: SomeNat -> SomeNat -> SomeNat #
Ord SomeSymbol |
Methods compare :: SomeSymbol -> SomeSymbol -> Ordering # (<) :: SomeSymbol -> SomeSymbol -> Bool # (<=) :: SomeSymbol -> SomeSymbol -> Bool # (>) :: SomeSymbol -> SomeSymbol -> Bool # (>=) :: SomeSymbol -> SomeSymbol -> Bool # max :: SomeSymbol -> SomeSymbol -> SomeSymbol # min :: SomeSymbol -> SomeSymbol -> SomeSymbol #
Ord IOMode |
Methods compare :: IOMode -> IOMode -> Ordering # (<) :: IOMode -> IOMode -> Bool # (<=) :: IOMode -> IOMode -> Bool # (>) :: IOMode -> IOMode -> Bool # (>=) :: IOMode -> IOMode -> Bool # max :: IOMode -> IOMode -> IOMode # min :: IOMode -> IOMode -> IOMode #
Ord GeneralCategory |

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 UTF32_Invalid |
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 # max :: UTF32_Invalid -> UTF32_Invalid -> UTF32_Invalid # min :: UTF32_Invalid -> UTF32_Invalid -> UTF32_Invalid #
Ord Encoding |
Methods compare :: Encoding -> Encoding -> Ordering # (<) :: Encoding -> Encoding -> Bool # (<=) :: Encoding -> Encoding -> Bool # (>) :: Encoding -> Encoding -> Bool # (>=) :: Encoding -> Encoding -> Bool # max :: Encoding -> Encoding -> Encoding # min :: Encoding -> Encoding -> Encoding #
Ord String |
Methods compare :: String -> String -> Ordering # (<) :: String -> String -> Bool # (<=) :: String -> String -> Bool # (>) :: String -> String -> Bool # (>=) :: String -> String -> Bool # max :: String -> String -> String # min :: String -> String -> String #
Ord 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 Addr |
Methods compare :: Addr -> Addr -> Ordering # (<) :: Addr -> Addr -> Bool # (<=) :: Addr -> Addr -> Bool # (>) :: Addr -> Addr -> Bool # (>=) :: Addr -> Addr -> Bool # max :: Addr -> Addr -> Addr # min :: Addr -> Addr -> Addr #
Ord FileSize |
Methods compare :: FileSize -> FileSize -> Ordering # (<) :: FileSize -> FileSize -> Bool # (<=) :: FileSize -> FileSize -> Bool # (>) :: FileSize -> FileSize -> Bool # (>=) :: FileSize -> FileSize -> Bool # max :: FileSize -> FileSize -> FileSize # min :: FileSize -> FileSize -> FileSize #
Ord Word256 |
Methods compare :: Word256 -> Word256 -> Ordering # (<) :: Word256 -> Word256 -> Bool # (<=) :: Word256 -> Word256 -> Bool # (>) :: Word256 -> Word256 -> Bool # (>=) :: Word256 -> Word256 -> Bool # max :: Word256 -> Word256 -> Word256 # min :: Word256 -> Word256 -> Word256 #
Ord Word128 |
Methods compare :: Word128 -> Word128 -> Ordering # (<) :: Word128 -> Word128 -> Bool # (<=) :: Word128 -> Word128 -> Bool # (>) :: Word128 -> Word128 -> Bool # (>=) :: Word128 -> Word128 -> Bool # max :: Word128 -> Word128 -> Word128 # min :: Word128 -> Word128 -> Word128 #
Ord Char7 |
Methods compare :: Char7 -> Char7 -> Ordering # (<) :: Char7 -> Char7 -> Bool # (<=) :: Char7 -> Char7 -> Bool # (>) :: Char7 -> Char7 -> Bool # (>=) :: Char7 -> Char7 -> Bool # max :: Char7 -> Char7 -> Char7 # min :: Char7 -> Char7 -> Char7 #
Ord Arch # |
Methods compare :: Arch -> Arch -> Ordering # (<) :: Arch -> Arch -> Bool # (<=) :: Arch -> Arch -> Bool # (>) :: Arch -> Arch -> Bool # (>=) :: Arch -> Arch -> Bool # max :: Arch -> Arch -> Arch # min :: Arch -> Arch -> Arch #
Ord OS # |
Methods compare :: OS -> OS -> Ordering # (<) :: OS -> OS -> Bool # (<=) :: OS -> OS -> Bool # (>) :: OS -> OS -> Bool # (>=) :: OS -> OS -> Bool # max :: OS -> OS -> OS # min :: OS -> OS -> OS #
Ord Seconds # |
Methods compare :: Seconds -> Seconds -> Ordering # (<) :: Seconds -> Seconds -> Bool # (<=) :: Seconds -> Seconds -> Bool # (>) :: Seconds -> Seconds -> Bool # (>=) :: Seconds -> Seconds -> Bool # max :: Seconds -> Seconds -> Seconds # min :: Seconds -> Seconds -> Seconds #
Ord NanoSeconds # |
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 Bitmap # |
Methods compare :: Bitmap -> Bitmap -> Ordering # (<) :: Bitmap -> Bitmap -> Bool # (<=) :: Bitmap -> Bitmap -> Bool # (>) :: Bitmap -> Bitmap -> Bool # (>=) :: Bitmap -> Bitmap -> Bool # max :: Bitmap -> Bitmap -> Bitmap # min :: Bitmap -> Bitmap -> Bitmap #
Ord IPv4 # |
Methods compare :: IPv4 -> IPv4 -> Ordering # (<) :: IPv4 -> IPv4 -> Bool # (<=) :: IPv4 -> IPv4 -> Bool # (>) :: IPv4 -> IPv4 -> Bool # (>=) :: IPv4 -> IPv4 -> Bool # max :: IPv4 -> IPv4 -> IPv4 # min :: IPv4 -> IPv4 -> IPv4 #
Ord IPv6 # |
Methods compare :: IPv6 -> IPv6 -> Ordering # (<) :: IPv6 -> IPv6 -> Bool # (<=) :: IPv6 -> IPv6 -> Bool # (>) :: IPv6 -> IPv6 -> Bool # (>=) :: IPv6 -> IPv6 -> Bool # max :: IPv6 -> IPv6 -> IPv6 # min :: IPv6 -> IPv6 -> IPv6 #
Ord UUID # |
Methods compare :: UUID -> UUID -> Ordering # (<) :: UUID -> UUID -> Bool # (<=) :: UUID -> UUID -> Bool # (>) :: UUID -> UUID -> Bool # (>=) :: UUID -> UUID -> Bool # max :: UUID -> UUID -> UUID # min :: UUID -> UUID -> UUID #
Ord FilePath # |
Methods compare :: FilePath -> FilePath -> Ordering # (<) :: FilePath -> FilePath -> Bool # (<=) :: FilePath -> FilePath -> Bool # (>) :: FilePath -> FilePath -> Bool # (>=) :: FilePath -> FilePath -> Bool # max :: FilePath -> FilePath -> FilePath # min :: FilePath -> FilePath -> FilePath #
Ord a => Ord [a] |
Methods compare :: [a] -> [a] -> Ordering # (<) :: [a] -> [a] -> Bool # (<=) :: [a] -> [a] -> Bool # (>) :: [a] -> [a] -> Bool # (>=) :: [a] -> [a] -> Bool # max :: [a] -> [a] -> [a] # min :: [a] -> [a] -> [a] #
Ord a => Ord (Maybe a) |
Methods compare :: Maybe a -> Maybe a -> Ordering # (<) :: Maybe a -> Maybe a -> Bool # (<=) :: Maybe a -> Maybe a -> Bool # (>) :: Maybe a -> Maybe a -> Bool # (>=) :: Maybe a -> Maybe a -> Bool # max :: Maybe a -> Maybe a -> Maybe a # min :: Maybe a -> Maybe a -> Maybe a #
Integral a => Ord (Ratio a) |
Methods compare :: Ratio a -> Ratio a -> Ordering # (<) :: Ratio a -> Ratio a -> Bool # (<=) :: Ratio a -> Ratio a -> Bool # (>) :: Ratio a -> Ratio a -> Bool # (>=) :: Ratio a -> Ratio a -> Bool # max :: Ratio a -> Ratio a -> Ratio a # min :: Ratio a -> Ratio a -> Ratio a #
Ord (Ptr a) |
Methods compare :: Ptr a -> Ptr a -> Ordering # (<) :: Ptr a -> Ptr a -> Bool # (<=) :: Ptr a -> Ptr a -> Bool # (>) :: Ptr a -> Ptr a -> Bool # (>=) :: Ptr a -> Ptr a -> Bool # max :: Ptr a -> Ptr a -> Ptr a # min :: Ptr a -> Ptr a -> Ptr a #
Ord (FunPtr a) |
Methods compare :: FunPtr a -> FunPtr a -> Ordering # (<) :: FunPtr a -> FunPtr a -> Bool # (<=) :: FunPtr a -> FunPtr a -> Bool # (>) :: FunPtr a -> FunPtr a -> Bool # (>=) :: FunPtr a -> FunPtr a -> Bool # max :: FunPtr a -> FunPtr a -> FunPtr a # min :: FunPtr a -> FunPtr a -> FunPtr a #
Ord (V1 p) |
Methods compare :: V1 p -> V1 p -> Ordering # (<) :: V1 p -> V1 p -> Bool # (<=) :: V1 p -> V1 p -> Bool # (>) :: V1 p -> V1 p -> Bool # (>=) :: V1 p -> V1 p -> Bool # max :: V1 p -> V1 p -> V1 p # min :: V1 p -> V1 p -> V1 p #
Ord (U1 p) |
Methods compare :: U1 p -> U1 p -> Ordering # (<) :: U1 p -> U1 p -> Bool # (<=) :: U1 p -> U1 p -> Bool # (>) :: U1 p -> U1 p -> Bool # (>=) :: U1 p -> U1 p -> Bool # max :: U1 p -> U1 p -> U1 p # min :: U1 p -> U1 p -> U1 p #
Ord p => Ord (Par1 p) |
Methods compare :: Par1 p -> Par1 p -> Ordering # (<) :: Par1 p -> Par1 p -> Bool # (<=) :: Par1 p -> Par1 p -> Bool # (>) :: Par1 p -> Par1 p -> Bool # (>=) :: Par1 p -> Par1 p -> Bool # max :: Par1 p -> Par1 p -> Par1 p # min :: Par1 p -> Par1 p -> Par1 p #
Ord a => Ord (Identity a) |
Methods compare :: Identity a -> Identity a -> Ordering # (<) :: Identity a -> Identity a -> Bool # (<=) :: Identity a -> Identity a -> Bool # (>) :: Identity a -> Identity a -> Bool # (>=) :: Identity a -> Identity a -> Bool # max :: Identity a -> Identity a -> Identity a # min :: Identity a -> Identity a -> Identity a #
Ord a => Ord (Min a) |
Methods compare :: Min a -> Min a -> Ordering # (<) :: Min a -> Min a -> Bool # (<=) :: Min a -> Min a -> Bool # (>) :: Min a -> Min a -> Bool # (>=) :: Min a -> Min a -> Bool # max :: Min a -> Min a -> Min a # min :: Min a -> Min a -> Min a #
Ord a => Ord (Max a) |
Methods compare :: Max a -> Max a -> Ordering # (<) :: Max a -> Max a -> Bool # (<=) :: Max a -> Max a -> Bool # (>) :: Max a -> Max a -> Bool # (>=) :: Max a -> Max a -> Bool # max :: Max a -> Max a -> Max a # min :: Max a -> Max a -> Max a #
Ord a => Ord (First a) |
Methods compare :: First a -> First a -> Ordering # (<) :: First a -> First a -> Bool # (<=) :: First a -> First a -> Bool # (>) :: First a -> First a -> Bool # (>=) :: First a -> First a -> Bool # max :: First a -> First a -> First a # min :: First a -> First a -> First a #
Ord a => Ord (Last a) |
Methods compare :: Last a -> Last a -> Ordering # (<) :: Last a -> Last a -> Bool # (<=) :: Last a -> Last a -> Bool # (>) :: Last a -> Last a -> Bool # (>=) :: Last a -> Last a -> Bool # max :: Last a -> Last a -> Last a # min :: Last a -> Last a -> Last a #
Ord m => Ord (WrappedMonoid m) |

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 a => Ord (Option a) |
Methods compare :: Option a -> Option a -> Ordering # (<) :: Option a -> Option a -> Bool # (<=) :: Option a -> Option a -> Bool # (>) :: Option a -> Option a -> Bool # (>=) :: Option a -> Option a -> Bool # max :: Option a -> Option a -> Option a # min :: Option a -> Option a -> Option a #
Ord a => Ord (NonEmpty a) |
Methods compare :: NonEmpty a -> NonEmpty a -> Ordering # (<) :: NonEmpty a -> NonEmpty a -> Bool # (<=) :: NonEmpty a -> NonEmpty a -> Bool # (>) :: NonEmpty a -> NonEmpty a -> Bool # (>=) :: NonEmpty a -> NonEmpty a -> Bool # max :: NonEmpty a -> NonEmpty a -> NonEmpty a # min :: NonEmpty a -> NonEmpty a -> NonEmpty a #
Ord a => Ord (ZipList a) |
Methods compare :: ZipList a -> ZipList a -> Ordering # (<) :: ZipList a -> ZipList a -> Bool # (<=) :: ZipList a -> ZipList a -> Bool # (>) :: ZipList a -> ZipList a -> Bool # (>=) :: ZipList a -> ZipList a -> Bool # max :: ZipList a -> ZipList a -> ZipList a # min :: ZipList a -> ZipList a -> ZipList a #
Ord (ForeignPtr a) |
Methods compare :: ForeignPtr a -> ForeignPtr a -> Ordering # (<) :: ForeignPtr a -> ForeignPtr a -> Bool # (<=) :: ForeignPtr a -> ForeignPtr a -> Bool # (>) :: ForeignPtr a -> ForeignPtr a -> Bool # (>=) :: ForeignPtr a -> ForeignPtr a -> Bool # max :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a # min :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a #
Ord a => Ord (Dual a) |
Methods compare :: Dual a -> Dual a -> Ordering # (<) :: Dual a -> Dual a -> Bool # (<=) :: Dual a -> Dual a -> Bool # (>) :: Dual a -> Dual a -> Bool # (>=) :: Dual a -> Dual a -> Bool # max :: Dual a -> Dual a -> Dual a # min :: Dual a -> Dual a -> Dual a #
Ord a => Ord (Sum a) |
Methods compare :: Sum a -> Sum a -> Ordering # (<) :: Sum a -> Sum a -> Bool # (<=) :: Sum a -> Sum a -> Bool # (>) :: Sum a -> Sum a -> Bool # (>=) :: Sum a -> Sum a -> Bool # max :: Sum a -> Sum a -> Sum a # min :: Sum a -> Sum a -> Sum a #
Ord a => Ord (Product a) |
Methods compare :: Product a -> Product a -> Ordering # (<) :: Product a -> Product a -> Bool # (<=) :: Product a -> Product a -> Bool # (>) :: Product a -> Product a -> Bool # (>=) :: Product a -> Product a -> Bool # max :: Product a -> Product a -> Product a # min :: Product a -> Product a -> Product a #
Ord a => Ord (First a) |
Methods compare :: First a -> First a -> Ordering # (<) :: First a -> First a -> Bool # (<=) :: First a -> First a -> Bool # (>) :: First a -> First a -> Bool # (>=) :: First a -> First a -> Bool # max :: First a -> First a -> First a # min :: First a -> First a -> First a #
Ord a => Ord (Last a) |
Methods compare :: Last a -> Last a -> Ordering # (<) :: Last a -> Last a -> Bool # (<=) :: Last a -> Last a -> Bool # (>) :: Last a -> Last a -> Bool # (>=) :: Last a -> Last a -> Bool # max :: Last a -> Last a -> Last a # min :: Last a -> Last a -> Last a #
Ord a => Ord (Array a) |
Methods compare :: Array a -> Array a -> Ordering # (<) :: Array a -> Array a -> Bool # (<=) :: Array a -> Array a -> Bool # (>) :: Array a -> Array a -> Bool # (>=) :: Array a -> Array a -> Bool # max :: Array a -> Array a -> Array a # min :: Array a -> Array a -> Array a #
(PrimType ty, Ord ty) => Ord (UArray ty) |
Methods compare :: UArray ty -> UArray ty -> Ordering # (<) :: UArray ty -> UArray ty -> Bool # (<=) :: UArray ty -> UArray ty -> Bool # (>) :: UArray ty -> UArray ty -> Bool # (>=) :: UArray ty -> UArray ty -> Bool # max :: UArray ty -> UArray ty -> UArray ty # min :: UArray ty -> UArray ty -> UArray ty #
(PrimType ty, Ord ty) => Ord (Block ty) |
Methods compare :: Block ty -> Block ty -> Ordering # (<) :: Block ty -> Block ty -> Bool # (<=) :: Block ty -> Block ty -> Bool # (>) :: Block ty -> Block ty -> Bool # (>=) :: Block ty -> Block ty -> Bool # max :: Block ty -> Block ty -> Block ty # min :: Block ty -> Block ty -> Block ty #
Ord (Offset ty) |
Methods compare :: Offset ty -> Offset ty -> Ordering # (<) :: Offset ty -> Offset ty -> Bool # (<=) :: Offset ty -> Offset ty -> Bool # (>) :: Offset ty -> Offset ty -> Bool # (>=) :: Offset ty -> Offset ty -> Bool # max :: Offset ty -> Offset ty -> Offset ty # min :: Offset ty -> Offset ty -> Offset ty #
Ord (CountOf ty) |
Methods compare :: CountOf ty -> CountOf ty -> Ordering # (<) :: CountOf ty -> CountOf ty -> Bool # (<=) :: CountOf ty -> CountOf ty -> Bool # (>) :: CountOf ty -> CountOf ty -> Bool # (>=) :: CountOf ty -> CountOf ty -> Bool # max :: CountOf ty -> CountOf ty -> CountOf ty # min :: CountOf ty -> CountOf ty -> CountOf ty #
Ord (Zn64 n) |
Methods compare :: Zn64 n -> Zn64 n -> Ordering # (<) :: Zn64 n -> Zn64 n -> Bool # (<=) :: Zn64 n -> Zn64 n -> Bool # (>) :: Zn64 n -> Zn64 n -> Bool # (>=) :: Zn64 n -> Zn64 n -> Bool # max :: Zn64 n -> Zn64 n -> Zn64 n # min :: Zn64 n -> Zn64 n -> Zn64 n #
Ord (Zn n) |
Methods compare :: Zn n -> Zn n -> Ordering # (<) :: Zn n -> Zn n -> Bool # (<=) :: Zn n -> Zn n -> Bool # (>) :: Zn n -> Zn n -> Bool # (>=) :: Zn n -> Zn n -> Bool # max :: Zn n -> Zn n -> Zn n # min :: Zn n -> Zn n -> Zn n #
Ord (FinalPtr a) |
Methods compare :: FinalPtr a -> FinalPtr a -> Ordering # (<) :: FinalPtr a -> FinalPtr a -> Bool # (<=) :: FinalPtr a -> FinalPtr a -> Bool # (>) :: FinalPtr a -> FinalPtr a -> Bool # (>=) :: FinalPtr a -> FinalPtr a -> Bool # max :: FinalPtr a -> FinalPtr a -> FinalPtr a # min :: FinalPtr a -> FinalPtr a -> FinalPtr a #
(ByteSwap a, Ord a) => Ord (LE a) |
Methods compare :: LE a -> LE a -> Ordering # (<) :: LE a -> LE a -> Bool # (<=) :: LE a -> LE a -> Bool # (>) :: LE a -> LE a -> Bool # (>=) :: LE a -> LE a -> Bool # max :: LE a -> LE a -> LE a # min :: LE a -> LE a -> LE a #
(ByteSwap a, Ord a) => Ord (BE a) |
Methods compare :: BE a -> BE a -> Ordering # (<) :: BE a -> BE a -> Bool # (<=) :: BE a -> BE a -> Bool # (>) :: BE a -> BE a -> Bool # (>=) :: BE a -> BE a -> Bool # max :: BE a -> BE a -> BE a # min :: BE a -> BE a -> BE a #
Ord a => Ord (DList a) # |
Methods compare :: DList a -> DList a -> Ordering # (<) :: DList a -> DList a -> Bool # (<=) :: DList a -> DList a -> Bool # (>) :: DList a -> DList a -> Bool # (>=) :: DList a -> DList a -> Bool # max :: DList a -> DList a -> DList a # min :: DList a -> DList a -> DList a #
(Ord ty, PrimType ty) => Ord (ChunkedUArray ty) # |

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 b, Ord a) => Ord (Either a b) |
Methods compare :: Either a b -> Either a b -> Ordering # (<) :: Either a b -> Either a b -> Bool # (<=) :: Either a b -> Either a b -> Bool # (>) :: Either a b -> Either a b -> Bool # (>=) :: Either a b -> Either a b -> Bool # max :: Either a b -> Either a b -> Either a b # min :: Either a b -> Either a b -> Either a b #
Ord (f p) => Ord (Rec1 f p) |
Methods compare :: Rec1 f p -> Rec1 f p -> Ordering # (<) :: Rec1 f p -> Rec1 f p -> Bool # (<=) :: Rec1 f p -> Rec1 f p -> Bool # (>) :: Rec1 f p -> Rec1 f p -> Bool # (>=) :: Rec1 f p -> Rec1 f p -> Bool # max :: Rec1 f p -> Rec1 f p -> Rec1 f p # min :: Rec1 f p -> Rec1 f p -> Rec1 f p #
Ord (URec Char p) |
Methods compare :: URec Char p -> URec Char p -> Ordering # (<) :: URec Char p -> URec Char p -> Bool # (<=) :: URec Char p -> URec Char p -> Bool # (>) :: URec Char p -> URec Char p -> Bool # (>=) :: URec Char p -> URec Char p -> Bool # max :: URec Char p -> URec Char p -> URec Char p # min :: URec Char p -> URec Char p -> URec Char p #
Ord (URec Double p) |
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 # max :: URec Double p -> URec Double p -> URec Double p # min :: URec Double p -> URec Double p -> URec Double p #
Ord (URec Float p) |
Methods compare :: URec Float p -> URec Float p -> Ordering # (<) :: URec Float p -> URec Float p -> Bool # (<=) :: URec Float p -> URec Float p -> Bool # (>) :: URec Float p -> URec Float p -> Bool # (>=) :: URec Float p -> URec Float p -> Bool # max :: URec Float p -> URec Float p -> URec Float p # min :: URec Float p -> URec Float p -> URec Float p #
Ord (URec Int p) |
Methods compare :: URec Int p -> URec Int p -> Ordering # (<) :: URec Int p -> URec Int p -> Bool # (<=) :: URec Int p -> URec Int p -> Bool # (>) :: URec Int p -> URec Int p -> Bool # (>=) :: URec Int p -> URec Int p -> Bool # max :: URec Int p -> URec Int p -> URec Int p # min :: URec Int p -> URec Int p -> URec Int p #
Ord (URec Word p) |
Methods compare :: URec Word p -> URec Word p -> Ordering # (<) :: URec Word p -> URec Word p -> Bool # (<=) :: URec Word p -> URec Word p -> Bool # (>) :: URec Word p -> URec Word p -> Bool # (>=) :: URec Word p -> URec Word p -> Bool # max :: URec Word p -> URec Word p -> URec Word p # min :: URec Word p -> URec Word p -> URec Word p #
Ord (URec (Ptr ()) p) |

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 a, Ord b) => Ord (a, b) |
Methods compare :: (a, b) -> (a, b) -> Ordering # (<) :: (a, b) -> (a, b) -> Bool # (<=) :: (a, b) -> (a, b) -> Bool # (>) :: (a, b) -> (a, b) -> Bool # (>=) :: (a, b) -> (a, b) -> Bool # max :: (a, b) -> (a, b) -> (a, b) # min :: (a, b) -> (a, b) -> (a, b) #
(Ix i, Ord e) => Ord (Array i e) |
Methods compare :: Array i e -> Array i e -> Ordering # (<) :: Array i e -> Array i e -> Bool # (<=) :: Array i e -> Array i e -> Bool # (>) :: Array i e -> Array i e -> Bool # (>=) :: Array i e -> Array i e -> Bool # max :: Array i e -> Array i e -> Array i e # min :: Array i e -> Array i e -> Array i e #
Ord a => Ord (Arg a b) |
Methods compare :: Arg a b -> Arg a b -> Ordering # (<) :: Arg a b -> Arg a b -> Bool # (<=) :: Arg a b -> Arg a b -> Bool # (>) :: Arg a b -> Arg a b -> Bool # (>=) :: Arg a b -> Arg a b -> Bool # max :: Arg a b -> Arg a b -> Arg a b # min :: Arg a b -> Arg a b -> Arg a b #
Ord (Proxy k s) |
Methods compare :: Proxy k s -> Proxy k s -> Ordering # (<) :: Proxy k s -> Proxy k s -> Bool # (<=) :: Proxy k s -> Proxy k s -> Bool # (>) :: Proxy k s -> Proxy k s -> Bool # (>=) :: Proxy k s -> Proxy k s -> Bool # max :: Proxy k s -> Proxy k s -> Proxy k s # min :: Proxy k s -> Proxy k s -> Proxy k s #
Ord a => Ord (ListN n a) |
Methods compare :: ListN n a -> ListN n a -> Ordering # (<) :: ListN n a -> ListN n a -> Bool # (<=) :: ListN n a -> ListN n a -> Bool # (>) :: ListN n a -> ListN n a -> Bool # (>=) :: ListN n a -> ListN n a -> Bool # max :: ListN n a -> ListN n a -> ListN n a # min :: ListN n a -> ListN n a -> ListN n a #
(Ord b, Ord a) => Ord (These a b) |
Methods compare :: These a b -> These a b -> Ordering # (<) :: These a b -> These a b -> Bool # (<=) :: These a b -> These a b -> Bool # (>) :: These a b -> These a b -> Bool # (>=) :: These a b -> These a b -> Bool # max :: These a b -> These a b -> These a b # min :: These a b -> These a b -> These a b #
(Ord b, Ord a) => Ord (Tuple2 a b) # |
Methods compare :: Tuple2 a b -> Tuple2 a b -> Ordering # (<) :: Tuple2 a b -> Tuple2 a b -> Bool # (<=) :: Tuple2 a b -> Tuple2 a b -> Bool # (>) :: Tuple2 a b -> Tuple2 a b -> Bool # (>=) :: Tuple2 a b -> Tuple2 a b -> Bool # max :: Tuple2 a b -> Tuple2 a b -> Tuple2 a b # min :: Tuple2 a b -> Tuple2 a b -> Tuple2 a b #
Ord c => Ord (K1 i c p) |
Methods compare :: K1 i c p -> K1 i c p -> Ordering # (<) :: K1 i c p -> K1 i c p -> Bool # (<=) :: K1 i c p -> K1 i c p -> Bool # (>) :: K1 i c p -> K1 i c p -> Bool # (>=) :: K1 i c p -> K1 i c p -> Bool # max :: K1 i c p -> K1 i c p -> K1 i c p # min :: K1 i c p -> K1 i c p -> K1 i c p #
(Ord (g p), Ord (f p)) => Ord ((:+:) f g p) |
Methods compare :: (f :+: g) p -> (f :+: g) p -> Ordering # (<) :: (f :+: g) p -> (f :+: g) p -> Bool # (<=) :: (f :+: g) p -> (f :+: g) p -> Bool # (>) :: (f :+: g) p -> (f :+: g) p -> Bool # (>=) :: (f :+: g) p -> (f :+: g) p -> Bool # max :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p # min :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p #
(Ord (g p), Ord (f p)) => Ord ((:*:) f g p) |
Methods compare :: (f :*: g) p -> (f :*: g) p -> Ordering # (<) :: (f :*: g) p -> (f :*: g) p -> Bool # (<=) :: (f :*: g) p -> (f :*: g) p -> Bool # (>) :: (f :*: g) p -> (f :*: g) p -> Bool # (>=) :: (f :*: g) p -> (f :*: g) p -> Bool # max :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p # min :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p #
Ord (f (g p)) => Ord ((:.:) f g p) |
Methods compare :: (f :.: g) p -> (f :.: g) p -> Ordering # (<) :: (f :.: g) p -> (f :.: g) p -> Bool # (<=) :: (f :.: g) p -> (f :.: g) p -> Bool # (>) :: (f :.: g) p -> (f :.: g) p -> Bool # (>=) :: (f :.: g) p -> (f :.: g) p -> Bool # max :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p # min :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p #
(Ord a, Ord b, Ord c) => Ord (a, b, c) |
Methods compare :: (a, b, c) -> (a, b, c) -> Ordering # (<) :: (a, b, c) -> (a, b, c) -> Bool # (<=) :: (a, b, c) -> (a, b, c) -> Bool # (>) :: (a, b, c) -> (a, b, c) -> Bool # (>=) :: (a, b, c) -> (a, b, c) -> Bool # max :: (a, b, c) -> (a, b, c) -> (a, b, c) # min :: (a, b, c) -> (a, b, c) -> (a, b, c) #
Ord a => Ord (Const k a b) |
Methods compare :: Const k a b -> Const k a b -> Ordering # (<) :: Const k a b -> Const k a b -> Bool # (<=) :: Const k a b -> Const k a b -> Bool # (>) :: Const k a b -> Const k a b -> Bool # (>=) :: Const k a b -> Const k a b -> Bool # max :: Const k a b -> Const k a b -> Const k a b # min :: Const k a b -> Const k a b -> Const k a b #
Ord (f a) => Ord (Alt k f a) |
Methods compare :: Alt k f a -> Alt k f a -> Ordering # (<) :: Alt k f a -> Alt k f a -> Bool # (<=) :: Alt k f a -> Alt k f a -> Bool # (>) :: Alt k f a -> Alt k f a -> Bool # (>=) :: Alt k f a -> Alt k f a -> Bool # max :: Alt k f a -> Alt k f a -> Alt k f a # min :: Alt k f a -> Alt k f a -> Alt k f a #
Ord (Coercion k a b) |
Methods compare :: Coercion k a b -> Coercion k a b -> Ordering # (<) :: Coercion k a b -> Coercion k a b -> Bool # (<=) :: Coercion k a b -> Coercion k a b -> Bool # (>) :: Coercion k a b -> Coercion k a b -> Bool # (>=) :: Coercion k a b -> Coercion k a b -> Bool # max :: Coercion k a b -> Coercion k a b -> Coercion k a b # min :: Coercion k a b -> Coercion k a b -> Coercion k a b #
Ord ((:~:) k a b) |
Methods compare :: (k :~: a) b -> (k :~: a) b -> Ordering # (<) :: (k :~: a) b -> (k :~: a) b -> Bool # (<=) :: (k :~: a) b -> (k :~: a) b -> Bool # (>) :: (k :~: a) b -> (k :~: a) b -> Bool # (>=) :: (k :~: a) b -> (k :~: a) b -> Bool # max :: (k :~: a) b -> (k :~: a) b -> (k :~: a) b # min :: (k :~: a) b -> (k :~: a) b -> (k :~: a) b #
(Ord c, Ord b, Ord a) => Ord (Tuple3 a b c) # |
Methods compare :: Tuple3 a b c -> Tuple3 a b c -> Ordering # (<) :: Tuple3 a b c -> Tuple3 a b c -> Bool # (<=) :: Tuple3 a b c -> Tuple3 a b c -> Bool # (>) :: Tuple3 a b c -> Tuple3 a b c -> Bool # (>=) :: Tuple3 a b c -> Tuple3 a b c -> Bool # max :: Tuple3 a b c -> Tuple3 a b c -> Tuple3 a b c # min :: Tuple3 a b c -> Tuple3 a b c -> Tuple3 a b c #
Ord (f p) => Ord (M1 i c f p) |
Methods compare :: M1 i c f p -> M1 i c f p -> Ordering # (<) :: M1 i c f p -> M1 i c f p -> Bool # (<=) :: M1 i c f p -> M1 i c f p -> Bool # (>) :: M1 i c f p -> M1 i c f p -> Bool # (>=) :: M1 i c f p -> M1 i c f p -> Bool # max :: M1 i c f p -> M1 i c f p -> M1 i c f p # min :: M1 i c f p -> M1 i c f p -> M1 i c f p #
(Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) |
Methods compare :: (a, b, c, d) -> (a, b, c, d) -> Ordering # (<) :: (a, b, c, d) -> (a, b, c, d) -> Bool # (<=) :: (a, b, c, d) -> (a, b, c, d) -> Bool # (>) :: (a, b, c, d) -> (a, b, c, d) -> Bool # (>=) :: (a, b, c, d) -> (a, b, c, d) -> Bool # max :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # min :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) #
(Ord d, Ord c, Ord b, Ord a) => Ord (Tuple4 a b c d) # |
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 # max :: Tuple4 a b c d -> Tuple4 a b c d -> Tuple4 a b c d # min :: Tuple4 a b c d -> Tuple4 a b c d -> Tuple4 a b c d #
(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) |

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) |

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) |

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) |

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) |

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) |

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) |

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) |

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) |

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) |

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) |

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) #

class Eq a where #

The `Eq` class defines equality (`==`) and inequality (`/=`). All the basic datatypes exported by the Prelude are instances of `Eq`, and `Eq` may be derived for any datatype whose constituents are also instances of `Eq`.

Minimal complete definition: either `==` or `/=`.

Minimal complete definition

(==) | (/=)

Methods

(==) :: a -> a -> Bool infix 4 #

(/=) :: a -> a -> Bool infix 4 #

Instances

Eq Bool |
Methods (==) :: Bool -> Bool -> Bool # (/=) :: Bool -> Bool -> Bool #
Eq Char |
Methods (==) :: Char -> Char -> Bool # (/=) :: Char -> Char -> Bool #
Eq Double |
Methods (==) :: Double -> Double -> Bool # (/=) :: Double -> Double -> Bool #
Eq Float |
Methods (==) :: Float -> Float -> Bool # (/=) :: Float -> Float -> Bool #
Eq Int |
Methods (==) :: Int -> Int -> Bool # (/=) :: Int -> Int -> Bool #
Eq Int8 |
Methods (==) :: Int8 -> Int8 -> Bool # (/=) :: Int8 -> Int8 -> Bool #
Eq Int16 |
Methods (==) :: Int16 -> Int16 -> Bool # (/=) :: Int16 -> Int16 -> Bool #
Eq Int32 |
Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Eq Int64 |
Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Eq Integer |
Methods (==) :: Integer -> Integer -> Bool # (/=) :: Integer -> Integer -> Bool #
Eq Ordering |
Methods (==) :: Ordering -> Ordering -> Bool # (/=) :: Ordering -> Ordering -> Bool #
Eq Word |
Methods (==) :: Word -> Word -> Bool # (/=) :: Word -> Word -> Bool #
Eq Word8 |
Methods (==) :: Word8 -> Word8 -> Bool # (/=) :: Word8 -> Word8 -> Bool #
Eq Word16 |
Methods (==) :: Word16 -> Word16 -> Bool # (/=) :: Word16 -> Word16 -> Bool #
Eq Word32 |
Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Eq Word64 |
Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Eq TypeRep |
Methods (==) :: TypeRep -> TypeRep -> Bool # (/=) :: TypeRep -> TypeRep -> Bool #
Eq () |
Methods (==) :: () -> () -> Bool # (/=) :: () -> () -> Bool #
Eq TyCon |
Methods (==) :: TyCon -> TyCon -> Bool # (/=) :: TyCon -> TyCon -> Bool #
Eq BigNat |
Methods (==) :: BigNat -> BigNat -> Bool # (/=) :: BigNat -> BigNat -> Bool #
Eq SpecConstrAnnotation |
Methods (==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool # (/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool #
Eq Natural |
Methods (==) :: Natural -> Natural -> Bool # (/=) :: Natural -> Natural -> Bool #
Eq Void |
Methods (==) :: Void -> Void -> Bool # (/=) :: Void -> Void -> Bool #
Eq Constr | Equality of constructors
Methods (==) :: Constr -> Constr -> Bool # (/=) :: Constr -> Constr -> Bool #
Eq DataRep |
Methods (==) :: DataRep -> DataRep -> Bool # (/=) :: DataRep -> DataRep -> Bool #
Eq ConstrRep |
Methods (==) :: ConstrRep -> ConstrRep -> Bool # (/=) :: ConstrRep -> ConstrRep -> Bool #
Eq Fixity |
Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq Version |
Methods (==) :: Version -> Version -> Bool # (/=) :: Version -> Version -> Bool #
Eq HandlePosn |
Methods (==) :: HandlePosn -> HandlePosn -> Bool # (/=) :: HandlePosn -> HandlePosn -> Bool #
Eq CDev |
Methods (==) :: CDev -> CDev -> Bool # (/=) :: CDev -> CDev -> Bool #
Eq CIno |
Methods (==) :: CIno -> CIno -> Bool # (/=) :: CIno -> CIno -> Bool #
Eq CMode |
Methods (==) :: CMode -> CMode -> Bool # (/=) :: CMode -> CMode -> Bool #
Eq COff |
Methods (==) :: COff -> COff -> Bool # (/=) :: COff -> COff -> Bool #
Eq CPid |
Methods (==) :: CPid -> CPid -> Bool # (/=) :: CPid -> CPid -> Bool #
Eq CSsize |
Methods (==) :: CSsize -> CSsize -> Bool # (/=) :: CSsize -> CSsize -> Bool #
Eq CGid |
Methods (==) :: CGid -> CGid -> Bool # (/=) :: CGid -> CGid -> Bool #
Eq CNlink |
Methods (==) :: CNlink -> CNlink -> Bool # (/=) :: CNlink -> CNlink -> Bool #
Eq CUid |
Methods (==) :: CUid -> CUid -> Bool # (/=) :: CUid -> CUid -> Bool #
Eq CCc |
Methods (==) :: CCc -> CCc -> Bool # (/=) :: CCc -> CCc -> Bool #
Eq CSpeed |
Methods (==) :: CSpeed -> CSpeed -> Bool # (/=) :: CSpeed -> CSpeed -> Bool #
Eq CTcflag |
Methods (==) :: CTcflag -> CTcflag -> Bool # (/=) :: CTcflag -> CTcflag -> Bool #
Eq CRLim |
Methods (==) :: CRLim -> CRLim -> Bool # (/=) :: CRLim -> CRLim -> Bool #
Eq Fd |
Methods (==) :: Fd -> Fd -> Bool # (/=) :: Fd -> Fd -> Bool #
Eq ThreadId |
Methods (==) :: ThreadId -> ThreadId -> Bool # (/=) :: ThreadId -> ThreadId -> Bool #
Eq BlockReason |
Methods (==) :: BlockReason -> BlockReason -> Bool # (/=) :: BlockReason -> BlockReason -> Bool #
Eq ThreadStatus |
Methods (==) :: ThreadStatus -> ThreadStatus -> Bool # (/=) :: ThreadStatus -> ThreadStatus -> Bool #
Eq Errno |
Methods (==) :: Errno -> Errno -> Bool # (/=) :: Errno -> Errno -> Bool #
Eq AsyncException |
Methods (==) :: AsyncException -> AsyncException -> Bool # (/=) :: AsyncException -> AsyncException -> Bool #
Eq ArrayException |
Methods (==) :: ArrayException -> ArrayException -> Bool # (/=) :: ArrayException -> ArrayException -> Bool #
Eq ExitCode |
Methods (==) :: ExitCode -> ExitCode -> Bool # (/=) :: ExitCode -> ExitCode -> Bool #
Eq IOErrorType |
Methods (==) :: IOErrorType -> IOErrorType -> Bool # (/=) :: IOErrorType -> IOErrorType -> Bool #
Eq Handle |
Methods (==) :: Handle -> Handle -> Bool # (/=) :: Handle -> Handle -> Bool #
Eq BufferMode |
Methods (==) :: BufferMode -> BufferMode -> Bool # (/=) :: BufferMode -> BufferMode -> Bool #
Eq Newline |
Methods (==) :: Newline -> Newline -> Bool # (/=) :: Newline -> Newline -> Bool #
Eq NewlineMode |
Methods (==) :: NewlineMode -> NewlineMode -> Bool # (/=) :: NewlineMode -> NewlineMode -> Bool #
Eq WordPtr |
Methods (==) :: WordPtr -> WordPtr -> Bool # (/=) :: WordPtr -> WordPtr -> Bool #
Eq IntPtr |
Methods (==) :: IntPtr -> IntPtr -> Bool # (/=) :: IntPtr -> IntPtr -> Bool #
Eq CChar |
Methods (==) :: CChar -> CChar -> Bool # (/=) :: CChar -> CChar -> Bool #
Eq CSChar |
Methods (==) :: CSChar -> CSChar -> Bool # (/=) :: CSChar -> CSChar -> Bool #
Eq CUChar |
Methods (==) :: CUChar -> CUChar -> Bool # (/=) :: CUChar -> CUChar -> Bool #
Eq CShort |
Methods (==) :: CShort -> CShort -> Bool # (/=) :: CShort -> CShort -> Bool #
Eq CUShort |
Methods (==) :: CUShort -> CUShort -> Bool # (/=) :: CUShort -> CUShort -> Bool #
Eq CInt |
Methods (==) :: CInt -> CInt -> Bool # (/=) :: CInt -> CInt -> Bool #
Eq CUInt |
Methods (==) :: CUInt -> CUInt -> Bool # (/=) :: CUInt -> CUInt -> Bool #
Eq CLong |
Methods (==) :: CLong -> CLong -> Bool # (/=) :: CLong -> CLong -> Bool #
Eq CULong |
Methods (==) :: CULong -> CULong -> Bool # (/=) :: CULong -> CULong -> Bool #
Eq CLLong |
Methods (==) :: CLLong -> CLLong -> Bool # (/=) :: CLLong -> CLLong -> Bool #
Eq CULLong |
Methods (==) :: CULLong -> CULLong -> Bool # (/=) :: CULLong -> CULLong -> Bool #
Eq CFloat |
Methods (==) :: CFloat -> CFloat -> Bool # (/=) :: CFloat -> CFloat -> Bool #
Eq CDouble |
Methods (==) :: CDouble -> CDouble -> Bool # (/=) :: CDouble -> CDouble -> Bool #
Eq CPtrdiff |
Methods (==) :: CPtrdiff -> CPtrdiff -> Bool # (/=) :: CPtrdiff -> CPtrdiff -> Bool #
Eq CSize |
Methods (==) :: CSize -> CSize -> Bool # (/=) :: CSize -> CSize -> Bool #
Eq CWchar |
Methods (==) :: CWchar -> CWchar -> Bool # (/=) :: CWchar -> CWchar -> Bool #
Eq CSigAtomic |
Methods (==) :: CSigAtomic -> CSigAtomic -> Bool # (/=) :: CSigAtomic -> CSigAtomic -> Bool #
Eq CClock |
Methods (==) :: CClock -> CClock -> Bool # (/=) :: CClock -> CClock -> Bool #
Eq CTime |
Methods (==) :: CTime -> CTime -> Bool # (/=) :: CTime -> CTime -> Bool #
Eq CUSeconds |
Methods (==) :: CUSeconds -> CUSeconds -> Bool # (/=) :: CUSeconds -> CUSeconds -> Bool #
Eq CSUSeconds |
Methods (==) :: CSUSeconds -> CSUSeconds -> Bool # (/=) :: CSUSeconds -> CSUSeconds -> Bool #
Eq CIntPtr |
Methods (==) :: CIntPtr -> CIntPtr -> Bool # (/=) :: CIntPtr -> CIntPtr -> Bool #
Eq CUIntPtr |
Methods (==) :: CUIntPtr -> CUIntPtr -> Bool # (/=) :: CUIntPtr -> CUIntPtr -> Bool #
Eq CIntMax |
Methods (==) :: CIntMax -> CIntMax -> Bool # (/=) :: CIntMax -> CIntMax -> Bool #
Eq CUIntMax |
Methods (==) :: CUIntMax -> CUIntMax -> Bool # (/=) :: CUIntMax -> CUIntMax -> Bool #
Eq IODeviceType |
Methods (==) :: IODeviceType -> IODeviceType -> Bool # (/=) :: IODeviceType -> IODeviceType -> Bool #
Eq SeekMode |
Methods (==) :: SeekMode -> SeekMode -> Bool # (/=) :: SeekMode -> SeekMode -> Bool #
Eq All |
Methods (==) :: All -> All -> Bool # (/=) :: All -> All -> Bool #
Eq Any |
Methods (==) :: Any -> Any -> Bool # (/=) :: Any -> Any -> Bool #
Eq Fixity |
Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq Associativity |
Methods (==) :: Associativity -> Associativity -> Bool # (/=) :: Associativity -> Associativity -> Bool #
Eq SourceUnpackedness |
Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool #
Eq SourceStrictness |
Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool #
Eq DecidedStrictness |
Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool #
Eq MaskingState |
Methods (==) :: MaskingState -> MaskingState -> Bool # (/=) :: MaskingState -> MaskingState -> Bool #
Eq IOException |
Methods (==) :: IOException -> IOException -> Bool # (/=) :: IOException -> IOException -> Bool #
Eq ErrorCall |
Methods (==) :: ErrorCall -> ErrorCall -> Bool # (/=) :: ErrorCall -> ErrorCall -> Bool #
Eq ArithException |
Methods (==) :: ArithException -> ArithException -> Bool # (/=) :: ArithException -> ArithException -> Bool #
Eq SomeNat |
Methods (==) :: SomeNat -> SomeNat -> Bool # (/=) :: SomeNat -> SomeNat -> Bool #
Eq SomeSymbol |
Methods (==) :: SomeSymbol -> SomeSymbol -> Bool # (/=) :: SomeSymbol -> SomeSymbol -> Bool #
Eq IOMode |
Methods (==) :: IOMode -> IOMode -> Bool # (/=) :: IOMode -> IOMode -> Bool #
Eq Lexeme |
Methods (==) :: Lexeme -> Lexeme -> Bool # (/=) :: Lexeme -> Lexeme -> Bool #
Eq Number |
Methods (==) :: Number -> Number -> Bool # (/=) :: Number -> Number -> Bool #
Eq GeneralCategory |
Methods (==) :: GeneralCategory -> GeneralCategory -> Bool # (/=) :: GeneralCategory -> GeneralCategory -> Bool #
Eq SrcLoc |
Methods (==) :: SrcLoc -> SrcLoc -> Bool # (/=) :: SrcLoc -> SrcLoc -> Bool #
Eq UTF32_Invalid |
Methods (==) :: UTF32_Invalid -> UTF32_Invalid -> Bool # (/=) :: UTF32_Invalid -> UTF32_Invalid -> Bool #
Eq UTF16_Invalid |
Methods (==) :: UTF16_Invalid -> UTF16_Invalid -> Bool # (/=) :: UTF16_Invalid -> UTF16_Invalid -> Bool #
Eq ISO_8859_1_Invalid |
Methods (==) :: ISO_8859_1_Invalid -> ISO_8859_1_Invalid -> Bool # (/=) :: ISO_8859_1_Invalid -> ISO_8859_1_Invalid -> Bool #
Eq ASCII7_Invalid |
Methods (==) :: ASCII7_Invalid -> ASCII7_Invalid -> Bool # (/=) :: ASCII7_Invalid -> ASCII7_Invalid -> Bool #
Eq Encoding |
Methods (==) :: Encoding -> Encoding -> Bool # (/=) :: Encoding -> Encoding -> Bool #
Eq String |
Methods (==) :: String -> String -> Bool # (/=) :: String -> String -> Bool #
Eq AsciiString |
Methods (==) :: AsciiString -> AsciiString -> Bool # (/=) :: AsciiString -> AsciiString -> Bool #
Eq ValidationFailure |
Methods (==) :: ValidationFailure -> ValidationFailure -> Bool # (/=) :: ValidationFailure -> ValidationFailure -> Bool #
Eq Addr |
Methods (==) :: Addr -> Addr -> Bool # (/=) :: Addr -> Addr -> Bool #
Eq OutOfBoundOperation |
Methods (==) :: OutOfBoundOperation -> OutOfBoundOperation -> Bool # (/=) :: OutOfBoundOperation -> OutOfBoundOperation -> Bool #
Eq RecastSourceSize |
Methods (==) :: RecastSourceSize -> RecastSourceSize -> Bool # (/=) :: RecastSourceSize -> RecastSourceSize -> Bool #
Eq RecastDestinationSize |
Methods (==) :: RecastDestinationSize -> RecastDestinationSize -> Bool # (/=) :: RecastDestinationSize -> RecastDestinationSize -> Bool #
Eq FileSize |
Methods (==) :: FileSize -> FileSize -> Bool # (/=) :: FileSize -> FileSize -> Bool #
Eq Word256 |
Methods (==) :: Word256 -> Word256 -> Bool # (/=) :: Word256 -> Word256 -> Bool #
Eq Word128 |
Methods (==) :: Word128 -> Word128 -> Bool # (/=) :: Word128 -> Word128 -> Bool #
Eq Char7 |
Methods (==) :: Char7 -> Char7 -> Bool # (/=) :: Char7 -> Char7 -> Bool #
Eq Endianness |
Methods (==) :: Endianness -> Endianness -> Bool # (/=) :: Endianness -> Endianness -> Bool #
Eq Arch # |
Methods (==) :: Arch -> Arch -> Bool # (/=) :: Arch -> Arch -> Bool #
Eq OS # |
Methods (==) :: OS -> OS -> Bool # (/=) :: OS -> OS -> Bool #
Eq PartialError # |
Methods (==) :: PartialError -> PartialError -> Bool # (/=) :: PartialError -> PartialError -> Bool #
Eq Sign # |
Methods (==) :: Sign -> Sign -> Bool # (/=) :: Sign -> Sign -> Bool #
Eq Seconds # |
Methods (==) :: Seconds -> Seconds -> Bool # (/=) :: Seconds -> Seconds -> Bool #
Eq NanoSeconds # |
Methods (==) :: NanoSeconds -> NanoSeconds -> Bool # (/=) :: NanoSeconds -> NanoSeconds -> Bool #
Eq And # |
Methods (==) :: And -> And -> Bool # (/=) :: And -> And -> Bool #
Eq Condition # |
Methods (==) :: Condition -> Condition -> Bool # (/=) :: Condition -> Condition -> Bool #
Eq Bitmap # |
Methods (==) :: Bitmap -> Bitmap -> Bool # (/=) :: Bitmap -> Bitmap -> Bool #
Eq IPv4 # |
Methods (==) :: IPv4 -> IPv4 -> Bool # (/=) :: IPv4 -> IPv4 -> Bool #
Eq IPv6 # |
Methods (==) :: IPv6 -> IPv6 -> Bool # (/=) :: IPv6 -> IPv6 -> Bool #
Eq UUID # |
Methods (==) :: UUID -> UUID -> Bool # (/=) :: UUID -> UUID -> Bool #
Eq FileName # |
Methods (==) :: FileName -> FileName -> Bool # (/=) :: FileName -> FileName -> Bool #
Eq FilePath # |
Methods (==) :: FilePath -> FilePath -> Bool # (/=) :: FilePath -> FilePath -> Bool #
Eq Relativity # |
Methods (==) :: Relativity -> Relativity -> Bool # (/=) :: Relativity -> Relativity -> Bool #
Eq a => Eq [a] |
Methods (==) :: [a] -> [a] -> Bool # (/=) :: [a] -> [a] -> Bool #
Eq a => Eq (Maybe a) |
Methods (==) :: Maybe a -> Maybe a -> Bool # (/=) :: Maybe a -> Maybe a -> Bool #
Eq a => Eq (Ratio a) |
Methods (==) :: Ratio a -> Ratio a -> Bool # (/=) :: Ratio a -> Ratio a -> Bool #
Eq (Ptr a) |
Methods (==) :: Ptr a -> Ptr a -> Bool # (/=) :: Ptr a -> Ptr a -> Bool #
Eq (FunPtr a) |
Methods (==) :: FunPtr a -> FunPtr a -> Bool # (/=) :: FunPtr a -> FunPtr a -> Bool #
Eq (V1 p) |
Methods (==) :: V1 p -> V1 p -> Bool # (/=) :: V1 p -> V1 p -> Bool #
Eq (U1 p) |
Methods (==) :: U1 p -> U1 p -> Bool # (/=) :: U1 p -> U1 p -> Bool #
Eq p => Eq (Par1 p) |
Methods (==) :: Par1 p -> Par1 p -> Bool # (/=) :: Par1 p -> Par1 p -> Bool #
Eq a => Eq (Identity a) |
Methods (==) :: Identity a -> Identity a -> Bool # (/=) :: Identity a -> Identity a -> Bool #
Eq a => Eq (Min a) |
Methods (==) :: Min a -> Min a -> Bool # (/=) :: Min a -> Min a -> Bool #
Eq a => Eq (Max a) |
Methods (==) :: Max a -> Max a -> Bool # (/=) :: Max a -> Max a -> Bool #
Eq a => Eq (First a) |
Methods (==) :: First a -> First a -> Bool # (/=) :: First a -> First a -> Bool #
Eq a => Eq (Last a) |
Methods (==) :: Last a -> Last a -> Bool # (/=) :: Last a -> Last a -> Bool #
Eq m => Eq (WrappedMonoid m) |
Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool #
Eq a => Eq (Option a) |
Methods (==) :: Option a -> Option a -> Bool # (/=) :: Option a -> Option a -> Bool #
Eq a => Eq (NonEmpty a) |
Methods (==) :: NonEmpty a -> NonEmpty a -> Bool # (/=) :: NonEmpty a -> NonEmpty a -> Bool #
Eq a => Eq (ZipList a) |
Methods (==) :: ZipList a -> ZipList a -> Bool # (/=) :: ZipList a -> ZipList a -> Bool #
Eq (TVar a) |
Methods (==) :: TVar a -> TVar a -> Bool # (/=) :: TVar a -> TVar a -> Bool #
Eq (ForeignPtr a) |
Methods (==) :: ForeignPtr a -> ForeignPtr a -> Bool # (/=) :: ForeignPtr a -> ForeignPtr a -> Bool #
Eq a => Eq (Dual a) |
Methods (==) :: Dual a -> Dual a -> Bool # (/=) :: Dual a -> Dual a -> Bool #
Eq a => Eq (Sum a) |
Methods (==) :: Sum a -> Sum a -> Bool # (/=) :: Sum a -> Sum a -> Bool #
Eq a => Eq (Product a) |
Methods (==) :: Product a -> Product a -> Bool # (/=) :: Product a -> Product a -> Bool #
Eq a => Eq (First a) |
Methods (==) :: First a -> First a -> Bool # (/=) :: First a -> First a -> Bool #
Eq a => Eq (Last a) |
Methods (==) :: Last a -> Last a -> Bool # (/=) :: Last a -> Last a -> Bool #
Eq (IORef a) |
Methods (==) :: IORef a -> IORef a -> Bool # (/=) :: IORef a -> IORef a -> Bool #
Eq a => Eq (Array a) |
Methods (==) :: Array a -> Array a -> Bool # (/=) :: Array a -> Array a -> Bool #
(PrimType ty, Eq ty) => Eq (UArray ty) |
Methods (==) :: UArray ty -> UArray ty -> Bool # (/=) :: UArray ty -> UArray ty -> Bool #
(PrimType ty, Eq ty) => Eq (Block ty) |
Methods (==) :: Block ty -> Block ty -> Bool # (/=) :: Block ty -> Block ty -> Bool #
Eq a => Eq (NonEmpty a) |
Methods (==) :: NonEmpty a -> NonEmpty a -> Bool # (/=) :: NonEmpty a -> NonEmpty a -> Bool #
Eq (Offset ty) |
Methods (==) :: Offset ty -> Offset ty -> Bool # (/=) :: Offset ty -> Offset ty -> Bool #
Eq (CountOf ty) |
Methods (==) :: CountOf ty -> CountOf ty -> Bool # (/=) :: CountOf ty -> CountOf ty -> Bool #
Eq (Zn64 n) |
Methods (==) :: Zn64 n -> Zn64 n -> Bool # (/=) :: Zn64 n -> Zn64 n -> Bool #
Eq (Zn n) |
Methods (==) :: Zn n -> Zn n -> Bool # (/=) :: Zn n -> Zn n -> Bool #
Eq (FinalPtr a) |
Methods (==) :: FinalPtr a -> FinalPtr a -> Bool # (/=) :: FinalPtr a -> FinalPtr a -> Bool #
Eq a => Eq (LE a) |
Methods (==) :: LE a -> LE a -> Bool # (/=) :: LE a -> LE a -> Bool #
Eq a => Eq (BE a) |
Methods (==) :: BE a -> BE a -> Bool # (/=) :: BE a -> BE a -> Bool #
Eq a => Eq (DList a) # |
Methods (==) :: DList a -> DList a -> Bool # (/=) :: DList a -> DList a -> Bool #
PrimType ty => Eq (ChunkedUArray ty) # |
Methods (==) :: ChunkedUArray ty -> ChunkedUArray ty -> Bool # (/=) :: ChunkedUArray ty -> ChunkedUArray ty -> Bool #
(Eq b, Eq a) => Eq (Either a b) |
Methods (==) :: Either a b -> Either a b -> Bool # (/=) :: Either a b -> Either a b -> Bool #
Eq (f p) => Eq (Rec1 f p) |
Methods (==) :: Rec1 f p -> Rec1 f p -> Bool # (/=) :: Rec1 f p -> Rec1 f p -> Bool #
Eq (URec Char p) |
Methods (==) :: URec Char p -> URec Char p -> Bool # (/=) :: URec Char p -> URec Char p -> Bool #
Eq (URec Double p) |
Methods (==) :: URec Double p -> URec Double p -> Bool # (/=) :: URec Double p -> URec Double p -> Bool #
Eq (URec Float p) |
Methods (==) :: URec Float p -> URec Float p -> Bool # (/=) :: URec Float p -> URec Float p -> Bool #
Eq (URec Int p) |
Methods (==) :: URec Int p -> URec Int p -> Bool # (/=) :: URec Int p -> URec Int p -> Bool #
Eq (URec Word p) |
Methods (==) :: URec Word p -> URec Word p -> Bool # (/=) :: URec Word p -> URec Word p -> Bool #
Eq (URec (Ptr ()) p) |
Methods (==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool #
(Eq a, Eq b) => Eq (a, b) |
Methods (==) :: (a, b) -> (a, b) -> Bool # (/=) :: (a, b) -> (a, b) -> Bool #
(Ix i, Eq e) => Eq (Array i e) |
Methods (==) :: Array i e -> Array i e -> Bool # (/=) :: Array i e -> Array i e -> Bool #
Eq a => Eq (Arg a b) |
Methods (==) :: Arg a b -> Arg a b -> Bool # (/=) :: Arg a b -> Arg a b -> Bool #
Eq (Proxy k s) |
Methods (==) :: Proxy k s -> Proxy k s -> Bool # (/=) :: Proxy k s -> Proxy k s -> Bool #
Eq (STRef s a) |
Methods (==) :: STRef s a -> STRef s a -> Bool # (/=) :: STRef s a -> STRef s a -> Bool #
Eq a => Eq (ListN n a) |
Methods (==) :: ListN n a -> ListN n a -> Bool # (/=) :: ListN n a -> ListN n a -> Bool #
(Eq b, Eq a) => Eq (These a b) |
Methods (==) :: These a b -> These a b -> Bool # (/=) :: These a b -> These a b -> Bool #
(Eq b, Eq a) => Eq (Tuple2 a b) # |
Methods (==) :: Tuple2 a b -> Tuple2 a b -> Bool # (/=) :: Tuple2 a b -> Tuple2 a b -> Bool #
Eq c => Eq (K1 i c p) |
Methods (==) :: K1 i c p -> K1 i c p -> Bool # (/=) :: K1 i c p -> K1 i c p -> Bool #
(Eq (g p), Eq (f p)) => Eq ((:+:) f g p) |
Methods (==) :: (f :+: g) p -> (f :+: g) p -> Bool # (/=) :: (f :+: g) p -> (f :+: g) p -> Bool #
(Eq (g p), Eq (f p)) => Eq ((:*:) f g p) |
Methods (==) :: (f :*: g) p -> (f :*: g) p -> Bool # (/=) :: (f :*: g) p -> (f :*: g) p -> Bool #
Eq (f (g p)) => Eq ((:.:) f g p) |
Methods (==) :: (f :.: g) p -> (f :.: g) p -> Bool # (/=) :: (f :.: g) p -> (f :.: g) p -> Bool #
(Eq a, Eq b, Eq c) => Eq (a, b, c) |
Methods (==) :: (a, b, c) -> (a, b, c) -> Bool # (/=) :: (a, b, c) -> (a, b, c) -> Bool #
Eq (STArray s i e) |
Methods (==) :: STArray s i e -> STArray s i e -> Bool # (/=) :: STArray s i e -> STArray s i e -> Bool #
Eq a => Eq (Const k a b) |
Methods (==) :: Const k a b -> Const k a b -> Bool # (/=) :: Const k a b -> Const k a b -> Bool #
Eq (f a) => Eq (Alt k f a) |
Methods (==) :: Alt k f a -> Alt k f a -> Bool # (/=) :: Alt k f a -> Alt k f a -> Bool #
Eq (Coercion k a b) |
Methods (==) :: Coercion k a b -> Coercion k a b -> Bool # (/=) :: Coercion k a b -> Coercion k a b -> Bool #
Eq ((:~:) k a b) |
Methods (==) :: (k :~: a) b -> (k :~: a) b -> Bool # (/=) :: (k :~: a) b -> (k :~: a) b -> Bool #
(Eq c, Eq b, Eq a) => Eq (Tuple3 a b c) # |
Methods (==) :: Tuple3 a b c -> Tuple3 a b c -> Bool # (/=) :: Tuple3 a b c -> Tuple3 a b c -> Bool #
Eq (f p) => Eq (M1 i c f p) |
Methods (==) :: M1 i c f p -> M1 i c f p -> Bool # (/=) :: M1 i c f p -> M1 i c f p -> Bool #
(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) |
Methods (==) :: (a, b, c, d) -> (a, b, c, d) -> Bool # (/=) :: (a, b, c, d) -> (a, b, c, d) -> Bool #
(Eq d, Eq c, Eq b, Eq a) => Eq (Tuple4 a b c d) # |
Methods (==) :: Tuple4 a b c d -> Tuple4 a b c d -> Bool # (/=) :: Tuple4 a b c d -> Tuple4 a b c d -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) |
Methods (==) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (/=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) |
Methods (==) :: (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 #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) |
Methods (==) :: (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 #
(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) |
Methods (==) :: (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 #
(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) |
Methods (==) :: (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 #
(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) |
Methods (==) :: (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 #
(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) |
Methods (==) :: (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 #
(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) |
Methods (==) :: (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 #
(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) |
Methods (==) :: (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 #
(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) |
Methods (==) :: (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 #
(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) |
Methods (==) :: (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 #

class Bounded a where #

The `Bounded` class is used to name the upper and lower limits of a type. `Ord` is not a superclass of `Bounded` since types that are not totally ordered may also have upper and lower bounds.

The `Bounded` class may be derived for any enumeration type; `minBound` is the first constructor listed in the `data` declaration and `maxBound` is the last. `Bounded` may also be derived for single-constructor datatypes whose constituent types are in `Bounded`.

Minimal complete definition

minBound, maxBound

Methods

minBound :: a #

maxBound :: a #

Instances

Bounded Bool |
Methods minBound :: Bool # maxBound :: Bool #
Bounded Char |
Methods minBound :: Char # maxBound :: Char #
Bounded Int |
Methods minBound :: Int # maxBound :: Int #
Bounded Int8 |
Methods minBound :: Int8 # maxBound :: Int8 #
Bounded Int16 |
Methods minBound :: Int16 # maxBound :: Int16 #
Bounded Int32 |
Methods minBound :: Int32 # maxBound :: Int32 #
Bounded Int64 |
Methods minBound :: Int64 # maxBound :: Int64 #
Bounded Ordering |
Methods minBound :: Ordering # maxBound :: Ordering #
Bounded Word |
Methods minBound :: Word # maxBound :: Word #
Bounded Word8 |
Methods minBound :: Word8 # maxBound :: Word8 #
Bounded Word16 |
Methods minBound :: Word16 # maxBound :: Word16 #
Bounded Word32 |
Methods minBound :: Word32 # maxBound :: Word32 #
Bounded Word64 |
Methods minBound :: Word64 # maxBound :: Word64 #
Bounded () |
Methods minBound :: () # maxBound :: () #
Bounded CDev |
Methods minBound :: CDev # maxBound :: CDev #
Bounded CIno |
Methods minBound :: CIno # maxBound :: CIno #
Bounded CMode |
Methods minBound :: CMode # maxBound :: CMode #
Bounded COff |
Methods minBound :: COff # maxBound :: COff #
Bounded CPid |
Methods minBound :: CPid # maxBound :: CPid #
Bounded CSsize |
Methods minBound :: CSsize # maxBound :: CSsize #
Bounded CGid |
Methods minBound :: CGid # maxBound :: CGid #
Bounded CNlink |
Methods minBound :: CNlink # maxBound :: CNlink #
Bounded CUid |
Methods minBound :: CUid # maxBound :: CUid #
Bounded CTcflag |
Methods minBound :: CTcflag # maxBound :: CTcflag #
Bounded CRLim |
Methods minBound :: CRLim # maxBound :: CRLim #
Bounded Fd |
Methods minBound :: Fd # maxBound :: Fd #
Bounded WordPtr |
Methods minBound :: WordPtr # maxBound :: WordPtr #
Bounded IntPtr |
Methods minBound :: IntPtr # maxBound :: IntPtr #
Bounded CChar |
Methods minBound :: CChar # maxBound :: CChar #
Bounded CSChar |
Methods minBound :: CSChar # maxBound :: CSChar #
Bounded CUChar |
Methods minBound :: CUChar # maxBound :: CUChar #
Bounded CShort |
Methods minBound :: CShort # maxBound :: CShort #
Bounded CUShort |
Methods minBound :: CUShort # maxBound :: CUShort #
Bounded CInt |
Methods minBound :: CInt # maxBound :: CInt #
Bounded CUInt |
Methods minBound :: CUInt # maxBound :: CUInt #
Bounded CLong |
Methods minBound :: CLong # maxBound :: CLong #
Bounded CULong |
Methods minBound :: CULong # maxBound :: CULong #
Bounded CLLong |
Methods minBound :: CLLong # maxBound :: CLLong #
Bounded CULLong |
Methods minBound :: CULLong # maxBound :: CULLong #
Bounded CPtrdiff |
Methods minBound :: CPtrdiff # maxBound :: CPtrdiff #
Bounded CSize |
Methods minBound :: CSize # maxBound :: CSize #
Bounded CWchar |
Methods minBound :: CWchar # maxBound :: CWchar #
Bounded CSigAtomic |
Methods minBound :: CSigAtomic # maxBound :: CSigAtomic #
Bounded CIntPtr |
Methods minBound :: CIntPtr # maxBound :: CIntPtr #
Bounded CUIntPtr |
Methods minBound :: CUIntPtr # maxBound :: CUIntPtr #
Bounded CIntMax |
Methods minBound :: CIntMax # maxBound :: CIntMax #
Bounded CUIntMax |
Methods minBound :: CUIntMax # maxBound :: CUIntMax #
Bounded All |
Methods minBound :: All # maxBound :: All #
Bounded Any |
Methods minBound :: Any # maxBound :: Any #
Bounded Associativity |
Methods minBound :: Associativity # maxBound :: Associativity #
Bounded SourceUnpackedness |
Methods minBound :: SourceUnpackedness # maxBound :: SourceUnpackedness #
Bounded SourceStrictness |
Methods minBound :: SourceStrictness # maxBound :: SourceStrictness #
Bounded DecidedStrictness |
Methods minBound :: DecidedStrictness # maxBound :: DecidedStrictness #
Bounded GeneralCategory |
Methods minBound :: GeneralCategory # maxBound :: GeneralCategory #
Bounded UTF32_Invalid |
Methods minBound :: UTF32_Invalid # maxBound :: UTF32_Invalid #
Bounded Encoding |
Methods minBound :: Encoding # maxBound :: Encoding #
Bounded Word256 |
Methods minBound :: Word256 # maxBound :: Word256 #
Bounded Word128 |
Methods minBound :: Word128 # maxBound :: Word128 #
Bounded Arch # |
Methods minBound :: Arch # maxBound :: Arch #
Bounded OS # |
Methods minBound :: OS # maxBound :: OS #
Bounded Seconds # |
Methods minBound :: Seconds # maxBound :: Seconds #
Bounded NanoSeconds # |
Methods minBound :: NanoSeconds # maxBound :: NanoSeconds #
Bounded a => Bounded (Identity a) |
Methods minBound :: Identity a # maxBound :: Identity a #
Bounded a => Bounded (Min a) |
Methods minBound :: Min a # maxBound :: Min a #
Bounded a => Bounded (Max a) |
Methods minBound :: Max a # maxBound :: Max a #
Bounded a => Bounded (First a) |
Methods minBound :: First a # maxBound :: First a #
Bounded a => Bounded (Last a) |
Methods minBound :: Last a # maxBound :: Last a #
Bounded a => Bounded (WrappedMonoid a) |
Methods minBound :: WrappedMonoid a # maxBound :: WrappedMonoid a #
Bounded a => Bounded (Dual a) |
Methods minBound :: Dual a # maxBound :: Dual a #
Bounded a => Bounded (Sum a) |
Methods minBound :: Sum a # maxBound :: Sum a #
Bounded a => Bounded (Product a) |
Methods minBound :: Product a # maxBound :: Product a #
(Bounded a, Bounded b) => Bounded (a, b) |
Methods minBound :: (a, b) # maxBound :: (a, b) #
Bounded (Proxy k s) |
Methods minBound :: Proxy k s # maxBound :: Proxy k s #
(Bounded a, Bounded b, Bounded c) => Bounded (a, b, c) |
Methods minBound :: (a, b, c) # maxBound :: (a, b, c) #
Bounded a => Bounded (Const k a b) |
Methods minBound :: Const k a b # maxBound :: Const k a b #
Coercible k a b => Bounded (Coercion k a b) |
Methods minBound :: Coercion k a b # maxBound :: Coercion k a b #
(~) k a b => Bounded ((:~:) k a b) |
Methods minBound :: (k :~: a) b # maxBound :: (k :~: a) b #
(Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a, b, c, d) |
Methods minBound :: (a, b, c, d) # maxBound :: (a, b, c, d) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a, b, c, d, e) |
Methods minBound :: (a, b, c, d, e) # maxBound :: (a, b, c, d, e) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f) => Bounded (a, b, c, d, e, f) |
Methods minBound :: (a, b, c, d, e, f) # maxBound :: (a, b, c, d, e, f) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g) => Bounded (a, b, c, d, e, f, g) |
Methods minBound :: (a, b, c, d, e, f, g) # maxBound :: (a, b, c, d, e, f, g) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h) => Bounded (a, b, c, d, e, f, g, h) |
Methods minBound :: (a, b, c, d, e, f, g, h) # maxBound :: (a, b, c, d, e, f, g, h) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i) => Bounded (a, b, c, d, e, f, g, h, i) |
Methods minBound :: (a, b, c, d, e, f, g, h, i) # maxBound :: (a, b, c, d, e, f, g, h, i) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j) => Bounded (a, b, c, d, e, f, g, h, i, j) |
Methods minBound :: (a, b, c, d, e, f, g, h, i, j) # maxBound :: (a, b, c, d, e, f, g, h, i, j) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k) => Bounded (a, b, c, d, e, f, g, h, i, j, k) |
Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l) |
Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m) |
Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n) |
Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n, Bounded o) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) |
Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) #

class Enum a where #

Class `Enum` defines operations on sequentially ordered types.

The `enumFrom`... methods are used in Haskell's translation of arithmetic sequences.

Instances of `Enum` may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by `fromEnum` from `0` through `n-1`. See Chapter 10 of the Haskell Report for more details.

For any type that is an instance of class `Bounded` as well as `Enum`, the following should hold:

- The calls ``succ` `maxBound`` and ``pred` `minBound`` should result in a runtime error.
- `fromEnum` and `toEnum` should give a runtime error if the result value is not representable in the result type. For example, ``toEnum` 7 :: `Bool`` is an error.
- `enumFrom` and `enumFromThen` should be defined with an implicit bound, thus:

       enumFrom     x   = enumFromTo     x maxBound
       enumFromThen x y = enumFromThenTo x y bound
         where
           bound | fromEnum y >= fromEnum x = maxBound
                 | otherwise                = minBound

Minimal complete definition

toEnum, fromEnum

Methods

succ :: a -> a #

the successor of a value. For numeric types, `succ` adds 1.

pred :: a -> a #

the predecessor of a value. For numeric types, `pred` subtracts 1.

toEnum :: Int -> a #

Convert from an `Int`.

fromEnum :: a -> Int #

Convert to an `Int`. It is implementation-dependent what `fromEnum` returns when applied to a value that is too large to fit in an `Int`.

enumFrom :: a -> [a] #

Used in Haskell's translation of `[n..]`.

enumFromThen :: a -> a -> [a] #

Used in Haskell's translation of `[n,n'..]`.

enumFromTo :: a -> a -> [a] #

Used in Haskell's translation of `[n..m]`.

enumFromThenTo :: a -> a -> a -> [a] #

Used in Haskell's translation of `[n,n'..m]`.

Instances

Enum Bool |
Methods succ :: Bool -> Bool # pred :: Bool -> Bool # toEnum :: Int -> Bool # fromEnum :: Bool -> Int # enumFrom :: Bool -> [Bool] # enumFromThen :: Bool -> Bool -> [Bool] # enumFromTo :: Bool -> Bool -> [Bool] # enumFromThenTo :: Bool -> Bool -> Bool -> [Bool] #
Enum Char |
Methods succ :: Char -> Char # pred :: Char -> Char # toEnum :: Int -> Char # fromEnum :: Char -> Int # enumFrom :: Char -> [Char] # enumFromThen :: Char -> Char -> [Char] # enumFromTo :: Char -> Char -> [Char] # enumFromThenTo :: Char -> Char -> Char -> [Char] #
Enum Int |
Methods succ :: Int -> Int # pred :: Int -> Int # toEnum :: Int -> Int # fromEnum :: Int -> Int # enumFrom :: Int -> [Int] # enumFromThen :: Int -> Int -> [Int] # enumFromTo :: Int -> Int -> [Int] # enumFromThenTo :: Int -> Int -> Int -> [Int] #
Enum Int8 |
Methods succ :: Int8 -> Int8 # pred :: Int8 -> Int8 # toEnum :: Int -> Int8 # fromEnum :: Int8 -> Int # enumFrom :: Int8 -> [Int8] # enumFromThen :: Int8 -> Int8 -> [Int8] # enumFromTo :: Int8 -> Int8 -> [Int8] # enumFromThenTo :: Int8 -> Int8 -> Int8 -> [Int8] #
Enum Int16 |
Methods succ :: Int16 -> Int16 # pred :: Int16 -> Int16 # toEnum :: Int -> Int16 # fromEnum :: Int16 -> Int # enumFrom :: Int16 -> [Int16] # enumFromThen :: Int16 -> Int16 -> [Int16] # enumFromTo :: Int16 -> Int16 -> [Int16] # enumFromThenTo :: Int16 -> Int16 -> Int16 -> [Int16] #
Enum Int32 |
Methods succ :: Int32 -> Int32 # pred :: Int32 -> Int32 # toEnum :: Int -> Int32 # fromEnum :: Int32 -> Int # enumFrom :: Int32 -> [Int32] # enumFromThen :: Int32 -> Int32 -> [Int32] # enumFromTo :: Int32 -> Int32 -> [Int32] # enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32] #
Enum Int64 |
Methods succ :: Int64 -> Int64 # pred :: Int64 -> Int64 # toEnum :: Int -> Int64 # fromEnum :: Int64 -> Int # enumFrom :: Int64 -> [Int64] # enumFromThen :: Int64 -> Int64 -> [Int64] # enumFromTo :: Int64 -> Int64 -> [Int64] # enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64] #
Enum Integer |
Methods succ :: Integer -> Integer # pred :: Integer -> Integer # toEnum :: Int -> Integer # fromEnum :: Integer -> Int # enumFrom :: Integer -> [Integer] # enumFromThen :: Integer -> Integer -> [Integer] # enumFromTo :: Integer -> Integer -> [Integer] # enumFromThenTo :: Integer -> Integer -> Integer -> [Integer] #
Enum Ordering |
Methods succ :: Ordering -> Ordering # pred :: Ordering -> Ordering # toEnum :: Int -> Ordering # fromEnum :: Ordering -> Int # enumFrom :: Ordering -> [Ordering] # enumFromThen :: Ordering -> Ordering -> [Ordering] # enumFromTo :: Ordering -> Ordering -> [Ordering] # enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering] #
Enum Word |
Methods succ :: Word -> Word # pred :: Word -> Word # toEnum :: Int -> Word # fromEnum :: Word -> Int # enumFrom :: Word -> [Word] # enumFromThen :: Word -> Word -> [Word] # enumFromTo :: Word -> Word -> [Word] # enumFromThenTo :: Word -> Word -> Word -> [Word] #
Enum Word8 |
Methods succ :: Word8 -> Word8 # pred :: Word8 -> Word8 # toEnum :: Int -> Word8 # fromEnum :: Word8 -> Int # enumFrom :: Word8 -> [Word8] # enumFromThen :: Word8 -> Word8 -> [Word8] # enumFromTo :: Word8 -> Word8 -> [Word8] # enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8] #
Enum Word16 |
Methods succ :: Word16 -> Word16 # pred :: Word16 -> Word16 # toEnum :: Int -> Word16 # fromEnum :: Word16 -> Int # enumFrom :: Word16 -> [Word16] # enumFromThen :: Word16 -> Word16 -> [Word16] # enumFromTo :: Word16 -> Word16 -> [Word16] # enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16] #
Enum Word32 |
Methods succ :: Word32 -> Word32 # pred :: Word32 -> Word32 # toEnum :: Int -> Word32 # fromEnum :: Word32 -> Int # enumFrom :: Word32 -> [Word32] # enumFromThen :: Word32 -> Word32 -> [Word32] # enumFromTo :: Word32 -> Word32 -> [Word32] # enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32] #
Enum Word64 |
Methods succ :: Word64 -> Word64 # pred :: Word64 -> Word64 # toEnum :: Int -> Word64 # fromEnum :: Word64 -> Int # enumFrom :: Word64 -> [Word64] # enumFromThen :: Word64 -> Word64 -> [Word64] # enumFromTo :: Word64 -> Word64 -> [Word64] # enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64] #
Enum () |
Methods succ :: () -> () # pred :: () -> () # toEnum :: Int -> () # fromEnum :: () -> Int # enumFrom :: () -> [()] # enumFromThen :: () -> () -> [()] # enumFromTo :: () -> () -> [()] # enumFromThenTo :: () -> () -> () -> [()] #
Enum Natural |
Methods succ :: Natural -> Natural # pred :: Natural -> Natural # toEnum :: Int -> Natural # fromEnum :: Natural -> Int # enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] #
Enum CDev |
Methods succ :: CDev -> CDev # pred :: CDev -> CDev # toEnum :: Int -> CDev # fromEnum :: CDev -> Int # enumFrom :: CDev -> [CDev] # enumFromThen :: CDev -> CDev -> [CDev] # enumFromTo :: CDev -> CDev -> [CDev] # enumFromThenTo :: CDev -> CDev -> CDev -> [CDev] #
Enum CIno |
Methods succ :: CIno -> CIno # pred :: CIno -> CIno # toEnum :: Int -> CIno # fromEnum :: CIno -> Int # enumFrom :: CIno -> [CIno] # enumFromThen :: CIno -> CIno -> [CIno] # enumFromTo :: CIno -> CIno -> [CIno] # enumFromThenTo :: CIno -> CIno -> CIno -> [CIno] #
Enum CMode |
Methods succ :: CMode -> CMode # pred :: CMode -> CMode # toEnum :: Int -> CMode # fromEnum :: CMode -> Int # enumFrom :: CMode -> [CMode] # enumFromThen :: CMode -> CMode -> [CMode] # enumFromTo :: CMode -> CMode -> [CMode] # enumFromThenTo :: CMode -> CMode -> CMode -> [CMode] #
Enum COff |
Methods succ :: COff -> COff # pred :: COff -> COff # toEnum :: Int -> COff # fromEnum :: COff -> Int # enumFrom :: COff -> [COff] # enumFromThen :: COff -> COff -> [COff] # enumFromTo :: COff -> COff -> [COff] # enumFromThenTo :: COff -> COff -> COff -> [COff] #
Enum CPid |
Methods succ :: CPid -> CPid # pred :: CPid -> CPid # toEnum :: Int -> CPid # fromEnum :: CPid -> Int # enumFrom :: CPid -> [CPid] # enumFromThen :: CPid -> CPid -> [CPid] # enumFromTo :: CPid -> CPid -> [CPid] # enumFromThenTo :: CPid -> CPid -> CPid -> [CPid] #
Enum CSsize |
Methods succ :: CSsize -> CSsize # pred :: CSsize -> CSsize # toEnum :: Int -> CSsize # fromEnum :: CSsize -> Int # enumFrom :: CSsize -> [CSsize] # enumFromThen :: CSsize -> CSsize -> [CSsize] # enumFromTo :: CSsize -> CSsize -> [CSsize] # enumFromThenTo :: CSsize -> CSsize -> CSsize -> [CSsize] #
Enum CGid |
Methods succ :: CGid -> CGid # pred :: CGid -> CGid # toEnum :: Int -> CGid # fromEnum :: CGid -> Int # enumFrom :: CGid -> [CGid] # enumFromThen :: CGid -> CGid -> [CGid] # enumFromTo :: CGid -> CGid -> [CGid] # enumFromThenTo :: CGid -> CGid -> CGid -> [CGid] #
Enum CNlink |
Methods succ :: CNlink -> CNlink # pred :: CNlink -> CNlink # toEnum :: Int -> CNlink # fromEnum :: CNlink -> Int # enumFrom :: CNlink -> [CNlink] # enumFromThen :: CNlink -> CNlink -> [CNlink] # enumFromTo :: CNlink -> CNlink -> [CNlink] # enumFromThenTo :: CNlink -> CNlink -> CNlink -> [CNlink] #
Enum CUid |
Methods succ :: CUid -> CUid # pred :: CUid -> CUid # toEnum :: Int -> CUid # fromEnum :: CUid -> Int # enumFrom :: CUid -> [CUid] # enumFromThen :: CUid -> CUid -> [CUid] # enumFromTo :: CUid -> CUid -> [CUid] # enumFromThenTo :: CUid -> CUid -> CUid -> [CUid] #
Enum CCc |
Methods succ :: CCc -> CCc # pred :: CCc -> CCc # toEnum :: Int -> CCc # fromEnum :: CCc -> Int # enumFrom :: CCc -> [CCc] # enumFromThen :: CCc -> CCc -> [CCc] # enumFromTo :: CCc -> CCc -> [CCc] # enumFromThenTo :: CCc -> CCc -> CCc -> [CCc] #
Enum CSpeed |
Methods succ :: CSpeed -> CSpeed # pred :: CSpeed -> CSpeed # toEnum :: Int -> CSpeed # fromEnum :: CSpeed -> Int # enumFrom :: CSpeed -> [CSpeed] # enumFromThen :: CSpeed -> CSpeed -> [CSpeed] # enumFromTo :: CSpeed -> CSpeed -> [CSpeed] # enumFromThenTo :: CSpeed -> CSpeed -> CSpeed -> [CSpeed] #
Enum CTcflag |
Methods succ :: CTcflag -> CTcflag # pred :: CTcflag -> CTcflag # toEnum :: Int -> CTcflag # fromEnum :: CTcflag -> Int # enumFrom :: CTcflag -> [CTcflag] # enumFromThen :: CTcflag -> CTcflag -> [CTcflag] # enumFromTo :: CTcflag -> CTcflag -> [CTcflag] # enumFromThenTo :: CTcflag -> CTcflag -> CTcflag -> [CTcflag] #
Enum CRLim |
Methods succ :: CRLim -> CRLim # pred :: CRLim -> CRLim # toEnum :: Int -> CRLim # fromEnum :: CRLim -> Int # enumFrom :: CRLim -> [CRLim] # enumFromThen :: CRLim -> CRLim -> [CRLim] # enumFromTo :: CRLim -> CRLim -> [CRLim] # enumFromThenTo :: CRLim -> CRLim -> CRLim -> [CRLim] #
Enum Fd |
Methods succ :: Fd -> Fd # pred :: Fd -> Fd # toEnum :: Int -> Fd # fromEnum :: Fd -> Int # enumFrom :: Fd -> [Fd] # enumFromThen :: Fd -> Fd -> [Fd] # enumFromTo :: Fd -> Fd -> [Fd] # enumFromThenTo :: Fd -> Fd -> Fd -> [Fd] #
Enum WordPtr |
Methods succ :: WordPtr -> WordPtr # pred :: WordPtr -> WordPtr # toEnum :: Int -> WordPtr # fromEnum :: WordPtr -> Int # enumFrom :: WordPtr -> [WordPtr] # enumFromThen :: WordPtr -> WordPtr -> [WordPtr] # enumFromTo :: WordPtr -> WordPtr -> [WordPtr] # enumFromThenTo :: WordPtr -> WordPtr -> WordPtr -> [WordPtr] #
Enum IntPtr |
Methods succ :: IntPtr -> IntPtr # pred :: IntPtr -> IntPtr # toEnum :: Int -> IntPtr # fromEnum :: IntPtr -> Int # enumFrom :: IntPtr -> [IntPtr] # enumFromThen :: IntPtr -> IntPtr -> [IntPtr] # enumFromTo :: IntPtr -> IntPtr -> [IntPtr] # enumFromThenTo :: IntPtr -> IntPtr -> IntPtr -> [IntPtr] #
Enum CChar |
Methods succ :: CChar -> CChar # pred :: CChar -> CChar # toEnum :: Int -> CChar # fromEnum :: CChar -> Int # enumFrom :: CChar -> [CChar] # enumFromThen :: CChar -> CChar -> [CChar] # enumFromTo :: CChar -> CChar -> [CChar] # enumFromThenTo :: CChar -> CChar -> CChar -> [CChar] #
Enum CSChar |
Methods succ :: CSChar -> CSChar # pred :: CSChar -> CSChar # toEnum :: Int -> CSChar # fromEnum :: CSChar -> Int # enumFrom :: CSChar -> [CSChar] # enumFromThen :: CSChar -> CSChar -> [CSChar] # enumFromTo :: CSChar -> CSChar -> [CSChar] # enumFromThenTo :: CSChar -> CSChar -> CSChar -> [CSChar] #
Enum CUChar |
Methods succ :: CUChar -> CUChar # pred :: CUChar -> CUChar # toEnum :: Int -> CUChar # fromEnum :: CUChar -> Int # enumFrom :: CUChar -> [CUChar] # enumFromThen :: CUChar -> CUChar -> [CUChar] # enumFromTo :: CUChar -> CUChar -> [CUChar] # enumFromThenTo :: CUChar -> CUChar -> CUChar -> [CUChar] #
Enum CShort |
Methods succ :: CShort -> CShort # pred :: CShort -> CShort # toEnum :: Int -> CShort # fromEnum :: CShort -> Int # enumFrom :: CShort -> [CShort] # enumFromThen :: CShort -> CShort -> [CShort] # enumFromTo :: CShort -> CShort -> [CShort] # enumFromThenTo :: CShort -> CShort -> CShort -> [CShort] #
Enum CUShort |
Methods succ :: CUShort -> CUShort # pred :: CUShort -> CUShort # toEnum :: Int -> CUShort # fromEnum :: CUShort -> Int # enumFrom :: CUShort -> [CUShort] # enumFromThen :: CUShort -> CUShort -> [CUShort] # enumFromTo :: CUShort -> CUShort -> [CUShort] # enumFromThenTo :: CUShort -> CUShort -> CUShort -> [CUShort] #
Enum CInt |
Methods succ :: CInt -> CInt # pred :: CInt -> CInt # toEnum :: Int -> CInt # fromEnum :: CInt -> Int # enumFrom :: CInt -> [CInt] # enumFromThen :: CInt -> CInt -> [CInt] # enumFromTo :: CInt -> CInt -> [CInt] # enumFromThenTo :: CInt -> CInt -> CInt -> [CInt] #
Enum CUInt |
Methods succ :: CUInt -> CUInt # pred :: CUInt -> CUInt # toEnum :: Int -> CUInt # fromEnum :: CUInt -> Int # enumFrom :: CUInt -> [CUInt] # enumFromThen :: CUInt -> CUInt -> [CUInt] # enumFromTo :: CUInt -> CUInt -> [CUInt] # enumFromThenTo :: CUInt -> CUInt -> CUInt -> [CUInt] #
Enum CLong |
Methods succ :: CLong -> CLong # pred :: CLong -> CLong # toEnum :: Int -> CLong # fromEnum :: CLong -> Int # enumFrom :: CLong -> [CLong] # enumFromThen :: CLong -> CLong -> [CLong] # enumFromTo :: CLong -> CLong -> [CLong] # enumFromThenTo :: CLong -> CLong -> CLong -> [CLong] #
Enum CULong |
Methods succ :: CULong -> CULong # pred :: CULong -> CULong # toEnum :: Int -> CULong # fromEnum :: CULong -> Int # enumFrom :: CULong -> [CULong] # enumFromThen :: CULong -> CULong -> [CULong] # enumFromTo :: CULong -> CULong -> [CULong] # enumFromThenTo :: CULong -> CULong -> CULong -> [CULong] #
Enum CLLong |
Methods succ :: CLLong -> CLLong # pred :: CLLong -> CLLong # toEnum :: Int -> CLLong # fromEnum :: CLLong -> Int # enumFrom :: CLLong -> [CLLong] # enumFromThen :: CLLong -> CLLong -> [CLLong] # enumFromTo :: CLLong -> CLLong -> [CLLong] # enumFromThenTo :: CLLong -> CLLong -> CLLong -> [CLLong] #
Enum CULLong |
Methods succ :: CULLong -> CULLong # pred :: CULLong -> CULLong # toEnum :: Int -> CULLong # fromEnum :: CULLong -> Int # enumFrom :: CULLong -> [CULLong] # enumFromThen :: CULLong -> CULLong -> [CULLong] # enumFromTo :: CULLong -> CULLong -> [CULLong] # enumFromThenTo :: CULLong -> CULLong -> CULLong -> [CULLong] #
Enum CFloat |
Methods succ :: CFloat -> CFloat # pred :: CFloat -> CFloat # toEnum :: Int -> CFloat # fromEnum :: CFloat -> Int # enumFrom :: CFloat -> [CFloat] # enumFromThen :: CFloat -> CFloat -> [CFloat] # enumFromTo :: CFloat -> CFloat -> [CFloat] # enumFromThenTo :: CFloat -> CFloat -> CFloat -> [CFloat] #
Enum CDouble |
Methods succ :: CDouble -> CDouble # pred :: CDouble -> CDouble # toEnum :: Int -> CDouble # fromEnum :: CDouble -> Int # enumFrom :: CDouble -> [CDouble] # enumFromThen :: CDouble -> CDouble -> [CDouble] # enumFromTo :: CDouble -> CDouble -> [CDouble] # enumFromThenTo :: CDouble -> CDouble -> CDouble -> [CDouble] #
Enum CPtrdiff |
Methods succ :: CPtrdiff -> CPtrdiff # pred :: CPtrdiff -> CPtrdiff # toEnum :: Int -> CPtrdiff # fromEnum :: CPtrdiff -> Int # enumFrom :: CPtrdiff -> [CPtrdiff] # enumFromThen :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromTo :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromThenTo :: CPtrdiff -> CPtrdiff -> CPtrdiff -> [CPtrdiff] #
Enum CSize |
Methods succ :: CSize -> CSize # pred :: CSize -> CSize # toEnum :: Int -> CSize # fromEnum :: CSize -> Int # enumFrom :: CSize -> [CSize] # enumFromThen :: CSize -> CSize -> [CSize] # enumFromTo :: CSize -> CSize -> [CSize] # enumFromThenTo :: CSize -> CSize -> CSize -> [CSize] #
Enum CWchar |
Methods succ :: CWchar -> CWchar # pred :: CWchar -> CWchar # toEnum :: Int -> CWchar # fromEnum :: CWchar -> Int # enumFrom :: CWchar -> [CWchar] # enumFromThen :: CWchar -> CWchar -> [CWchar] # enumFromTo :: CWchar -> CWchar -> [CWchar] # enumFromThenTo :: CWchar -> CWchar -> CWchar -> [CWchar] #
Enum CSigAtomic |
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 CClock |
Methods succ :: CClock -> CClock # pred :: CClock -> CClock # toEnum :: Int -> CClock # fromEnum :: CClock -> Int # enumFrom :: CClock -> [CClock] # enumFromThen :: CClock -> CClock -> [CClock] # enumFromTo :: CClock -> CClock -> [CClock] # enumFromThenTo :: CClock -> CClock -> CClock -> [CClock] #
Enum CTime |
Methods succ :: CTime -> CTime # pred :: CTime -> CTime # toEnum :: Int -> CTime # fromEnum :: CTime -> Int # enumFrom :: CTime -> [CTime] # enumFromThen :: CTime -> CTime -> [CTime] # enumFromTo :: CTime -> CTime -> [CTime] # enumFromThenTo :: CTime -> CTime -> CTime -> [CTime] #
Enum CUSeconds |
Methods succ :: CUSeconds -> CUSeconds # pred :: CUSeconds -> CUSeconds # toEnum :: Int -> CUSeconds # fromEnum :: CUSeconds -> Int # enumFrom :: CUSeconds -> [CUSeconds] # enumFromThen :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromTo :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromThenTo :: CUSeconds -> CUSeconds -> CUSeconds -> [CUSeconds] #
Enum CSUSeconds |
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 CIntPtr |
Methods succ :: CIntPtr -> CIntPtr # pred :: CIntPtr -> CIntPtr # toEnum :: Int -> CIntPtr # fromEnum :: CIntPtr -> Int # enumFrom :: CIntPtr -> [CIntPtr] # enumFromThen :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromTo :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromThenTo :: CIntPtr -> CIntPtr -> CIntPtr -> [CIntPtr] #
Enum CUIntPtr |
Methods succ :: CUIntPtr -> CUIntPtr # pred :: CUIntPtr -> CUIntPtr # toEnum :: Int -> CUIntPtr # fromEnum :: CUIntPtr -> Int # enumFrom :: CUIntPtr -> [CUIntPtr] # enumFromThen :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromTo :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromThenTo :: CUIntPtr -> CUIntPtr -> CUIntPtr -> [CUIntPtr] #
Enum CIntMax |
Methods succ :: CIntMax -> CIntMax # pred :: CIntMax -> CIntMax # toEnum :: Int -> CIntMax # fromEnum :: CIntMax -> Int # enumFrom :: CIntMax -> [CIntMax] # enumFromThen :: CIntMax -> CIntMax -> [CIntMax] # enumFromTo :: CIntMax -> CIntMax -> [CIntMax] # enumFromThenTo :: CIntMax -> CIntMax -> CIntMax -> [CIntMax] #
Enum CUIntMax |
Methods succ :: CUIntMax -> CUIntMax # pred :: CUIntMax -> CUIntMax # toEnum :: Int -> CUIntMax # fromEnum :: CUIntMax -> Int # enumFrom :: CUIntMax -> [CUIntMax] # enumFromThen :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromTo :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromThenTo :: CUIntMax -> CUIntMax -> CUIntMax -> [CUIntMax] #
Enum SeekMode |
Methods succ :: SeekMode -> SeekMode # pred :: SeekMode -> SeekMode # toEnum :: Int -> SeekMode # fromEnum :: SeekMode -> Int # enumFrom :: SeekMode -> [SeekMode] # enumFromThen :: SeekMode -> SeekMode -> [SeekMode] # enumFromTo :: SeekMode -> SeekMode -> [SeekMode] # enumFromThenTo :: SeekMode -> SeekMode -> SeekMode -> [SeekMode] #
Enum Associativity |

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 SourceUnpackedness |

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 SourceStrictness |

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 DecidedStrictness |

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 IOMode |
Methods succ :: IOMode -> IOMode # pred :: IOMode -> IOMode # toEnum :: Int -> IOMode # fromEnum :: IOMode -> Int # enumFrom :: IOMode -> [IOMode] # enumFromThen :: IOMode -> IOMode -> [IOMode] # enumFromTo :: IOMode -> IOMode -> [IOMode] # enumFromThenTo :: IOMode -> IOMode -> IOMode -> [IOMode] #
Enum GeneralCategory |

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 UTF32_Invalid |

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 Encoding |
Methods succ :: Encoding -> Encoding # pred :: Encoding -> Encoding # toEnum :: Int -> Encoding # fromEnum :: Encoding -> Int # enumFrom :: Encoding -> [Encoding] # enumFromThen :: Encoding -> Encoding -> [Encoding] # enumFromTo :: Encoding -> Encoding -> [Encoding] # enumFromThenTo :: Encoding -> Encoding -> Encoding -> [Encoding] #
Enum Word256 |
Methods succ :: Word256 -> Word256 # pred :: Word256 -> Word256 # toEnum :: Int -> Word256 # fromEnum :: Word256 -> Int # enumFrom :: Word256 -> [Word256] # enumFromThen :: Word256 -> Word256 -> [Word256] # enumFromTo :: Word256 -> Word256 -> [Word256] # enumFromThenTo :: Word256 -> Word256 -> Word256 -> [Word256] #
Enum Word128 |
Methods succ :: Word128 -> Word128 # pred :: Word128 -> Word128 # toEnum :: Int -> Word128 # fromEnum :: Word128 -> Int # enumFrom :: Word128 -> [Word128] # enumFromThen :: Word128 -> Word128 -> [Word128] # enumFromTo :: Word128 -> Word128 -> [Word128] # enumFromThenTo :: Word128 -> Word128 -> Word128 -> [Word128] #
Enum Arch # |
Methods succ :: Arch -> Arch # pred :: Arch -> Arch # toEnum :: Int -> Arch # fromEnum :: Arch -> Int # enumFrom :: Arch -> [Arch] # enumFromThen :: Arch -> Arch -> [Arch] # enumFromTo :: Arch -> Arch -> [Arch] # enumFromThenTo :: Arch -> Arch -> Arch -> [Arch] #
Enum OS # |
Methods succ :: OS -> OS # pred :: OS -> OS # toEnum :: Int -> OS # fromEnum :: OS -> Int # enumFrom :: OS -> [OS] # enumFromThen :: OS -> OS -> [OS] # enumFromTo :: OS -> OS -> [OS] # enumFromThenTo :: OS -> OS -> OS -> [OS] #
Enum Seconds # |
Methods succ :: Seconds -> Seconds # pred :: Seconds -> Seconds # toEnum :: Int -> Seconds # fromEnum :: Seconds -> Int # enumFrom :: Seconds -> [Seconds] # enumFromThen :: Seconds -> Seconds -> [Seconds] # enumFromTo :: Seconds -> Seconds -> [Seconds] # enumFromThenTo :: Seconds -> Seconds -> Seconds -> [Seconds] #
Enum NanoSeconds # |
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] #
Integral a => Enum (Ratio a) |
Methods succ :: Ratio a -> Ratio a # pred :: Ratio a -> Ratio a # toEnum :: Int -> Ratio a # fromEnum :: Ratio a -> Int # 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 (Identity a) |
Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # toEnum :: Int -> 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] #
Enum a => Enum (Min a) |
Methods succ :: Min a -> Min a # pred :: Min a -> Min a # toEnum :: Int -> Min a # fromEnum :: Min a -> Int # enumFrom :: Min a -> [Min a] # enumFromThen :: Min a -> Min a -> [Min a] # enumFromTo :: Min a -> Min a -> [Min a] # enumFromThenTo :: Min a -> Min a -> Min a -> [Min a] #
Enum a => Enum (Max a) |
Methods succ :: Max a -> Max a # pred :: Max a -> Max a # toEnum :: Int -> Max a # fromEnum :: Max a -> Int # enumFrom :: Max a -> [Max a] # enumFromThen :: Max a -> Max a -> [Max a] # enumFromTo :: Max a -> Max a -> [Max a] # enumFromThenTo :: Max a -> Max a -> Max a -> [Max a] #
Enum a => Enum (First a) |
Methods succ :: First a -> First a # pred :: First a -> First a # toEnum :: Int -> First a # fromEnum :: First a -> Int # 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) |
Methods succ :: Last a -> Last a # pred :: Last a -> Last a # toEnum :: Int -> Last a # fromEnum :: Last a -> Int # enumFrom :: Last a -> [Last a] # enumFromThen :: Last a -> Last a -> [Last a] # enumFromTo :: Last a -> Last a -> [Last a] # enumFromThenTo :: Last a -> Last a -> Last a -> [Last a] #
Enum a => Enum (WrappedMonoid a) |

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] #

Enum (Offset ty) |
Methods succ :: Offset ty -> Offset ty # pred :: Offset ty -> Offset ty # toEnum :: Int -> 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 (CountOf ty) |
Methods succ :: CountOf ty -> CountOf ty # pred :: CountOf ty -> CountOf ty # toEnum :: Int -> 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 (Proxy k s) |
Methods succ :: Proxy k s -> Proxy k s # pred :: Proxy k s -> Proxy k s # toEnum :: Int -> Proxy k s # fromEnum :: Proxy k s -> Int # enumFrom :: Proxy k s -> [Proxy k s] # enumFromThen :: Proxy k s -> Proxy k s -> [Proxy k s] # enumFromTo :: Proxy k s -> Proxy k s -> [Proxy k s] # enumFromThenTo :: Proxy k s -> Proxy k s -> Proxy k s -> [Proxy k s] #
Enum a => Enum (Const k a b) |
Methods succ :: Const k a b -> Const k a b # pred :: Const k a b -> Const k a b # toEnum :: Int -> Const k a b # fromEnum :: Const k a b -> Int # enumFrom :: Const k a b -> [Const k a b] # enumFromThen :: Const k a b -> Const k a b -> [Const k a b] # enumFromTo :: Const k a b -> Const k a b -> [Const k a b] # enumFromThenTo :: Const k a b -> Const k a b -> Const k a b -> [Const k a b] #
Enum (f a) => Enum (Alt k f a) |
Methods succ :: Alt k f a -> Alt k f a # pred :: Alt k f a -> Alt k f a # toEnum :: Int -> Alt k f a # fromEnum :: Alt k f a -> Int # enumFrom :: Alt k f a -> [Alt k f a] # enumFromThen :: Alt k f a -> Alt k f a -> [Alt k f a] # enumFromTo :: Alt k f a -> Alt k f a -> [Alt k f a] # enumFromThenTo :: Alt k f a -> Alt k f a -> Alt k f a -> [Alt k f a] #
Coercible k a b => Enum (Coercion k a b) |

Methods

succ :: Coercion k a b -> Coercion k a b #

pred :: Coercion k a b -> Coercion k a b #

toEnum :: Int -> Coercion k a b #

fromEnum :: Coercion k a b -> Int #

enumFrom :: Coercion k a b -> [Coercion k a b] #

enumFromThen :: Coercion k a b -> Coercion k a b -> [Coercion k a b] #

enumFromTo :: Coercion k a b -> Coercion k a b -> [Coercion k a b] #

enumFromThenTo :: Coercion k a b -> Coercion k a b -> Coercion k a b -> [Coercion k a b] #

(~) k a b => Enum ((:~:) k a b) |
Methods succ :: (k :~: a) b -> (k :~: a) b # pred :: (k :~: a) b -> (k :~: a) b # toEnum :: Int -> (k :~: a) b # fromEnum :: (k :~: a) b -> Int # enumFrom :: (k :~: a) b -> [(k :~: a) b] # enumFromThen :: (k :~: a) b -> (k :~: a) b -> [(k :~: a) b] # enumFromTo :: (k :~: a) b -> (k :~: a) b -> [(k :~: a) b] # enumFromThenTo :: (k :~: a) b -> (k :~: a) b -> (k :~: a) b -> [(k :~: a) b] #

class Functor f where #

The `Functor` class is used for types that can be mapped over. Instances of `Functor` should satisfy the following laws:

    fmap id  ==  id
    fmap (f . g)  ==  fmap f . fmap g

The instances of `Functor` for lists, `Maybe` and `IO` satisfy these laws.

Minimal complete definition

fmap

Methods

fmap :: (a -> b) -> f a -> f b #

(<$) :: a -> f b -> f a infixl 4 #

Replace all locations in the input with the same value. The default definition is ``fmap` . `const``, but this may be overridden with a more efficient version.

Instances

Functor [] |
Methods fmap :: (a -> b) -> [a] -> [b] # (<$) :: a -> [b] -> [a] #
Functor Maybe |
Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Functor IO |
Methods fmap :: (a -> b) -> IO a -> IO b # (<$) :: a -> IO b -> IO a #
Functor V1 |
Methods fmap :: (a -> b) -> V1 a -> V1 b # (<$) :: a -> V1 b -> V1 a #
Functor U1 |
Methods fmap :: (a -> b) -> U1 a -> U1 b # (<$) :: a -> U1 b -> U1 a #
Functor Par1 |
Methods fmap :: (a -> b) -> Par1 a -> Par1 b # (<$) :: a -> Par1 b -> Par1 a #
Functor Id |
Methods fmap :: (a -> b) -> Id a -> Id b # (<$) :: a -> Id b -> Id a #
Functor P |
Methods fmap :: (a -> b) -> P a -> P b # (<$) :: a -> P b -> P a #
Functor Identity |
Methods fmap :: (a -> b) -> Identity a -> Identity b # (<$) :: a -> Identity b -> Identity a #
Functor Min |
Methods fmap :: (a -> b) -> Min a -> Min b # (<$) :: a -> Min b -> Min a #
Functor Max |
Methods fmap :: (a -> b) -> Max a -> Max b # (<$) :: a -> Max b -> Max a #
Functor First |
Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a #
Functor Last |
Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a #
Functor Option |
Methods fmap :: (a -> b) -> Option a -> Option b # (<$) :: a -> Option b -> Option a #
Functor NonEmpty |
Methods fmap :: (a -> b) -> NonEmpty a -> NonEmpty b # (<$) :: a -> NonEmpty b -> NonEmpty a #
Functor ZipList |
Methods fmap :: (a -> b) -> ZipList a -> ZipList b # (<$) :: a -> ZipList b -> ZipList a #
Functor Handler |
Methods fmap :: (a -> b) -> Handler a -> Handler b # (<$) :: a -> Handler b -> Handler a #
Functor STM |
Methods fmap :: (a -> b) -> STM a -> STM b # (<$) :: a -> STM b -> STM a #
Functor Dual |
Methods fmap :: (a -> b) -> Dual a -> Dual b # (<$) :: a -> Dual b -> Dual a #
Functor Sum |
Methods fmap :: (a -> b) -> Sum a -> Sum b # (<$) :: a -> Sum b -> Sum a #
Functor Product |
Methods fmap :: (a -> b) -> Product a -> Product b # (<$) :: a -> Product b -> Product a #
Functor First |
Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a #
Functor Last |
Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a #
Functor ReadP |
Methods fmap :: (a -> b) -> ReadP a -> ReadP b # (<$) :: a -> ReadP b -> ReadP a #
Functor Array |
Methods fmap :: (a -> b) -> Array a -> Array b # (<$) :: a -> Array b -> Array a #
Functor Partial # |
Methods fmap :: (a -> b) -> Partial a -> Partial b # (<$) :: a -> Partial b -> Partial a #
Functor DList # |
Methods fmap :: (a -> b) -> DList a -> DList b # (<$) :: a -> DList b -> DList a #
Functor Gen # |
Methods fmap :: (a -> b) -> Gen a -> Gen b # (<$) :: a -> Gen b -> Gen a #
Functor Check # |
Methods fmap :: (a -> b) -> Check a -> Check b # (<$) :: a -> Check b -> Check a #
Functor ((->) r) |
Methods fmap :: (a -> b) -> (r -> a) -> r -> b # (<$) :: a -> (r -> b) -> r -> a #
Functor (Either a) |
Methods fmap :: (a -> b) -> Either a a -> Either a b # (<$) :: a -> Either a b -> Either a a #
Functor f => Functor (Rec1 f) |
Methods fmap :: (a -> b) -> Rec1 f a -> Rec1 f b # (<$) :: a -> Rec1 f b -> Rec1 f a #
Functor (URec Char) |
Methods fmap :: (a -> b) -> URec Char a -> URec Char b # (<$) :: a -> URec Char b -> URec Char a #
Functor (URec Double) |
Methods fmap :: (a -> b) -> URec Double a -> URec Double b # (<$) :: a -> URec Double b -> URec Double a #
Functor (URec Float) |
Methods fmap :: (a -> b) -> URec Float a -> URec Float b # (<$) :: a -> URec Float b -> URec Float a #
Functor (URec Int) |
Methods fmap :: (a -> b) -> URec Int a -> URec Int b # (<$) :: a -> URec Int b -> URec Int a #
Functor (URec Word) |
Methods fmap :: (a -> b) -> URec Word a -> URec Word b # (<$) :: a -> URec Word b -> URec Word a #
Functor (URec (Ptr ())) |
Methods fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b # (<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a #
Functor ((,) a) |
Methods fmap :: (a -> b) -> (a, a) -> (a, b) # (<$) :: a -> (a, b) -> (a, a) #
Functor (StateL s) |
Methods fmap :: (a -> b) -> StateL s a -> StateL s b # (<$) :: a -> StateL s b -> StateL s a #
Functor (StateR s) |
Methods fmap :: (a -> b) -> StateR s a -> StateR s b # (<$) :: a -> StateR s b -> StateR s a #
Functor (Array i) |
Methods fmap :: (a -> b) -> Array i a -> Array i b # (<$) :: a -> Array i b -> Array i a #
Functor (Arg a) |
Methods fmap :: (a -> b) -> Arg a a -> Arg a b # (<$) :: a -> Arg a b -> Arg a a #
Monad m => Functor (WrappedMonad m) |
Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a #
Arrow a => Functor (ArrowMonad a) |
Methods fmap :: (a -> b) -> ArrowMonad a a -> ArrowMonad a b # (<$) :: a -> ArrowMonad a b -> ArrowMonad a a #
Functor (Proxy *) |
Methods fmap :: (a -> b) -> Proxy * a -> Proxy * b # (<$) :: a -> Proxy * b -> Proxy * a #
Functor (ST s) |
Methods fmap :: (a -> b) -> ST s a -> ST s b # (<$) :: a -> ST s b -> ST s a #
Functor (These a) |
Methods fmap :: (a -> b) -> These a a -> These a b # (<$) :: a -> These a b -> These a a #
Functor (MonadRandomState gen) # |
Methods fmap :: (a -> b) -> MonadRandomState gen a -> MonadRandomState gen b # (<$) :: a -> MonadRandomState gen b -> MonadRandomState gen a #
Functor m => Functor (ResourceT m) # |
Methods fmap :: (a -> b) -> ResourceT m a -> ResourceT m b # (<$) :: a -> ResourceT m b -> ResourceT m a #
Functor (Parser input) # |
Methods fmap :: (a -> b) -> Parser input a -> Parser input b # (<$) :: a -> Parser input b -> Parser input a #
Functor (Result input) # |
Methods fmap :: (a -> b) -> Result input a -> Result input b # (<$) :: a -> Result input b -> Result input a #
Functor (K1 i c) |
Methods fmap :: (a -> b) -> K1 i c a -> K1 i c b # (<$) :: a -> K1 i c b -> K1 i c a #
(Functor g, Functor f) => Functor ((:+:) f g) |
Methods fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b # (<$) :: a -> (f :+: g) b -> (f :+: g) a #
(Functor g, Functor f) => Functor ((:*:) f g) |
Methods fmap :: (a -> b) -> (f :*: g) a -> (f :*: g) b # (<$) :: a -> (f :*: g) b -> (f :*: g) a #
(Functor g, Functor f) => Functor ((:.:) f g) |
Methods fmap :: (a -> b) -> (f :.: g) a -> (f :.: g) b # (<$) :: a -> (f :.: g) b -> (f :.: g) a #
Arrow a => Functor (WrappedArrow a b) |
Methods fmap :: (a -> b) -> WrappedArrow a b a -> WrappedArrow a b b # (<$) :: a -> WrappedArrow a b b -> WrappedArrow a b a #
Functor (Const * m) |
Methods fmap :: (a -> b) -> Const * m a -> Const * m b # (<$) :: a -> Const * m b -> Const * m a #
Functor f => Functor (Alt * f) |
Methods fmap :: (a -> b) -> Alt * f a -> Alt * f b # (<$) :: a -> Alt * f b -> Alt * f a #
Monad m => Functor (State s m) |
Methods fmap :: (a -> b) -> State s m a -> State s m b # (<$) :: a -> State s m b -> State s m a #
Monad m => Functor (Reader r m) |
Methods fmap :: (a -> b) -> Reader r m a -> Reader r m b # (<$) :: a -> Reader r m b -> Reader r m a #
Functor m => Functor (ReaderT r m) # |
Methods fmap :: (a -> b) -> ReaderT r m a -> ReaderT r m b # (<$) :: a -> ReaderT r m b -> ReaderT r m a #
Functor m => Functor (ExceptT e m) # |
Methods fmap :: (a -> b) -> ExceptT e m a -> ExceptT e m b # (<$) :: a -> ExceptT e m b -> ExceptT e m a #
Functor m => Functor (StateT s m) # |
Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b # (<$) :: a -> StateT s m b -> StateT s m a #
Monad m => Functor (ZipSink i m) # |
Methods fmap :: (a -> b) -> ZipSink i m a -> ZipSink i m b # (<$) :: a -> ZipSink i m b -> ZipSink i m a #
Functor f => Functor (M1 i c f) |
Methods fmap :: (a -> b) -> M1 i c f a -> M1 i c f b # (<$) :: a -> M1 i c f b -> M1 i c f a #
Functor (Conduit i o m) # |
Methods fmap :: (a -> b) -> Conduit i o m a -> Conduit i o m b # (<$) :: a -> Conduit i o m b -> Conduit i o m a #
Monad state => Functor (Builder collection mutCollection step state err) |
Methods fmap :: (a -> b) -> Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b # (<$) :: a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err a #

class Integral a where #

Integral Literal support

e.g. 123 :: Integer 123 :: Word8

Minimal complete definition

fromInteger

Methods

fromInteger :: Integer -> a #

Instances

Integral Double |
Methods fromInteger :: Integer -> Double #
Integral Float |
Methods fromInteger :: Integer -> Float #
Integral Int |
Methods fromInteger :: Integer -> Int #
Integral Int8 |
Methods fromInteger :: Integer -> Int8 #
Integral Int16 |
Methods fromInteger :: Integer -> Int16 #
Integral Int32 |
Methods fromInteger :: Integer -> Int32 #
Integral Int64 |
Methods fromInteger :: Integer -> Int64 #
Integral Integer |
Methods fromInteger :: Integer -> Integer #
Integral Word |
Methods fromInteger :: Integer -> Word #
Integral Word8 |
Methods fromInteger :: Integer -> Word8 #
Integral Word16 |
Methods fromInteger :: Integer -> Word16 #
Integral Word32 |
Methods fromInteger :: Integer -> Word32 #
Integral Word64 |
Methods fromInteger :: Integer -> Word64 #
Integral Natural |
Methods fromInteger :: Integer -> Natural #
Integral COff |
Methods fromInteger :: Integer -> COff #
Integral IntPtr |
Methods fromInteger :: Integer -> IntPtr #
Integral CShort |
Methods fromInteger :: Integer -> CShort #
Integral CUShort |
Methods fromInteger :: Integer -> CUShort #
Integral CInt |
Methods fromInteger :: Integer -> CInt #
Integral CUInt |
Methods fromInteger :: Integer -> CUInt #
Integral CLong |
Methods fromInteger :: Integer -> CLong #
Integral CULong |
Methods fromInteger :: Integer -> CULong #
Integral CFloat |
Methods fromInteger :: Integer -> CFloat #
Integral CDouble |
Methods fromInteger :: Integer -> CDouble #
Integral CSize |
Methods fromInteger :: Integer -> CSize #
Integral CIntPtr |
Methods fromInteger :: Integer -> CIntPtr #
Integral CUIntPtr |
Methods fromInteger :: Integer -> CUIntPtr #
Integral Word256 |
Methods fromInteger :: Integer -> Word256 #
Integral Word128 |
Methods fromInteger :: Integer -> Word128 #
Integral (Offset ty) |
Methods fromInteger :: Integer -> Offset ty #
Integral (CountOf ty) |
Methods fromInteger :: Integer -> CountOf ty #

class Fractional a where #

Fractional Literal support

e.g. 1.2 :: Double 0.03 :: Float

Minimal complete definition

fromRational

Methods

fromRational :: Rational -> a #

Instances

Fractional Double |
Methods fromRational :: Rational -> Double #
Fractional Float |
Methods fromRational :: Rational -> Float #
Fractional Rational |
Methods fromRational :: Rational -> Rational #
Fractional CFloat |
Methods fromRational :: Rational -> CFloat #
Fractional CDouble |
Methods fromRational :: Rational -> CDouble #

class HasNegation a where #

Negation support

e.g. -(f x)

Minimal complete definition

negate

Methods

negate :: a -> a #

Instances

HasNegation Double |
Methods negate :: Double -> Double #
HasNegation Float |
Methods negate :: Float -> Float #
HasNegation Int |
Methods negate :: Int -> Int #
HasNegation Int8 |
Methods negate :: Int8 -> Int8 #
HasNegation Int16 |
Methods negate :: Int16 -> Int16 #
HasNegation Int32 |
Methods negate :: Int32 -> Int32 #
HasNegation Int64 |
Methods negate :: Int64 -> Int64 #
HasNegation Integer |
Methods negate :: Integer -> Integer #
HasNegation Word |
Methods negate :: Word -> Word #
HasNegation Word8 |
Methods negate :: Word8 -> Word8 #
HasNegation Word16 |
Methods negate :: Word16 -> Word16 #
HasNegation Word32 |
Methods negate :: Word32 -> Word32 #
HasNegation Word64 |
Methods negate :: Word64 -> Word64 #
HasNegation CInt |
Methods negate :: CInt -> CInt #
HasNegation CFloat |
Methods negate :: CFloat -> CFloat #
HasNegation CDouble |
Methods negate :: CDouble -> CDouble #
HasNegation Word256 |
Methods negate :: Word256 -> Word256 #
HasNegation Word128 |
Methods negate :: Word128 -> Word128 #

class Bifunctor p where #

Formally, the class `Bifunctor` represents a bifunctor from `Hask` -> `Hask`.

Intuitively it is a bifunctor where both the first and second arguments are covariant.

You can define a `Bifunctor` by either defining `bimap` or by defining both `first` and `second`.

If you supply `bimap`, you should ensure that:

    bimap id id ≡ id

If you supply `first` and `second`, ensure:

    first id ≡ id
    second id ≡ id

If you supply both, you should also ensure:

    bimap f g ≡ first f . second g

These ensure by parametricity:

    bimap  (f . g) (h . i) ≡ bimap f h . bimap g i
    first  (f . g) ≡ first  f . first  g
    second (f . g) ≡ second f . second g

Since: 4.8.0.0

Minimal complete definition

bimap | first, second

Methods

bimap :: (a -> b) -> (c -> d) -> p a c -> p b d #

Map over both arguments at the same time.

    bimap f g ≡ first f . second g

first :: (a -> b) -> p a c -> p b c #

Map covariantly over the first argument.

    first f ≡ bimap f id

second :: (b -> c) -> p a b -> p a c #

Map covariantly over the second argument.

    second ≡ bimap id

Instances

Bifunctor Either |
Methods bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d # first :: (a -> b) -> Either a c -> Either b c # second :: (b -> c) -> Either a b -> Either a c #
Bifunctor (,) |
Methods bimap :: (a -> b) -> (c -> d) -> (a, c) -> (b, d) # first :: (a -> b) -> (a, c) -> (b, c) # second :: (b -> c) -> (a, b) -> (a, c) #
Bifunctor Arg |
Methods bimap :: (a -> b) -> (c -> d) -> Arg a c -> Arg b d # first :: (a -> b) -> Arg a c -> Arg b c # second :: (b -> c) -> Arg a b -> Arg a c #
Bifunctor These |
Methods bimap :: (a -> b) -> (c -> d) -> These a c -> These b d # first :: (a -> b) -> These a c -> These b c # second :: (b -> c) -> These a b -> These a c #
Bifunctor Tuple2 # |
Methods bimap :: (a -> b) -> (c -> d) -> Tuple2 a c -> Tuple2 b d # first :: (a -> b) -> Tuple2 a c -> Tuple2 b c # second :: (b -> c) -> Tuple2 a b -> Tuple2 a c #
Bifunctor (K1 i) |
Methods bimap :: (a -> b) -> (c -> d) -> K1 i a c -> K1 i b d # first :: (a -> b) -> K1 i a c -> K1 i b c # second :: (b -> c) -> K1 i a b -> K1 i a c #
Bifunctor ((,,) x1) |
Methods bimap :: (a -> b) -> (c -> d) -> (x1, a, c) -> (x1, b, d) # first :: (a -> b) -> (x1, a, c) -> (x1, b, c) # second :: (b -> c) -> (x1, a, b) -> (x1, a, c) #
Bifunctor (Const *) |
Methods bimap :: (a -> b) -> (c -> d) -> Const * a c -> Const * b d # first :: (a -> b) -> Const * a c -> Const * b c # second :: (b -> c) -> Const * a b -> Const * a c #
Bifunctor ((,,,) x1 x2) |
Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, a, c) -> (x1, x2, b, d) # first :: (a -> b) -> (x1, x2, a, c) -> (x1, x2, b, c) # second :: (b -> c) -> (x1, x2, a, b) -> (x1, x2, a, c) #
Bifunctor ((,,,,) x1 x2 x3) |
Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, d) # first :: (a -> b) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, c) # second :: (b -> c) -> (x1, x2, x3, a, b) -> (x1, x2, x3, a, c) #
Bifunctor ((,,,,,) x1 x2 x3 x4) |
Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, d) # first :: (a -> b) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, c) # second :: (b -> c) -> (x1, x2, x3, x4, a, b) -> (x1, x2, x3, x4, a, c) #
Bifunctor ((,,,,,,) x1 x2 x3 x4 x5) |
Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, d) # first :: (a -> b) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, c) # second :: (b -> c) -> (x1, x2, x3, x4, x5, a, b) -> (x1, x2, x3, x4, x5, a, c) #

class Functor f => Applicative f where #

A functor with application, providing operations to

- embed pure expressions (`pure`), and
- sequence computations and combine their results (`<*>`).

A minimal complete definition must include implementations of these functions satisfying the following laws:

identity

      pure id <*> v = v

composition

      pure (.) <*> u <*> v <*> w = u <*> (v <*> w)

homomorphism

      pure f <*> pure x = pure (f x)

interchange

      u <*> pure y = pure ($ y) <*> u

The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:

-     u *> v = pure (const id) <*> u <*> v

-     u <* v = pure const <*> u <*> v

As a consequence of these laws, the `Functor` instance for `f` will satisfy

-     fmap f x = pure f <*> x

If `f` is also a `Monad`, it should satisfy

-     pure = return

-     (<*>) = ap

(which implies that `pure` and `<*>` satisfy the applicative functor laws).

Minimal complete definition

pure, (<*>)

Methods

pure :: a -> f a #

Lift a value.

(<*>) :: f (a -> b) -> f a -> f b infixl 4 #

Sequential application.

(*>) :: f a -> f b -> f b infixl 4 #

Sequence actions, discarding the value of the first argument.

(<*) :: f a -> f b -> f a infixl 4 #

Sequence actions, discarding the value of the second argument.

Instances

Applicative [] |
Methods pure :: a -> [a] # (<*>) :: [a -> b] -> [a] -> [b] # (*>) :: [a] -> [b] -> [b] # (<*) :: [a] -> [b] -> [a] #
Applicative Maybe |
Methods pure :: a -> Maybe a # (<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b # (*>) :: Maybe a -> Maybe b -> Maybe b # (<*) :: Maybe a -> Maybe b -> Maybe a #
Applicative IO |
Methods pure :: a -> IO a # (<*>) :: IO (a -> b) -> IO a -> IO b # (*>) :: IO a -> IO b -> IO b # (<*) :: IO a -> IO b -> IO a #
Applicative U1 |
Methods pure :: a -> U1 a # (<*>) :: U1 (a -> b) -> U1 a -> U1 b # (*>) :: U1 a -> U1 b -> U1 b # (<*) :: U1 a -> U1 b -> U1 a #
Applicative Par1 |
Methods pure :: a -> Par1 a # (<*>) :: Par1 (a -> b) -> Par1 a -> Par1 b # (*>) :: Par1 a -> Par1 b -> Par1 b # (<*) :: Par1 a -> Par1 b -> Par1 a #
Applicative Id |
Methods pure :: a -> Id a # (<*>) :: Id (a -> b) -> Id a -> Id b # (*>) :: Id a -> Id b -> Id b # (<*) :: Id a -> Id b -> Id a #
Applicative P |
Methods pure :: a -> P a # (<*>) :: P (a -> b) -> P a -> P b # (*>) :: P a -> P b -> P b # (<*) :: P a -> P b -> P a #
Applicative Identity |
Methods pure :: a -> Identity a # (<*>) :: Identity (a -> b) -> Identity a -> Identity b # (*>) :: Identity a -> Identity b -> Identity b # (<*) :: Identity a -> Identity b -> Identity a #
Applicative Min |
Methods pure :: a -> Min a # (<*>) :: Min (a -> b) -> Min a -> Min b # (*>) :: Min a -> Min b -> Min b # (<*) :: Min a -> Min b -> Min a #
Applicative Max |
Methods pure :: a -> Max a # (<*>) :: Max (a -> b) -> Max a -> Max b # (*>) :: Max a -> Max b -> Max b # (<*) :: Max a -> Max b -> Max a #
Applicative First |
Methods pure :: a -> First a # (<*>) :: First (a -> b) -> First a -> First b # (*>) :: First a -> First b -> First b # (<*) :: First a -> First b -> First a #
Applicative Last |
Methods pure :: a -> Last a # (<*>) :: Last (a -> b) -> Last a -> Last b # (*>) :: Last a -> Last b -> Last b # (<*) :: Last a -> Last b -> Last a #
Applicative Option |
Methods pure :: a -> Option a # (<*>) :: Option (a -> b) -> Option a -> Option b # (*>) :: Option a -> Option b -> Option b # (<*) :: Option a -> Option b -> Option a #
Applicative NonEmpty |
Methods pure :: a -> NonEmpty a # (<*>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b # (*>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # (<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a #
Applicative ZipList |
Methods pure :: a -> ZipList a # (<*>) :: ZipList (a -> b) -> ZipList a -> ZipList b # (*>) :: ZipList a -> ZipList b -> ZipList b # (<*) :: ZipList a -> ZipList b -> ZipList a #
Applicative STM |
Methods pure :: a -> STM a # (<*>) :: STM (a -> b) -> STM a -> STM b # (*>) :: STM a -> STM b -> STM b # (<*) :: STM a -> STM b -> STM a #
Applicative Dual |
Methods pure :: a -> Dual a # (<*>) :: Dual (a -> b) -> Dual a -> Dual b # (*>) :: Dual a -> Dual b -> Dual b # (<*) :: Dual a -> Dual b -> Dual a #
Applicative Sum |
Methods pure :: a -> Sum a # (<*>) :: Sum (a -> b) -> Sum a -> Sum b # (*>) :: Sum a -> Sum b -> Sum b # (<*) :: Sum a -> Sum b -> Sum a #
Applicative Product |
Methods pure :: a -> Product a # (<*>) :: Product (a -> b) -> Product a -> Product b # (*>) :: Product a -> Product b -> Product b # (<*) :: Product a -> Product b -> Product a #
Applicative First |
Methods pure :: a -> First a # (<*>) :: First (a -> b) -> First a -> First b # (*>) :: First a -> First b -> First b # (<*) :: First a -> First b -> First a #
Applicative Last |
Methods pure :: a -> Last a # (<*>) :: Last (a -> b) -> Last a -> Last b # (*>) :: Last a -> Last b -> Last b # (<*) :: Last a -> Last b -> Last a #
Applicative ReadP |
Methods pure :: a -> ReadP a # (<*>) :: ReadP (a -> b) -> ReadP a -> ReadP b # (*>) :: ReadP a -> ReadP b -> ReadP b # (<*) :: ReadP a -> ReadP b -> ReadP a #
Applicative Partial # |
Methods pure :: a -> Partial a # (<*>) :: Partial (a -> b) -> Partial a -> Partial b # (*>) :: Partial a -> Partial b -> Partial b # (<*) :: Partial a -> Partial b -> Partial a #
Applicative DList # |
Methods pure :: a -> DList a # (<*>) :: DList (a -> b) -> DList a -> DList b # (*>) :: DList a -> DList b -> DList b # (<*) :: DList a -> DList b -> DList a #
Applicative Gen # |
Methods pure :: a -> Gen a # (<*>) :: Gen (a -> b) -> Gen a -> Gen b # (*>) :: Gen a -> Gen b -> Gen b # (<*) :: Gen a -> Gen b -> Gen a #
Applicative Check # |
Methods pure :: a -> Check a # (<*>) :: Check (a -> b) -> Check a -> Check b # (*>) :: Check a -> Check b -> Check b # (<*) :: Check a -> Check b -> Check a #
Applicative ((->) a) |
Methods pure :: a -> a -> a # (<*>) :: (a -> a -> b) -> (a -> a) -> a -> b # (*>) :: (a -> a) -> (a -> b) -> a -> b # (<*) :: (a -> a) -> (a -> b) -> a -> a #
Applicative (Either e) |
Methods pure :: a -> Either e a # (<*>) :: Either e (a -> b) -> Either e a -> Either e b # (*>) :: Either e a -> Either e b -> Either e b # (<*) :: Either e a -> Either e b -> Either e a #
Applicative f => Applicative (Rec1 f) |
Methods pure :: a -> Rec1 f a # (<*>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b # (*>) :: Rec1 f a -> Rec1 f b -> Rec1 f b # (<*) :: Rec1 f a -> Rec1 f b -> Rec1 f a #
Monoid a => Applicative ((,) a) |
Methods pure :: a -> (a, a) # (<*>) :: (a, a -> b) -> (a, a) -> (a, b) # (*>) :: (a, a) -> (a, b) -> (a, b) # (<*) :: (a, a) -> (a, b) -> (a, a) #
Applicative (StateL s) |
Methods pure :: a -> StateL s a # (<*>) :: StateL s (a -> b) -> StateL s a -> StateL s b # (*>) :: StateL s a -> StateL s b -> StateL s b # (<*) :: StateL s a -> StateL s b -> StateL s a #
Applicative (StateR s) |
Methods pure :: a -> StateR s a # (<*>) :: StateR s (a -> b) -> StateR s a -> StateR s b # (*>) :: StateR s a -> StateR s b -> StateR s b # (<*) :: StateR s a -> StateR s b -> StateR s a #
Monad m => Applicative (WrappedMonad m) |
Methods pure :: a -> WrappedMonad m a # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a #
Arrow a => Applicative (ArrowMonad a) |
Methods pure :: a -> ArrowMonad a a # (<*>) :: ArrowMonad a (a -> b) -> ArrowMonad a a -> ArrowMonad a b # (*>) :: ArrowMonad a a -> ArrowMonad a b -> ArrowMonad a b # (<*) :: ArrowMonad a a -> ArrowMonad a b -> ArrowMonad a a #
Applicative (Proxy *) |
Methods pure :: a -> Proxy * a # (<*>) :: Proxy * (a -> b) -> Proxy * a -> Proxy * b # (*>) :: Proxy * a -> Proxy * b -> Proxy * b # (<*) :: Proxy * a -> Proxy * b -> Proxy * a #
Applicative (ST s) |
Methods pure :: a -> ST s a # (<*>) :: ST s (a -> b) -> ST s a -> ST s b # (*>) :: ST s a -> ST s b -> ST s b # (<*) :: ST s a -> ST s b -> ST s a #
Applicative (MonadRandomState gen) # |
Methods pure :: a -> MonadRandomState gen a # (<*>) :: MonadRandomState gen (a -> b) -> MonadRandomState gen a -> MonadRandomState gen b # (*>) :: MonadRandomState gen a -> MonadRandomState gen b -> MonadRandomState gen b # (<*) :: MonadRandomState gen a -> MonadRandomState gen b -> MonadRandomState gen a #
Applicative m => Applicative (ResourceT m) # |
Methods pure :: a -> ResourceT m a # (<*>) :: ResourceT m (a -> b) -> ResourceT m a -> ResourceT m b # (*>) :: ResourceT m a -> ResourceT m b -> ResourceT m b # (<*) :: ResourceT m a -> ResourceT m b -> ResourceT m a #
ParserSource input => Applicative (Parser input) # |
Methods pure :: a -> Parser input a # (<*>) :: Parser input (a -> b) -> Parser input a -> Parser input b # (*>) :: Parser input a -> Parser input b -> Parser input b # (<*) :: Parser input a -> Parser input b -> Parser input a #
(Applicative f, Applicative g) => Applicative ((:*:) f g) |
Methods pure :: a -> (f :*: g) a # (<*>) :: (f :*: g) (a -> b) -> (f :*: g) a -> (f :*: g) b # (*>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b # (<*) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) a #
(Applicative f, Applicative g) => Applicative ((:.:) f g) |
Methods pure :: a -> (f :.: g) a # (<*>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b # (*>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b # (<*) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a #
Arrow a => Applicative (WrappedArrow a b) |
Methods pure :: a -> WrappedArrow a b a # (<*>) :: WrappedArrow a b (a -> b) -> WrappedArrow a b a -> WrappedArrow a b b # (*>) :: WrappedArrow a b a -> WrappedArrow a b b -> WrappedArrow a b b # (<*) :: WrappedArrow a b a -> WrappedArrow a b b -> WrappedArrow a b a #
Monoid m => Applicative (Const * m) |
Methods pure :: a -> Const * m a # (<*>) :: Const * m (a -> b) -> Const * m a -> Const * m b # (*>) :: Const * m a -> Const * m b -> Const * m b # (<*) :: Const * m a -> Const * m b -> Const * m a #
Applicative f => Applicative (Alt * f) |
Methods pure :: a -> Alt * f a # (<*>) :: Alt * f (a -> b) -> Alt * f a -> Alt * f b # (*>) :: Alt * f a -> Alt * f b -> Alt * f b # (<*) :: Alt * f a -> Alt * f b -> Alt * f a #
Monad m => Applicative (State s m) |
Methods pure :: a -> State s m a # (<*>) :: State s m (a -> b) -> State s m a -> State s m b # (*>) :: State s m a -> State s m b -> State s m b # (<*) :: State s m a -> State s m b -> State s m a #
Monad m => Applicative (Reader r m) |
Methods pure :: a -> Reader r m a # (<*>) :: Reader r m (a -> b) -> Reader r m a -> Reader r m b # (*>) :: Reader r m a -> Reader r m b -> Reader r m b # (<*) :: Reader r m a -> Reader r m b -> Reader r m a #
Applicative m => Applicative (ReaderT r m) # |
Methods pure :: a -> ReaderT r m a # (<*>) :: ReaderT r m (a -> b) -> ReaderT r m a -> ReaderT r m b # (*>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b # (<*) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m a #
(Functor m, Monad m) => Applicative (ExceptT e m) # |
Methods pure :: a -> ExceptT e m a # (<*>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b # (*>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # (<*) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a #
(Applicative m, Monad m) => Applicative (StateT s m) # |
Methods pure :: a -> StateT s m a # (<*>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b # (*>) :: StateT s m a -> StateT s m b -> StateT s m b # (<*) :: StateT s m a -> StateT s m b -> StateT s m a #
Monad m => Applicative (ZipSink i m) # |
Methods pure :: a -> ZipSink i m a # (<*>) :: ZipSink i m (a -> b) -> ZipSink i m a -> ZipSink i m b # (*>) :: ZipSink i m a -> ZipSink i m b -> ZipSink i m b # (<*) :: ZipSink i m a -> ZipSink i m b -> ZipSink i m a #
Applicative f => Applicative (M1 i c f) |
Methods pure :: a -> M1 i c f a # (<*>) :: M1 i c f (a -> b) -> M1 i c f a -> M1 i c f b # (*>) :: M1 i c f a -> M1 i c f b -> M1 i c f b # (<*) :: M1 i c f a -> M1 i c f b -> M1 i c f a #
Applicative (Conduit i o m) # |
Methods pure :: a -> Conduit i o m a # (<*>) :: Conduit i o m (a -> b) -> Conduit i o m a -> Conduit i o m b # (*>) :: 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 #
Monad state => Applicative (Builder collection mutCollection step state err) |

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 #

(*>) :: 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 where #

The `Monad` class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's `do` expressions provide a convenient syntax for writing monadic expressions.

Instances of `Monad` should satisfy the following laws:

-     return a >>= k  =  k a

-     m >>= return  =  m

-     m >>= (\x -> k x >>= h)  =  (m >>= k) >>= h

Furthermore, the `Monad` and `Applicative` operations should relate as follows:

-     pure = return

-     (<*>) = ap

The above laws imply:

-     fmap f xs  =  xs >>= return . f

-     (>>) = (*>)

and that `pure` and (`<*>`) satisfy the applicative functor laws.

The instances of `Monad` for lists, `Maybe` and `IO` defined in the Prelude satisfy these laws.

Minimal complete definition

(>>=)

Methods

(>>=) :: m a -> (a -> m b) -> m b infixl 1 #

Sequentially compose two actions, passing any value produced by the first as an argument to the second.

(>>) :: m a -> m b -> m b infixl 1 #

Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.

return :: a -> m a #

Inject a value into the monadic type.

fail :: String -> m a #

Fail with a message. This operation is not part of the mathematical definition of a monad, but is invoked on pattern-match failure in a `do` expression.

As part of the MonadFail proposal (MFP), this function is moved to its own class `MonadFail` (see Control.Monad.Fail for more details). The definition here will be removed in a future release.

Instances

Monad [] |
Methods (>>=) :: [a] -> (a -> [b]) -> [b] # (>>) :: [a] -> [b] -> [b] # return :: a -> [a] # fail :: String -> [a] #
Monad Maybe |
Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b # (>>) :: Maybe a -> Maybe b -> Maybe b # return :: a -> Maybe a # fail :: String -> Maybe a #
Monad IO |
Methods (>>=) :: IO a -> (a -> IO b) -> IO b # (>>) :: IO a -> IO b -> IO b # return :: a -> IO a # fail :: String -> IO a #
Monad U1 |
Methods (>>=) :: U1 a -> (a -> U1 b) -> U1 b # (>>) :: U1 a -> U1 b -> U1 b # return :: a -> U1 a # fail :: String -> U1 a #
Monad Par1 |
Methods (>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b # (>>) :: Par1 a -> Par1 b -> Par1 b # return :: a -> Par1 a # fail :: String -> Par1 a #
Monad P |
Methods (>>=) :: P a -> (a -> P b) -> P b # (>>) :: P a -> P b -> P b # return :: a -> P a # fail :: String -> P a #
Monad Identity |
Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b # (>>) :: Identity a -> Identity b -> Identity b # return :: a -> Identity a # fail :: String -> Identity a #
Monad Min |
Methods (>>=) :: Min a -> (a -> Min b) -> Min b # (>>) :: Min a -> Min b -> Min b # return :: a -> Min a # fail :: String -> Min a #
Monad Max |
Methods (>>=) :: Max a -> (a -> Max b) -> Max b # (>>) :: Max a -> Max b -> Max b # return :: a -> Max a # fail :: String -> Max a #
Monad First |
Methods (>>=) :: First a -> (a -> First b) -> First b # (>>) :: First a -> First b -> First b # return :: a -> First a # fail :: String -> First a #
Monad Last |
Methods (>>=) :: Last a -> (a -> Last b) -> Last b # (>>) :: Last a -> Last b -> Last b # return :: a -> Last a # fail :: String -> Last a #
Monad Option |
Methods (>>=) :: Option a -> (a -> Option b) -> Option b # (>>) :: Option a -> Option b -> Option b # return :: a -> Option a # fail :: String -> Option a #
Monad NonEmpty |
Methods (>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b # (>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # return :: a -> NonEmpty a # fail :: String -> NonEmpty a #
Monad STM |
Methods (>>=) :: STM a -> (a -> STM b) -> STM b # (>>) :: STM a -> STM b -> STM b # return :: a -> STM a # fail :: String -> STM a #
Monad Dual |
Methods (>>=) :: Dual a -> (a -> Dual b) -> Dual b # (>>) :: Dual a -> Dual b -> Dual b # return :: a -> Dual a # fail :: String -> Dual a #
Monad Sum |
Methods (>>=) :: Sum a -> (a -> Sum b) -> Sum b # (>>) :: Sum a -> Sum b -> Sum b # return :: a -> Sum a # fail :: String -> Sum a #
Monad Product |
Methods (>>=) :: Product a -> (a -> Product b) -> Product b # (>>) :: Product a -> Product b -> Product b # return :: a -> Product a # fail :: String -> Product a #
Monad First |
Methods (>>=) :: First a -> (a -> First b) -> First b # (>>) :: First a -> First b -> First b # return :: a -> First a # fail :: String -> First a #
Monad Last |
Methods (>>=) :: Last a -> (a -> Last b) -> Last b # (>>) :: Last a -> Last b -> Last b # return :: a -> Last a # fail :: String -> Last a #
Monad ReadP |
Methods (>>=) :: ReadP a -> (a -> ReadP b) -> ReadP b # (>>) :: ReadP a -> ReadP b -> ReadP b # return :: a -> ReadP a # fail :: String -> ReadP a #
Monad Partial # |
Methods (>>=) :: Partial a -> (a -> Partial b) -> Partial b # (>>) :: Partial a -> Partial b -> Partial b # return :: a -> Partial a # fail :: String -> Partial a #
Monad DList # |
Methods (>>=) :: DList a -> (a -> DList b) -> DList b # (>>) :: DList a -> DList b -> DList b # return :: a -> DList a # fail :: String -> DList a #
Monad Gen # |
Methods (>>=) :: Gen a -> (a -> Gen b) -> Gen b # (>>) :: Gen a -> Gen b -> Gen b # return :: a -> Gen a # fail :: String -> Gen a #
Monad Check # |
Methods (>>=) :: Check a -> (a -> Check b) -> Check b # (>>) :: Check a -> Check b -> Check b # return :: a -> Check a # fail :: String -> Check a #
Monad ((->) r) |
Methods (>>=) :: (r -> a) -> (a -> r -> b) -> r -> b # (>>) :: (r -> a) -> (r -> b) -> r -> b # return :: a -> r -> a # fail :: String -> r -> a #
Monad (Either e) |
Methods (>>=) :: Either e a -> (a -> Either e b) -> Either e b # (>>) :: Either e a -> Either e b -> Either e b # return :: a -> Either e a # fail :: String -> Either e a #
Monad f => Monad (Rec1 f) |
Methods (>>=) :: Rec1 f a -> (a -> Rec1 f b) -> Rec1 f b # (>>) :: Rec1 f a -> Rec1 f b -> Rec1 f b # return :: a -> Rec1 f a # fail :: String -> Rec1 f a #
Monoid a => Monad ((,) a) |
Methods (>>=) :: (a, a) -> (a -> (a, b)) -> (a, b) # (>>) :: (a, a) -> (a, b) -> (a, b) # return :: a -> (a, a) # fail :: String -> (a, a) #
Monad m => Monad (WrappedMonad m) |
Methods (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # return :: a -> WrappedMonad m a # fail :: String -> WrappedMonad m a #
ArrowApply a => Monad (ArrowMonad a) |
Methods (>>=) :: ArrowMonad a a -> (a -> ArrowMonad a b) -> ArrowMonad a b # (>>) :: ArrowMonad a a -> ArrowMonad a b -> ArrowMonad a b # return :: a -> ArrowMonad a a # fail :: String -> ArrowMonad a a #
Monad (Proxy *) |
Methods (>>=) :: Proxy * a -> (a -> Proxy * b) -> Proxy * b # (>>) :: Proxy * a -> Proxy * b -> Proxy * b # return :: a -> Proxy * a # fail :: String -> Proxy * a #
Monad (ST s) |
Methods (>>=) :: ST s a -> (a -> ST s b) -> ST s b # (>>) :: ST s a -> ST s b -> ST s b # return :: a -> ST s a # fail :: String -> ST s a #
Monad (MonadRandomState gen) # |
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 # fail :: String -> MonadRandomState gen a #
Monad m => Monad (ResourceT m) # |
Methods (>>=) :: ResourceT m a -> (a -> ResourceT m b) -> ResourceT m b # (>>) :: ResourceT m a -> ResourceT m b -> ResourceT m b # return :: a -> ResourceT m a # fail :: String -> ResourceT m a #
ParserSource input => Monad (Parser input) # |
Methods (>>=) :: Parser input a -> (a -> Parser input b) -> Parser input b # (>>) :: Parser input a -> Parser input b -> Parser input b # return :: a -> Parser input a # fail :: String -> Parser input a #
(Monad f, Monad g) => Monad ((:*:) f g) |
Methods (>>=) :: (f :*: g) a -> (a -> (f :*: g) b) -> (f :*: g) b # (>>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b # return :: a -> (f :*: g) a # fail :: String -> (f :*: g) a #
Monad f => Monad (Alt * f) |
Methods (>>=) :: Alt * f a -> (a -> Alt * f b) -> Alt * f b # (>>) :: Alt * f a -> Alt * f b -> Alt * f b # return :: a -> Alt * f a # fail :: String -> Alt * f a #
Monad m => Monad (State r m) |
Methods (>>=) :: State r m a -> (a -> State r m b) -> State r m b # (>>) :: State r m a -> State r m b -> State r m b # return :: a -> State r m a # fail :: String -> State r m a #
Monad m => Monad (Reader r m) |
Methods (>>=) :: Reader r m a -> (a -> Reader r m b) -> Reader r m b # (>>) :: Reader r m a -> Reader r m b -> Reader r m b # return :: a -> Reader r m a # fail :: String -> Reader r m a #
Monad m => Monad (ReaderT r m) # |
Methods (>>=) :: ReaderT r m a -> (a -> ReaderT r m b) -> ReaderT r m b # (>>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b # return :: a -> ReaderT r m a # fail :: String -> ReaderT r m a #
Monad m => Monad (ExceptT e m) # |
Methods (>>=) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b # (>>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # return :: a -> ExceptT e m a # fail :: String -> ExceptT e m a #
(Functor m, Monad m) => Monad (StateT s m) # |
Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # (>>) :: StateT s m a -> StateT s m b -> StateT s m b # return :: a -> StateT s m a # fail :: String -> StateT s m a #
Monad f => Monad (M1 i c f) |
Methods (>>=) :: M1 i c f a -> (a -> M1 i c f b) -> M1 i c f b # (>>) :: M1 i c f a -> M1 i c f b -> M1 i c f b # return :: a -> M1 i c f a # fail :: String -> M1 i c f a #
Monad (Conduit i o m) # |
Methods (>>=) :: Conduit i o m a -> (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 b # return :: a -> Conduit i o m a # fail :: String -> Conduit i o m a #
Monad state => Monad (Builder collection mutCollection step state err) |

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 #

fail :: String -> Builder collection mutCollection step state err a #

(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1 #

Same as `>>=`, but with the arguments interchanged.

class IsString a where #

Class for string-like datastructures; used by the overloaded string extension (-XOverloadedStrings in GHC).

Minimal complete definition

fromString

Methods

fromString :: String -> a #

Instances

IsString String |
Methods fromString :: String -> String #
IsString AsciiString |
Methods fromString :: String -> AsciiString #
IsString Builder # |
Methods fromString :: String -> Builder #
IsString IPv4 # |
Methods fromString :: String -> IPv4 #
IsString IPv6 # |
Methods fromString :: String -> IPv6 #
IsString FileName # |
Methods fromString :: String -> FileName #
IsString FilePath # |
Methods fromString :: String -> FilePath #
(~) * a Char => IsString [a] |
Methods fromString :: String -> [a] #
IsString a => IsString (Identity a) |
Methods fromString :: String -> Identity a #
IsString a => IsString (Const * a b) |
Methods fromString :: String -> Const * a b #

class IsList l where #

The `IsList` class and its methods are intended to be used in conjunction with the OverloadedLists extension.

Since: 4.7.0.0

Minimal complete definition

fromList, toList

Associated Types

type Item l :: * #

The `Item` type function returns the type of items of the structure `l`.

Methods

fromList :: [Item l] -> l #

The `fromList` function constructs the structure `l` from the given list of `Item l`

fromListN :: Int -> [Item l] -> l #

The `fromListN` function takes the input list's length as a hint. Its behaviour should be equivalent to `fromList`. The hint can be used to construct the structure `l` more efficiently compared to `fromList`. If the given hint does not equal to the input list's length the behaviour of `fromListN` is not specified.

toList :: l -> [Item l] #

The `toList` function extracts a list of `Item l` from the structure `l`. It should satisfy fromList . toList = id.

Instances

IsList CallStack | Be aware that 'fromList . toList = id' only for unfrozen `CallStack`s, since `toList` removes frozenness information. Since: 4.9.0.0
Associated Types type Item CallStack :: * # Methods fromList :: [Item CallStack] -> CallStack # fromListN :: Int -> [Item CallStack] -> CallStack # toList :: CallStack -> [Item CallStack] #
IsList Version | Since: 4.8.0.0
Associated Types type Item Version :: * # Methods fromList :: [Item Version] -> Version # fromListN :: Int -> [Item Version] -> Version # toList :: Version -> [Item Version] #
IsList String |
Associated Types type Item String :: * # Methods fromList :: [Item String] -> String # fromListN :: Int -> [Item String] -> String # toList :: String -> [Item String] #
IsList AsciiString |
Associated Types type Item AsciiString :: * # Methods fromList :: [Item AsciiString] -> AsciiString # fromListN :: Int -> [Item AsciiString] -> AsciiString # toList :: AsciiString -> [Item AsciiString] #
IsList Bitmap # |
Associated Types type Item Bitmap :: * # Methods fromList :: [Item Bitmap] -> Bitmap # fromListN :: Int -> [Item Bitmap] -> Bitmap # toList :: Bitmap -> [Item Bitmap] #
IsList [a] |
Associated Types type Item [a] :: * # Methods fromList :: [Item [a]] -> [a] # fromListN :: Int -> [Item [a]] -> [a] # toList :: [a] -> [Item [a]] #
IsList (NonEmpty a) |
Associated Types type Item (NonEmpty a) :: * # Methods fromList :: [Item (NonEmpty a)] -> NonEmpty a # fromListN :: Int -> [Item (NonEmpty a)] -> NonEmpty a # toList :: NonEmpty a -> [Item (NonEmpty a)] #
IsList (Array ty) |
Associated Types type Item (Array ty) :: * # Methods fromList :: [Item (Array ty)] -> Array ty # fromListN :: Int -> [Item (Array ty)] -> Array ty # toList :: Array ty -> [Item (Array ty)] #
PrimType ty => IsList (UArray ty) |
Associated Types type Item (UArray ty) :: * # Methods fromList :: [Item (UArray ty)] -> UArray ty # fromListN :: Int -> [Item (UArray ty)] -> UArray ty # toList :: UArray ty -> [Item (UArray ty)] #
PrimType ty => IsList (Block ty) |
Associated Types type Item (Block ty) :: * # Methods fromList :: [Item (Block ty)] -> Block ty # fromListN :: Int -> [Item (Block ty)] -> Block ty # toList :: Block ty -> [Item (Block ty)] #
IsList c => IsList (NonEmpty c) |
Associated Types type Item (NonEmpty c) :: * # Methods fromList :: [Item (NonEmpty c)] -> NonEmpty c # fromListN :: Int -> [Item (NonEmpty c)] -> NonEmpty c # toList :: NonEmpty c -> [Item (NonEmpty c)] #
IsList (DList a) # |
Associated Types type Item (DList a) :: * # Methods fromList :: [Item (DList a)] -> DList a # fromListN :: Int -> [Item (DList a)] -> DList a # toList :: DList a -> [Item (DList a)] #
PrimType ty => IsList (ChunkedUArray ty) # |
Associated Types type Item (ChunkedUArray ty) :: * # Methods fromList :: [Item (ChunkedUArray ty)] -> ChunkedUArray ty # fromListN :: Int -> [Item (ChunkedUArray ty)] -> ChunkedUArray ty # toList :: ChunkedUArray ty -> [Item (ChunkedUArray ty)] #

## Numeric type classes

class (Enum a, Eq a, Ord a, Integral a) => IsIntegral a where #

Number literals, convertible through the generic Integer type.

all number are Enum'erable, meaning that you can move to next element

Minimal complete definition

toInteger

Methods

toInteger :: a -> Integer #

Instances

IsIntegral Int |
Methods toInteger :: Int -> Integer #
IsIntegral Int8 |
Methods toInteger :: Int8 -> Integer #
IsIntegral Int16 |
Methods toInteger :: Int16 -> Integer #
IsIntegral Int32 |
Methods toInteger :: Int32 -> Integer #
IsIntegral Int64 |
Methods toInteger :: Int64 -> Integer #
IsIntegral Integer |
Methods toInteger :: Integer -> Integer #
IsIntegral Word |
Methods toInteger :: Word -> Integer #
IsIntegral Word8 |
Methods toInteger :: Word8 -> Integer #
IsIntegral Word16 |
Methods toInteger :: Word16 -> Integer #
IsIntegral Word32 |
Methods toInteger :: Word32 -> Integer #
IsIntegral Word64 |
Methods toInteger :: Word64 -> Integer #
IsIntegral Natural |
Methods toInteger :: Natural -> Integer #
IsIntegral CSize |
Methods toInteger :: CSize -> Integer #
IsIntegral Word256 |
Methods toInteger :: Word256 -> Integer #
IsIntegral Word128 |
Methods toInteger :: Word128 -> Integer #
IsIntegral (Offset ty) |
Methods toInteger :: Offset ty -> Integer #
IsIntegral (CountOf ty) |
Methods toInteger :: CountOf ty -> Integer #

class (Enum a, Eq a, Ord a, Integral a, IsIntegral a) => IsNatural a where #

Non Negative Number literals, convertible through the generic Natural type

Minimal complete definition

toNatural

Methods

toNatural :: a -> Natural #

Instances

IsNatural Word |
Methods toNatural :: Word -> Natural #
IsNatural Word8 |
Methods toNatural :: Word8 -> Natural #
IsNatural Word16 |
Methods toNatural :: Word16 -> Natural #
IsNatural Word32 |
Methods toNatural :: Word32 -> Natural #
IsNatural Word64 |
Methods toNatural :: Word64 -> Natural #
IsNatural Natural |
Methods toNatural :: Natural -> Natural #
IsNatural CSize |
Methods toNatural :: CSize -> Natural #
IsNatural Word256 |
Methods toNatural :: Word256 -> Natural #
IsNatural Word128 |
Methods toNatural :: Word128 -> Natural #
IsNatural (Offset ty) |
Methods toNatural :: Offset ty -> Natural #
IsNatural (CountOf ty) |
Methods toNatural :: CountOf ty -> Natural #

class Signed a where Source #

types that have sign and can be made absolute

Minimal complete definition

abs, signum

Methods

abs :: a -> a Source #

signum :: a -> Sign Source #

Instances

Signed Double Source # |
Methods abs :: Double -> Double Source # signum :: Double -> Sign Source #
Signed Float Source # |
Methods abs :: Float -> Float Source # signum :: Float -> Sign Source #
Signed Int Source # |
Methods abs :: Int -> Int Source # signum :: Int -> Sign Source #
Signed Int8 Source # |
Methods abs :: Int8 -> Int8 Source # signum :: Int8 -> Sign Source #
Signed Int16 Source # |
Methods abs :: Int16 -> Int16 Source # signum :: Int16 -> Sign Source #
Signed Int32 Source # |
Methods abs :: Int32 -> Int32 Source # signum :: Int32 -> Sign Source #
Signed Int64 Source # |
Methods abs :: Int64 -> Int64 Source # signum :: Int64 -> Sign Source #
Signed Integer Source # |
Methods abs :: Integer -> Integer Source # signum :: Integer -> Sign Source #

class Additive a where #

Represent class of things that can be added together, contains a neutral element and is commutative.

    x + azero = x
    azero + x = x
    x + y = y + x

Minimal complete definition

azero, (+)

Methods

azero :: a #

(+) :: a -> a -> a infixl 6 #

scale :: IsNatural n => n -> a -> a #

Instances

Additive Double |
Methods azero :: Double # (+) :: Double -> Double -> Double # scale :: IsNatural n => n -> Double -> Double #
Additive Float |
Methods azero :: Float # (+) :: Float -> Float -> Float # scale :: IsNatural n => n -> Float -> Float #
Additive Int |
Methods azero :: Int # (+) :: Int -> Int -> Int # scale :: IsNatural n => n -> Int -> Int #
Additive Int8 |
Methods azero :: Int8 # (+) :: Int8 -> Int8 -> Int8 # scale :: IsNatural n => n -> Int8 -> Int8 #
Additive Int16 |
Methods azero :: Int16 # (+) :: Int16 -> Int16 -> Int16 # scale :: IsNatural n => n -> Int16 -> Int16 #
Additive Int32 |
Methods azero :: Int32 # (+) :: Int32 -> Int32 -> Int32 # scale :: IsNatural n => n -> Int32 -> Int32 #
Additive Int64 |
Methods azero :: Int64 # (+) :: Int64 -> Int64 -> Int64 # scale :: IsNatural n => n -> Int64 -> Int64 #
Additive Integer |
Methods azero :: Integer # (+) :: Integer -> Integer -> Integer # scale :: IsNatural n => n -> Integer -> Integer #
Additive Word |
Methods azero :: Word # (+) :: Word -> Word -> Word # scale :: IsNatural n => n -> Word -> Word #
Additive Word8 |
Methods azero :: Word8 # (+) :: Word8 -> Word8 -> Word8 # scale :: IsNatural n => n -> Word8 -> Word8 #
Additive Word16 |
Methods azero :: Word16 # (+) :: Word16 -> Word16 -> Word16 # scale :: IsNatural n => n -> Word16 -> Word16 #
Additive Word32 |
Methods azero :: Word32 # (+) :: Word32 -> Word32 -> Word32 # scale :: IsNatural n => n -> Word32 -> Word32 #
Additive Word64 |
Methods azero :: Word64 # (+) :: Word64 -> Word64 -> Word64 # scale :: IsNatural n => n -> Word64 -> Word64 #
Additive Natural |
Methods azero :: Natural # (+) :: Natural -> Natural -> Natural # scale :: IsNatural n => n -> Natural -> Natural #
Additive CSize |
Methods azero :: CSize # (+) :: CSize -> CSize -> CSize # scale :: IsNatural n => n -> CSize -> CSize #
Additive Word256 |
Methods azero :: Word256 # (+) :: Word256 -> Word256 -> Word256 # scale :: IsNatural n => n -> Word256 -> Word256 #
Additive Word128 |
Methods azero :: Word128 # (+) :: Word128 -> Word128 -> Word128 # scale :: IsNatural n => n -> Word128 -> Word128 #
Additive Seconds # |
Methods azero :: Seconds # (+) :: Seconds -> Seconds -> Seconds # scale :: IsNatural n => n -> Seconds -> Seconds #
Additive NanoSeconds # |
Methods azero :: NanoSeconds # (+) :: NanoSeconds -> NanoSeconds -> NanoSeconds # scale :: IsNatural n => n -> NanoSeconds -> NanoSeconds #
Additive (Offset ty) |
Methods azero :: Offset ty # (+) :: Offset ty -> Offset ty -> Offset ty # scale :: IsNatural n => n -> Offset ty -> Offset ty #
Additive (CountOf ty) |
Methods azero :: CountOf ty # (+) :: CountOf ty -> CountOf ty -> CountOf ty # scale :: IsNatural n => n -> CountOf ty -> CountOf ty #
(KnownNat n, NatWithinBound Word64 n) => Additive (Zn64 n) |
Methods azero :: Zn64 n # (+) :: Zn64 n -> Zn64 n -> Zn64 n # scale :: IsNatural n => n -> Zn64 n -> Zn64 n #
KnownNat n => Additive (Zn n) |
Methods azero :: Zn n # (+) :: Zn n -> Zn n -> Zn n # scale :: IsNatural n => n -> Zn n -> Zn n #

class Subtractive a where #

Represent class of things that can be subtracted.

Note that the result is not necessary of the same type as the operand depending on the actual type.

For example:

    (-) :: Int -> Int -> Int
    (-) :: DateTime -> DateTime -> Seconds
    (-) :: Ptr a -> Ptr a -> PtrDiff
    (-) :: Natural -> Natural -> Maybe Natural

Minimal complete definition

(-)

Associated Types

type Difference a :: * #

Methods

(-) :: a -> a -> Difference a infixl 6 #

Instances

Subtractive Char |
Associated Types type Difference Char :: * # Methods (-) :: Char -> Char -> Difference Char #
Subtractive Double |
Associated Types type Difference Double :: * # Methods (-) :: Double -> Double -> Difference Double #
Subtractive Float |
Associated Types type Difference Float :: * # Methods (-) :: Float -> Float -> Difference Float #
Subtractive Int |
Associated Types type Difference Int :: * # Methods (-) :: Int -> Int -> Difference Int #
Subtractive Int8 |
Associated Types type Difference Int8 :: * # Methods (-) :: Int8 -> Int8 -> Difference Int8 #
Subtractive Int16 |
Associated Types type Difference Int16 :: * # Methods (-) :: Int16 -> Int16 -> Difference Int16 #
Subtractive Int32 |
Associated Types type Difference Int32 :: * # Methods (-) :: Int32 -> Int32 -> Difference Int32 #
Subtractive Int64 |
Associated Types type Difference Int64 :: * # Methods (-) :: Int64 -> Int64 -> Difference Int64 #
Subtractive Integer |
Associated Types type Difference Integer :: * # Methods (-) :: Integer -> Integer -> Difference Integer #
Subtractive Word |
Associated Types type Difference Word :: * # Methods (-) :: Word -> Word -> Difference Word #
Subtractive Word8 |
Associated Types type Difference Word8 :: * # Methods (-) :: Word8 -> Word8 -> Difference Word8 #
Subtractive Word16 |
Associated Types type Difference Word16 :: * # Methods (-) :: Word16 -> Word16 -> Difference Word16 #
Subtractive Word32 |
Associated Types type Difference Word32 :: * # Methods (-) :: Word32 -> Word32 -> Difference Word32 #
Subtractive Word64 |
Associated Types type Difference Word64 :: * # Methods (-) :: Word64 -> Word64 -> Difference Word64 #
Subtractive Natural |
Associated Types type Difference Natural :: * # Methods (-) :: Natural -> Natural -> Difference Natural #
Subtractive Word256 |
Associated Types type Difference Word256 :: * # Methods (-) :: Word256 -> Word256 -> Difference Word256 #
Subtractive Word128 |
Associated Types type Difference Word128 :: * # Methods (-) :: Word128 -> Word128 -> Difference Word128 #
Subtractive (Offset ty) |
Associated Types type Difference (Offset ty) :: * # Methods (-) :: Offset ty -> Offset ty -> Difference (Offset ty) #
Subtractive (CountOf ty) |
Associated Types type Difference (CountOf ty) :: * # Methods (-) :: CountOf ty -> CountOf ty -> Difference (CountOf ty) #
(KnownNat n, NatWithinBound Word64 n) => Subtractive (Zn64 n) |
Associated Types type Difference (Zn64 n) :: * # Methods (-) :: Zn64 n -> Zn64 n -> Difference (Zn64 n) #
KnownNat n => Subtractive (Zn n) |
Associated Types type Difference (Zn n) :: * # Methods (-) :: Zn n -> Zn n -> Difference (Zn n) #

class Multiplicative a where #

Represent class of things that can be multiplied together

    x * midentity = x
    midentity * x = x

Minimal complete definition

midentity, (*)

Methods

midentity :: a #

Identity element over multiplication

(*) :: a -> a -> a infixl 7 #

Multiplication of 2 elements that result in another element

(^) :: (IsNatural n, IDivisible n) => a -> n -> a infixr 8 #

Raise to power, repeated multiplication e.g. > a ^ 2 = a * a > a ^ 10 = (a ^ 5) * (a ^ 5) .. (^) :: (IsNatural n) => a -> n -> a

Instances

Multiplicative Double |
Methods midentity :: Double # (*) :: Double -> Double -> Double # (^) :: (IsNatural n, IDivisible n) => Double -> n -> Double #
Multiplicative Float |
Methods midentity :: Float # (*) :: Float -> Float -> Float # (^) :: (IsNatural n, IDivisible n) => Float -> n -> Float #
Multiplicative Int |
Methods midentity :: Int # (*) :: Int -> Int -> Int # (^) :: (IsNatural n, IDivisible n) => Int -> n -> Int #
Multiplicative Int8 |
Methods midentity :: Int8 # (*) :: Int8 -> Int8 -> Int8 # (^) :: (IsNatural n, IDivisible n) => Int8 -> n -> Int8 #
Multiplicative Int16 |
Methods midentity :: Int16 # (*) :: Int16 -> Int16 -> Int16 # (^) :: (IsNatural n, IDivisible n) => Int16 -> n -> Int16 #
Multiplicative Int32 |
Methods midentity :: Int32 # (*) :: Int32 -> Int32 -> Int32 # (^) :: (IsNatural n, IDivisible n) => Int32 -> n -> Int32 #
Multiplicative Int64 |
Methods midentity :: Int64 # (*) :: Int64 -> Int64 -> Int64 # (^) :: (IsNatural n, IDivisible n) => Int64 -> n -> Int64 #
Multiplicative Integer |
Methods midentity :: Integer # (*) :: Integer -> Integer -> Integer # (^) :: (IsNatural n, IDivisible n) => Integer -> n -> Integer #
Multiplicative Rational |
Methods midentity :: Rational # (*) :: Rational -> Rational -> Rational # (^) :: (IsNatural n, IDivisible n) => Rational -> n -> Rational #
Multiplicative Word |
Methods midentity :: Word # (*) :: Word -> Word -> Word # (^) :: (IsNatural n, IDivisible n) => Word -> n -> Word #
Multiplicative Word8 |
Methods midentity :: Word8 # (*) :: Word8 -> Word8 -> Word8 # (^) :: (IsNatural n, IDivisible n) => Word8 -> n -> Word8 #
Multiplicative Word16 |
Methods midentity :: Word16 # (*) :: Word16 -> Word16 -> Word16 # (^) :: (IsNatural n, IDivisible n) => Word16 -> n -> Word16 #
Multiplicative Word32 |
Methods midentity :: Word32 # (*) :: Word32 -> Word32 -> Word32 # (^) :: (IsNatural n, IDivisible n) => Word32 -> n -> Word32 #
Multiplicative Word64 |
Methods midentity :: Word64 # (*) :: Word64 -> Word64 -> Word64 # (^) :: (IsNatural n, IDivisible n) => Word64 -> n -> Word64 #
Multiplicative Natural |
Methods midentity :: Natural # (*) :: Natural -> Natural -> Natural # (^) :: (IsNatural n, IDivisible n) => Natural -> n -> Natural #
Multiplicative Word256 |
Methods midentity :: Word256 # (*) :: Word256 -> Word256 -> Word256 # (^) :: (IsNatural n, IDivisible n) => Word256 -> n -> Word256 #
Multiplicative Word128 |
Methods midentity :: Word128 # (*) :: Word128 -> Word128 -> Word128 # (^) :: (IsNatural n, IDivisible n) => Word128 -> n -> Word128 #

class (Additive a, Multiplicative a) => IDivisible a where #

Represent types that supports an euclidian division

    (x ‘div‘ y) * y + (x ‘mod‘ y) == x

Minimal complete definition

div, mod | divMod

Methods

div :: a -> a -> a #

mod :: a -> a -> a #

divMod :: a -> a -> (a, a) #

Instances

IDivisible Int |
Methods div :: Int -> Int -> Int # mod :: Int -> Int -> Int # divMod :: Int -> Int -> (Int, Int) #
IDivisible Int8 |
Methods div :: Int8 -> Int8 -> Int8 # mod :: Int8 -> Int8 -> Int8 # divMod :: Int8 -> Int8 -> (Int8, Int8) #
IDivisible Int16 |
Methods div :: Int16 -> Int16 -> Int16 # mod :: Int16 -> Int16 -> Int16 # divMod :: Int16 -> Int16 -> (Int16, Int16) #
IDivisible Int32 |
Methods div :: Int32 -> Int32 -> Int32 # mod :: Int32 -> Int32 -> Int32 # divMod :: Int32 -> Int32 -> (Int32, Int32) #
IDivisible Int64 |
Methods div :: Int64 -> Int64 -> Int64 # mod :: Int64 -> Int64 -> Int64 # divMod :: Int64 -> Int64 -> (Int64, Int64) #
IDivisible Integer |
Methods div :: Integer -> Integer -> Integer # mod :: Integer -> Integer -> Integer # divMod :: Integer -> Integer -> (Integer, Integer) #
IDivisible Word |
Methods div :: Word -> Word -> Word # mod :: Word -> Word -> Word # divMod :: Word -> Word -> (Word, Word) #
IDivisible Word8 |
Methods div :: Word8 -> Word8 -> Word8 # mod :: Word8 -> Word8 -> Word8 # divMod :: Word8 -> Word8 -> (Word8, Word8) #
IDivisible Word16 |
Methods div :: Word16 -> Word16 -> Word16 # mod :: Word16 -> Word16 -> Word16 # divMod :: Word16 -> Word16 -> (Word16, Word16) #
IDivisible Word32 |
Methods div :: Word32 -> Word32 -> Word32 # mod :: Word32 -> Word32 -> Word32 # divMod :: Word32 -> Word32 -> (Word32, Word32) #
IDivisible Word64 |
Methods div :: Word64 -> Word64 -> Word64 # mod :: Word64 -> Word64 -> Word64 # divMod :: Word64 -> Word64 -> (Word64, Word64) #
IDivisible Natural |
Methods div :: Natural -> Natural -> Natural # mod :: Natural -> Natural -> Natural # divMod :: Natural -> Natural -> (Natural, Natural) #
IDivisible Word256 |
Methods div :: Word256 -> Word256 -> Word256 # mod :: Word256 -> Word256 -> Word256 # divMod :: Word256 -> Word256 -> (Word256, Word256) #
IDivisible Word128 |
Methods div :: Word128 -> Word128 -> Word128 # mod :: Word128 -> Word128 -> Word128 # divMod :: Word128 -> Word128 -> (Word128, Word128) #

class Multiplicative a => Divisible a where #

Support for division between same types

This is likely to change to represent specific mathematic divisions

Minimal complete definition

(/)

Methods

(/) :: a -> a -> a infixl 7 #

Instances

Divisible Double |
Methods (/) :: Double -> Double -> Double #
Divisible Float |
Methods (/) :: Float -> Float -> Float #
Divisible Rational |
Methods (/) :: Rational -> Rational -> Rational #

## Data types

data Maybe a :: * -> * #

The `Maybe` type encapsulates an optional value. A value of type ``Maybe` a` either contains a value of type `a` (represented as ``Just` a`), or it is empty (represented as `Nothing`). Using `Maybe` is a good way to deal with errors or exceptional cases without resorting to drastic measures such as `error`.

The `Maybe` type is also a monad. It is a simple kind of error monad, where all errors are represented by `Nothing`. A richer error monad can be built using the `Either` type.

Constructors

Nothing |
Just a |

Instances

Monad Maybe |
Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b # (>>) :: Maybe a -> Maybe b -> Maybe b # return :: a -> Maybe a # fail :: String -> Maybe a #
Functor Maybe |
Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Applicative Maybe |
Methods pure :: a -> Maybe a # (<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b # (*>) :: Maybe a -> Maybe b -> Maybe b # (<*) :: Maybe a -> Maybe b -> Maybe a #
Foldable Maybe |

Methods

fold :: Monoid m => Maybe m -> 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 #

toList :: Maybe a -> [a] #

null :: Maybe a -> Bool #

length :: Maybe a -> Int #

elem :: Eq a => a -> Maybe a -> Bool #

maximum :: Ord a => Maybe a -> a #

minimum :: Ord a => Maybe a -> a #

sum :: Num a => Maybe a -> a #

product :: Num a => Maybe a -> a #

Traversable Maybe |
Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) # sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) # mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) # sequence :: Monad m => Maybe (m a) -> m (Maybe a) #
Generic1 Maybe |
Associated Types type Rep1 (Maybe :: * -> *) :: * -> * # Methods from1 :: Maybe a -> Rep1 Maybe a # to1 :: Rep1 Maybe a -> Maybe a #
Alternative Maybe |
Methods empty :: Maybe a # (<|>) :: Maybe a -> Maybe a -> Maybe a # some :: Maybe a -> Maybe [a] # many :: Maybe a -> Maybe [a] #
MonadPlus Maybe |
Methods mzero :: Maybe a # mplus :: Maybe a -> Maybe a -> Maybe a #
MonadFailure Maybe |
Associated Types type Failure (Maybe :: * -> *) :: * # Methods mFail :: Failure Maybe -> Maybe () #
Eq a => Eq (Maybe a) |
Methods (==) :: Maybe a -> Maybe a -> Bool # (/=) :: Maybe a -> Maybe a -> Bool #
Data a => Data (Maybe a) |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) #

toConstr :: Maybe a -> Constr #

dataTypeOf :: Maybe a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) #

gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r #

gmapQr :: (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) #

Ord a => Ord (Maybe a) |
Methods compare :: Maybe a -> Maybe a -> Ordering # (<) :: Maybe a -> Maybe a -> Bool # (<=) :: Maybe a -> Maybe a -> Bool # (>) :: Maybe a -> Maybe a -> Bool # (>=) :: Maybe a -> Maybe a -> Bool # max :: Maybe a -> Maybe a -> Maybe a # min :: Maybe a -> Maybe a -> Maybe a #
Read a => Read (Maybe a) |
Methods readsPrec :: Int -> ReadS (Maybe a) # readList :: ReadS [Maybe a] # readPrec :: ReadPrec (Maybe a) # readListPrec :: ReadPrec [Maybe a] #
Show a => Show (Maybe a) |
Methods showsPrec :: Int -> Maybe a -> ShowS # show :: Maybe a -> String # showList :: [Maybe a] -> ShowS #
Generic (Maybe a) |
Associated Types type Rep (Maybe a) :: * -> * # Methods from :: Maybe a -> Rep (Maybe a) x # to :: Rep (Maybe a) x -> Maybe a #
Semigroup a => Semigroup (Maybe a) |
Methods (<>) :: Maybe a -> Maybe a -> Maybe a # sconcat :: NonEmpty (Maybe a) -> Maybe a # stimes :: Integral b => b -> Maybe a -> Maybe a #
Monoid a => Monoid (Maybe a) | Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `e*e = e` and `e*s = s = s*e` for all `s ∈ S`." Since there is no "Semigroup" typeclass providing just `mappend`, we use `Monoid` instead.
Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
NormalForm a => NormalForm (Maybe a) |
Methods toNormalForm :: Maybe a -> () #
Arbitrary a => Arbitrary (Maybe a) Source # |
Methods arbitrary :: Gen (Maybe a) Source #
SingI (Maybe a) (Nothing a) |
Methods sing :: Sing (Nothing a) a
SingKind a (KProxy a) => SingKind (Maybe a) (KProxy (Maybe a)) |
Associated Types type DemoteRep (KProxy (Maybe a)) (kparam :: KProxy (KProxy (Maybe a))) :: * Methods fromSing :: Sing (KProxy (Maybe a)) a -> DemoteRep (KProxy (Maybe a)) kparam
SingI a a1 => SingI (Maybe a) (Just a a1) |
Methods sing :: Sing (Just a a1) a
type Rep1 Maybe |
type Rep1 Maybe = D1 (MetaData "Maybe" "GHC.Base" "base" False) ((:+:) (C1 (MetaCons "Nothing" PrefixI False) U1) (C1 (MetaCons "Just" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)))
type Failure Maybe |
type Failure Maybe = ()
type Rep (Maybe a) |
type Rep (Maybe a) = D1 (MetaData "Maybe" "GHC.Base" "base" False) ((:+:) (C1 (MetaCons "Nothing" PrefixI False) U1) (C1 (MetaCons "Just" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))))
data Sing (Maybe a) |

data Sing (Maybe a) where

- SNothing :: Sing (Maybe a) (Nothing a)
- SJust :: Sing (Maybe a) (Just a a1)

type (==) (Maybe k) a b |
type (==) (Maybe k) a b = EqMaybe k a b
type DemoteRep (Maybe a) (KProxy (Maybe a)) |
type DemoteRep (Maybe a) (KProxy (Maybe a)) = Maybe (DemoteRep a (KProxy a))

data Ordering :: * #

Constructors

LT |
EQ |
GT |

Instances

Bounded Ordering |
Methods minBound :: Ordering # maxBound :: Ordering #
Enum Ordering |
Methods succ :: Ordering -> Ordering # pred :: Ordering -> Ordering # toEnum :: Int -> Ordering # fromEnum :: Ordering -> Int # enumFrom :: Ordering -> [Ordering] # enumFromThen :: Ordering -> Ordering -> [Ordering] # enumFromTo :: Ordering -> Ordering -> [Ordering] # enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering] #
Eq Ordering |
Methods (==) :: Ordering -> Ordering -> Bool # (/=) :: Ordering -> Ordering -> Bool #
Data Ordering |

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 :: (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 #

Ord Ordering |
Methods compare :: Ordering -> Ordering -> Ordering # (<) :: Ordering -> Ordering -> Bool # (<=) :: Ordering -> Ordering -> Bool # (>) :: Ordering -> Ordering -> Bool # (>=) :: Ordering -> Ordering -> Bool # max :: Ordering -> Ordering -> Ordering # min :: Ordering -> Ordering -> Ordering #
Read Ordering |
Methods readsPrec :: Int -> ReadS Ordering # readList :: ReadS [Ordering] # readPrec :: ReadPrec Ordering # readListPrec :: ReadPrec [Ordering] #
Show Ordering |
Methods showsPrec :: Int -> Ordering -> ShowS # show :: Ordering -> String # showList :: [Ordering] -> ShowS #
Ix Ordering |
Methods range :: (Ordering, Ordering) -> [Ordering] # index :: (Ordering, Ordering) -> Ordering -> Int # unsafeIndex :: (Ordering, Ordering) -> Ordering -> Int inRange :: (Ordering, Ordering) -> Ordering -> Bool # rangeSize :: (Ordering, Ordering) -> Int # unsafeRangeSize :: (Ordering, Ordering) -> Int
Generic Ordering |
Associated Types type Rep Ordering :: * -> * # Methods from :: Ordering -> Rep Ordering x # to :: Rep Ordering x -> Ordering #
Semigroup Ordering |
Methods (<>) :: Ordering -> Ordering -> Ordering # sconcat :: NonEmpty Ordering -> Ordering # stimes :: Integral b => b -> Ordering -> Ordering #
Monoid Ordering |
Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
type Rep Ordering |
type Rep Ordering = D1 (MetaData "Ordering" "GHC.Types" "ghc-prim" False) ((:+:) (C1 (MetaCons "LT" PrefixI False) U1) ((:+:) (C1 (MetaCons "EQ" PrefixI False) U1) (C1 (MetaCons "GT" PrefixI False) U1)))
type (==) Ordering a b |
type (==) Ordering a b = EqOrdering a b

data Bool :: * #

Constructors

False |
True |

Instances

Bounded Bool |
Methods minBound :: Bool # maxBound :: Bool #
Enum Bool |
Methods succ :: Bool -> Bool # pred :: Bool -> Bool # toEnum :: Int -> Bool # fromEnum :: Bool -> Int # enumFrom :: Bool -> [Bool] # enumFromThen :: Bool -> Bool -> [Bool] # enumFromTo :: Bool -> Bool -> [Bool] # enumFromThenTo :: Bool -> Bool -> Bool -> [Bool] #
Eq Bool |
Methods (==) :: Bool -> Bool -> Bool # (/=) :: Bool -> Bool -> Bool #
Data Bool |

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 #

toConstr :: Bool -> Constr #

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 :: (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 #

Ord Bool |
Methods compare :: Bool -> Bool -> Ordering # (<) :: Bool -> Bool -> Bool # (<=) :: Bool -> Bool -> Bool # (>) :: Bool -> Bool -> Bool # (>=) :: Bool -> Bool -> Bool # max :: Bool -> Bool -> Bool # min :: Bool -> Bool -> Bool #
Read Bool |
Methods readsPrec :: Int -> ReadS Bool # readList :: ReadS [Bool] # readPrec :: ReadPrec Bool # readListPrec :: ReadPrec [Bool] #
Show Bool |
Methods showsPrec :: Int -> Bool -> ShowS # show :: Bool -> String # showList :: [Bool] -> ShowS #
Ix Bool |
Methods range :: (Bool, Bool) -> [Bool] # index :: (Bool, Bool) -> Bool -> Int # unsafeIndex :: (Bool, Bool) -> Bool -> Int inRange :: (Bool, Bool) -> Bool -> Bool # rangeSize :: (Bool, Bool) -> Int # unsafeRangeSize :: (Bool, Bool) -> Int
Generic Bool |
Associated Types type Rep Bool :: * -> * # Methods from :: Bool -> Rep Bool x # to :: Rep Bool x -> Bool #
Storable Bool |
Methods sizeOf :: Bool -> Int # alignment :: Bool -> Int # peekElemOff :: Ptr Bool -> Int -> IO Bool # pokeElemOff :: Ptr Bool -> Int -> Bool -> IO () # peekByteOff :: Ptr b -> Int -> IO Bool # pokeByteOff :: Ptr b -> Int -> Bool -> IO () # peek :: Ptr Bool -> IO Bool # poke :: Ptr Bool -> Bool -> IO () #
Bits Bool |

Methods

(.&.) :: Bool -> Bool -> Bool #

(.|.) :: Bool -> Bool -> Bool #

xor :: Bool -> Bool -> Bool #

complement :: Bool -> Bool #

shift :: Bool -> Int -> Bool #

rotate :: Bool -> Int -> Bool #

zeroBits :: Bool #

bit :: Int -> Bool #

setBit :: Bool -> Int -> Bool #

clearBit :: Bool -> Int -> Bool #

complementBit :: Bool -> Int -> Bool #

testBit :: Bool -> Int -> Bool #

bitSizeMaybe :: Bool -> Maybe Int #

bitSize :: Bool -> Int #

isSigned :: Bool -> Bool #

shiftL :: Bool -> Int -> Bool #

unsafeShiftL :: Bool -> Int -> Bool #

shiftR :: Bool -> Int -> Bool #

unsafeShiftR :: Bool -> Int -> Bool #

rotateL :: Bool -> Int -> Bool #

rotateR :: Bool -> Int -> Bool #

popCount :: Bool -> Int #

FiniteBits Bool |
Methods finiteBitSize :: Bool -> Int # countLeadingZeros :: Bool -> Int # countTrailingZeros :: Bool -> Int #
NormalForm Bool |
Methods toNormalForm :: Bool -> () #
Arbitrary Bool Source # |
Methods arbitrary :: Gen Bool Source #
IsProperty Bool Source # |
Methods property :: Bool -> Property Source #
SingI Bool False |
Methods sing :: Sing False a
SingI Bool True |
Methods sing :: Sing True a
SingKind Bool (KProxy Bool) |
Associated Types type DemoteRep (KProxy Bool) (kparam :: KProxy (KProxy Bool)) :: * Methods fromSing :: Sing (KProxy Bool) a -> DemoteRep (KProxy Bool) kparam
IsProperty (String, Bool) Source # |
Methods property :: (String, Bool) -> Property Source #
type Rep Bool |
type Rep Bool = D1 (MetaData "Bool" "GHC.Types" "ghc-prim" False) ((:+:) (C1 (MetaCons "False" PrefixI False) U1) (C1 (MetaCons "True" PrefixI False) U1))
data Sing Bool |

data Sing Bool where

- STrue :: Sing Bool True
- SFalse :: Sing Bool False

type (==) Bool a b |
type (==) Bool a b = EqBool a b
type DemoteRep Bool (KProxy Bool) |
type DemoteRep Bool (KProxy Bool) = Bool

data Char :: * #

The character type `Char` is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) characters (see http://www.unicode.org/ for details). This set extends the ISO 8859-1 (Latin-1) character set (the first 256 characters), which is itself an extension of the ASCII character set (the first 128 characters). A character literal in Haskell has type `Char`.

To convert a `Char` to or from the corresponding `Int` value defined by Unicode, use `toEnum` and `fromEnum` from the `Enum` class respectively (or equivalently `ord` and `chr`).

Instances

Bounded Char |
Methods minBound :: Char # maxBound :: Char #
Enum Char |
Methods succ :: Char -> Char # pred :: Char -> Char # toEnum :: Int -> Char # fromEnum :: Char -> Int # enumFrom :: Char -> [Char] # enumFromThen :: Char -> Char -> [Char] # enumFromTo :: Char -> Char -> [Char] # enumFromThenTo :: Char -> Char -> Char -> [Char] #
Eq Char |
Methods (==) :: Char -> Char -> Bool # (/=) :: Char -> Char -> Bool #
Data Char |

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 #

toConstr :: Char -> Constr #

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 :: (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 #

Ord Char |
Methods compare :: Char -> Char -> Ordering # (<) :: Char -> Char -> Bool # (<=) :: Char -> Char -> Bool # (>) :: Char -> Char -> Bool # (>=) :: Char -> Char -> Bool # max :: Char -> Char -> Char # min :: Char -> Char -> Char #
Read Char |
Methods readsPrec :: Int -> ReadS Char # readList :: ReadS [Char] # readPrec :: ReadPrec Char # readListPrec :: ReadPrec [Char] #
Show Char |
Methods showsPrec :: Int -> Char -> ShowS # show :: Char -> String # showList :: [Char] -> ShowS #
Ix Char |
Methods range :: (Char, Char) -> [Char] # index :: (Char, Char) -> Char -> Int # unsafeIndex :: (Char, Char) -> Char -> Int inRange :: (Char, Char) -> Char -> Bool # rangeSize :: (Char, Char) -> Int # unsafeRangeSize :: (Char, Char) -> Int
PrintfArg Char |
Methods formatArg :: Char -> FieldFormatter # parseFormat :: Char -> ModifierParser #
IsChar Char |
Methods toChar :: Char -> Char # fromChar :: Char -> Char #
Storable Char |
Methods sizeOf :: Char -> Int # alignment :: Char -> Int # peekElemOff :: Ptr Char -> Int -> IO Char # pokeElemOff :: Ptr Char -> Int -> Char -> IO () # peekByteOff :: Ptr b -> Int -> IO Char # pokeByteOff :: Ptr b -> Int -> Char -> IO () # peek :: Ptr Char -> IO Char # poke :: Ptr Char -> Char -> IO () #
PrimType Char |

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 () #

PrimMemoryComparable Char |
NormalForm Char |
Methods toNormalForm :: Char -> () #
Subtractive Char |
Associated Types type Difference Char :: * # Methods (-) :: Char -> Char -> Difference Char #
StorableFixed Char Source # |
Methods size :: proxy Char -> CountOf Word8 Source # alignment :: proxy Char -> CountOf Word8 Source #
Storable Char Source # |
Methods peek :: Ptr Char -> IO Char Source # poke :: Ptr Char -> Char -> IO () Source #
Arbitrary Char Source # |
Methods arbitrary :: Gen Char Source #
Functor (URec Char) |
Methods fmap :: (a -> b) -> URec Char a -> URec Char b # (<$) :: a -> URec Char b -> URec Char a #
Foldable (URec Char) |

Methods

fold :: Monoid m => URec Char m -> m #

foldMap :: Monoid m => (a -> m) -> URec Char a -> m #

foldr :: (a -> b -> b) -> b -> URec Char a -> b #

foldr' :: (a -> b -> b) -> b -> URec Char a -> b #

foldl :: (b -> a -> b) -> b -> URec Char a -> b #

foldl' :: (b -> a -> b) -> b -> URec Char a -> b #

foldr1 :: (a -> a -> a) -> URec Char a -> a #

foldl1 :: (a -> a -> a) -> URec Char a -> a #

toList :: URec Char a -> [a] #

null :: URec Char a -> Bool #

length :: URec Char a -> Int #

elem :: Eq a => a -> URec Char a -> Bool #

maximum :: Ord a => URec Char a -> a #

minimum :: Ord a => URec Char a -> a #

sum :: Num a => URec Char a -> a #

product :: Num a => URec Char a -> a #

Traversable (URec Char) |
Methods traverse :: Applicative f => (a -> f b) -> URec Char a -> f (URec Char b) # sequenceA :: Applicative f => URec Char (f a) -> f (URec Char a) # mapM :: Monad m => (a -> m b) -> URec Char a -> m (URec Char b) # sequence :: Monad m => URec Char (m a) -> m (URec Char a) #
Generic1 (URec Char) |
Associated Types type Rep1 (URec Char :: * -> *) :: * -> * # Methods from1 :: URec Char a -> Rep1 (URec Char) a # to1 :: Rep1 (URec Char) a -> URec Char a #
Eq (URec Char p) |
Methods (==) :: URec Char p -> URec Char p -> Bool # (/=) :: URec Char p -> URec Char p -> Bool #
Ord (URec Char p) |
Methods compare :: URec Char p -> URec Char p -> Ordering # (<) :: URec Char p -> URec Char p -> Bool # (<=) :: URec Char p -> URec Char p -> Bool # (>) :: URec Char p -> URec Char p -> Bool # (>=) :: URec Char p -> URec Char p -> Bool # max :: URec Char p -> URec Char p -> URec Char p # min :: URec Char p -> URec Char p -> URec Char p #
Show (URec Char p) |
Methods showsPrec :: Int -> URec Char p -> ShowS # show :: URec Char p -> String # showList :: [URec Char p] -> ShowS #
Generic (URec Char p) |
Associated Types type Rep (URec Char p) :: * -> * # Methods from :: URec Char p -> Rep (URec Char p) x # to :: Rep (URec Char p) x -> URec Char p #
data URec Char | Used for marking occurrences of `Char#`

data URec Char = UChar {

- uChar# :: Char#

}

type Difference Char |
type Difference Char = Int
type NatNumMaxBound Char |
type NatNumMaxBound Char = 1114111
type Rep1 (URec Char) |
type Rep1 (URec Char) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UChar))
type Rep (URec Char p) |
type Rep (URec Char p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UChar))

data Char7 :: * #

ASCII value between 0x0 and 0x7f

Instances

Eq Char7 |
Methods (==) :: Char7 -> Char7 -> Bool # (/=) :: Char7 -> Char7 -> Bool #
Ord Char7 |
Methods compare :: Char7 -> Char7 -> Ordering # (<) :: Char7 -> Char7 -> Bool # (<=) :: Char7 -> Char7 -> Bool # (>) :: Char7 -> Char7 -> Bool # (>=) :: Char7 -> Char7 -> Bool # max :: Char7 -> Char7 -> Char7 # min :: Char7 -> Char7 -> Char7 #
Show Char7 |
Methods showsPrec :: Int -> Char7 -> ShowS # show :: Char7 -> String # showList :: [Char7] -> ShowS #
PrimType Char7 |

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 () #

NormalForm Char7 |
Methods toNormalForm :: Char7 -> () #
Arbitrary Char7 Source # |
Methods arbitrary :: Gen Char7 Source #
type NatNumMaxBound Char7 |
type NatNumMaxBound Char7 = 127

data IO a :: * -> * #

A value of type ``IO` a` is a computation which, when performed, does some I/O before returning a value of type `a`.

There is really only one way to "perform" an I/O action: bind it to `Main.main` in your program. When your program is run, the I/O will be performed. It isn't possible to perform I/O from an arbitrary function, unless that function is itself in the `IO` monad and called at some point, directly or indirectly, from `Main.main`.

`IO` is a monad, so `IO` actions can be combined using either the do-notation or the `>>` and `>>=` operations from the `Monad` class.

Instances

Monad IO |
Methods (>>=) :: IO a -> (a -> IO b) -> IO b # (>>) :: IO a -> IO b -> IO b # return :: a -> IO a # fail :: String -> IO a #
Functor IO |
Methods fmap :: (a -> b) -> IO a -> IO b # (<$) :: a -> IO b -> IO a #
Applicative IO |
Methods pure :: a -> IO a # (<*>) :: IO (a -> b) -> IO a -> IO b # (*>) :: IO a -> IO b -> IO b # (<*) :: IO a -> IO b -> IO a #
MonadIO IO |
Methods liftIO :: IO a -> IO a #
Alternative IO |
Methods empty :: IO a # (<|>) :: IO a -> IO a -> IO a # some :: IO a -> IO [a] # many :: IO a -> IO [a] #
MonadPlus IO |
Methods mzero :: IO a # mplus :: IO a -> IO a -> IO a #
PrimMonad IO |

Associated Types

type PrimState (IO :: * -> *) :: * #

type PrimVar (IO :: * -> *) :: * -> * #

Methods

primitive :: (State# (PrimState IO) -> (#VoidRep, PtrRepLifted, State# (PrimState IO), a#)) -> IO a #

primThrow :: Exception e => e -> IO a #

unPrimMonad :: IO a -> State# (PrimState IO) -> (#VoidRep, PtrRepLifted, State# (PrimState IO), a#) #

primVarNew :: a -> IO (PrimVar IO a) #

primVarRead :: PrimVar IO a -> IO a #

primVarWrite :: PrimVar IO a -> a -> IO () #

MonadRandom IO Source # |
Methods getRandomBytes :: CountOf Word8 -> IO (UArray Word8) Source # getRandomWord64 :: IO Word64 Source # getRandomF32 :: IO Float Source # getRandomF64 :: IO Double Source #
MonadBracket IO Source # |
Methods generalBracket :: IO a -> (a -> b -> IO ignored1) -> (a -> SomeException -> IO ignored2) -> (a -> IO b) -> IO b Source #
MonadCatch IO Source # |
Methods catch :: Exception e => IO a -> (e -> IO a) -> IO a Source #
MonadThrow IO Source # |
Methods throw :: Exception e => e -> IO a Source #
Monoid a => Monoid (IO a) |
Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
(~) * a () => PrintfType (IO a) |
Methods spr :: String -> [UPrintf] -> IO a
(~) * a () => HPrintfType (IO a) |
Methods hspr :: Handle -> String -> [UPrintf] -> IO a
type PrimVar IO |
type PrimVar IO = IORef
type PrimState IO |
type PrimState IO = RealWorld

data Either a b :: * -> * -> * #

The `Either` type represents values with two possibilities: a value of type ``Either` a b` is either ``Left` a` or ``Right` b`.

The `Either` type is sometimes used to represent a value which is either correct or an error; by convention, the `Left` constructor is used to hold an error value and the `Right` constructor is used to hold a correct value (mnemonic: "right" also means "correct").

#### Examples

The type ``Either` `String` `Int`` is the type of values which can be either a `String` or an `Int`. The `Left` constructor can be used only on `String`s, and the `Right` constructor can be used only on `Int`s:

    >>> let s = Left "foo" :: Either String Int
    >>> s
    Left "foo"
    >>> let n = Right 3 :: Either String Int
    >>> n
    Right 3
    >>> :type s
    s :: Either String Int
    >>> :type n
    n :: Either String Int

The `fmap` from our `Functor` instance will ignore `Left` values, but will apply the supplied function to values contained in a `Right`:

    >>> let s = Left "foo" :: Either String Int
    >>> let n = Right 3 :: Either String Int
    >>> fmap (*2) s
    Left "foo"
    >>> fmap (*2) n
    Right 6

The `Monad` instance for `Either` allows us to chain together multiple actions which may fail, and fail overall if any of the individual steps failed. First we'll write a function that can either parse an `Int` from a `Char`, or fail.

    >>> import Data.Char ( digitToInt, isDigit )
    >>> :{
        let parseEither :: Char -> Either String Int
            parseEither c
              | isDigit c = Right (digitToInt c)
              | otherwise = Left "parse error"
    >>> :}

The following should work, since both `'1'` and `'2'` can be parsed as `Int`s.

    >>> :{
        let parseMultiple :: Either String Int
            parseMultiple = do
              x <- parseEither '1'
              y <- parseEither '2'
              return (x + y)
    >>> :}

    >>> parseMultiple
    Right 3

But the following should fail overall, since the first operation where we attempt to parse `'m'` as an `Int` will fail:

    >>> :{
        let parseMultiple :: Either String Int
            parseMultiple = do
              x <- parseEither 'm'
              y <- parseEither '2'
              return (x + y)
    >>> :}

    >>> parseMultiple
    Left "parse error"

Constructors

Left a |
Right b |

Instances

Bifunctor Either |
Methods bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d # first :: (a -> b) -> Either a c -> Either b c # second :: (b -> c) -> Either a b -> Either a c #
Monad (Either e) |
Methods (>>=) :: Either e a -> (a -> Either e b) -> Either e b # (>>) :: Either e a -> Either e b -> Either e b # return :: a -> Either e a # fail :: String -> Either e a #
Functor (Either a) |
Methods fmap :: (a -> b) -> Either a a -> Either a b # (<$) :: a -> Either a b -> Either a a #
Applicative (Either e) |
Methods pure :: a -> Either e a # (<*>) :: Either e (a -> b) -> Either e a -> Either e b # (*>) :: Either e a -> Either e b -> Either e b # (<*) :: Either e a -> Either e b -> Either e a #
Foldable (Either a) |

Methods

fold :: Monoid m => Either a m -> m #

foldMap :: Monoid m => (a -> m) -> Either a a -> m #

foldr :: (a -> b -> b) -> b -> Either a a -> b #

foldr' :: (a -> b -> b) -> b -> Either a a -> b #

foldl :: (b -> a -> b) -> b -> Either a a -> b #

foldl' :: (b -> a -> b) -> b -> Either a a -> b #

foldr1 :: (a -> a -> a) -> Either a a -> a #

foldl1 :: (a -> a -> a) -> Either a a -> a #

toList :: Either a a -> [a] #

null :: Either a a -> Bool #

length :: Either a a -> Int #

elem :: Eq a => a -> Either a a -> Bool #

maximum :: Ord a => Either a a -> a #

minimum :: Ord a => Either a a -> a #

sum :: Num a => Either a a -> a #

product :: Num a => Either a a -> a #

Traversable (Either a) |
Methods traverse :: Applicative f => (a -> f b) -> Either a a -> f (Either a b) # sequenceA :: Applicative f => Either a (f a) -> f (Either a a) # mapM :: Monad m => (a -> m b) -> Either a a -> m (Either a b) # sequence :: Monad m => Either a (m a) -> m (Either a a) #
Generic1 (Either a) |
Associated Types type Rep1 (Either a :: * -> *) :: * -> * # Methods from1 :: Either a a -> Rep1 (Either a) a # to1 :: Rep1 (Either a) a -> Either a a #
MonadFailure (Either a) |
Associated Types type Failure (Either a :: * -> *) :: * # Methods mFail :: Failure (Either a) -> Either a () #
(Eq b, Eq a) => Eq (Either a b) |
Methods (==) :: Either a b -> Either a b -> Bool # (/=) :: Either a b -> Either a b -> Bool #
(Data a, Data b) => Data (Either a b) |

Methods

gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> Either a b -> c (Either a b) #

gunfold :: (forall c r. Data c => c (c -> 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 c. Data c => c -> c) -> Either a b -> Either a b #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r #

gmapQr :: (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) #

(Ord b, Ord a) => Ord (Either a b) |
Methods compare :: Either a b -> Either a b -> Ordering # (<) :: Either a b -> Either a b -> Bool # (<=) :: Either a b -> Either a b -> Bool # (>) :: Either a b -> Either a b -> Bool # (>=) :: Either a b -> Either a b -> Bool # max :: Either a b -> Either a b -> Either a b # min :: Either a b -> Either a b -> Either a b #
(Read b, Read a) => Read (Either a b) |
Methods readsPrec :: Int -> ReadS (Either a b) # readList :: ReadS [Either a b] # readPrec :: ReadPrec (Either a b) # readListPrec :: ReadPrec [Either a b] #
(Show b, Show a) => Show (Either a b) |
Methods showsPrec :: Int -> Either a b -> ShowS # show :: Either a b -> String # showList :: [Either a b] -> ShowS #
Generic (Either a b) |
Associated Types type Rep (Either a b) :: * -> * # Methods from :: Either a b -> Rep (Either a b) x # to :: Rep (Either a b) x -> Either a b #
Semigroup (Either a b) |
Methods (<>) :: Either a b -> Either a b -> Either a b # sconcat :: NonEmpty (Either a b) -> Either a b # stimes :: Integral b => b -> Either a b -> Either a b #
(NormalForm l, NormalForm r) => NormalForm (Either l r) |
Methods toNormalForm :: Either l r -> () #
(Arbitrary l, Arbitrary r) => Arbitrary (Either l r) Source # |
Methods arbitrary :: Gen (Either l r) Source #
type Rep1 (Either a) |
type Rep1 (Either a) = D1 (MetaData "Either" "Data.Either" "base" False) ((:+:) (C1 (MetaCons "Left" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))) (C1 (MetaCons "Right" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)))
type Failure (Either a) |
type Failure (Either a) = a
type Rep (Either a b) |
type Rep (Either a b) = D1 (MetaData "Either" "Data.Either" "base" False) ((:+:) (C1 (MetaCons "Left" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))) (C1 (MetaCons "Right" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b))))
type (==) (Either k k1) a b |
type (==) (Either k k1) a b = EqEither k k1 a b

## Numbers

data Int8 :: * #

8-bit signed integer type

Instances

Bounded Int8 |
Methods minBound :: Int8 # maxBound :: Int8 #
Enum Int8 |
Methods succ :: Int8 -> Int8 # pred :: Int8 -> Int8 # toEnum :: Int -> Int8 # fromEnum :: Int8 -> Int # enumFrom :: Int8 -> [Int8] # enumFromThen :: Int8 -> Int8 -> [Int8] # enumFromTo :: Int8 -> Int8 -> [Int8] # enumFromThenTo :: Int8 -> Int8 -> Int8 -> [Int8] #
Eq Int8 |
Methods (==) :: Int8 -> Int8 -> Bool # (/=) :: Int8 -> Int8 -> Bool #
Integral Int8 |
Methods quot :: Int8 -> Int8 -> Int8 # rem :: Int8 -> Int8 -> Int8 # div :: Int8 -> Int8 -> Int8 # mod :: Int8 -> Int8 -> Int8 # quotRem :: Int8 -> Int8 -> (Int8, Int8) # divMod :: Int8 -> Int8 -> (Int8, Int8) # toInteger :: Int8 -> Integer #
Data Int8 |

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 #

toConstr :: Int8 -> Constr #

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 :: (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 #

Num Int8 |
Methods (+) :: Int8 -> Int8 -> Int8 # (-) :: Int8 -> Int8 -> Int8 # (*) :: Int8 -> Int8 -> Int8 # negate :: Int8 -> Int8 # abs :: Int8 -> Int8 # signum :: Int8 -> Int8 # fromInteger :: Integer -> Int8 #
Ord Int8 |
Methods compare :: Int8 -> Int8 -> Ordering # (<) :: Int8 -> Int8 -> Bool # (<=) :: Int8 -> Int8 -> Bool # (>) :: Int8 -> Int8 -> Bool # (>=) :: Int8 -> Int8 -> Bool # max :: Int8 -> Int8 -> Int8 # min :: Int8 -> Int8 -> Int8 #
Read Int8 |
Methods readsPrec :: Int -> ReadS Int8 # readList :: ReadS [Int8] # readPrec :: ReadPrec Int8 # readListPrec :: ReadPrec [Int8] #
Real Int8 |
Methods toRational :: Int8 -> Rational #
Show Int8 |
Methods showsPrec :: Int -> Int8 -> ShowS # show :: Int8 -> String # showList :: [Int8] -> ShowS #
Ix Int8 |
Methods range :: (Int8, Int8) -> [Int8] # index :: (Int8, Int8) -> Int8 -> Int # unsafeIndex :: (Int8, Int8) -> Int8 -> Int inRange :: (Int8, Int8) -> Int8 -> Bool # rangeSize :: (Int8, Int8) -> Int # unsafeRangeSize :: (Int8, Int8) -> Int
PrintfArg Int8 |
Methods formatArg :: Int8 -> FieldFormatter # parseFormat :: Int8 -> ModifierParser #
Storable Int8 |
Methods sizeOf :: Int8 -> Int # alignment :: Int8 -> Int # peekElemOff :: Ptr Int8 -> Int -> IO Int8 # pokeElemOff :: Ptr Int8 -> Int -> Int8 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int8 # pokeByteOff :: Ptr b -> Int -> Int8 -> IO () # peek :: Ptr Int8 -> IO Int8 # poke :: Ptr Int8 -> Int8 -> IO () #
Bits Int8 |

Methods

(.&.) :: Int8 -> Int8 -> Int8 #

(.|.) :: Int8 -> Int8 -> Int8 #

xor :: Int8 -> Int8 -> Int8 #

complement :: Int8 -> Int8 #

shift :: Int8 -> Int -> Int8 #

rotate :: Int8 -> Int -> Int8 #

zeroBits :: Int8 #

bit :: Int -> Int8 #

setBit :: Int8 -> Int -> Int8 #

clearBit :: Int8 -> Int -> Int8 #

complementBit :: Int8 -> Int -> Int8 #

testBit :: Int8 -> Int -> Bool #

bitSizeMaybe :: Int8 -> Maybe Int #

bitSize :: Int8 -> Int #

isSigned :: Int8 -> Bool #

shiftL :: Int8 -> Int -> Int8 #

unsafeShiftL :: Int8 -> Int -> Int8 #

shiftR :: Int8 -> Int -> Int8 #

unsafeShiftR :: Int8 -> Int -> Int8 #

rotateL :: Int8 -> Int -> Int8 #

rotateR :: Int8 -> Int -> Int8 #

popCount :: Int8 -> Int #

FiniteBits Int8 |
Methods finiteBitSize :: Int8 -> Int # countLeadingZeros :: Int8 -> Int # countTrailingZeros :: Int8 -> Int #
PrimType Int8 |

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 () #

PrimMemoryComparable Int8 |
NormalForm Int8 |
Methods toNormalForm :: Int8 -> () #
Subtractive Int8 |
Associated Types type Difference Int8 :: * # Methods (-) :: Int8 -> Int8 -> Difference Int8 #
Multiplicative Int8 |
Methods midentity :: Int8 # (*) :: Int8 -> Int8 -> Int8 # (^) :: (IsNatural n, IDivisible n) => Int8 -> n -> Int8 #
IDivisible Int8 |
Methods div :: Int8 -> Int8 -> Int8 # mod :: Int8 -> Int8 -> Int8 # divMod :: Int8 -> Int8 -> (Int8, Int8) #
Additive Int8 |
Methods azero :: Int8 # (+) :: Int8 -> Int8 -> Int8 # scale :: IsNatural n => n -> Int8 -> Int8 #
IsIntegral Int8 |
Methods toInteger :: Int8 -> Integer #
Integral Int8 |
Methods fromInteger :: Integer -> Int8 #
HasNegation Int8 |
Methods negate :: Int8 -> Int8 #
Signed Int8 Source # |
Methods abs :: Int8 -> Int8 Source # signum :: Int8 -> Sign Source #
StorableFixed Int8 Source # |
Methods size :: proxy Int8 -> CountOf Word8 Source # alignment :: proxy Int8 -> CountOf Word8 Source #
Storable Int8 Source # |
Methods peek :: Ptr Int8 -> IO Int8 Source # poke :: Ptr Int8 -> Int8 -> IO () Source #
Hashable Int8 Source # |
Methods hashMix :: Hasher st => Int8 -> st -> st Source #
Arbitrary Int8 Source # |
Methods arbitrary :: Gen Int8 Source #
IntegralDownsize Int Int8 |
Methods integralDownsize :: Int -> Int8 # integralDownsizeCheck :: Int -> Maybe Int8 #
IntegralDownsize Int64 Int8 |
Methods integralDownsize :: Int64 -> Int8 # integralDownsizeCheck :: Int64 -> Maybe Int8 #
IntegralDownsize Integer Int8 |
Methods integralDownsize :: Integer -> Int8 # integralDownsizeCheck :: Integer -> Maybe Int8 #
IntegralUpsize Int8 Int |
Methods integralUpsize :: Int8 -> Int #
IntegralUpsize Int8 Int16 |
Methods integralUpsize :: Int8 -> Int16 #
IntegralUpsize Int8 Int32 |
Methods integralUpsize :: Int8 -> Int32 #
IntegralUpsize Int8 Int64 |
Methods integralUpsize :: Int8 -> Int64 #
IntegralCast Int8 Word8 |
Methods integralCast :: Int8 -> Word8 #
IntegralCast Word8 Int8 |
Methods integralCast :: Word8 -> Int8 #
type Difference Int8 |
type Difference Int8 = Int8
type NatNumMaxBound Int8 |
type NatNumMaxBound Int8 = 127

data Int16 :: * #

16-bit signed integer type

Instances

Bounded Int16 |
Methods minBound :: Int16 # maxBound :: Int16 #
Enum Int16 |
Methods succ :: Int16 -> Int16 # pred :: Int16 -> Int16 # toEnum :: Int -> Int16 # fromEnum :: Int16 -> Int # enumFrom :: Int16 -> [Int16] # enumFromThen :: Int16 -> Int16 -> [Int16] # enumFromTo :: Int16 -> Int16 -> [Int16] # enumFromThenTo :: Int16 -> Int16 -> Int16 -> [Int16] #
Eq Int16 |
Methods (==) :: Int16 -> Int16 -> Bool # (/=) :: Int16 -> Int16 -> Bool #
Integral Int16 |
Methods quot :: Int16 -> Int16 -> Int16 # rem :: Int16 -> Int16 -> Int16 # div :: Int16 -> Int16 -> Int16 # mod :: Int16 -> Int16 -> Int16 # quotRem :: Int16 -> Int16 -> (Int16, Int16) # divMod :: Int16 -> Int16 -> (Int16, Int16) # toInteger :: Int16 -> Integer #
Data Int16 |

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 #

toConstr :: Int16 -> Constr #

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 :: (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 #

Num Int16 |
Methods (+) :: Int16 -> Int16 -> Int16 # (-) :: Int16 -> Int16 -> Int16 # (*) :: Int16 -> Int16 -> Int16 # negate :: Int16 -> Int16 # abs :: Int16 -> Int16 # signum :: Int16 -> Int16 # fromInteger :: Integer -> Int16 #
Ord Int16 |
Methods compare :: Int16 -> Int16 -> Ordering # (<) :: Int16 -> Int16 -> Bool # (<=) :: Int16 -> Int16 -> Bool # (>) :: Int16 -> Int16 -> Bool # (>=) :: Int16 -> Int16 -> Bool # max :: Int16 -> Int16 -> Int16 # min :: Int16 -> Int16 -> Int16 #
Read Int16 |
Methods readsPrec :: Int -> ReadS Int16 # readList :: ReadS [Int16] # readPrec :: ReadPrec Int16 # readListPrec :: ReadPrec [Int16] #
Real Int16 |
Methods toRational :: Int16 -> Rational #
Show Int16 |
Methods showsPrec :: Int -> Int16 -> ShowS # show :: Int16 -> String # showList :: [Int16] -> ShowS #
Ix Int16 |
Methods range :: (Int16, Int16) -> [Int16] # index :: (Int16, Int16) -> Int16 -> Int # unsafeIndex :: (Int16, Int16) -> Int16 -> Int inRange :: (Int16, Int16) -> Int16 -> Bool # rangeSize :: (Int16, Int16) -> Int # unsafeRangeSize :: (Int16, Int16) -> Int
PrintfArg Int16 |
Methods formatArg :: Int16 -> FieldFormatter # parseFormat :: Int16 -> ModifierParser #
Storable Int16 |
Methods sizeOf :: Int16 -> Int # alignment :: Int16 -> Int # peekElemOff :: Ptr Int16 -> Int -> IO Int16 # pokeElemOff :: Ptr Int16 -> Int -> Int16 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int16 # pokeByteOff :: Ptr b -> Int -> Int16 -> IO () # peek :: Ptr Int16 -> IO Int16 # poke :: Ptr Int16 -> Int16 -> IO () #
Bits Int16 |

Methods

(.&.) :: Int16 -> Int16 -> Int16 #

(.|.) :: Int16 -> Int16 -> Int16 #

xor :: Int16 -> Int16 -> Int16 #

complement :: Int16 -> Int16 #

shift :: Int16 -> Int -> Int16 #

rotate :: Int16 -> Int -> Int16 #

zeroBits :: Int16 #

bit :: Int -> Int16 #

setBit :: Int16 -> Int -> Int16 #

clearBit :: Int16 -> Int -> Int16 #

complementBit :: Int16 -> Int -> Int16 #

testBit :: Int16 -> Int -> Bool #

bitSizeMaybe :: Int16 -> Maybe Int #

bitSize :: Int16 -> Int #

isSigned :: Int16 -> Bool #

shiftL :: Int16 -> Int -> Int16 #

unsafeShiftL :: Int16 -> Int -> Int16 #

shiftR :: Int16 -> Int -> Int16 #

unsafeShiftR :: Int16 -> Int -> Int16 #

rotateL :: Int16 -> Int -> Int16 #

rotateR :: Int16 -> Int -> Int16 #

popCount :: Int16 -> Int #

FiniteBits Int16 |
Methods finiteBitSize :: Int16 -> Int # countLeadingZeros :: Int16 -> Int # countTrailingZeros :: Int16 -> Int #
PrimType Int16 |

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 () #

PrimMemoryComparable Int16 |
NormalForm Int16 |
Methods toNormalForm :: Int16 -> () #
Subtractive Int16 |
Associated Types type Difference Int16 :: * # Methods (-) :: Int16 -> Int16 -> Difference Int16 #
Multiplicative Int16 |
Methods midentity :: Int16 # (*) :: Int16 -> Int16 -> Int16 # (^) :: (IsNatural n, IDivisible n) => Int16 -> n -> Int16 #
IDivisible Int16 |
Methods div :: Int16 -> Int16 -> Int16 # mod :: Int16 -> Int16 -> Int16 # divMod :: Int16 -> Int16 -> (Int16, Int16) #
Additive Int16 |
Methods azero :: Int16 # (+) :: Int16 -> Int16 -> Int16 # scale :: IsNatural n => n -> Int16 -> Int16 #
IsIntegral Int16 |
Methods toInteger :: Int16 -> Integer #
Integral Int16 |
Methods fromInteger :: Integer -> Int16 #
HasNegation Int16 |
Methods negate :: Int16 -> Int16 #
Signed Int16 Source # |
Methods abs :: Int16 -> Int16 Source # signum :: Int16 -> Sign Source #
StorableFixed Int16 Source # |
Methods size :: proxy Int16 -> CountOf Word8 Source # alignment :: proxy Int16 -> CountOf Word8 Source #
Storable Int16 Source # |
Methods peek :: Ptr Int16 -> IO Int16 Source # poke :: Ptr Int16 -> Int16 -> IO () Source #
Hashable Int16 Source # |
Methods hashMix :: Hasher st => Int16 -> st -> st Source #
Arbitrary Int16 Source # |
Methods arbitrary :: Gen Int16 Source #
IntegralDownsize Int Int16 |
Methods integralDownsize :: Int -> Int16 # integralDownsizeCheck :: Int -> Maybe Int16 #
IntegralDownsize Int64 Int16 |
Methods integralDownsize :: Int64 -> Int16 # integralDownsizeCheck :: Int64 -> Maybe Int16 #
IntegralDownsize Integer Int16 |
Methods integralDownsize :: Integer -> Int16 # integralDownsizeCheck :: Integer -> Maybe Int16 #
IntegralUpsize Int8 Int16 |
Methods integralUpsize :: Int8 -> Int16 #
IntegralUpsize Int16 Int |
Methods integralUpsize :: Int16 -> Int #
IntegralUpsize Int16 Int32 |
Methods integralUpsize :: Int16 -> Int32 #
IntegralUpsize Int16 Int64 |
Methods integralUpsize :: Int16 -> Int64 #
IntegralUpsize Word8 Int16 |
Methods integralUpsize :: Word8 -> Int16 #
IntegralCast Int16 Word16 |
Methods integralCast :: Int16 -> Word16 #
IntegralCast Word16 Int16 |
Methods integralCast :: Word16 -> Int16 #
type Difference Int16 |
type Difference Int16 = Int16
type NatNumMaxBound Int16 |
type NatNumMaxBound Int16 = 32767

data Int32 :: * #

32-bit signed integer type

Instances

Bounded Int32 |
Methods minBound :: Int32 # maxBound :: Int32 #
Enum Int32 |
Methods succ :: Int32 -> Int32 # pred :: Int32 -> Int32 # toEnum :: Int -> Int32 # fromEnum :: Int32 -> Int # enumFrom :: Int32 -> [Int32] # enumFromThen :: Int32 -> Int32 -> [Int32] # enumFromTo :: Int32 -> Int32 -> [Int32] # enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32] #
Eq Int32 |
Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Integral Int32 |
Methods quot :: Int32 -> Int32 -> Int32 # rem :: Int32 -> Int32 -> Int32 # div :: Int32 -> Int32 -> Int32 # mod :: Int32 -> Int32 -> Int32 # quotRem :: Int32 -> Int32 -> (Int32, Int32) # divMod :: Int32 -> Int32 -> (Int32, Int32) # toInteger :: Int32 -> Integer #
Data Int32 |

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 #

toConstr :: Int32 -> Constr #

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 :: (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 #

Num Int32 |
Methods (+) :: Int32 -> Int32 -> Int32 # (-) :: Int32 -> Int32 -> Int32 # (*) :: Int32 -> Int32 -> Int32 # negate :: Int32 -> Int32 # abs :: Int32 -> Int32 # signum :: Int32 -> Int32 # fromInteger :: Integer -> Int32 #
Ord Int32 |
Methods compare :: Int32 -> Int32 -> Ordering # (<) :: Int32 -> Int32 -> Bool # (<=) :: Int32 -> Int32 -> Bool # (>) :: Int32 -> Int32 -> Bool # (>=) :: Int32 -> Int32 -> Bool # max :: Int32 -> Int32 -> Int32 # min :: Int32 -> Int32 -> Int32 #
Read Int32 |
Methods readsPrec :: Int -> ReadS Int32 # readList :: ReadS [Int32] # readPrec :: ReadPrec Int32 # readListPrec :: ReadPrec [Int32] #
Real Int32 |
Methods toRational :: Int32 -> Rational #
Show Int32 |
Methods showsPrec :: Int -> Int32 -> ShowS # show :: Int32 -> String # showList :: [Int32] -> ShowS #
Ix Int32 |
Methods range :: (Int32, Int32) -> [Int32] # index :: (Int32, Int32) -> Int32 -> Int # unsafeIndex :: (Int32, Int32) -> Int32 -> Int inRange :: (Int32, Int32) -> Int32 -> Bool # rangeSize :: (Int32, Int32) -> Int # unsafeRangeSize :: (Int32, Int32) -> Int
PrintfArg Int32 |
Methods formatArg :: Int32 -> FieldFormatter # parseFormat :: Int32 -> ModifierParser #
Storable Int32 |
Methods sizeOf :: Int32 -> Int # alignment :: Int32 -> Int # peekElemOff :: Ptr Int32 -> Int -> IO Int32 # pokeElemOff :: Ptr Int32 -> Int -> Int32 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int32 # pokeByteOff :: Ptr b -> Int -> Int32 -> IO () # peek :: Ptr Int32 -> IO Int32 # poke :: Ptr Int32 -> Int32 -> IO () #
Bits Int32 |

Methods

(.&.) :: Int32 -> Int32 -> Int32 #

(.|.) :: Int32 -> Int32 -> Int32 #

xor :: Int32 -> Int32 -> Int32 #

complement :: Int32 -> Int32 #

shift :: Int32 -> Int -> Int32 #

rotate :: Int32 -> Int -> Int32 #

zeroBits :: Int32 #

bit :: Int -> Int32 #

setBit :: Int32 -> Int -> Int32 #

clearBit :: Int32 -> Int -> Int32 #

complementBit :: Int32 -> Int -> Int32 #

testBit :: Int32 -> Int -> Bool #

bitSizeMaybe :: Int32 -> Maybe Int #

bitSize :: Int32 -> Int #

isSigned :: Int32 -> Bool #

shiftL :: Int32 -> Int -> Int32 #

unsafeShiftL :: Int32 -> Int -> Int32 #

shiftR :: Int32 -> Int -> Int32 #

unsafeShiftR :: Int32 -> Int -> Int32 #

rotateL :: Int32 -> Int -> Int32 #

rotateR :: Int32 -> Int -> Int32 #

popCount :: Int32 -> Int #

FiniteBits Int32 |
Methods finiteBitSize :: Int32 -> Int # countLeadingZeros :: Int32 -> Int # countTrailingZeros :: Int32 -> Int #
PrimType Int32 |

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 () #

PrimMemoryComparable Int32 |
NormalForm Int32 |
Methods toNormalForm :: Int32 -> () #
Subtractive Int32 |
Associated Types type Difference Int32 :: * # Methods (-) :: Int32 -> Int32 -> Difference Int32 #
Multiplicative Int32 |
Methods midentity :: Int32 # (*) :: Int32 -> Int32 -> Int32 # (^) :: (IsNatural n, IDivisible n) => Int32 -> n -> Int32 #
IDivisible Int32 |
Methods div :: Int32 -> Int32 -> Int32 # mod :: Int32 -> Int32 -> Int32 # divMod :: Int32 -> Int32 -> (Int32, Int32) #
Additive Int32 |
Methods azero :: Int32 # (+) :: Int32 -> Int32 -> Int32 # scale :: IsNatural n => n -> Int32 -> Int32 #
IsIntegral Int32 |
Methods toInteger :: Int32 -> Integer #
Integral Int32 |
Methods fromInteger :: Integer -> Int32 #
HasNegation Int32 |
Methods negate :: Int32 -> Int32 #
Signed Int32 Source # |
Methods abs :: Int32 -> Int32 Source # signum :: Int32 -> Sign Source #
StorableFixed Int32 Source # |
Methods size :: proxy Int32 -> CountOf Word8 Source # alignment :: proxy Int32 -> CountOf Word8 Source #
Storable Int32 Source # |
Methods peek :: Ptr Int32 -> IO Int32 Source # poke :: Ptr Int32 -> Int32 -> IO () Source #
Hashable Int32 Source # |
Methods hashMix :: Hasher st => Int32 -> st -> st Source #
Arbitrary Int32 Source # |
Methods arbitrary :: Gen Int32 Source #
IntegralDownsize Int Int32 |
Methods integralDownsize :: Int -> Int32 # integralDownsizeCheck :: Int -> Maybe Int32 #
IntegralDownsize Int64 Int32 |
Methods integralDownsize :: Int64 -> Int32 # integralDownsizeCheck :: Int64 -> Maybe Int32 #
IntegralDownsize Integer Int32 |
Methods integralDownsize :: Integer -> Int32 # integralDownsizeCheck :: Integer -> Maybe Int32 #
IntegralUpsize Int8 Int32 |
Methods integralUpsize :: Int8 -> Int32 #
IntegralUpsize Int16 Int32 |
Methods integralUpsize :: Int16 -> Int32 #
IntegralUpsize Int32 Int |
Methods integralUpsize :: Int32 -> Int #
IntegralUpsize Int32 Int64 |
Methods integralUpsize :: Int32 -> Int64 #
IntegralUpsize Word8 Int32 |
Methods integralUpsize :: Word8 -> Int32 #
IntegralCast Int32 Word32 |
Methods integralCast :: Int32 -> Word32 #
IntegralCast Word32 Int32 |
Methods integralCast :: Word32 -> Int32 #
type Difference Int32 |
type Difference Int32 = Int32
type NatNumMaxBound Int32 |
type NatNumMaxBound Int32 = 2147483647

data Int64 :: * #

64-bit signed integer type

Instances

Bounded Int64 |
Methods minBound :: Int64 # maxBound :: Int64 #
Enum Int64 |
Methods succ :: Int64 -> Int64 # pred :: Int64 -> Int64 # toEnum :: Int -> Int64 # fromEnum :: Int64 -> Int # enumFrom :: Int64 -> [Int64] # enumFromThen :: Int64 -> Int64 -> [Int64] # enumFromTo :: Int64 -> Int64 -> [Int64] # enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64] #
Eq Int64 |
Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Integral Int64 |
Methods quot :: Int64 -> Int64 -> Int64 # rem :: Int64 -> Int64 -> Int64 # div :: Int64 -> Int64 -> Int64 # mod :: Int64 -> Int64 -> Int64 # quotRem :: Int64 -> Int64 -> (Int64, Int64) # divMod :: Int64 -> Int64 -> (Int64, Int64) # toInteger :: Int64 -> Integer #
Data Int64 |

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 #

toConstr :: Int64 -> Constr #

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 :: (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 #

Num Int64 |
Methods (+) :: Int64 -> Int64 -> Int64 # (-) :: Int64 -> Int64 -> Int64 # (*) :: Int64 -> Int64 -> Int64 # negate :: Int64 -> Int64 # abs :: Int64 -> Int64 # signum :: Int64 -> Int64 # fromInteger :: Integer -> Int64 #
Ord Int64 |
Methods compare :: Int64 -> Int64 -> Ordering # (<) :: Int64 -> Int64 -> Bool # (<=) :: Int64 -> Int64 -> Bool # (>) :: Int64 -> Int64 -> Bool # (>=) :: Int64 -> Int64 -> Bool # max :: Int64 -> Int64 -> Int64 # min :: Int64 -> Int64 -> Int64 #
Read Int64 |
Methods readsPrec :: Int -> ReadS Int64 # readList :: ReadS [Int64] # readPrec :: ReadPrec Int64 # readListPrec :: ReadPrec [Int64] #
Real Int64 |
Methods toRational :: Int64 -> Rational #
Show Int64 |
Methods showsPrec :: Int -> Int64 -> ShowS # show :: Int64 -> String # showList :: [Int64] -> ShowS #
Ix Int64 |
Methods range :: (Int64, Int64) -> [Int64] # index :: (Int64, Int64) -> Int64 -> Int # unsafeIndex :: (Int64, Int64) -> Int64 -> Int inRange :: (Int64, Int64) -> Int64 -> Bool # rangeSize :: (Int64, Int64) -> Int # unsafeRangeSize :: (Int64, Int64) -> Int
PrintfArg Int64 |
Methods formatArg :: Int64 -> FieldFormatter # parseFormat :: Int64 -> ModifierParser #
Storable Int64 |
Methods sizeOf :: Int64 -> Int # alignment :: Int64 -> Int # peekElemOff :: Ptr Int64 -> Int -> IO Int64 # pokeElemOff :: Ptr Int64 -> Int -> Int64 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int64 # pokeByteOff :: Ptr b -> Int -> Int64 -> IO () # peek :: Ptr Int64 -> IO Int64 # poke :: Ptr Int64 -> Int64 -> IO () #
Bits Int64 |

Methods

(.&.) :: Int64 -> Int64 -> Int64 #

(.|.) :: Int64 -> Int64 -> Int64 #

xor :: Int64 -> Int64 -> Int64 #

complement :: Int64 -> Int64 #

shift :: Int64 -> Int -> Int64 #

rotate :: Int64 -> Int -> Int64 #

zeroBits :: Int64 #

bit :: Int -> Int64 #

setBit :: Int64 -> Int -> Int64 #

clearBit :: Int64 -> Int -> Int64 #

complementBit :: Int64 -> Int -> Int64 #

testBit :: Int64 -> Int -> Bool #

bitSizeMaybe :: Int64 -> Maybe Int #

bitSize :: Int64 -> Int #

isSigned :: Int64 -> Bool #

shiftL :: Int64 -> Int -> Int64 #

unsafeShiftL :: Int64 -> Int -> Int64 #

shiftR :: Int64 -> Int -> Int64 #

unsafeShiftR :: Int64 -> Int -> Int64 #

rotateL :: Int64 -> Int -> Int64 #

rotateR :: Int64 -> Int -> Int64 #

popCount :: Int64 -> Int #

FiniteBits Int64 |
Methods finiteBitSize :: Int64 -> Int # countLeadingZeros :: Int64 -> Int # countTrailingZeros :: Int64 -> Int #
PrimType Int64 |

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 () #

PrimMemoryComparable Int64 |
NormalForm Int64 |
Methods toNormalForm :: Int64 -> () #
Subtractive Int64 |
Associated Types type Difference Int64 :: * # Methods (-) :: Int64 -> Int64 -> Difference Int64 #
Multiplicative Int64 |
Methods midentity :: Int64 # (*) :: Int64 -> Int64 -> Int64 # (^) :: (IsNatural n, IDivisible n) => Int64 -> n -> Int64 #
IDivisible Int64 |
Methods div :: Int64 -> Int64 -> Int64 # mod :: Int64 -> Int64 -> Int64 # divMod :: Int64 -> Int64 -> (Int64, Int64) #
Additive Int64 |
Methods azero :: Int64 # (+) :: Int64 -> Int64 -> Int64 # scale :: IsNatural n => n -> Int64 -> Int64 #
IsIntegral Int64 |
Methods toInteger :: Int64 -> Integer #
Integral Int64 |
Methods fromInteger :: Integer -> Int64 #
HasNegation Int64 |
Methods negate :: Int64 -> Int64 #
Signed Int64 Source # |
Methods abs :: Int64 -> Int64 Source # signum :: Int64 -> Sign Source #
StorableFixed Int64 Source # |
Methods size :: proxy Int64 -> CountOf Word8 Source # alignment :: proxy Int64 -> CountOf Word8 Source #
Storable Int64 Source # |
Methods peek :: Ptr Int64 -> IO Int64 Source # poke :: Ptr Int64 -> Int64 -> IO () Source #
Hashable Int64 Source # |
Methods hashMix :: Hasher st => Int64 -> st -> st Source #
Arbitrary Int64 Source # |
Methods arbitrary :: Gen Int64 Source #
IntegralDownsize Int64 Int |
Methods integralDownsize :: Int64 -> Int # integralDownsizeCheck :: Int64 -> Maybe Int #
IntegralDownsize Int64 Int8 |
Methods integralDownsize :: Int64 -> Int8 # integralDownsizeCheck :: Int64 -> Maybe Int8 #
IntegralDownsize Int64 Int16 |
Methods integralDownsize :: Int64 -> Int16 # integralDownsizeCheck :: Int64 -> Maybe Int16 #
IntegralDownsize Int64 Int32 |
Methods integralDownsize :: Int64 -> Int32 # integralDownsizeCheck :: Int64 -> Maybe Int32 #
IntegralDownsize Integer Int64 |
Methods integralDownsize :: Integer -> Int64 # integralDownsizeCheck :: Integer -> Maybe Int64 #
IntegralUpsize Int Int64 |
Methods integralUpsize :: Int -> Int64 #
IntegralUpsize Int8 Int64 |
Methods integralUpsize :: Int8 -> Int64 #
IntegralUpsize Int16 Int64 |
Methods integralUpsize :: Int16 -> Int64 #
IntegralUpsize Int32 Int64 |
Methods integralUpsize :: Int32 -> Int64 #
IntegralUpsize Word8 Int64 |
Methods integralUpsize :: Word8 -> Int64 #
IntegralCast Int64 Word64 |
Methods integralCast :: Int64 -> Word64 #
IntegralCast Word64 Int64 |
Methods integralCast :: Word64 -> Int64 #
type Difference Int64 |
type Difference Int64 = Int64
type NatNumMaxBound Int64 |
type NatNumMaxBound Int64 = 9223372036854775807

data Word8 :: * #

8-bit unsigned integer type

Instances

Bounded Word8 |
Methods minBound :: Word8 # maxBound :: Word8 #
Enum Word8 |
Methods succ :: Word8 -> Word8 # pred :: Word8 -> Word8 # toEnum :: Int -> Word8 # fromEnum :: Word8 -> Int # enumFrom :: Word8 -> [Word8] # enumFromThen :: Word8 -> Word8 -> [Word8] # enumFromTo :: Word8 -> Word8 -> [Word8] # enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8] #
Eq Word8 |
Methods (==) :: Word8 -> Word8 -> Bool # (/=) :: Word8 -> Word8 -> Bool #
Integral Word8 |
Methods quot :: Word8 -> Word8 -> Word8 # rem :: Word8 -> Word8 -> Word8 # div :: Word8 -> Word8 -> Word8 # mod :: Word8 -> Word8 -> Word8 # quotRem :: Word8 -> Word8 -> (Word8, Word8) # divMod :: Word8 -> Word8 -> (Word8, Word8) # toInteger :: Word8 -> Integer #
Data Word8 |

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 #

toConstr :: Word8 -> Constr #

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 :: (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 #

Num Word8 |
Methods (+) :: Word8 -> Word8 -> Word8 # (-) :: Word8 -> Word8 -> Word8 # (*) :: Word8 -> Word8 -> Word8 # negate :: Word8 -> Word8 # abs :: Word8 -> Word8 # signum :: Word8 -> Word8 # fromInteger :: Integer -> Word8 #
Ord Word8 |
Methods compare :: Word8 -> Word8 -> Ordering # (<) :: Word8 -> Word8 -> Bool # (<=) :: Word8 -> Word8 -> Bool # (>) :: Word8 -> Word8 -> Bool # (>=) :: Word8 -> Word8 -> Bool # max :: Word8 -> Word8 -> Word8 # min :: Word8 -> Word8 -> Word8 #
Read Word8 |
Methods readsPrec :: Int -> ReadS Word8 # readList :: ReadS [Word8] # readPrec :: ReadPrec Word8 # readListPrec :: ReadPrec [Word8] #
Real Word8 |
Methods toRational :: Word8 -> Rational #
Show Word8 |
Methods showsPrec :: Int -> Word8 -> ShowS # show :: Word8 -> String # showList :: [Word8] -> ShowS #
Ix Word8 |
Methods range :: (Word8, Word8) -> [Word8] # index :: (Word8, Word8) -> Word8 -> Int # unsafeIndex :: (Word8, Word8) -> Word8 -> Int inRange :: (Word8, Word8) -> Word8 -> Bool # rangeSize :: (Word8, Word8) -> Int # unsafeRangeSize :: (Word8, Word8) -> Int
PrintfArg Word8 |
Methods formatArg :: Word8 -> FieldFormatter # parseFormat :: Word8 -> ModifierParser #
Storable Word8 |
Methods sizeOf :: Word8 -> Int # alignment :: Word8 -> Int # peekElemOff :: Ptr Word8 -> Int -> IO Word8 # pokeElemOff :: Ptr Word8 -> Int -> Word8 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word8 # pokeByteOff :: Ptr b -> Int -> Word8 -> IO () # peek :: Ptr Word8 -> IO Word8 # poke :: Ptr Word8 -> Word8 -> IO () #
Bits Word8 |

Methods

(.&.) :: Word8 -> Word8 -> Word8 #

(.|.) :: Word8 -> Word8 -> Word8 #

xor :: Word8 -> Word8 -> Word8 #

complement :: Word8 -> Word8 #

shift :: Word8 -> Int -> Word8 #

rotate :: Word8 -> Int -> Word8 #

zeroBits :: Word8 #

bit :: Int -> Word8 #

setBit :: Word8 -> Int -> Word8 #

clearBit :: Word8 -> Int -> Word8 #

complementBit :: Word8 -> Int -> Word8 #

testBit :: Word8 -> Int -> Bool #

bitSizeMaybe :: Word8 -> Maybe Int #

bitSize :: Word8 -> Int #

isSigned :: Word8 -> Bool #

shiftL :: Word8 -> Int -> Word8 #

unsafeShiftL :: Word8 -> Int -> Word8 #

shiftR :: Word8 -> Int -> Word8 #

unsafeShiftR :: Word8 -> Int -> Word8 #

rotateL :: Word8 -> Int -> Word8 #

rotateR :: Word8 -> Int -> Word8 #

popCount :: Word8 -> Int #

FiniteBits Word8 |
Methods finiteBitSize :: Word8 -> Int # countLeadingZeros :: Word8 -> Int # countTrailingZeros :: Word8 -> Int #
PrimType Word8 |

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 () #

PrimMemoryComparable Word8 |
NormalForm Word8 |
Methods toNormalForm :: Word8 -> () #
Subtractive Word8 |
Associated Types type Difference Word8 :: * # Methods (-) :: Word8 -> Word8 -> Difference Word8 #
Multiplicative Word8 |
Methods midentity :: Word8 # (*) :: Word8 -> Word8 -> Word8 # (^) :: (IsNatural n, IDivisible n) => Word8 -> n -> Word8 #
IDivisible Word8 |
Methods div :: Word8 -> Word8 -> Word8 # mod :: Word8 -> Word8 -> Word8 # divMod :: Word8 -> Word8 -> (Word8, Word8) #
Additive Word8 |
Methods azero :: Word8 # (+) :: Word8 -> Word8 -> Word8 # scale :: IsNatural n => n -> Word8 -> Word8 #
IsIntegral Word8 |
Methods toInteger :: Word8 -> Integer #
IsNatural Word8 |
Methods toNatural :: Word8 -> Natural #
Integral Word8 |
Methods fromInteger :: Integer -> Word8 #
HasNegation Word8 |
Methods negate :: Word8 -> Word8 #
StorableFixed Word8 Source # |
Methods size :: proxy Word8 -> CountOf Word8 Source # alignment :: proxy Word8 -> CountOf Word8 Source #
Storable Word8 Source # |
Methods peek :: Ptr Word8 -> IO Word8 Source # poke :: Ptr Word8 -> Word8 -> IO () Source #
Hashable Word8 Source # |
Methods hashMix :: Hasher st => Word8 -> st -> st Source #
Arbitrary Word8 Source # |
Methods arbitrary :: Gen Word8 Source #
IntegralDownsize Integer Word8 |
Methods integralDownsize :: Integer -> Word8 # integralDownsizeCheck :: Integer -> Maybe Word8 #
IntegralDownsize Word Word8 |
Methods integralDownsize :: Word -> Word8 # integralDownsizeCheck :: Word -> Maybe Word8 #
IntegralDownsize Word16 Word8 |
Methods integralDownsize :: Word16 -> Word8 # integralDownsizeCheck :: Word16 -> Maybe Word8 #
IntegralDownsize Word32 Word8 |
Methods integralDownsize :: Word32 -> Word8 # integralDownsizeCheck :: Word32 -> Maybe Word8 #
IntegralDownsize Word64 Word8 |
Methods integralDownsize :: Word64 -> Word8 # integralDownsizeCheck :: Word64 -> Maybe Word8 #
IntegralDownsize Natural Word8 |
Methods integralDownsize :: Natural -> Word8 # integralDownsizeCheck :: Natural -> Maybe Word8 #
IntegralUpsize Word8 Int |
Methods integralUpsize :: Word8 -> Int #
IntegralUpsize Word8 Int16 |
Methods integralUpsize :: Word8 -> Int16 #
IntegralUpsize Word8 Int32 |
Methods integralUpsize :: Word8 -> Int32 #
IntegralUpsize Word8 Int64 |
Methods integralUpsize :: Word8 -> Int64 #
IntegralUpsize Word8 Word |
Methods integralUpsize :: Word8 -> Word #
IntegralUpsize Word8 Word16 |
Methods integralUpsize :: Word8 -> Word16 #
IntegralUpsize Word8 Word32 |
Methods integralUpsize :: Word8 -> Word32 #
IntegralUpsize Word8 Word64 |
Methods integralUpsize :: Word8 -> Word64 #
IntegralCast Int8 Word8 |
Methods integralCast :: Int8 -> Word8 #
IntegralCast Word8 Int8 |
Methods integralCast :: Word8 -> Int8 #
type Difference Word8 |
type Difference Word8 = Word8
type NatNumMaxBound Word8 |
type NatNumMaxBound Word8 = 255

data Word16 :: * #

16-bit unsigned integer type

Instances

Bounded Word16 |
Methods minBound :: Word16 # maxBound :: Word16 #
Enum Word16 |
Methods succ :: Word16 -> Word16 # pred :: Word16 -> Word16 # toEnum :: Int -> Word16 # fromEnum :: Word16 -> Int # enumFrom :: Word16 -> [Word16] # enumFromThen :: Word16 -> Word16 -> [Word16] # enumFromTo :: Word16 -> Word16 -> [Word16] # enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16] #
Eq Word16 |
Methods (==) :: Word16 -> Word16 -> Bool # (/=) :: Word16 -> Word16 -> Bool #
Integral Word16 |
Methods quot :: Word16 -> Word16 -> Word16 # rem :: Word16 -> Word16 -> Word16 # div :: Word16 -> Word16 -> Word16 # mod :: Word16 -> Word16 -> Word16 # quotRem :: Word16 -> Word16 -> (Word16, Word16) # divMod :: Word16 -> Word16 -> (Word16, Word16) # toInteger :: Word16 -> Integer #
Data Word16 |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word16 -> c Word16 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word16 #

toConstr :: Word16 -> Constr #

dataTypeOf :: Word16 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word16) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word16) #

gmapT :: (forall b. Data b => b -> b) -> Word16 -> Word16 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r #

gmapQr :: (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 #

Num Word16 |
Methods (+) :: Word16 -> Word16 -> Word16 # (-) :: Word16 -> Word16 -> Word16 # (*) :: Word16 -> Word16 -> Word16 # negate :: Word16 -> Word16 # abs :: Word16 -> Word16 # signum :: Word16 -> Word16 # fromInteger :: Integer -> Word16 #
Ord Word16 |
Methods compare :: Word16 -> Word16 -> Ordering # (<) :: Word16 -> Word16 -> Bool # (<=) :: Word16 -> Word16 -> Bool # (>) :: Word16 -> Word16 -> Bool # (>=) :: Word16 -> Word16 -> Bool # max :: Word16 -> Word16 -> Word16 # min :: Word16 -> Word16 -> Word16 #
Read Word16 |
Methods readsPrec :: Int -> ReadS Word16 # readList :: ReadS [Word16] # readPrec :: ReadPrec Word16 # readListPrec :: ReadPrec [Word16] #
Real Word16 |
Methods toRational :: Word16 -> Rational #
Show Word16 |
Methods showsPrec :: Int -> Word16 -> ShowS # show :: Word16 -> String # showList :: [Word16] -> ShowS #
Ix Word16 |
Methods range :: (Word16, Word16) -> [Word16] # index :: (Word16, Word16) -> Word16 -> Int # unsafeIndex :: (Word16, Word16) -> Word16 -> Int inRange :: (Word16, Word16) -> Word16 -> Bool # rangeSize :: (Word16, Word16) -> Int # unsafeRangeSize :: (Word16, Word16) -> Int
PrintfArg Word16 |
Methods formatArg :: Word16 -> FieldFormatter # parseFormat :: Word16 -> ModifierParser #
Storable Word16 |
Methods sizeOf :: Word16 -> Int # alignment :: Word16 -> Int # peekElemOff :: Ptr Word16 -> Int -> IO Word16 # pokeElemOff :: Ptr Word16 -> Int -> Word16 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word16 # pokeByteOff :: Ptr b -> Int -> Word16 -> IO () # peek :: Ptr Word16 -> IO Word16 # poke :: Ptr Word16 -> Word16 -> IO () #
Bits Word16 |

Methods

(.&.) :: Word16 -> Word16 -> Word16 #

(.|.) :: Word16 -> Word16 -> Word16 #

xor :: Word16 -> Word16 -> Word16 #

complement :: Word16 -> Word16 #

shift :: Word16 -> Int -> Word16 #

rotate :: Word16 -> Int -> Word16 #

zeroBits :: Word16 #

bit :: Int -> Word16 #

setBit :: Word16 -> Int -> Word16 #

clearBit :: Word16 -> Int -> Word16 #

complementBit :: Word16 -> Int -> Word16 #

testBit :: Word16 -> Int -> Bool #

bitSizeMaybe :: Word16 -> Maybe Int #

bitSize :: Word16 -> Int #

isSigned :: Word16 -> Bool #

shiftL :: Word16 -> Int -> Word16 #

unsafeShiftL :: Word16 -> Int -> Word16 #

shiftR :: Word16 -> Int -> Word16 #

unsafeShiftR :: Word16 -> Int -> Word16 #

rotateL :: Word16 -> Int -> Word16 #

rotateR :: Word16 -> Int -> Word16 #

popCount :: Word16 -> Int #

FiniteBits Word16 |
Methods finiteBitSize :: Word16 -> Int # countLeadingZeros :: Word16 -> Int # countTrailingZeros :: Word16 -> Int #
PrimType Word16 |

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 () #

PrimMemoryComparable Word16 |
NormalForm Word16 |
Methods toNormalForm :: Word16 -> () #
Subtractive Word16 |
Associated Types type Difference Word16 :: * # Methods (-) :: Word16 -> Word16 -> Difference Word16 #
Multiplicative Word16 |
Methods midentity :: Word16 # (*) :: Word16 -> Word16 -> Word16 # (^) :: (IsNatural n, IDivisible n) => Word16 -> n -> Word16 #
IDivisible Word16 |
Methods div :: Word16 -> Word16 -> Word16 # mod :: Word16 -> Word16 -> Word16 # divMod :: Word16 -> Word16 -> (Word16, Word16) #
Additive Word16 |
Methods azero :: Word16 # (+) :: Word16 -> Word16 -> Word16 # scale :: IsNatural n => n -> Word16 -> Word16 #
IsIntegral Word16 |
Methods toInteger :: Word16 -> Integer #
IsNatural Word16 |
Methods toNatural :: Word16 -> Natural #
ByteSwap Word16 |
Methods byteSwap :: Word16 -> Word16
Integral Word16 |
Methods fromInteger :: Integer -> Word16 #
HasNegation Word16 |
Methods negate :: Word16 -> Word16 #
StorableFixed Word16 Source # |
Methods size :: proxy Word16 -> CountOf Word8 Source # alignment :: proxy Word16 -> CountOf Word8 Source #
Storable Word16 Source # |
Methods peek :: Ptr Word16 -> IO Word16 Source # poke :: Ptr Word16 -> Word16 -> IO () Source #
Hashable Word16 Source # |
Methods hashMix :: Hasher st => Word16 -> st -> st Source #
Arbitrary Word16 Source # |
Methods arbitrary :: Gen Word16 Source #
IntegralDownsize Integer Word16 |
Methods integralDownsize :: Integer -> Word16 # integralDownsizeCheck :: Integer -> Maybe Word16 #
IntegralDownsize Word Word16 |
Methods integralDownsize :: Word -> Word16 # integralDownsizeCheck :: Word -> Maybe Word16 #
IntegralDownsize Word16 Word8 |
Methods integralDownsize :: Word16 -> Word8 # integralDownsizeCheck :: Word16 -> Maybe Word8 #
IntegralDownsize Word32 Word16 |
Methods integralDownsize :: Word32 -> Word16 # integralDownsizeCheck :: Word32 -> Maybe Word16 #
IntegralDownsize Word64 Word16 |
Methods integralDownsize :: Word64 -> Word16 # integralDownsizeCheck :: Word64 -> Maybe Word16 #
IntegralDownsize Natural Word16 |
Methods integralDownsize :: Natural -> Word16 # integralDownsizeCheck :: Natural -> Maybe Word16 #
IntegralUpsize Word8 Word16 |
Methods integralUpsize :: Word8 -> Word16 #
IntegralUpsize Word16 Word |
Methods integralUpsize :: Word16 -> Word #
IntegralUpsize Word16 Word32 |
Methods integralUpsize :: Word16 -> Word32 #
IntegralUpsize Word16 Word64 |
Methods integralUpsize :: Word16 -> Word64 #
IntegralCast Int16 Word16 |
Methods integralCast :: Int16 -> Word16 #
IntegralCast Word16 Int16 |
Methods integralCast :: Word16 -> Int16 #
StorableFixed (LE Word16) Source # |
Methods size :: proxy (LE Word16) -> CountOf Word8 Source # alignment :: proxy (LE Word16) -> CountOf Word8 Source #
StorableFixed (BE Word16) Source # |
Methods size :: proxy (BE Word16) -> CountOf Word8 Source # alignment :: proxy (BE Word16) -> CountOf Word8 Source #
Storable (LE Word16) Source # |
Methods peek :: Ptr (LE Word16) -> IO (LE Word16) Source # poke :: Ptr (LE Word16) -> LE Word16 -> IO () Source #
Storable (BE Word16) Source # |
Methods peek :: Ptr (BE Word16) -> IO (BE Word16) Source # poke :: Ptr (BE Word16) -> BE Word16 -> IO () Source #
type Difference Word16 |
type Difference Word16 = Word16
type NatNumMaxBound Word16 |
type NatNumMaxBound Word16 = 65535

data Word32 :: * #

32-bit unsigned integer type

Instances

Bounded Word32 |
Methods minBound :: Word32 # maxBound :: Word32 #
Enum Word32 |
Methods succ :: Word32 -> Word32 # pred :: Word32 -> Word32 # toEnum :: Int -> Word32 # fromEnum :: Word32 -> Int # enumFrom :: Word32 -> [Word32] # enumFromThen :: Word32 -> Word32 -> [Word32] # enumFromTo :: Word32 -> Word32 -> [Word32] # enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32] #
Eq Word32 |
Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Integral Word32 |
Methods quot :: Word32 -> Word32 -> Word32 # rem :: Word32 -> Word32 -> Word32 # div :: Word32 -> Word32 -> Word32 # mod :: Word32 -> Word32 -> Word32 # quotRem :: Word32 -> Word32 -> (Word32, Word32) # divMod :: Word32 -> Word32 -> (Word32, Word32) # toInteger :: Word32 -> Integer #
Data Word32 |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word32 -> c Word32 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word32 #

toConstr :: Word32 -> Constr #

dataTypeOf :: Word32 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word32) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word32) #

gmapT :: (forall b. Data b => b -> b) -> Word32 -> Word32 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r #

gmapQr :: (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 #

Num Word32 |
Methods (+) :: Word32 -> Word32 -> Word32 # (-) :: Word32 -> Word32 -> Word32 # (*) :: Word32 -> Word32 -> Word32 # negate :: Word32 -> Word32 # abs :: Word32 -> Word32 # signum :: Word32 -> Word32 # fromInteger :: Integer -> Word32 #
Ord Word32 |
Methods compare :: Word32 -> Word32 -> Ordering # (<) :: Word32 -> Word32 -> Bool # (<=) :: Word32 -> Word32 -> Bool # (>) :: Word32 -> Word32 -> Bool # (>=) :: Word32 -> Word32 -> Bool # max :: Word32 -> Word32 -> Word32 # min :: Word32 -> Word32 -> Word32 #
Read Word32 |
Methods readsPrec :: Int -> ReadS Word32 # readList :: ReadS [Word32] # readPrec :: ReadPrec Word32 # readListPrec :: ReadPrec [Word32] #
Real Word32 |
Methods toRational :: Word32 -> Rational #
Show Word32 |
Methods showsPrec :: Int -> Word32 -> ShowS # show :: Word32 -> String # showList :: [Word32] -> ShowS #
Ix Word32 |
Methods range :: (Word32, Word32) -> [Word32] # index :: (Word32, Word32) -> Word32 -> Int # unsafeIndex :: (Word32, Word32) -> Word32 -> Int inRange :: (Word32, Word32) -> Word32 -> Bool # rangeSize :: (Word32, Word32) -> Int # unsafeRangeSize :: (Word32, Word32) -> Int
PrintfArg Word32 |
Methods formatArg :: Word32 -> FieldFormatter # parseFormat :: Word32 -> ModifierParser #
Storable Word32 |
Methods sizeOf :: Word32 -> Int # alignment :: Word32 -> Int # peekElemOff :: Ptr Word32 -> Int -> IO Word32 # pokeElemOff :: Ptr Word32 -> Int -> Word32 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word32 # pokeByteOff :: Ptr b -> Int -> Word32 -> IO () # peek :: Ptr Word32 -> IO Word32 # poke :: Ptr Word32 -> Word32 -> IO () #
Bits Word32 |

Methods

(.&.) :: Word32 -> Word32 -> Word32 #

(.|.) :: Word32 -> Word32 -> Word32 #

xor :: Word32 -> Word32 -> Word32 #

complement :: Word32 -> Word32 #

shift :: Word32 -> Int -> Word32 #

rotate :: Word32 -> Int -> Word32 #

zeroBits :: Word32 #

bit :: Int -> Word32 #

setBit :: Word32 -> Int -> Word32 #

clearBit :: Word32 -> Int -> Word32 #

complementBit :: Word32 -> Int -> Word32 #

testBit :: Word32 -> Int -> Bool #

bitSizeMaybe :: Word32 -> Maybe Int #

bitSize :: Word32 -> Int #

isSigned :: Word32 -> Bool #

shiftL :: Word32 -> Int -> Word32 #

unsafeShiftL :: Word32 -> Int -> Word32 #

shiftR :: Word32 -> Int -> Word32 #

unsafeShiftR :: Word32 -> Int -> Word32 #

rotateL :: Word32 -> Int -> Word32 #

rotateR :: Word32 -> Int -> Word32 #

popCount :: Word32 -> Int #

FiniteBits Word32 |
Methods finiteBitSize :: Word32 -> Int # countLeadingZeros :: Word32 -> Int # countTrailingZeros :: Word32 -> Int #
PrimType Word32 |

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 () #

PrimMemoryComparable Word32 |
NormalForm Word32 |
Methods toNormalForm :: Word32 -> () #
Subtractive Word32 |
Associated Types type Difference Word32 :: * # Methods (-) :: Word32 -> Word32 -> Difference Word32 #
Multiplicative Word32 |
Methods midentity :: Word32 # (*) :: Word32 -> Word32 -> Word32 # (^) :: (IsNatural n, IDivisible n) => Word32 -> n -> Word32 #
IDivisible Word32 |
Methods div :: Word32 -> Word32 -> Word32 # mod :: Word32 -> Word32 -> Word32 # divMod :: Word32 -> Word32 -> (Word32, Word32) #
Additive Word32 |
Methods azero :: Word32 # (+) :: Word32 -> Word32 -> Word32 # scale :: IsNatural n => n -> Word32 -> Word32 #
IsIntegral Word32 |
Methods toInteger :: Word32 -> Integer #
IsNatural Word32 |
Methods toNatural :: Word32 -> Natural #
ByteSwap Word32 |
Methods byteSwap :: Word32 -> Word32
Integral Word32 |
Methods fromInteger :: Integer -> Word32 #
HasNegation Word32 |
Methods negate :: Word32 -> Word32 #
StorableFixed Word32 Source # |
Methods size :: proxy Word32 -> CountOf Word8 Source # alignment :: proxy Word32 -> CountOf Word8 Source #
Storable Word32 Source # |
Methods peek :: Ptr Word32 -> IO Word32 Source # poke :: Ptr Word32 -> Word32 -> IO () Source #
Hashable Word32 Source # |
Methods hashMix :: Hasher st => Word32 -> st -> st Source #
Arbitrary Word32 Source # |
Methods arbitrary :: Gen Word32 Source #
IntegralDownsize Integer Word32 |
Methods integralDownsize :: Integer -> Word32 # integralDownsizeCheck :: Integer -> Maybe Word32 #
IntegralDownsize Word Word32 |
Methods integralDownsize :: Word -> Word32 # integralDownsizeCheck :: Word -> Maybe Word32 #
IntegralDownsize Word32 Word8 |
Methods integralDownsize :: Word32 -> Word8 # integralDownsizeCheck :: Word32 -> Maybe Word8 #
IntegralDownsize Word32 Word16 |
Methods integralDownsize :: Word32 -> Word16 # integralDownsizeCheck :: Word32 -> Maybe Word16 #
IntegralDownsize Word64 Word32 |
Methods integralDownsize :: Word64 -> Word32 # integralDownsizeCheck :: Word64 -> Maybe Word32 #
IntegralDownsize Natural Word32 |
Methods integralDownsize :: Natural -> Word32 # integralDownsizeCheck :: Natural -> Maybe Word32 #
IntegralUpsize Word8 Word32 |
Methods integralUpsize :: Word8 -> Word32 #
IntegralUpsize Word16 Word32 |
Methods integralUpsize :: Word16 -> Word32 #
IntegralUpsize Word32 Word |
Methods integralUpsize :: Word32 -> Word #
IntegralUpsize Word32 Word64 |
Methods integralUpsize :: Word32 -> Word64 #
IntegralCast Int32 Word32 |
Methods integralCast :: Int32 -> Word32 #
IntegralCast Word32 Int32 |
Methods integralCast :: Word32 -> Int32 #
StorableFixed (LE Word32) Source # |
Methods size :: proxy (LE Word32) -> CountOf Word8 Source # alignment :: proxy (LE Word32) -> CountOf Word8 Source #
StorableFixed (BE Word32) Source # |
Methods size :: proxy (BE Word32) -> CountOf Word8 Source # alignment :: proxy (BE Word32) -> CountOf Word8 Source #
Storable (LE Word32) Source # |
Methods peek :: Ptr (LE Word32) -> IO (LE Word32) Source # poke :: Ptr (LE Word32) -> LE Word32 -> IO () Source #
Storable (BE Word32) Source # |
Methods peek :: Ptr (BE Word32) -> IO (BE Word32) Source # poke :: Ptr (BE Word32) -> BE Word32 -> IO () Source #
type Difference Word32 |
type Difference Word32 = Word32
type NatNumMaxBound Word32 |
type NatNumMaxBound Word32 = 4294967295

data Word64 :: * #

64-bit unsigned integer type

Instances

Bounded Word64 |
Methods minBound :: Word64 # maxBound :: Word64 #
Enum Word64 |
Methods succ :: Word64 -> Word64 # pred :: Word64 -> Word64 # toEnum :: Int -> Word64 # fromEnum :: Word64 -> Int # enumFrom :: Word64 -> [Word64] # enumFromThen :: Word64 -> Word64 -> [Word64] # enumFromTo :: Word64 -> Word64 -> [Word64] # enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64] #
Eq Word64 |
Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Integral Word64 |
Methods quot :: Word64 -> Word64 -> Word64 # rem :: Word64 -> Word64 -> Word64 # div :: Word64 -> Word64 -> Word64 # mod :: Word64 -> Word64 -> Word64 # quotRem :: Word64 -> Word64 -> (Word64, Word64) # divMod :: Word64 -> Word64 -> (Word64, Word64) # toInteger :: Word64 -> Integer #
Data Word64 |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word64 -> c Word64 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word64 #

toConstr :: Word64 -> Constr #

dataTypeOf :: Word64 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word64) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word64) #

gmapT :: (forall b. Data b => b -> b) -> Word64 -> Word64 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r #

gmapQr :: (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 #

Num Word64 |
Methods (+) :: Word64 -> Word64 -> Word64 # (-) :: Word64 -> Word64 -> Word64 # (*) :: Word64 -> Word64 -> Word64 # negate :: Word64 -> Word64 # abs :: Word64 -> Word64 # signum :: Word64 -> Word64 # fromInteger :: Integer -> Word64 #
Ord Word64 |
Methods compare :: Word64 -> Word64 -> Ordering # (<) :: Word64 -> Word64 -> Bool # (<=) :: Word64 -> Word64 -> Bool # (>) :: Word64 -> Word64 -> Bool # (>=) :: Word64 -> Word64 -> Bool # max :: Word64 -> Word64 -> Word64 # min :: Word64 -> Word64 -> Word64 #
Read Word64 |
Methods readsPrec :: Int -> ReadS Word64 # readList :: ReadS [Word64] # readPrec :: ReadPrec Word64 # readListPrec :: ReadPrec [Word64] #
Real Word64 |
Methods toRational :: Word64 -> Rational #
Show Word64 |
Methods showsPrec :: Int -> Word64 -> ShowS # show :: Word64 -> String # showList :: [Word64] -> ShowS #
Ix Word64 |
Methods range :: (Word64, Word64) -> [Word64] # index :: (Word64, Word64) -> Word64 -> Int # unsafeIndex :: (Word64, Word64) -> Word64 -> Int inRange :: (Word64, Word64) -> Word64 -> Bool # rangeSize :: (Word64, Word64) -> Int # unsafeRangeSize :: (Word64, Word64) -> Int
PrintfArg Word64 |
Methods formatArg :: Word64 -> FieldFormatter # parseFormat :: Word64 -> ModifierParser #
Storable Word64 |
Methods sizeOf :: Word64 -> Int # alignment :: Word64 -> Int # peekElemOff :: Ptr Word64 -> Int -> IO Word64 # pokeElemOff :: Ptr Word64 -> Int -> Word64 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word64 # pokeByteOff :: Ptr b -> Int -> Word64 -> IO () # peek :: Ptr Word64 -> IO Word64 # poke :: Ptr Word64 -> Word64 -> IO () #
Bits Word64 |

Methods

(.&.) :: Word64 -> Word64 -> Word64 #

(.|.) :: Word64 -> Word64 -> Word64 #

xor :: Word64 -> Word64 -> Word64 #

complement :: Word64 -> Word64 #

shift :: Word64 -> Int -> Word64 #

rotate :: Word64 -> Int -> Word64 #

zeroBits :: Word64 #

bit :: Int -> Word64 #

setBit :: Word64 -> Int -> Word64 #

clearBit :: Word64 -> Int -> Word64 #

complementBit :: Word64 -> Int -> Word64 #

testBit :: Word64 -> Int -> Bool #

bitSizeMaybe :: Word64 -> Maybe Int #

bitSize :: Word64 -> Int #

isSigned :: Word64 -> Bool #

shiftL :: Word64 -> Int -> Word64 #

unsafeShiftL :: Word64 -> Int -> Word64 #

shiftR :: Word64 -> Int -> Word64 #

unsafeShiftR :: Word64 -> Int -> Word64 #

rotateL :: Word64 -> Int -> Word64 #

rotateR :: Word64 -> Int -> Word64 #

popCount :: Word64 -> Int #

FiniteBits Word64 |
Methods finiteBitSize :: Word64 -> Int # countLeadingZeros :: Word64 -> Int # countTrailingZeros :: Word64 -> Int #
PrimType Word64 |

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 () #

PrimMemoryComparable Word64 |
NormalForm Word64 |
Methods toNormalForm :: Word64 -> () #
Subtractive Word64 |
Associated Types type Difference Word64 :: * # Methods (-) :: Word64 -> Word64 -> Difference Word64 #
Multiplicative Word64 |
Methods midentity :: Word64 # (*) :: Word64 -> Word64 -> Word64 # (^) :: (IsNatural n, IDivisible n) => Word64 -> n -> Word64 #
IDivisible Word64 |
Methods div :: Word64 -> Word64 -> Word64 # mod :: Word64 -> Word64 -> Word64 # divMod :: Word64 -> Word64 -> (Word64, Word64) #
Additive Word64 |
Methods azero :: Word64 # (+) :: Word64 -> Word64 -> Word64 # scale :: IsNatural n => n -> Word64 -> Word64 #
IsIntegral Word64 |
Methods toInteger :: Word64 -> Integer #
IsNatural Word64 |
Methods toNatural :: Word64 -> Natural #
ByteSwap Word64 |
Methods byteSwap :: Word64 -> Word64
Integral Word64 |
Methods fromInteger :: Integer -> Word64 #
HasNegation Word64 |
Methods negate :: Word64 -> Word64 #
StorableFixed Word64 Source # |
Methods size :: proxy Word64 -> CountOf Word8 Source # alignment :: proxy Word64 -> CountOf Word8 Source #
Storable Word64 Source # |
Methods peek :: Ptr Word64 -> IO Word64 Source # poke :: Ptr Word64 -> Word64 -> IO () Source #
Hashable Word64 Source # |
Methods hashMix :: Hasher st => Word64 -> st -> st Source #
Arbitrary Word64 Source # |
Methods arbitrary :: Gen Word64 Source #
IntegralDownsize Integer Word64 |
Methods integralDownsize :: Integer -> Word64 # integralDownsizeCheck :: Integer -> Maybe Word64 #
IntegralDownsize Word64 Word8 |
Methods integralDownsize :: Word64 -> Word8 # integralDownsizeCheck :: Word64 -> Maybe Word8 #
IntegralDownsize Word64 Word16 |
Methods integralDownsize :: Word64 -> Word16 # integralDownsizeCheck :: Word64 -> Maybe Word16 #
IntegralDownsize Word64 Word32 |
Methods integralDownsize :: Word64 -> Word32 # integralDownsizeCheck :: Word64 -> Maybe Word32 #
IntegralDownsize Natural Word64 |
Methods integralDownsize :: Natural -> Word64 # integralDownsizeCheck :: Natural -> Maybe Word64 #
IntegralUpsize Word Word64 |
Methods integralUpsize :: Word -> Word64 #
IntegralUpsize Word8 Word64 |
Methods integralUpsize :: Word8 -> Word64 #
IntegralUpsize Word16 Word64 |
Methods integralUpsize :: Word16 -> Word64 #
IntegralUpsize Word32 Word64 |
Methods integralUpsize :: Word32 -> Word64 #
IntegralCast Int64 Word64 |
Methods integralCast :: Int64 -> Word64 #
IntegralCast Word64 Int64 |
Methods integralCast :: Word64 -> Int64 #
StorableFixed (LE Word64) Source # |
Methods size :: proxy (LE Word64) -> CountOf Word8 Source # alignment :: proxy (LE Word64) -> CountOf Word8 Source #
StorableFixed (BE Word64) Source # |
Methods size :: proxy (BE Word64) -> CountOf Word8 Source # alignment :: proxy (BE Word64) -> CountOf Word8 Source #
Storable (LE Word64) Source # |
Methods peek :: Ptr (LE Word64) -> IO (LE Word64) Source # poke :: Ptr (LE Word64) -> LE Word64 -> IO () Source #
Storable (BE Word64) Source # |
Methods peek :: Ptr (BE Word64) -> IO (BE Word64) Source # poke :: Ptr (BE Word64) -> BE Word64 -> IO () Source #
type Difference Word64 |
type Difference Word64 = Word64
type NatNumMaxBound Word64 |
type NatNumMaxBound Word64 = 18446744073709551615

data Word :: * #

A `Word` is an unsigned integral type, with the same size as `Int`.

Instances

Bounded Word |
Methods minBound :: Word # maxBound :: Word #
Enum Word |
Methods succ :: Word -> Word # pred :: Word -> Word # toEnum :: Int -> Word # fromEnum :: Word -> Int # enumFrom :: Word -> [Word] # enumFromThen :: Word -> Word -> [Word] # enumFromTo :: Word -> Word -> [Word] # enumFromThenTo :: Word -> Word -> Word -> [Word] #
Eq Word |
Methods (==) :: Word -> Word -> Bool # (/=) :: Word -> Word -> Bool #
Integral Word |
Methods quot :: Word -> Word -> Word # rem :: Word -> Word -> Word # div :: Word -> Word -> Word # mod :: Word -> Word -> Word # quotRem :: Word -> Word -> (Word, Word) # divMod :: Word -> Word -> (Word, Word) # toInteger :: Word -> Integer #
Data Word |

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 #

toConstr :: Word -> Constr #

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 :: (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 #

Num Word |
Methods (+) :: Word -> Word -> Word # (-) :: Word -> Word -> Word # (*) :: Word -> Word -> Word # negate :: Word -> Word # abs :: Word -> Word # signum :: Word -> Word # fromInteger :: Integer -> Word #
Ord Word |
Methods compare :: Word -> Word -> Ordering # (<) :: Word -> Word -> Bool # (<=) :: Word -> Word -> Bool # (>) :: Word -> Word -> Bool # (>=) :: Word -> Word -> Bool # max :: Word -> Word -> Word # min :: Word -> Word -> Word #
Read Word |
Methods readsPrec :: Int -> ReadS Word # readList :: ReadS [Word] # readPrec :: ReadPrec Word # readListPrec :: ReadPrec [Word] #
Real Word |
Methods toRational :: Word -> Rational #
Show Word |
Methods showsPrec :: Int -> Word -> ShowS # show :: Word -> String # showList :: [Word] -> ShowS #
Ix Word |
Methods range :: (Word, Word) -> [Word] # index :: (Word, Word) -> Word -> Int # unsafeIndex :: (Word, Word) -> Word -> Int inRange :: (Word, Word) -> Word -> Bool # rangeSize :: (Word, Word) -> Int # unsafeRangeSize :: (Word, Word) -> Int
PrintfArg Word |
Methods formatArg :: Word -> FieldFormatter # parseFormat :: Word -> ModifierParser #
Storable Word |
Methods sizeOf :: Word -> Int # alignment :: Word -> Int # peekElemOff :: Ptr Word -> Int -> IO Word # pokeElemOff :: Ptr Word -> Int -> Word -> IO () # peekByteOff :: Ptr b -> Int -> IO Word # pokeByteOff :: Ptr b -> Int -> Word -> IO () # peek :: Ptr Word -> IO Word # poke :: Ptr Word -> Word -> IO () #
Bits Word |

Methods

(.&.) :: Word -> Word -> Word #

(.|.) :: Word -> Word -> Word #

xor :: Word -> Word -> Word #

complement :: Word -> Word #

shift :: Word -> Int -> Word #

rotate :: Word -> Int -> Word #

zeroBits :: Word #

bit :: Int -> Word #

setBit :: Word -> Int -> Word #

clearBit :: Word -> Int -> Word #

complementBit :: Word -> Int -> Word #

testBit :: Word -> Int -> Bool #

bitSizeMaybe :: Word -> Maybe Int #

bitSize :: Word -> Int #

isSigned :: Word -> Bool #

shiftL :: Word -> Int -> Word #

unsafeShiftL :: Word -> Int -> Word #

shiftR :: Word -> Int -> Word #

unsafeShiftR :: Word -> Int -> Word #

rotateL :: Word -> Int -> Word #

rotateR :: Word -> Int -> Word #

popCount :: Word -> Int #

FiniteBits Word |
Methods finiteBitSize :: Word -> Int # countLeadingZeros :: Word -> Int # countTrailingZeros :: Word -> Int #
PrimType Word |

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 () #

PrimMemoryComparable Word |
NormalForm Word |
Methods toNormalForm :: Word -> () #
Subtractive Word |
Associated Types type Difference Word :: * # Methods (-) :: Word -> Word -> Difference Word #
Multiplicative Word |
Methods midentity :: Word # (*) :: Word -> Word -> Word # (^) :: (IsNatural n, IDivisible n) => Word -> n -> Word #
IDivisible Word |
Methods div :: Word -> Word -> Word # mod :: Word -> Word -> Word # divMod :: Word -> Word -> (Word, Word) #
Additive Word |
Methods azero :: Word # (+) :: Word -> Word -> Word # scale :: IsNatural n => n -> Word -> Word #
IsIntegral Word |
Methods toInteger :: Word -> Integer #
IsNatural Word |
Methods toNatural :: Word -> Natural #
Integral Word |
Methods fromInteger :: Integer -> Word #
HasNegation Word |
Methods negate :: Word -> Word #
Arbitrary Word Source # |
Methods arbitrary :: Gen Word Source #
IntegralDownsize Word Word8 |
Methods integralDownsize :: Word -> Word8 # integralDownsizeCheck :: Word -> Maybe Word8 #
IntegralDownsize Word Word16 |
Methods integralDownsize :: Word -> Word16 # integralDownsizeCheck :: Word -> Maybe Word16 #
IntegralDownsize Word Word32 |
Methods integralDownsize :: Word -> Word32 # integralDownsizeCheck :: Word -> Maybe Word32 #
IntegralUpsize Word Word64 |
Methods integralUpsize :: Word -> Word64 #
IntegralUpsize Word8 Word |
Methods integralUpsize :: Word8 -> Word #
IntegralUpsize Word16 Word |
Methods integralUpsize :: Word16 -> Word #
IntegralUpsize Word32 Word |
Methods integralUpsize :: Word32 -> Word #
IntegralCast Int Word |
Methods integralCast :: Int -> Word #
IntegralCast Word Int |
Methods integralCast :: Word -> Int #
IntegralCast Word (Offset ty) |
Methods integralCast :: Word -> Offset ty #
IntegralCast Word (CountOf ty) |
Methods integralCast :: Word -> CountOf ty #
Functor (URec Word) |
Methods fmap :: (a -> b) -> URec Word a -> URec Word b # (<$) :: a -> URec Word b -> URec Word a #
Foldable (URec Word) |

Methods

fold :: Monoid m => URec Word m -> m #

foldMap :: Monoid m => (a -> m) -> URec Word a -> m #

foldr :: (a -> b -> b) -> b -> URec Word a -> b #

foldr' :: (a -> b -> b) -> b -> URec Word a -> b #

foldl :: (b -> a -> b) -> b -> URec Word a -> b #

foldl' :: (b -> a -> b) -> b -> URec Word a -> b #

foldr1 :: (a -> a -> a) -> URec Word a -> a #

foldl1 :: (a -> a -> a) -> URec Word a -> a #

toList :: URec Word a -> [a] #

null :: URec Word a -> Bool #

length :: URec Word a -> Int #

elem :: Eq a => a -> URec Word a -> Bool #

maximum :: Ord a => URec Word a -> a #

minimum :: Ord a => URec Word a -> a #

sum :: Num a => URec Word a -> a #

product :: Num a => URec Word a -> a #

Traversable (URec Word) |
Methods traverse :: Applicative f => (a -> f b) -> URec Word a -> f (URec Word b) # sequenceA :: Applicative f => URec Word (f a) -> f (URec Word a) # mapM :: Monad m => (a -> m b) -> URec Word a -> m (URec Word b) # sequence :: Monad m => URec Word (m a) -> m (URec Word a) #
Generic1 (URec Word) |
Associated Types type Rep1 (URec Word :: * -> *) :: * -> * # Methods from1 :: URec Word a -> Rep1 (URec Word) a # to1 :: Rep1 (URec Word) a -> URec Word a #
Eq (URec Word p) |
Methods (==) :: URec Word p -> URec Word p -> Bool # (/=) :: URec Word p -> URec Word p -> Bool #
Ord (URec Word p) |
Methods compare :: URec Word p -> URec Word p -> Ordering # (<) :: URec Word p -> URec Word p -> Bool # (<=) :: URec Word p -> URec Word p -> Bool # (>) :: URec Word p -> URec Word p -> Bool # (>=) :: URec Word p -> URec Word p -> Bool # max :: URec Word p -> URec Word p -> URec Word p # min :: URec Word p -> URec Word p -> URec Word p #
Show (URec Word p) |
Methods showsPrec :: Int -> URec Word p -> ShowS # show :: URec Word p -> String # showList :: [URec Word p] -> ShowS #
Generic (URec Word p) |
Associated Types type Rep (URec Word p) :: * -> * # Methods from :: URec Word p -> Rep (URec Word p) x # to :: Rep (URec Word p) x -> URec Word p #
data URec Word | Used for marking occurrences of `Word#`

data URec Word = UWord {

- uWord# :: Word#

}

type Difference Word |
type Difference Word = Word
type NatNumMaxBound Word |
type NatNumMaxBound Word = NatNumMaxBound Word64
type Rep1 (URec Word) |
type Rep1 (URec Word) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UWord" PrefixI True) (S1 (MetaSel (Just Symbol "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UWord))
type Rep (URec Word p) |
type Rep (URec Word p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UWord" PrefixI True) (S1 (MetaSel (Just Symbol "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UWord))

data Word128 :: * #

128 bits Word

Instances

Bounded Word128 |
Methods minBound :: Word128 # maxBound :: Word128 #
Enum Word128 |
Methods succ :: Word128 -> Word128 # pred :: Word128 -> Word128 # toEnum :: Int -> Word128 # fromEnum :: Word128 -> Int # enumFrom :: Word128 -> [Word128] # enumFromThen :: Word128 -> Word128 -> [Word128] # enumFromTo :: Word128 -> Word128 -> [Word128] # enumFromThenTo :: Word128 -> Word128 -> Word128 -> [Word128] #
Eq Word128 |
Methods (==) :: Word128 -> Word128 -> Bool # (/=) :: Word128 -> Word128 -> Bool #
Num Word128 |
Methods (+) :: Word128 -> Word128 -> Word128 # (-) :: Word128 -> Word128 -> Word128 # (*) :: Word128 -> Word128 -> Word128 # negate :: Word128 -> Word128 # abs :: Word128 -> Word128 # signum :: Word128 -> Word128 # fromInteger :: Integer -> Word128 #
Ord Word128 |
Methods compare :: Word128 -> Word128 -> Ordering # (<) :: Word128 -> Word128 -> Bool # (<=) :: Word128 -> Word128 -> Bool # (>) :: Word128 -> Word128 -> Bool # (>=) :: Word128 -> Word128 -> Bool # max :: Word128 -> Word128 -> Word128 # min :: Word128 -> Word128 -> Word128 #
Show Word128 |
Methods showsPrec :: Int -> Word128 -> ShowS # show :: Word128 -> String # showList :: [Word128] -> ShowS #
Storable Word128 |
Methods sizeOf :: Word128 -> Int # alignment :: Word128 -> Int # peekElemOff :: Ptr Word128 -> Int -> IO Word128 # pokeElemOff :: Ptr Word128 -> Int -> Word128 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word128 # pokeByteOff :: Ptr b -> Int -> Word128 -> IO () # peek :: Ptr Word128 -> IO Word128 # poke :: Ptr Word128 -> Word128 -> IO () #
Bits Word128 |

Methods

(.&.) :: Word128 -> Word128 -> Word128 #

(.|.) :: Word128 -> Word128 -> Word128 #

xor :: Word128 -> Word128 -> Word128 #

complement :: Word128 -> Word128 #

shift :: Word128 -> Int -> Word128 #

rotate :: Word128 -> Int -> Word128 #

zeroBits :: Word128 #

bit :: Int -> Word128 #

setBit :: Word128 -> Int -> Word128 #

clearBit :: Word128 -> Int -> Word128 #

complementBit :: Word128 -> Int -> Word128 #

testBit :: Word128 -> Int -> Bool #

bitSizeMaybe :: Word128 -> Maybe Int #

bitSize :: Word128 -> Int #

isSigned :: Word128 -> Bool #

shiftL :: Word128 -> Int -> Word128 #

unsafeShiftL :: Word128 -> Int -> Word128 #

shiftR :: Word128 -> Int -> Word128 #

unsafeShiftR :: Word128 -> Int -> Word128 #

rotateL :: Word128 -> Int -> Word128 #

rotateR :: Word128 -> Int -> Word128 #

popCount :: Word128 -> Int #

PrimType Word128 |

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 () #

PrimMemoryComparable Word128 |
NormalForm Word128 |
Methods toNormalForm :: Word128 -> () #
Subtractive Word128 |
Associated Types type Difference Word128 :: * # Methods (-) :: Word128 -> Word128 -> Difference Word128 #
Multiplicative Word128 |
Methods midentity :: Word128 # (*) :: Word128 -> Word128 -> Word128 # (^) :: (IsNatural n, IDivisible n) => Word128 -> n -> Word128 #
IDivisible Word128 |
Methods div :: Word128 -> Word128 -> Word128 # mod :: Word128 -> Word128 -> Word128 # divMod :: Word128 -> Word128 -> (Word128, Word128) #
Additive Word128 |
Methods azero :: Word128 # (+) :: Word128 -> Word128 -> Word128 # scale :: IsNatural n => n -> Word128 -> Word128 #
IsIntegral Word128 |
Methods toInteger :: Word128 -> Integer #
IsNatural Word128 |
Methods toNatural :: Word128 -> Natural #
Integral Word128 |
Methods fromInteger :: Integer -> Word128 #
HasNegation Word128 |
Methods negate :: Word128 -> Word128 #
StorableFixed Word128 Source # |
Methods size :: proxy Word128 -> CountOf Word8 Source # alignment :: proxy Word128 -> CountOf Word8 Source #
Storable Word128 Source # |
Methods peek :: Ptr Word128 -> IO Word128 Source # poke :: Ptr Word128 -> Word128 -> IO () Source #
Hashable Word128 Source # |
Methods hashMix :: Hasher st => Word128 -> st -> st Source #
Arbitrary Word128 Source # |
Methods arbitrary :: Gen Word128 Source #
StorableFixed (LE Word128) Source # |
Methods size :: proxy (LE Word128) -> CountOf Word8 Source # alignment :: proxy (LE Word128) -> CountOf Word8 Source #
StorableFixed (BE Word128) Source # |
Methods size :: proxy (BE Word128) -> CountOf Word8 Source # alignment :: proxy (BE Word128) -> CountOf Word8 Source #
Storable (LE Word128) Source # |
Methods peek :: Ptr (LE Word128) -> IO (LE Word128) Source # poke :: Ptr (LE Word128) -> LE Word128 -> IO () Source #
Storable (BE Word128) Source # |
Methods peek :: Ptr (BE Word128) -> IO (BE Word128) Source # poke :: Ptr (BE Word128) -> BE Word128 -> IO () Source #
type Difference Word128 |
type Difference Word128 = Word128
type NatNumMaxBound Word128 |
type NatNumMaxBound Word128 = 340282366920938463463374607431768211455

data Word256 :: * #

256 bits Word

Instances

Bounded Word256 |
Methods minBound :: Word256 # maxBound :: Word256 #
Enum Word256 |
Methods succ :: Word256 -> Word256 # pred :: Word256 -> Word256 # toEnum :: Int -> Word256 # fromEnum :: Word256 -> Int # enumFrom :: Word256 -> [Word256] # enumFromThen :: Word256 -> Word256 -> [Word256] # enumFromTo :: Word256 -> Word256 -> [Word256] # enumFromThenTo :: Word256 -> Word256 -> Word256 -> [Word256] #
Eq Word256 |
Methods (==) :: Word256 -> Word256 -> Bool # (/=) :: Word256 -> Word256 -> Bool #
Num Word256 |
Methods (+) :: Word256 -> Word256 -> Word256 # (-) :: Word256 -> Word256 -> Word256 # (*) :: Word256 -> Word256 -> Word256 # negate :: Word256 -> Word256 # abs :: Word256 -> Word256 # signum :: Word256 -> Word256 # fromInteger :: Integer -> Word256 #
Ord Word256 |
Methods compare :: Word256 -> Word256 -> Ordering # (<) :: Word256 -> Word256 -> Bool # (<=) :: Word256 -> Word256 -> Bool # (>) :: Word256 -> Word256 -> Bool # (>=) :: Word256 -> Word256 -> Bool # max :: Word256 -> Word256 -> Word256 # min :: Word256 -> Word256 -> Word256 #
Show Word256 |
Methods showsPrec :: Int -> Word256 -> ShowS # show :: Word256 -> String # showList :: [Word256] -> ShowS #
Storable Word256 |
Methods sizeOf :: Word256 -> Int # alignment :: Word256 -> Int # peekElemOff :: Ptr Word256 -> Int -> IO Word256 # pokeElemOff :: Ptr Word256 -> Int -> Word256 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word256 # pokeByteOff :: Ptr b -> Int -> Word256 -> IO () # peek :: Ptr Word256 -> IO Word256 # poke :: Ptr Word256 -> Word256 -> IO () #
Bits Word256 |

Methods

(.&.) :: Word256 -> Word256 -> Word256 #

(.|.) :: Word256 -> Word256 -> Word256 #

xor :: Word256 -> Word256 -> Word256 #

complement :: Word256 -> Word256 #

shift :: Word256 -> Int -> Word256 #

rotate :: Word256 -> Int -> Word256 #

zeroBits :: Word256 #

bit :: Int -> Word256 #

setBit :: Word256 -> Int -> Word256 #

clearBit :: Word256 -> Int -> Word256 #

complementBit :: Word256 -> Int -> Word256 #

testBit :: Word256 -> Int -> Bool #

bitSizeMaybe :: Word256 -> Maybe Int #

bitSize :: Word256 -> Int #

isSigned :: Word256 -> Bool #

shiftL :: Word256 -> Int -> Word256 #

unsafeShiftL :: Word256 -> Int -> Word256 #

shiftR :: Word256 -> Int -> Word256 #

unsafeShiftR :: Word256 -> Int -> Word256 #

rotateL :: Word256 -> Int -> Word256 #

rotateR :: Word256 -> Int -> Word256 #

popCount :: Word256 -> Int #

PrimType Word256 |

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 () #

PrimMemoryComparable Word256 |
NormalForm Word256 |
Methods toNormalForm :: Word256 -> () #
Subtractive Word256 |
Associated Types type Difference Word256 :: * # Methods (-) :: Word256 -> Word256 -> Difference Word256 #
Multiplicative Word256 |
Methods midentity :: Word256 # (*) :: Word256 -> Word256 -> Word256 # (^) :: (IsNatural n, IDivisible n) => Word256 -> n -> Word256 #
IDivisible Word256 |
Methods div :: Word256 -> Word256 -> Word256 # mod :: Word256 -> Word256 -> Word256 # divMod :: Word256 -> Word256 -> (Word256, Word256) #
Additive Word256 |
Methods azero :: Word256 # (+) :: Word256 -> Word256 -> Word256 # scale :: IsNatural n => n -> Word256 -> Word256 #
IsIntegral Word256 |
Methods toInteger :: Word256 -> Integer #
IsNatural Word256 |
Methods toNatural :: Word256 -> Natural #
Integral Word256 |
Methods fromInteger :: Integer -> Word256 #
HasNegation Word256 |
Methods negate :: Word256 -> Word256 #
StorableFixed Word256 Source # |
Methods size :: proxy Word256 -> CountOf Word8 Source # alignment :: proxy Word256 -> CountOf Word8 Source #
Storable Word256 Source # |
Methods peek :: Ptr Word256 -> IO Word256 Source # poke :: Ptr Word256 -> Word256 -> IO () Source #
Hashable Word256 Source # |
Methods hashMix :: Hasher st => Word256 -> st -> st Source #
Arbitrary Word256 Source # |
Methods arbitrary :: Gen Word256 Source #
StorableFixed (LE Word256) Source # |
Methods size :: proxy (LE Word256) -> CountOf Word8 Source # alignment :: proxy (LE Word256) -> CountOf Word8 Source #
StorableFixed (BE Word256) Source # |
Methods size :: proxy (BE Word256) -> CountOf Word8 Source # alignment :: proxy (BE Word256) -> CountOf Word8 Source #
Storable (LE Word256) Source # |
Methods peek :: Ptr (LE Word256) -> IO (LE Word256) Source # poke :: Ptr (LE Word256) -> LE Word256 -> IO () Source #
Storable (BE Word256) Source # |
Methods peek :: Ptr (BE Word256) -> IO (BE Word256) Source # poke :: Ptr (BE Word256) -> BE Word256 -> IO () Source #
type Difference Word256 |
type Difference Word256 = Word256
type NatNumMaxBound Word256 |
type NatNumMaxBound Word256 = 115792089237316195423570985008687907853269984665640564039457584007913129639935

data Int :: * #

A fixed-precision integer type with at least the range `[-2^29 .. 2^29-1]`. The exact range for a given implementation can be determined by using `minBound` and `maxBound` from the `Bounded` class.

Instances

Bounded Int |
Methods minBound :: Int # maxBound :: Int #
Enum Int |
Methods succ :: Int -> Int # pred :: Int -> Int # toEnum :: Int -> Int # fromEnum :: Int -> Int # enumFrom :: Int -> [Int] # enumFromThen :: Int -> Int -> [Int] # enumFromTo :: Int -> Int -> [Int] # enumFromThenTo :: Int -> Int -> Int -> [Int] #
Eq Int |
Methods (==) :: Int -> Int -> Bool # (/=) :: Int -> Int -> Bool #
Integral Int |
Methods quot :: Int -> Int -> Int # rem :: Int -> Int -> Int # div :: Int -> Int -> Int # mod :: Int -> Int -> Int # quotRem :: Int -> Int -> (Int, Int) # divMod :: Int -> Int -> (Int, Int) # toInteger :: Int -> Integer #
Data Int |

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 #

toConstr :: Int -> Constr #

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 :: (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 #

Num Int |
Methods (+) :: Int -> Int -> Int # (-) :: Int -> Int -> Int # (*) :: Int -> Int -> Int # negate :: Int -> Int # abs :: Int -> Int # signum :: Int -> Int # fromInteger :: Integer -> Int #
Ord Int |
Methods compare :: Int -> Int -> Ordering # (<) :: Int -> Int -> Bool # (<=) :: Int -> Int -> Bool # (>) :: Int -> Int -> Bool # (>=) :: Int -> Int -> Bool # max :: Int -> Int -> Int # min :: Int -> Int -> Int #
Read Int |
Methods readsPrec :: Int -> ReadS Int # readList :: ReadS [Int] # readPrec :: ReadPrec Int # readListPrec :: ReadPrec [Int] #
Real Int |
Methods toRational :: Int -> Rational #
Show Int |
Methods showsPrec :: Int -> Int -> ShowS # show :: Int -> String # showList :: [Int] -> ShowS #
Ix Int |
Methods range :: (Int, Int) -> [Int] # index :: (Int, Int) -> Int -> Int # unsafeIndex :: (Int, Int) -> Int -> Int inRange :: (Int, Int) -> Int -> Bool # rangeSize :: (Int, Int) -> Int # unsafeRangeSize :: (Int, Int) -> Int
PrintfArg Int |
Methods formatArg :: Int -> FieldFormatter # parseFormat :: Int -> ModifierParser #
Storable Int |
Methods sizeOf :: Int -> Int # alignment :: Int -> Int # peekElemOff :: Ptr Int -> Int -> IO Int # pokeElemOff :: Ptr Int -> Int -> Int -> IO () # peekByteOff :: Ptr b -> Int -> IO Int # pokeByteOff :: Ptr b -> Int -> Int -> IO () # peek :: Ptr Int -> IO Int # poke :: Ptr Int -> Int -> IO () #
Bits Int |

Methods

(.&.) :: Int -> Int -> Int #

(.|.) :: Int -> Int -> Int #

xor :: Int -> Int -> Int #

complement :: Int -> Int #

shift :: Int -> Int -> Int #

rotate :: Int -> Int -> Int #

zeroBits :: Int #

bit :: Int -> Int #

setBit :: Int -> Int -> Int #

clearBit :: Int -> Int -> Int #

complementBit :: Int -> Int -> Int #

testBit :: Int -> Int -> Bool #

bitSizeMaybe :: Int -> Maybe Int #

bitSize :: Int -> Int #

isSigned :: Int -> Bool #

shiftL :: Int -> Int -> Int #

unsafeShiftL :: Int -> Int -> Int #

shiftR :: Int -> Int -> Int #

unsafeShiftR :: Int -> Int -> Int #

rotateL :: Int -> Int -> Int #

rotateR :: Int -> Int -> Int #

popCount :: Int -> Int #

FiniteBits Int |
Methods finiteBitSize :: Int -> Int # countLeadingZeros :: Int -> Int # countTrailingZeros :: Int -> Int #
PrimType Int |

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 () #

PrimMemoryComparable Int |
NormalForm Int |
Methods toNormalForm :: Int -> () #
Subtractive Int |
Associated Types type Difference Int :: * # Methods (-) :: Int -> Int -> Difference Int #
Multiplicative Int |
Methods midentity :: Int # (*) :: Int -> Int -> Int # (^) :: (IsNatural n, IDivisible n) => Int -> n -> Int #
IDivisible Int |
Methods div :: Int -> Int -> Int # mod :: Int -> Int -> Int # divMod :: Int -> Int -> (Int, Int) #
Additive Int |
Methods azero :: Int # (+) :: Int -> Int -> Int # scale :: IsNatural n => n -> Int -> Int #
IsIntegral Int |
Methods toInteger :: Int -> Integer #
Integral Int |
Methods fromInteger :: Integer -> Int #
HasNegation Int |
Methods negate :: Int -> Int #
Signed Int Source # |
Methods abs :: Int -> Int Source # signum :: Int -> Sign Source #
Arbitrary Int Source # |
Methods arbitrary :: Gen Int Source #
IntegralDownsize Int Int8 |
Methods integralDownsize :: Int -> Int8 # integralDownsizeCheck :: Int -> Maybe Int8 #
IntegralDownsize Int Int16 |
Methods integralDownsize :: Int -> Int16 # integralDownsizeCheck :: Int -> Maybe Int16 #
IntegralDownsize Int Int32 |
Methods integralDownsize :: Int -> Int32 # integralDownsizeCheck :: Int -> Maybe Int32 #
IntegralDownsize Int64 Int |
Methods integralDownsize :: Int64 -> Int # integralDownsizeCheck :: Int64 -> Maybe Int #
IntegralUpsize Int Int64 |
Methods integralUpsize :: Int -> Int64 #
IntegralUpsize Int8 Int |
Methods integralUpsize :: Int8 -> Int #
IntegralUpsize Int16 Int |
Methods integralUpsize :: Int16 -> Int #
IntegralUpsize Int32 Int |
Methods integralUpsize :: Int32 -> Int #
IntegralUpsize Word8 Int |
Methods integralUpsize :: Word8 -> Int #
IntegralCast Int Word |
Methods integralCast :: Int -> Word #
IntegralCast Word Int |
Methods integralCast :: Word -> Int #
IntegralCast Int (Offset ty) |
Methods integralCast :: Int -> Offset ty #
IntegralCast Int (CountOf ty) |
Methods integralCast :: Int -> CountOf ty #
Functor (URec Int) |
Methods fmap :: (a -> b) -> URec Int a -> URec Int b # (<$) :: a -> URec Int b -> URec Int a #
Foldable (URec Int) |

Methods

fold :: Monoid m => URec Int m -> m #

foldMap :: Monoid m => (a -> m) -> URec Int a -> m #

foldr :: (a -> b -> b) -> b -> URec Int a -> b #

foldr' :: (a -> b -> b) -> b -> URec Int a -> b #

foldl :: (b -> a -> b) -> b -> URec Int a -> b #

foldl' :: (b -> a -> b) -> b -> URec Int a -> b #

foldr1 :: (a -> a -> a) -> URec Int a -> a #

foldl1 :: (a -> a -> a) -> URec Int a -> a #

toList :: URec Int a -> [a] #

null :: URec Int a -> Bool #

length :: URec Int a -> Int #

elem :: Eq a => a -> URec Int a -> Bool #

maximum :: Ord a => URec Int a -> a #

minimum :: Ord a => URec Int a -> a #

sum :: Num a => URec Int a -> a #

product :: Num a => URec Int a -> a #

Traversable (URec Int) |
Methods traverse :: Applicative f => (a -> f b) -> URec Int a -> f (URec Int b) # sequenceA :: Applicative f => URec Int (f a) -> f (URec Int a) # mapM :: Monad m => (a -> m b) -> URec Int a -> m (URec Int b) # sequence :: Monad m => URec Int (m a) -> m (URec Int a) #
Generic1 (URec Int) |
Associated Types type Rep1 (URec Int :: * -> *) :: * -> * # Methods from1 :: URec Int a -> Rep1 (URec Int) a # to1 :: Rep1 (URec Int) a -> URec Int a #
Eq (URec Int p) |
Methods (==) :: URec Int p -> URec Int p -> Bool # (/=) :: URec Int p -> URec Int p -> Bool #
Ord (URec Int p) |
Methods compare :: URec Int p -> URec Int p -> Ordering # (<) :: URec Int p -> URec Int p -> Bool # (<=) :: URec Int p -> URec Int p -> Bool # (>) :: URec Int p -> URec Int p -> Bool # (>=) :: URec Int p -> URec Int p -> Bool # max :: URec Int p -> URec Int p -> URec Int p # min :: URec Int p -> URec Int p -> URec Int p #
Show (URec Int p) |
Methods showsPrec :: Int -> URec Int p -> ShowS # show :: URec Int p -> String # showList :: [URec Int p] -> ShowS #
Generic (URec Int p) |
Associated Types type Rep (URec Int p) :: * -> * # Methods from :: URec Int p -> Rep (URec Int p) x # to :: Rep (URec Int p) x -> URec Int p #
data URec Int | Used for marking occurrences of `Int#`

data URec Int = UInt {

- uInt# :: Int#

}

type Difference Int |
type Difference Int = Int
type NatNumMaxBound Int |
type NatNumMaxBound Int = NatNumMaxBound Int64
type Rep1 (URec Int) |
type Rep1 (URec Int) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UInt" PrefixI True) (S1 (MetaSel (Just Symbol "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UInt))
type Rep (URec Int p) |
type Rep (URec Int p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UInt" PrefixI True) (S1 (MetaSel (Just Symbol "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UInt))

data Integer :: * #

Invariant: `Jn#` and `Jp#` are used iff value doesn't fit in `S#`

Useful properties resulting from the invariants:

-     abs (S# _) <= abs (Jp# _)

-     abs (S# _) <  abs (Jn# _)

Instances

Enum Integer |
Methods succ :: Integer -> Integer # pred :: Integer -> Integer # toEnum :: Int -> Integer # fromEnum :: Integer -> Int # enumFrom :: Integer -> [Integer] # enumFromThen :: Integer -> Integer -> [Integer] # enumFromTo :: Integer -> Integer -> [Integer] # enumFromThenTo :: Integer -> Integer -> Integer -> [Integer] #
Eq Integer |
Methods (==) :: Integer -> Integer -> Bool # (/=) :: Integer -> Integer -> Bool #
Integral Integer |
Methods quot :: Integer -> Integer -> Integer # rem :: Integer -> Integer -> Integer # div :: Integer -> Integer -> Integer # mod :: Integer -> Integer -> Integer # quotRem :: Integer -> Integer -> (Integer, Integer) # divMod :: Integer -> Integer -> (Integer, Integer) # toInteger :: Integer -> Integer #
Data Integer |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Integer -> c Integer #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Integer #

toConstr :: Integer -> Constr #

dataTypeOf :: Integer -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Integer) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Integer) #

gmapT :: (forall b. Data b => b -> b) -> Integer -> Integer #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r #

gmapQr :: (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 #

Num Integer |
Methods (+) :: Integer -> Integer -> Integer # (-) :: Integer -> Integer -> Integer # (*) :: Integer -> Integer -> Integer # negate :: Integer -> Integer # abs :: Integer -> Integer # signum :: Integer -> Integer # fromInteger :: Integer -> Integer #
Ord Integer |
Methods compare :: Integer -> Integer -> Ordering # (<) :: Integer -> Integer -> Bool # (<=) :: Integer -> Integer -> Bool # (>) :: Integer -> Integer -> Bool # (>=) :: Integer -> Integer -> Bool # max :: Integer -> Integer -> Integer # min :: Integer -> Integer -> Integer #
Read Integer |
Methods readsPrec :: Int -> ReadS Integer # readList :: ReadS [Integer] # readPrec :: ReadPrec Integer # readListPrec :: ReadPrec [Integer] #
Real Integer |
Methods toRational :: Integer -> Rational #
Show Integer |
Methods showsPrec :: Int -> Integer -> ShowS # show :: Integer -> String # showList :: [Integer] -> ShowS #
Ix Integer |
Methods range :: (Integer, Integer) -> [Integer] # index :: (Integer, Integer) -> Integer -> Int # unsafeIndex :: (Integer, Integer) -> Integer -> Int inRange :: (Integer, Integer) -> Integer -> Bool # rangeSize :: (Integer, Integer) -> Int # unsafeRangeSize :: (Integer, Integer) -> Int
PrintfArg Integer |
Methods formatArg :: Integer -> FieldFormatter # parseFormat :: Integer -> ModifierParser #
Bits Integer |

Methods

(.&.) :: Integer -> Integer -> Integer #

(.|.) :: Integer -> Integer -> Integer #

xor :: Integer -> Integer -> Integer #

complement :: Integer -> Integer #

shift :: Integer -> Int -> Integer #

rotate :: Integer -> Int -> Integer #

zeroBits :: Integer #

bit :: Int -> Integer #

setBit :: Integer -> Int -> Integer #

clearBit :: Integer -> Int -> Integer #

complementBit :: Integer -> Int -> Integer #

testBit :: Integer -> Int -> Bool #

bitSizeMaybe :: Integer -> Maybe Int #

bitSize :: Integer -> Int #

isSigned :: Integer -> Bool #

shiftL :: Integer -> Int -> Integer #

unsafeShiftL :: Integer -> Int -> Integer #

shiftR :: Integer -> Int -> Integer #

unsafeShiftR :: Integer -> Int -> Integer #

rotateL :: Integer -> Int -> Integer #

rotateR :: Integer -> Int -> Integer #

popCount :: Integer -> Int #

NormalForm Integer |
Methods toNormalForm :: Integer -> () #
Subtractive Integer |
Associated Types type Difference Integer :: * # Methods (-) :: Integer -> Integer -> Difference Integer #
Multiplicative Integer |
Methods midentity :: Integer # (*) :: Integer -> Integer -> Integer # (^) :: (IsNatural n, IDivisible n) => Integer -> n -> Integer #
Multiplicative Rational |
Methods midentity :: Rational # (*) :: Rational -> Rational -> Rational # (^) :: (IsNatural n, IDivisible n) => Rational -> n -> Rational #
IDivisible Integer |
Methods div :: Integer -> Integer -> Integer # mod :: Integer -> Integer -> Integer # divMod :: Integer -> Integer -> (Integer, Integer) #
Divisible Rational |
Methods (/) :: Rational -> Rational -> Rational #
Additive Integer |
Methods azero :: Integer # (+) :: Integer -> Integer -> Integer # scale :: IsNatural n => n -> Integer -> Integer #
IsIntegral Integer |
Methods toInteger :: Integer -> Integer #
Integral Integer |
Methods fromInteger :: Integer -> Integer #
Fractional Rational |
Methods fromRational :: Rational -> Rational #
HasNegation Integer |
Methods negate :: Integer -> Integer #
IntegralRounding Rational Source # |
Methods roundUp :: Integral n => Rational -> n Source # roundDown :: Integral n => Rational -> n Source # roundTruncate :: Integral n => Rational -> n Source # roundNearest :: Integral n => Rational -> n Source #
Signed Integer Source # |
Methods abs :: Integer -> Integer Source # signum :: Integer -> Sign Source #
Hashable Integer Source # |
Methods hashMix :: Hasher st => Integer -> st -> st Source #
Arbitrary Integer Source # |
Methods arbitrary :: Gen Integer Source #
IntegralDownsize Integer Int8 |
Methods integralDownsize :: Integer -> Int8 # integralDownsizeCheck :: Integer -> Maybe Int8 #
IntegralDownsize Integer Int16 |
Methods integralDownsize :: Integer -> Int16 # integralDownsizeCheck :: Integer -> Maybe Int16 #
IntegralDownsize Integer Int32 |
Methods integralDownsize :: Integer -> Int32 # integralDownsizeCheck :: Integer -> Maybe Int32 #
IntegralDownsize Integer Int64 |
Methods integralDownsize :: Integer -> Int64 # integralDownsizeCheck :: Integer -> Maybe Int64 #
IntegralDownsize Integer Word8 |
Methods integralDownsize :: Integer -> Word8 # integralDownsizeCheck :: Integer -> Maybe Word8 #
IntegralDownsize Integer Word16 |
Methods integralDownsize :: Integer -> Word16 # integralDownsizeCheck :: Integer -> Maybe Word16 #
IntegralDownsize Integer Word32 |
Methods integralDownsize :: Integer -> Word32 # integralDownsizeCheck :: Integer -> Maybe Word32 #
IntegralDownsize Integer Word64 |
Methods integralDownsize :: Integer -> Word64 # integralDownsizeCheck :: Integer -> Maybe Word64 #
IntegralDownsize Integer Natural |
Methods integralDownsize :: Integer -> Natural # integralDownsizeCheck :: Integer -> Maybe Natural #
IsIntegral a => IntegralUpsize a Integer |
Methods integralUpsize :: a -> Integer #
type Difference Integer |
type Difference Integer = Integer

data Natural :: * #

Type representing arbitrary-precision non-negative integers.

Operations whose result would be negative ``throw` (`Underflow` :: `ArithException`)`.

Since: 4.8.0.0

Instances

Enum Natural |
Methods succ :: Natural -> Natural # pred :: Natural -> Natural # toEnum :: Int -> Natural # fromEnum :: Natural -> Int # enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] #
Eq Natural |
Methods (==) :: Natural -> Natural -> Bool # (/=) :: Natural -> Natural -> Bool #
Integral Natural |
Methods quot :: Natural -> Natural -> Natural # rem :: Natural -> Natural -> Natural # div :: Natural -> Natural -> Natural # mod :: Natural -> Natural -> Natural # quotRem :: Natural -> Natural -> (Natural, Natural) # divMod :: Natural -> Natural -> (Natural, Natural) # toInteger :: Natural -> Integer #
Data Natural |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Natural -> c Natural #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Natural #

toConstr :: Natural -> Constr #

dataTypeOf :: Natural -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Natural) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Natural) #

gmapT :: (forall b. Data b => b -> b) -> Natural -> Natural #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r #

gmapQr :: (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 #

Num Natural |
Methods (+) :: Natural -> Natural -> Natural # (-) :: Natural -> Natural -> Natural # (*) :: Natural -> Natural -> Natural # negate :: Natural -> Natural # abs :: Natural -> Natural # signum :: Natural -> Natural # fromInteger :: Integer -> Natural #
Ord Natural |
Methods compare :: Natural -> Natural -> Ordering # (<) :: Natural -> Natural -> Bool # (<=) :: Natural -> Natural -> Bool # (>) :: Natural -> Natural -> Bool # (>=) :: Natural -> Natural -> Bool # max :: Natural -> Natural -> Natural # min :: Natural -> Natural -> Natural #
Read Natural |
Methods readsPrec :: Int -> ReadS Natural # readList :: ReadS [Natural] # readPrec :: ReadPrec Natural # readListPrec :: ReadPrec [Natural] #
Real Natural |
Methods toRational :: Natural -> Rational #
Show Natural |
Methods showsPrec :: Int -> Natural -> ShowS # show :: Natural -> String # showList :: [Natural] -> ShowS #
Ix Natural |
Methods range :: (Natural, Natural) -> [Natural] # index :: (Natural, Natural) -> Natural -> Int # unsafeIndex :: (Natural, Natural) -> Natural -> Int inRange :: (Natural, Natural) -> Natural -> Bool # rangeSize :: (Natural, Natural) -> Int # unsafeRangeSize :: (Natural, Natural) -> Int
PrintfArg Natural |
Methods formatArg :: Natural -> FieldFormatter # parseFormat :: Natural -> ModifierParser #
Bits Natural |

Methods

(.&.) :: Natural -> Natural -> Natural #

(.|.) :: Natural -> Natural -> Natural #

xor :: Natural -> Natural -> Natural #

complement :: Natural -> Natural #

shift :: Natural -> Int -> Natural #

rotate :: Natural -> Int -> Natural #

zeroBits :: Natural #

bit :: Int -> Natural #

setBit :: Natural -> Int -> Natural #

clearBit :: Natural -> Int -> Natural #

complementBit :: Natural -> Int -> Natural #

testBit :: Natural -> Int -> Bool #

bitSizeMaybe :: Natural -> Maybe Int #

bitSize :: Natural -> Int #

isSigned :: Natural -> Bool #

shiftL :: Natural -> Int -> Natural #

unsafeShiftL :: Natural -> Int -> Natural #

shiftR :: Natural -> Int -> Natural #

unsafeShiftR :: Natural -> Int -> Natural #

rotateL :: Natural -> Int -> Natural #

rotateR :: Natural -> Int -> Natural #

popCount :: Natural -> Int #

NormalForm Natural |
Methods toNormalForm :: Natural -> () #
Subtractive Natural |
Associated Types type Difference Natural :: * # Methods (-) :: Natural -> Natural -> Difference Natural #
Multiplicative Natural |
Methods midentity :: Natural # (*) :: Natural -> Natural -> Natural # (^) :: (IsNatural n, IDivisible n) => Natural -> n -> Natural #
IDivisible Natural |
Methods div :: Natural -> Natural -> Natural # mod :: Natural -> Natural -> Natural # divMod :: Natural -> Natural -> (Natural, Natural) #
Additive Natural |
Methods azero :: Natural # (+) :: Natural -> Natural -> Natural # scale :: IsNatural n => n -> Natural -> Natural #
IsIntegral Natural |
Methods toInteger :: Natural -> Integer #
IsNatural Natural |
Methods toNatural :: Natural -> Natural #
Integral Natural |
Methods fromInteger :: Integer -> Natural #
Hashable Natural Source # |
Methods hashMix :: Hasher st => Natural -> st -> st Source #
Arbitrary Natural Source # |
Methods arbitrary :: Gen Natural Source #
IntegralDownsize Integer Natural |
Methods integralDownsize :: Integer -> Natural # integralDownsizeCheck :: Integer -> Maybe Natural #
IntegralDownsize Natural Word8 |
Methods integralDownsize :: Natural -> Word8 # integralDownsizeCheck :: Natural -> Maybe Word8 #
IntegralDownsize Natural Word16 |
Methods integralDownsize :: Natural -> Word16 # integralDownsizeCheck :: Natural -> Maybe Word16 #
IntegralDownsize Natural Word32 |
Methods integralDownsize :: Natural -> Word32 # integralDownsizeCheck :: Natural -> Maybe Word32 #
IntegralDownsize Natural Word64 |
Methods integralDownsize :: Natural -> Word64 # integralDownsizeCheck :: Natural -> Maybe Word64 #
IsNatural a => IntegralUpsize a Natural |
Methods integralUpsize :: a -> Natural #
type Difference Natural |
type Difference Natural = Maybe Natural

type Rational = Ratio Integer #

Arbitrary-precision rational numbers, represented as a ratio of two `Integer` values. A rational number may be constructed using the `%` operator.

data Float :: * #

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

Instances

Eq Float |
Methods (==) :: Float -> Float -> Bool # (/=) :: Float -> Float -> Bool #
Floating Float |

Methods

pi :: Float #

exp :: Float -> Float #

log :: Float -> Float #

sqrt :: Float -> Float #

(**) :: Float -> Float -> Float #

logBase :: Float -> Float -> Float #

sin :: Float -> Float #

cos :: Float -> Float #

tan :: Float -> Float #

asin :: Float -> Float #

acos :: Float -> Float #

atan :: Float -> Float #

sinh :: Float -> Float #

cosh :: Float -> Float #

tanh :: Float -> Float #

asinh :: Float -> Float #

acosh :: Float -> Float #

atanh :: Float -> Float #

log1p :: Float -> Float #

expm1 :: Float -> Float #

log1pexp :: Float -> Float #

log1mexp :: Float -> Float #

Data Float |

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 #

toConstr :: Float -> Constr #

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 :: (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 #

Ord Float |
Methods compare :: Float -> Float -> Ordering # (<) :: Float -> Float -> Bool # (<=) :: Float -> Float -> Bool # (>) :: Float -> Float -> Bool # (>=) :: Float -> Float -> Bool # max :: Float -> Float -> Float # min :: Float -> Float -> Float #
Read Float |
Methods readsPrec :: Int -> ReadS Float # readList :: ReadS [Float] # readPrec :: ReadPrec Float # readListPrec :: ReadPrec [Float] #
RealFloat Float |

Methods

floatRadix :: Float -> Integer #

floatDigits :: Float -> Int #

floatRange :: Float -> (Int, Int) #

decodeFloat :: Float -> (Integer, Int) #

encodeFloat :: Integer -> Int -> Float #

exponent :: Float -> Int #

significand :: Float -> Float #

scaleFloat :: Int -> Float -> Float #

isNaN :: Float -> Bool #

isInfinite :: Float -> Bool #

isDenormalized :: Float -> Bool #

isNegativeZero :: Float -> Bool #

isIEEE :: Float -> Bool #

atan2 :: Float -> Float -> Float #

PrintfArg Float |
Methods formatArg :: Float -> FieldFormatter # parseFormat :: Float -> ModifierParser #
Storable Float |
Methods sizeOf :: Float -> Int # alignment :: Float -> Int # peekElemOff :: Ptr Float -> Int -> IO Float # pokeElemOff :: Ptr Float -> Int -> Float -> IO () # peekByteOff :: Ptr b -> Int -> IO Float # pokeByteOff :: Ptr b -> Int -> Float -> IO () # peek :: Ptr Float -> IO Float # poke :: Ptr Float -> Float -> IO () #
PrimType Float |

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 () #

NormalForm Float |
Methods toNormalForm :: Float -> () #
Subtractive Float |
Associated Types type Difference Float :: * # Methods (-) :: Float -> Float -> Difference Float #
Multiplicative Float |
Methods midentity :: Float # (*) :: Float -> Float -> Float # (^) :: (IsNatural n, IDivisible n) => Float -> n -> Float #
Divisible Float |
Methods (/) :: Float -> Float -> Float #
Additive Float |
Methods azero :: Float # (+) :: Float -> Float -> Float # scale :: IsNatural n => n -> Float -> Float #
Integral Float |
Methods fromInteger :: Integer -> Float #
Fractional Float |
Methods fromRational :: Rational -> Float #
HasNegation Float |
Methods negate :: Float -> Float #
FloatingPoint Float Source # |
Methods floatRadix :: Proxy * Float -> Integer Source # floatDigits :: Proxy * Float -> Int Source # floatRange :: Proxy * Float -> (Int, Int) Source # floatDecode :: Float -> (Integer, Int) Source # floatEncode :: Integer -> Int -> Float Source #
IntegralRounding Float Source # |
Methods roundUp :: Integral n => Float -> n Source # roundDown :: Integral n => Float -> n Source # roundTruncate :: Integral n => Float -> n Source # roundNearest :: Integral n => Float -> n Source #
Signed Float Source # |
Methods abs :: Float -> Float Source # signum :: Float -> Sign Source #
Trigonometry Float Source # |

Methods

pi :: Float Source #

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 #

acosh :: Float -> Float Source #

atanh :: Float -> Float Source #

StorableFixed Float Source # |
Methods size :: proxy Float -> CountOf Word8 Source # alignment :: proxy Float -> CountOf Word8 Source #
Storable Float Source # |
Methods peek :: Ptr Float -> IO Float Source # poke :: Ptr Float -> Float -> IO () Source #
Arbitrary Float Source # |
Methods arbitrary :: Gen Float Source #
Functor (URec Float) |
Methods fmap :: (a -> b) -> URec Float a -> URec Float b # (<$) :: a -> URec Float b -> URec Float a #
Foldable (URec Float) |

Methods

fold :: Monoid m => URec Float m -> m #

foldMap :: Monoid m => (a -> m) -> URec Float a -> m #

foldr :: (a -> b -> b) -> b -> URec Float a -> b #

foldr' :: (a -> b -> b) -> b -> URec Float a -> b #

foldl :: (b -> a -> b) -> b -> URec Float a -> b #

foldl' :: (b -> a -> b) -> b -> URec Float a -> b #

foldr1 :: (a -> a -> a) -> URec Float a -> a #

foldl1 :: (a -> a -> a) -> URec Float a -> a #

toList :: URec Float a -> [a] #

null :: URec Float a -> Bool #

length :: URec Float a -> Int #

elem :: Eq a => a -> URec Float a -> Bool #

maximum :: Ord a => URec Float a -> a #

minimum :: Ord a => URec Float a -> a #

sum :: Num a => URec Float a -> a #

product :: Num a => URec Float a -> a #

Traversable (URec Float) |
Methods traverse :: Applicative f => (a -> f b) -> URec Float a -> f (URec Float b) # sequenceA :: Applicative f => URec Float (f a) -> f (URec Float a) # mapM :: Monad m => (a -> m b) -> URec Float a -> m (URec Float b) # sequence :: Monad m => URec Float (m a) -> m (URec Float a) #
Generic1 (URec Float) |
Associated Types type Rep1 (URec Float :: * -> *) :: * -> * # Methods from1 :: URec Float a -> Rep1 (URec Float) a # to1 :: Rep1 (URec Float) a -> URec Float a #
Eq (URec Float p) |
Methods (==) :: URec Float p -> URec Float p -> Bool # (/=) :: URec Float p -> URec Float p -> Bool #
Ord (URec Float p) |
Methods compare :: URec Float p -> URec Float p -> Ordering # (<) :: URec Float p -> URec Float p -> Bool # (<=) :: URec Float p -> URec Float p -> Bool # (>) :: URec Float p -> URec Float p -> Bool # (>=) :: URec Float p -> URec Float p -> Bool # max :: URec Float p -> URec Float p -> URec Float p # min :: URec Float p -> URec Float p -> URec Float p #
Show (URec Float p) |
Methods showsPrec :: Int -> URec Float p -> ShowS # show :: URec Float p -> String # showList :: [URec Float p] -> ShowS #
Generic (URec Float p) |
Associated Types type Rep (URec Float p) :: * -> * # Methods from :: URec Float p -> Rep (URec Float p) x # to :: Rep (URec Float p) x -> URec Float p #
data URec Float | Used for marking occurrences of `Float#`

data URec Float = UFloat {

- uFloat# :: Float#

}

type Difference Float |
type Difference Float = Float
type Rep1 (URec Float) |
type Rep1 (URec Float) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UFloat))
type Rep (URec Float p) |
type Rep (URec Float p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UFloat))

data Double :: * #

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

Instances

Eq Double |
Methods (==) :: Double -> Double -> Bool # (/=) :: Double -> Double -> Bool #
Floating Double |

Methods

pi :: Double #

exp :: Double -> Double #

log :: Double -> Double #

sqrt :: Double -> Double #

(**) :: Double -> Double -> Double #

logBase :: Double -> Double -> Double #

sin :: Double -> Double #

cos :: Double -> Double #

tan :: Double -> Double #

asin :: Double -> Double #

acos :: Double -> Double #

atan :: Double -> Double #

sinh :: Double -> Double #

cosh :: Double -> Double #

tanh :: Double -> Double #

asinh :: Double -> Double #

acosh :: Double -> Double #

atanh :: Double -> Double #

log1p :: Double -> Double #

expm1 :: Double -> Double #

log1pexp :: Double -> Double #

log1mexp :: Double -> Double #

Data Double |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double #

toConstr :: Double -> Constr #

dataTypeOf :: Double -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Double) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) #

gmapT :: (forall b. Data b => b -> b) -> Double -> Double #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r #

gmapQr :: (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 #

Ord Double |
Methods compare :: Double -> Double -> Ordering # (<) :: Double -> Double -> Bool # (<=) :: Double -> Double -> Bool # (>) :: Double -> Double -> Bool # (>=) :: Double -> Double -> Bool # max :: Double -> Double -> Double # min :: Double -> Double -> Double #
Read Double |
Methods readsPrec :: Int -> ReadS Double # readList :: ReadS [Double] # readPrec :: ReadPrec Double # readListPrec :: ReadPrec [Double] #
RealFloat Double |

Methods

floatRadix :: Double -> Integer #

floatDigits :: Double -> Int #

floatRange :: Double -> (Int, Int) #

decodeFloat :: Double -> (Integer, Int) #

encodeFloat :: Integer -> Int -> Double #

exponent :: Double -> Int #

significand :: Double -> Double #

scaleFloat :: Int -> Double -> Double #

isNaN :: Double -> Bool #

isInfinite :: Double -> Bool #

isDenormalized :: Double -> Bool #

isNegativeZero :: Double -> Bool #

isIEEE :: Double -> Bool #

atan2 :: Double -> Double -> Double #

PrintfArg Double |
Methods formatArg :: Double -> FieldFormatter # parseFormat :: Double -> ModifierParser #
Storable Double |
Methods sizeOf :: Double -> Int # alignment :: Double -> Int # peekElemOff :: Ptr Double -> Int -> IO Double # pokeElemOff :: Ptr Double -> Int -> Double -> IO () # peekByteOff :: Ptr b -> Int -> IO Double # pokeByteOff :: Ptr b -> Int -> Double -> IO () # peek :: Ptr Double -> IO Double # poke :: Ptr Double -> Double -> IO () #
PrimType Double |

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 () #

NormalForm Double |
Methods toNormalForm :: Double -> () #
Subtractive Double |
Associated Types type Difference Double :: * # Methods (-) :: Double -> Double -> Difference Double #
Multiplicative Double |
Methods midentity :: Double # (*) :: Double -> Double -> Double # (^) :: (IsNatural n, IDivisible n) => Double -> n -> Double #
Divisible Double |
Methods (/) :: Double -> Double -> Double #
Additive Double |
Methods azero :: Double # (+) :: Double -> Double -> Double # scale :: IsNatural n => n -> Double -> Double #
Integral Double |
Methods fromInteger :: Integer -> Double #
Fractional Double |
Methods fromRational :: Rational -> Double #
HasNegation Double |
Methods negate :: Double -> Double #
FloatingPoint Double Source # |
Methods floatRadix :: Proxy * Double -> Integer Source # floatDigits :: Proxy * Double -> Int Source # floatRange :: Proxy * Double -> (Int, Int) Source # floatDecode :: Double -> (Integer, Int) Source # floatEncode :: Integer -> Int -> Double Source #
IntegralRounding Double Source # |
Methods roundUp :: Integral n => Double -> n Source # roundDown :: Integral n => Double -> n Source # roundTruncate :: Integral n => Double -> n Source # roundNearest :: Integral n => Double -> n Source #
Signed Double Source # |
Methods abs :: Double -> Double Source # signum :: Double -> Sign Source #
Trigonometry Double Source # |

Methods

pi :: Double Source #

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 #

acosh :: Double -> Double Source #

atanh :: Double -> Double Source #

StorableFixed Double Source # |
Methods size :: proxy Double -> CountOf Word8 Source # alignment :: proxy Double -> CountOf Word8 Source #
Storable Double Source # |
Methods peek :: Ptr Double -> IO Double Source # poke :: Ptr Double -> Double -> IO () Source #
Arbitrary Double Source # |
Methods arbitrary :: Gen Double Source #
Functor (URec Double) |
Methods fmap :: (a -> b) -> URec Double a -> URec Double b # (<$) :: a -> URec Double b -> URec Double a #
Foldable (URec Double) |

Methods

fold :: Monoid m => URec Double m -> m #

foldMap :: Monoid m => (a -> m) -> URec Double a -> m #

foldr :: (a -> b -> b) -> b -> URec Double a -> b #

foldr' :: (a -> b -> b) -> b -> URec Double a -> b #

foldl :: (b -> a -> b) -> b -> URec Double a -> b #

foldl' :: (b -> a -> b) -> b -> URec Double a -> b #

foldr1 :: (a -> a -> a) -> URec Double a -> a #

foldl1 :: (a -> a -> a) -> URec Double a -> a #

toList :: URec Double a -> [a] #

null :: URec Double a -> Bool #

length :: URec Double a -> Int #

elem :: Eq a => a -> URec Double a -> Bool #

maximum :: Ord a => URec Double a -> a #

minimum :: Ord a => URec Double a -> a #

sum :: Num a => URec Double a -> a #

product :: Num a => URec Double a -> a #

Traversable (URec Double) |
Methods traverse :: Applicative f => (a -> f b) -> URec Double a -> f (URec Double b) # sequenceA :: Applicative f => URec Double (f a) -> f (URec Double a) # mapM :: Monad m => (a -> m b) -> URec Double a -> m (URec Double b) # sequence :: Monad m => URec Double (m a) -> m (URec Double a) #
Generic1 (URec Double) |
Associated Types type Rep1 (URec Double :: * -> *) :: * -> * # Methods from1 :: URec Double a -> Rep1 (URec Double) a # to1 :: Rep1 (URec Double) a -> URec Double a #
Eq (URec Double p) |
Methods (==) :: URec Double p -> URec Double p -> Bool # (/=) :: URec Double p -> URec Double p -> Bool #
Ord (URec Double p) |
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 # max :: URec Double p -> URec Double p -> URec Double p # min :: URec Double p -> URec Double p -> URec Double p #
Show (URec Double p) |
Methods showsPrec :: Int -> URec Double p -> ShowS # show :: URec Double p -> String # showList :: [URec Double p] -> ShowS #
Generic (URec Double p) |
Associated Types type Rep (URec Double p) :: * -> * # Methods from :: URec Double p -> Rep (URec Double p) x # to :: Rep (URec Double p) x -> URec Double p #
data URec Double | Used for marking occurrences of `Double#`

data URec Double = UDouble {

- uDouble# :: Double#

}

type Difference Double |
type Difference Double = Double
type Rep1 (URec Double) |
type Rep1 (URec Double) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UDouble))
type Rep (URec Double p) |
type Rep (URec Double p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UDouble))

newtype CountOf ty :: * -> * #

CountOf of a data structure.

More specifically, it represents the number of elements of type `ty` that fit into the data structure.

    >>> length (fromList ['a', 'b', 'c', '🌟']) :: CountOf Char
    CountOf 4

Same caveats as `Offset` apply here.

Constructors

CountOf Int |

Instances

IntegralCast Int (CountOf ty) |
Methods integralCast :: Int -> CountOf ty #
IntegralCast Word (CountOf ty) |
Methods integralCast :: Word -> CountOf ty #
Enum (CountOf ty) |
Methods succ :: CountOf ty -> CountOf ty # pred :: CountOf ty -> CountOf ty # toEnum :: Int -> 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] #
Eq (CountOf ty) |
Methods (==) :: CountOf ty -> CountOf ty -> Bool # (/=) :: CountOf ty -> CountOf ty -> Bool #
Num (CountOf ty) |
Methods (+) :: CountOf ty -> CountOf ty -> CountOf ty # (-) :: CountOf ty -> CountOf ty -> CountOf ty # (*) :: CountOf ty -> CountOf ty -> CountOf ty # negate :: CountOf ty -> CountOf ty # abs :: CountOf ty -> CountOf ty # signum :: CountOf ty -> CountOf ty # fromInteger :: Integer -> CountOf ty #
Ord (CountOf ty) |
Methods compare :: CountOf ty -> CountOf ty -> Ordering # (<) :: CountOf ty -> CountOf ty -> Bool # (<=) :: CountOf ty -> CountOf ty -> Bool # (>) :: CountOf ty -> CountOf ty -> Bool # (>=) :: CountOf ty -> CountOf ty -> Bool # max :: CountOf ty -> CountOf ty -> CountOf ty # min :: CountOf ty -> CountOf ty -> CountOf ty #
Show (CountOf ty) |
Methods showsPrec :: Int -> CountOf ty -> ShowS # show :: CountOf ty -> String # showList :: [CountOf ty] -> ShowS #
Semigroup (CountOf ty) |
Methods (<>) :: CountOf ty -> CountOf ty -> CountOf ty # sconcat :: NonEmpty (CountOf ty) -> CountOf ty # stimes :: Integral b => b -> CountOf ty -> CountOf ty #
Monoid (CountOf ty) |
Methods mempty :: CountOf ty # mappend :: CountOf ty -> CountOf ty -> CountOf ty # mconcat :: [CountOf ty] -> CountOf ty #
NormalForm (CountOf a) |
Methods toNormalForm :: CountOf a -> () #
Subtractive (CountOf ty) |
Associated Types type Difference (CountOf ty) :: * # Methods (-) :: CountOf ty -> CountOf ty -> Difference (CountOf ty) #
Additive (CountOf ty) |
Methods azero :: CountOf ty # (+) :: CountOf ty -> CountOf ty -> CountOf ty # scale :: IsNatural n => n -> CountOf ty -> CountOf ty #
IsIntegral (CountOf ty) |
Methods toInteger :: CountOf ty -> Integer #
IsNatural (CountOf ty) |
Methods toNatural :: CountOf ty -> Natural #
Integral (CountOf ty) |
Methods fromInteger :: Integer -> CountOf ty #
Arbitrary (CountOf ty) Source # |
Methods arbitrary :: Gen (CountOf ty) Source #
type Difference (CountOf ty) |
type Difference (CountOf ty) = Maybe (CountOf ty)
type NatNumMaxBound (CountOf x) |
type NatNumMaxBound (CountOf x) = NatNumMaxBound Int

newtype Offset ty :: * -> * #

Offset in a data structure consisting of elements of type `ty`.

Int is a terrible backing type which is hard to get away from, considering that GHC/Haskell are mostly using this for offset. Trying to bring some sanity by a lightweight wrapping.

Constructors

Offset Int |

Instances

IntegralCast Int (Offset ty) |
Methods integralCast :: Int -> Offset ty #
IntegralCast Word (Offset ty) |
Methods integralCast :: Word -> Offset ty #
Enum (Offset ty) |
Methods succ :: Offset ty -> Offset ty # pred :: Offset ty -> Offset ty # toEnum :: Int -> 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] #
Eq (Offset ty) |
Methods (==) :: Offset ty -> Offset ty -> Bool # (/=) :: Offset ty -> Offset ty -> Bool #
Num (Offset ty) |
Methods (+) :: Offset ty -> Offset ty -> Offset ty # (-) :: Offset ty -> Offset ty -> Offset ty # (*) :: Offset ty -> Offset ty -> Offset ty # negate :: Offset ty -> Offset ty # abs :: Offset ty -> Offset ty # signum :: Offset ty -> Offset ty # fromInteger :: Integer -> Offset ty #
Ord (Offset ty) |
Methods compare :: Offset ty -> Offset ty -> Ordering # (<) :: Offset ty -> Offset ty -> Bool # (<=) :: Offset ty -> Offset ty -> Bool # (>) :: Offset ty -> Offset ty -> Bool # (>=) :: Offset ty -> Offset ty -> Bool # max :: Offset ty -> Offset ty -> Offset ty # min :: Offset ty -> Offset ty -> Offset ty #
Show (Offset ty) |
Methods showsPrec :: Int -> Offset ty -> ShowS # show :: Offset ty -> String # showList :: [Offset ty] -> ShowS #
NormalForm (Offset a) |
Methods toNormalForm :: Offset a -> () #
Subtractive (Offset ty) |
Associated Types type Difference (Offset ty) :: * # Methods (-) :: Offset ty -> Offset ty -> Difference (Offset ty) #
Additive (Offset ty) |
Methods azero :: Offset ty # (+) :: Offset ty -> Offset ty -> Offset ty # scale :: IsNatural n => n -> Offset ty -> Offset ty #
IsIntegral (Offset ty) |
Methods toInteger :: Offset ty -> Integer #
IsNatural (Offset ty) |
Methods toNatural :: Offset ty -> Natural #
Integral (Offset ty) |
Methods fromInteger :: Integer -> Offset ty #
type Difference (Offset ty) |
type Difference (Offset ty) = CountOf ty
type NatNumMaxBound (Offset x) |
type NatNumMaxBound (Offset x) = NatNumMaxBound Int

toCount :: Int -> CountOf ty Source #

fromCount :: CountOf ty -> Int Source #

## Collection types

data UArray ty :: * -> * #

An array of type built on top of GHC primitive.

The elements need to have fixed sized and the representation is a packed contiguous array in memory that can easily be passed to foreign interface

Instances

PrimType ty => IsList (UArray ty) |
Associated Types type Item (UArray ty) :: * # Methods fromList :: [Item (UArray ty)] -> UArray ty # fromListN :: Int -> [Item (UArray ty)] -> UArray ty # toList :: UArray ty -> [Item (UArray ty)] #
(PrimType ty, Eq ty) => Eq (UArray ty) |
Methods (==) :: UArray ty -> UArray ty -> Bool # (/=) :: UArray ty -> UArray ty -> Bool #
Data ty => Data (UArray ty) |

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 :: (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, Ord ty) => Ord (UArray ty) |
Methods compare :: UArray ty -> UArray ty -> Ordering # (<) :: UArray ty -> UArray ty -> Bool # (<=) :: UArray ty -> UArray ty -> Bool # (>) :: UArray ty -> UArray ty -> Bool # (>=) :: UArray ty -> UArray ty -> Bool # max :: UArray ty -> UArray ty -> UArray ty # min :: UArray ty -> UArray ty -> UArray ty #
(PrimType ty, Show ty) => Show (UArray ty) |
Methods showsPrec :: Int -> UArray ty -> ShowS # show :: UArray ty -> String # showList :: [UArray ty] -> ShowS #
PrimType ty => Semigroup (UArray ty) |
Methods (<>) :: UArray ty -> UArray ty -> UArray ty # sconcat :: NonEmpty (UArray ty) -> UArray ty # stimes :: Integral b => b -> UArray ty -> UArray ty #
PrimType ty => Monoid (UArray ty) |
Methods mempty :: UArray ty # mappend :: UArray ty -> UArray ty -> UArray ty # mconcat :: [UArray ty] -> UArray ty #
NormalForm (UArray ty) |
Methods toNormalForm :: UArray ty -> () #
PrimType ty => Fold1able (UArray ty) Source # |
Methods foldl1' :: (Element (UArray ty) -> Element (UArray ty) -> Element (UArray ty)) -> NonEmpty (UArray ty) -> Element (UArray ty) Source # foldr1 :: (Element (UArray ty) -> Element (UArray ty) -> Element (UArray ty)) -> NonEmpty (UArray ty) -> Element (UArray ty) Source #
PrimType ty => Foldable (UArray ty) Source # |
Methods foldl' :: (a -> Element (UArray ty) -> a) -> a -> UArray ty -> a Source # foldr :: (Element (UArray ty) -> a -> a) -> a -> UArray ty -> a Source # foldr' :: (Element (UArray ty) -> a -> a) -> a -> UArray ty -> a Source #
PrimType ty => IndexedCollection (UArray ty) Source # |
Methods (!) :: UArray ty -> Offset (Element (UArray ty)) -> Maybe (Element (UArray ty)) Source # findIndex :: (Element (UArray ty) -> Bool) -> UArray ty -> Maybe (Offset (Element (UArray ty))) Source #
PrimType ty => InnerFunctor (UArray ty) Source # |
Methods imap :: (Element (UArray ty) -> Element (UArray ty)) -> UArray ty -> UArray ty Source #
PrimType ty => Copy (UArray ty) Source # |
Methods copy :: UArray ty -> UArray ty Source #
PrimType ty => Collection (UArray ty) Source # |

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 => Sequential (UArray ty) Source # |

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 # |

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 ty => Buildable (UArray ty) Source # |
Associated Types type Mutable (UArray ty) :: * -> * Source # type Step (UArray ty) :: * Source # Methods append :: 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 a => Hashable (UArray a) Source # |
Methods hashMix :: Hasher st => UArray a -> st -> st Source #
type Item (UArray ty) |
type Item (UArray ty) = ty
type Element (UArray ty) Source # |
type Element (UArray ty) = ty
type Mutable (UArray ty) Source # |
type Mutable (UArray ty) = MUArray ty
type Step (UArray ty) Source # |
type Step (UArray ty) = ty

class Eq ty => PrimType ty #

Represent the accessor for types that can be stored in the UArray and MUArray.

Types need to be a instance of storable and have fixed sized.

Minimal complete definition

primSizeInBytes, primShiftToBytes, primBaUIndex, primMbaURead, primMbaUWrite, primAddrIndex, primAddrRead, primAddrWrite

Instances

PrimType Char |

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 |

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 |

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 |

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 Int8 |

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 Int16 |

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 |

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 |

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 Word |

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 Word8 |

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 Word16 |

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 |

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 |

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 CChar |

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 |

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 Word256 |

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 Word128 |

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 Char7 |

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 Seconds # |

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 NanoSeconds # |

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 a => PrimType (LE a) |

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 () #

PrimType a => PrimType (BE a) |

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 () #

data Array a :: * -> * #

Array of a

Instances

Functor Array |
Methods fmap :: (a -> b) -> Array a -> Array b # (<$) :: a -> Array b -> Array a #
Mappable Array Source # |
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 #
IsList (Array ty) |
Associated Types type Item (Array ty) :: * # Methods fromList :: [Item (Array ty)] -> Array ty # fromListN :: Int -> [Item (Array ty)] -> Array ty # toList :: Array ty -> [Item (Array ty)] #
Eq a => Eq (Array a) |
Methods (==) :: Array a -> Array a -> Bool # (/=) :: Array a -> Array a -> Bool #
Data ty => Data (Array ty) |

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 :: (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) #

Ord a => Ord (Array a) |
Methods compare :: Array a -> Array a -> Ordering # (<) :: Array a -> Array a -> Bool # (<=) :: Array a -> Array a -> Bool # (>) :: Array a -> Array a -> Bool # (>=) :: Array a -> Array a -> Bool # max :: Array a -> Array a -> Array a # min :: Array a -> Array a -> Array a #
Show a => Show (Array a) |
Methods showsPrec :: Int -> Array a -> ShowS # show :: Array a -> String # showList :: [Array a] -> ShowS #
Semigroup (Array a) |
Methods (<>) :: Array a -> Array a -> Array a # sconcat :: NonEmpty (Array a) -> Array a # stimes :: Integral b => b -> Array a -> Array a #
Monoid (Array a) |
Methods mempty :: Array a # mappend :: Array a -> Array a -> Array a # mconcat :: [Array a] -> Array a #
NormalForm a => NormalForm (Array a) |
Methods toNormalForm :: Array a -> () #
Fold1able (Array ty) Source # |
Methods foldl1' :: (Element (Array ty) -> Element (Array ty) -> Element (Array ty)) -> NonEmpty (Array ty) -> Element (Array ty) Source # foldr1 :: (Element (Array ty) -> Element (Array ty) -> Element (Array ty)) -> NonEmpty (Array ty) -> Element (Array ty) Source #
Foldable (Array ty) Source # |
Methods foldl' :: (a -> Element (Array ty) -> a) -> a -> Array ty -> a Source # foldr :: (Element (Array ty) -> a -> a) -> a -> Array ty -> a Source # foldr' :: (Element (Array ty) -> a -> a) -> a -> Array ty -> a Source #
IndexedCollection (Array ty) Source # |
Methods (!) :: Array ty -> Offset (Element (Array ty)) -> Maybe (Element (Array ty)) Source # findIndex :: (Element (Array ty) -> Bool) -> Array ty -> Maybe (Offset (Element (Array ty))) Source #
InnerFunctor (Array ty) Source # |
Methods imap :: (Element (Array ty) -> Element (Array ty)) -> Array ty -> Array ty Source #
Copy (Array ty) Source # |
Methods copy :: Array ty -> Array ty Source #
Collection (Array ty) Source # |

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 #

Sequential (Array ty) Source # |

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 # |

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 # |

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 #

Buildable (Array ty) Source # |
Associated Types type Mutable (Array ty) :: * -> * Source # type Step (Array ty) :: * Source # Methods append :: 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 #
Hashable a => Hashable (Array a) Source # |
Methods hashMix :: Hasher st => Array a -> st -> st Source #
type Item (Array ty) |
type Item (Array ty) = ty
type Element (Array ty) Source # |
type Element (Array ty) = ty
type Mutable (Array ty) Source # |
type Mutable (Array ty) = MArray ty
type Step (Array ty) Source # |
type Step (Array ty) = ty

data String :: * #

Opaque packed array of characters in the UTF8 encoding

Instances

IsList String |
Associated Types type Item String :: * # Methods fromList :: [Item String] -> String # fromListN :: Int -> [Item String] -> String # toList :: String -> [Item String] #
Eq String |
Methods (==) :: String -> String -> Bool # (/=) :: String -> String -> Bool #
Data String |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> String -> c String #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c String #

toConstr :: String -> Constr #

dataTypeOf :: String -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c String) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c String) #

gmapT :: (forall b. Data b => b -> b) -> String -> String #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> String -> r #

gmapQr :: (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 #

Ord String |
Methods compare :: String -> String -> Ordering # (<) :: String -> String -> Bool # (<=) :: String -> String -> Bool # (>) :: String -> String -> Bool # (>=) :: String -> String -> Bool # max :: String -> String -> String # min :: String -> String -> String #
Show String |
Methods showsPrec :: Int -> String -> ShowS # show :: String -> String # showList :: [String] -> ShowS #
IsString String |
Methods fromString :: String -> String #
Semigroup String |
Methods (<>) :: String -> String -> String # sconcat :: NonEmpty String -> String # stimes :: Integral b => b -> String -> String #
Monoid String |
Methods mempty :: String # mappend :: String -> String -> String # mconcat :: [String] -> String #
NormalForm String |
Methods toNormalForm :: String -> () #
IndexedCollection String Source # |
Methods (!) :: String -> Offset (Element String) -> Maybe (Element String) Source # findIndex :: (Element String -> Bool) -> String -> Maybe (Offset (Element String)) Source #
InnerFunctor String Source # |
Methods imap :: (Element String -> Element String) -> String -> String Source #
Copy String Source # |
Methods copy :: String -> String Source #
Collection String Source # |

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 #

any :: (Element String -> Bool) -> String -> Bool Source #

all :: (Element String -> Bool) -> String -> Bool Source #

Sequential String Source # |

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 #

stripPrefix :: String -> String -> Maybe String Source #

stripSuffix :: String -> String -> Maybe String Source #

Zippable String Source # |

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 #

Buildable String Source # |
Associated Types type Mutable String :: * -> * Source # type Step String :: * Source # Methods append :: PrimMonad prim => Element String -> Builder String (Mutable String) (Step String) prim err () Source # build :: PrimMonad prim => Int -> Builder String (Mutable String) (Step String) prim err () -> prim (Either err String) Source #
ParserSource String Source # |
Associated Types type Chunk String :: * Source # 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 #
Hashable String Source # |
Methods hashMix :: Hasher st => String -> st -> st Source #
Arbitrary String Source # |
Methods arbitrary :: Gen String Source #
IsProperty (String, Bool) Source # |
Methods property :: (String, Bool) -> Property Source #
type Item String |
type Item String = Char
type Element String Source # |
type Element String = Char
type Mutable String Source # |
type Mutable String = MutableString
type Step String Source # |
type Step String = Word8
type Chunk String Source # |
type Chunk String = String

## Numeric functions

(^^) :: (Fractional a, Integral b) => a -> b -> a infixr 8 #

raise a number to an integral power

fromIntegral :: (Integral a, Num b) => a -> b #

general coercion from integral types

realToFrac :: (Real a, Fractional b) => a -> b #

general coercion to fractional types

## Monoids

class Semigroup a #

The class of semigroups (types with an associative binary operation).

Since: 4.9.0.0

Instances

Semigroup Ordering |
Methods (<>) :: Ordering -> Ordering -> Ordering # sconcat :: NonEmpty Ordering -> Ordering # stimes :: Integral b => b -> Ordering -> Ordering #
Semigroup () |
Methods (<>) :: () -> () -> () # sconcat :: NonEmpty () -> () # stimes :: Integral b => b -> () -> () #
Semigroup Void |
Methods (<>) :: Void -> Void -> Void # sconcat :: NonEmpty Void -> Void # stimes :: Integral b => b -> Void -> Void #
Semigroup All |
Methods (<>) :: All -> All -> All # sconcat :: NonEmpty All -> All # stimes :: Integral b => b -> All -> All #
Semigroup Any |
Methods (<>) :: Any -> Any -> Any # sconcat :: NonEmpty Any -> Any # stimes :: Integral b => b -> Any -> Any #
Semigroup String |
Methods (<>) :: String -> String -> String # sconcat :: NonEmpty String -> String # stimes :: Integral b => b -> String -> String #
Semigroup AsciiString |
Methods (<>) :: AsciiString -> AsciiString -> AsciiString # sconcat :: NonEmpty AsciiString -> AsciiString # stimes :: Integral b => b -> AsciiString -> AsciiString #
Semigroup Builder # |
Methods (<>) :: Builder -> Builder -> Builder # sconcat :: NonEmpty Builder -> Builder # stimes :: Integral b => b -> Builder -> Builder #
Semigroup Bitmap # |
Methods (<>) :: Bitmap -> Bitmap -> Bitmap # sconcat :: NonEmpty Bitmap -> Bitmap # stimes :: Integral b => b -> Bitmap -> Bitmap #
Semigroup FileName # |
Methods (<>) :: FileName -> FileName -> FileName # sconcat :: NonEmpty FileName -> FileName # stimes :: Integral b => b -> FileName -> FileName #
Semigroup [a] |
Methods (<>) :: [a] -> [a] -> [a] # sconcat :: NonEmpty [a] -> [a] # stimes :: Integral b => b -> [a] -> [a] #
Semigroup a => Semigroup (Maybe a) |
Methods (<>) :: Maybe a -> Maybe a -> Maybe a # sconcat :: NonEmpty (Maybe a) -> Maybe a # stimes :: Integral b => b -> Maybe a -> Maybe a #
Semigroup a => Semigroup (Identity a) |
Methods (<>) :: Identity a -> Identity a -> Identity a # sconcat :: NonEmpty (Identity a) -> Identity a # stimes :: Integral b => b -> Identity a -> Identity a #
Ord a => Semigroup (Min a) |
Methods (<>) :: Min a -> Min a -> Min a # sconcat :: NonEmpty (Min a) -> Min a # stimes :: Integral b => b -> Min a -> Min a #
Ord a => Semigroup (Max a) |
Methods (<>) :: Max a -> Max a -> Max a # sconcat :: NonEmpty (Max a) -> Max a # stimes :: Integral b => b -> Max a -> Max a #
Semigroup (First a) |
Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # stimes :: Integral b => b -> First a -> First a #
Semigroup (Last a) |
Methods (<>) :: Last a -> Last a -> Last a # sconcat :: NonEmpty (Last a) -> Last a # stimes :: Integral b => b -> Last a -> Last a #
Monoid m => Semigroup (WrappedMonoid m) |
Methods (<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # sconcat :: NonEmpty (WrappedMonoid m) -> WrappedMonoid m # stimes :: Integral b => b -> WrappedMonoid m -> WrappedMonoid m #
Semigroup a => Semigroup (Option a) |
Methods (<>) :: Option a -> Option a -> Option a # sconcat :: NonEmpty (Option a) -> Option a # stimes :: Integral b => b -> Option a -> Option a #
Semigroup (NonEmpty a) |
Methods (<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a # sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a # stimes :: Integral b => b -> NonEmpty a -> NonEmpty a #
Semigroup a => Semigroup (Dual a) |
Methods (<>) :: Dual a -> Dual a -> Dual a # sconcat :: NonEmpty (Dual a) -> Dual a # stimes :: Integral b => b -> Dual a -> Dual a #
Semigroup (Endo a) |
Methods (<>) :: Endo a -> Endo a -> Endo a # sconcat :: NonEmpty (Endo a) -> Endo a # stimes :: Integral b => b -> Endo a -> Endo a #
Num a => Semigroup (Sum a) |
Methods (<>) :: Sum a -> Sum a -> Sum a # sconcat :: NonEmpty (Sum a) -> Sum a # stimes :: Integral b => b -> Sum a -> Sum a #
Num a => Semigroup (Product a) |
Methods (<>) :: Product a -> Product a -> Product a # sconcat :: NonEmpty (Product a) -> Product a # stimes :: Integral b => b -> Product a -> Product a #
Semigroup (First a) |
Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # stimes :: Integral b => b -> First a -> First a #
Semigroup (Last a) |
Methods (<>) :: Last a -> Last a -> Last a # sconcat :: NonEmpty (Last a) -> Last a # stimes :: Integral b => b -> Last a -> Last a #
Semigroup (Array a) |
Methods (<>) :: Array a -> Array a -> Array a # sconcat :: NonEmpty (Array a) -> Array a # stimes :: Integral b => b -> Array a -> Array a #
PrimType ty => Semigroup (UArray ty) |
Methods (<>) :: UArray ty -> UArray ty -> UArray ty # sconcat :: NonEmpty (UArray ty) -> UArray ty # stimes :: Integral b => b -> UArray ty -> UArray ty #
PrimType ty => Semigroup (Block ty) |
Methods (<>) :: Block ty -> Block ty -> Block ty # sconcat :: NonEmpty (Block ty) -> Block ty # stimes :: Integral b => b -> Block ty -> Block ty #
Semigroup (CountOf ty) |
Methods (<>) :: CountOf ty -> CountOf ty -> CountOf ty # sconcat :: NonEmpty (CountOf ty) -> CountOf ty # stimes :: Integral b => b -> CountOf ty -> CountOf ty #
Semigroup (DList a) # |
Methods (<>) :: DList a -> DList a -> DList a # sconcat :: NonEmpty (DList a) -> DList a # stimes :: Integral b => b -> DList a -> DList a #
Semigroup (ChunkedUArray a) # |
Methods (<>) :: ChunkedUArray a -> ChunkedUArray a -> ChunkedUArray a # sconcat :: NonEmpty (ChunkedUArray a) -> ChunkedUArray a # stimes :: Integral b => b -> ChunkedUArray a -> ChunkedUArray a #
Semigroup b => Semigroup (a -> b) |
Methods (<>) :: (a -> b) -> (a -> b) -> a -> b # sconcat :: NonEmpty (a -> b) -> a -> b # stimes :: Integral b => b -> (a -> b) -> a -> b #
Semigroup (Either a b) |
Methods (<>) :: Either a b -> Either a b -> Either a b # sconcat :: NonEmpty (Either a b) -> Either a b # stimes :: Integral b => b -> Either a b -> Either a b #
(Semigroup a, Semigroup b) => Semigroup (a, b) |
Methods (<>) :: (a, b) -> (a, b) -> (a, b) # sconcat :: NonEmpty (a, b) -> (a, b) # stimes :: Integral b => b -> (a, b) -> (a, b) #
Semigroup (Proxy k s) |
Methods (<>) :: Proxy k s -> Proxy k s -> Proxy k s # sconcat :: NonEmpty (Proxy k s) -> Proxy k s # stimes :: Integral b => b -> Proxy k s -> Proxy k s #
(Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c) |
Methods (<>) :: (a, b, c) -> (a, b, c) -> (a, b, c) # sconcat :: NonEmpty (a, b, c) -> (a, b, c) # stimes :: Integral b => b -> (a, b, c) -> (a, b, c) #
Semigroup a => Semigroup (Const k a b) |
Methods (<>) :: Const k a b -> Const k a b -> Const k a b # sconcat :: NonEmpty (Const k a b) -> Const k a b # stimes :: Integral b => b -> Const k a b -> Const k a b #
Alternative f => Semigroup (Alt * f a) |
Methods (<>) :: Alt * f a -> Alt * f a -> Alt * f a # sconcat :: NonEmpty (Alt * f a) -> Alt * f a # stimes :: Integral b => b -> Alt * f a -> Alt * f a #
(Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d) |
Methods (<>) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # sconcat :: NonEmpty (a, b, c, d) -> (a, b, c, d) # stimes :: Integral b => b -> (a, b, c, d) -> (a, b, c, d) #
(Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e) |
Methods (<>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # sconcat :: NonEmpty (a, b, c, d, e) -> (a, b, c, d, e) # stimes :: Integral b => b -> (a, b, c, d, e) -> (a, b, c, d, e) #

class Monoid a where #

The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:

-     mappend mempty x = x

-     mappend x mempty = x

-     mappend x (mappend y z) = mappend (mappend x y) z

-     mconcat = foldr mappend mempty

The method names refer to the monoid of lists under concatenation, but there are many other instances.

Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define `newtype`s and make those instances of `Monoid`, e.g. `Sum` and `Product`.

Minimal complete definition

mempty, mappend

Methods

mempty :: a #

Identity of `mappend`

mappend :: a -> a -> a #

An associative operation

mconcat :: [a] -> a #

Fold a list using the monoid. For most types, the default definition for `mconcat` will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.

Instances

Monoid Ordering |
Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
Monoid () |
Methods mempty :: () # mappend :: () -> () -> () # mconcat :: [()] -> () #
Monoid All |
Methods mempty :: All # mappend :: All -> All -> All # mconcat :: [All] -> All #
Monoid Any |
Methods mempty :: Any # mappend :: Any -> Any -> Any # mconcat :: [Any] -> Any #
Monoid String |
Methods mempty :: String # mappend :: String -> String -> String # mconcat :: [String] -> String #
Monoid AsciiString |
Methods mempty :: AsciiString # mappend :: AsciiString -> AsciiString -> AsciiString # mconcat :: [AsciiString] -> AsciiString #
Monoid Builder # |
Methods mempty :: Builder # mappend :: Builder -> Builder -> Builder # mconcat :: [Builder] -> Builder #
Monoid Bitmap # |
Methods mempty :: Bitmap # mappend :: Bitmap -> Bitmap -> Bitmap # mconcat :: [Bitmap] -> Bitmap #
Monoid FileName # |
Methods mempty :: FileName # mappend :: FileName -> FileName -> FileName # mconcat :: [FileName] -> FileName #
Monoid [a] |
Methods mempty :: [a] # mappend :: [a] -> [a] -> [a] # mconcat :: [[a]] -> [a] #
Monoid a => Monoid (Maybe a) | Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `e*e = e` and `e*s = s = s*e` for all `s ∈ S`." Since there is no "Semigroup" typeclass providing just `mappend`, we use `Monoid` instead.
Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Monoid a => Monoid (IO a) |
Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
Ord a => Monoid (Max a) |
Methods mempty :: Max a # mappend :: Max a -> Max a -> Max a # mconcat :: [Max a] -> Max a #
Ord a => Monoid (Min a) |
Methods mempty :: Min a # mappend :: Min a -> Min a -> Min a # mconcat :: [Min a] -> Min a #
Monoid a => Monoid (Identity a) |
Methods mempty :: Identity a # mappend :: Identity a -> Identity a -> Identity a # mconcat :: [Identity a] -> Identity a #
(Ord a, Bounded a) => Monoid (Min a) |
Methods mempty :: Min a # mappend :: Min a -> Min a -> Min a # mconcat :: [Min a] -> Min a #
(Ord a, Bounded a) => Monoid (Max a) |
Methods mempty :: Max a # mappend :: Max a -> Max a -> Max a # mconcat :: [Max a] -> Max a #
Monoid m => Monoid (WrappedMonoid m) |
Methods mempty :: WrappedMonoid m # mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # mconcat :: [WrappedMonoid m] -> WrappedMonoid m #
Semigroup a => Monoid (Option a) |
Methods mempty :: Option a # mappend :: Option a -> Option a -> Option a # mconcat :: [Option a] -> Option a #
Monoid a => Monoid (Dual a) |
Methods mempty :: Dual a # mappend :: Dual a -> Dual a -> Dual a # mconcat :: [Dual a] -> Dual a #
Monoid (Endo a) |
Methods mempty :: Endo a # mappend :: Endo a -> Endo a -> Endo a # mconcat :: [Endo a] -> Endo a #
Num a => Monoid (Sum a) |
Methods mempty :: Sum a # mappend :: Sum a -> Sum a -> Sum a # mconcat :: [Sum a] -> Sum a #
Num a => Monoid (Product a) |
Methods mempty :: Product a # mappend :: Product a -> Product a -> Product a # mconcat :: [Product a] -> Product a #
Monoid (First a) |
Methods mempty :: First a # mappend :: First a -> First a -> First a # mconcat :: [First a] -> First a #
Monoid (Last a) |
Methods mempty :: Last a # mappend :: Last a -> Last a -> Last a # mconcat :: [Last a] -> Last a #
Monoid (Array a) |
Methods mempty :: Array a # mappend :: Array a -> Array a -> Array a # mconcat :: [Array a] -> Array a #
PrimType ty => Monoid (UArray ty) |
Methods mempty :: UArray ty # mappend :: UArray ty -> UArray ty -> UArray ty # mconcat :: [UArray ty] -> UArray ty #
PrimType ty => Monoid (Block ty) |
Methods mempty :: Block ty # mappend :: Block ty -> Block ty -> Block ty # mconcat :: [Block ty] -> Block ty #
Monoid (CountOf ty) |
Methods mempty :: CountOf ty # mappend :: CountOf ty -> CountOf ty -> CountOf ty # mconcat :: [CountOf ty] -> CountOf ty #
Monoid (DList a) # |
Methods mempty :: DList a # mappend :: DList a -> DList a -> DList a # mconcat :: [DList a] -> DList a #
Monoid (ChunkedUArray a) # |
Methods mempty :: ChunkedUArray a # mappend :: ChunkedUArray a -> ChunkedUArray a -> ChunkedUArray a # mconcat :: [ChunkedUArray a] -> ChunkedUArray a #
Monoid b => Monoid (a -> b) |
Methods mempty :: a -> b # mappend :: (a -> b) -> (a -> b) -> a -> b # mconcat :: [a -> b] -> a -> b #
(Monoid a, Monoid b) => Monoid (a, b) |
Methods mempty :: (a, b) # mappend :: (a, b) -> (a, b) -> (a, b) # mconcat :: [(a, b)] -> (a, b) #
Monoid (Proxy k s) |
Methods mempty :: Proxy k s # mappend :: Proxy k s -> Proxy k s -> Proxy k s # mconcat :: [Proxy k s] -> Proxy k s #
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) |
Methods mempty :: (a, b, c) # mappend :: (a, b, c) -> (a, b, c) -> (a, b, c) # mconcat :: [(a, b, c)] -> (a, b, c) #
Monoid a => Monoid (Const k a b) |
Methods mempty :: Const k a b # mappend :: Const k a b -> Const k a b -> Const k a b # mconcat :: [Const k a b] -> Const k a b #
Alternative f => Monoid (Alt * f a) |
Methods mempty :: Alt * f a # mappend :: Alt * f a -> Alt * f a -> Alt * f a # mconcat :: [Alt * f a] -> Alt * f a #
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) |
Methods mempty :: (a, b, c, d) # mappend :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # mconcat :: [(a, b, c, d)] -> (a, b, c, d) #
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) |
Methods mempty :: (a, b, c, d, e) # mappend :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # mconcat :: [(a, b, c, d, e)] -> (a, b, c, d, e) #

(<>) :: Monoid m => m -> m -> m infixr 6 #

An infix synonym for `mappend`.

Since: 4.5.0.0

## Collection

class (IsList c, Item c ~ Element c) => Collection c where Source #

A set of methods for ordered colection

Minimal complete definition

null, length, (elem | notElem), minimum, maximum, all, any

Methods

null :: c -> Bool Source #

Check if a collection is empty

length :: c -> CountOf (Element c) Source #

Length of a collection (number of Element c)

elem :: forall a. (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 :: forall a. (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 :: forall a. (Ord a, a ~ Element c) => NonEmpty c -> Element c Source #

Get the maximum element of a collection

minimum :: forall a. (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 String Source # |

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 #

any :: (Element String -> Bool) -> String -> Bool Source #

all :: (Element String -> Bool) -> String -> Bool Source #

Collection AsciiString Source # |

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 Bitmap Source # |

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 #

any :: (Element Bitmap -> Bool) -> Bitmap -> Bool Source #

all :: (Element Bitmap -> Bool) -> Bitmap -> Bool Source #

Collection [a] Source # |

Methods

null :: [a] -> Bool Source #

length :: [a] -> CountOf (Element [a]) Source #

elem :: (Eq a, (* ~ a) (Element [a])) => Element [a] -> [a] -> Bool Source #

notElem :: (Eq a, (* ~ a) (Element [a])) => Element [a] -> [a] -> Bool Source #

maximum :: (Ord a, (* ~ a) (Element [a])) => NonEmpty [a] -> Element [a] Source #

minimum :: (Ord a, (* ~ a) (Element [a])) => NonEmpty [a] -> Element [a] Source #

any :: (Element [a] -> Bool) -> [a] -> Bool Source #

all :: (Element [a] -> Bool) -> [a] -> Bool Source #

Collection (Array ty) Source # |

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 #

PrimType ty => Collection (UArray ty) Source # |

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 (Block ty) Source # |

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 c => Collection (NonEmpty c) Source # |

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 #

Collection (DList a) Source # |

Methods

null :: DList a -> Bool Source #

length :: DList a -> CountOf (Element (DList a)) Source #

elem :: (Eq a, (* ~ a) (Element (DList a))) => Element (DList a) -> DList a -> Bool Source #

notElem :: (Eq a, (* ~ a) (Element (DList a))) => Element (DList a) -> DList a -> Bool Source #

maximum :: (Ord a, (* ~ a) (Element (DList a))) => NonEmpty (DList a) -> Element (DList a) Source #

minimum :: (Ord a, (* ~ a) (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 #

PrimType ty => Collection (ChunkedUArray ty) Source # |

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 #

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

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

breakElem :: Eq (Element c) => Element c -> c -> (c, c) Source #

Split a collection when the predicate return true starting from the end of the collection

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 :: Monoid (Item c) => Element c -> c -> Element c Source #

`intercalate` `xs xss` is equivalent to `(`mconcat` (`intersperse` xs xss))`. It inserts the list `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 thtat satisfy the predicate and those that don't

reverse :: c -> c Source #

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 :: Eq (Element c) => c -> c -> Bool Source #

Takes two collections and returns True iff the first collection is a prefix of the second.

isPrefixOf :: Eq c => c -> c -> Bool Source #

Takes two collections and returns True iff the first collection is a prefix of the second.

isSuffixOf :: Eq (Element c) => c -> c -> Bool Source #

Takes two collections and returns True iff the first collection is a suffix of the second.

isSuffixOf :: Eq c => c -> c -> Bool Source #

Takes two collections and returns True iff the first collection is a suffix of the second.

isInfixOf :: Eq (Element c) => c -> c -> Bool Source #

Takes two collections and returns True iff the first collection is an infix of the second.

isInfixOf :: Eq c => c -> c -> Bool Source #

Takes two collections and returns True iff the first collection is an infix of the second.

stripPrefix :: Eq (Element c) => c -> c -> Maybe c Source #

Try to strip a prefix from a collection

stripSuffix :: Eq (Element c) => c -> c -> Maybe c Source #

Try to strip a suffix from a collection

Instances

Sequential String Source # |

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 #

stripPrefix :: String -> String -> Maybe String Source #

stripSuffix :: String -> String -> Maybe String Source #

Sequential AsciiString Source # |

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 Bitmap Source # |

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 #

stripPrefix :: Bitmap -> Bitmap -> Maybe Bitmap Source #

stripSuffix :: Bitmap -> Bitmap -> Maybe Bitmap Source #

Sequential [a] Source # |

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 #

Sequential (Array ty) Source # |

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 # |

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 (Block ty) Source # |

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 (DList a) Source # |

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 #

PrimType ty => Sequential (ChunkedUArray ty) Source # |

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 #

data NonEmpty a :: * -> * #

NonEmpty property for any Collection

Instances

IsList c => IsList (NonEmpty c) |
Associated Types type Item (NonEmpty c) :: * # Methods fromList :: [Item (NonEmpty c)] -> NonEmpty c # fromListN :: Int -> [Item (NonEmpty c)] -> NonEmpty c # toList :: NonEmpty c -> [Item (NonEmpty c)] #
Eq a => Eq (NonEmpty a) |
Methods (==) :: NonEmpty a -> NonEmpty a -> Bool # (/=) :: NonEmpty a -> NonEmpty a -> Bool #
Show a => Show (NonEmpty a) |
Methods showsPrec :: Int -> NonEmpty a -> ShowS # show :: NonEmpty a -> String # showList :: [NonEmpty a] -> ShowS #
Collection c => Collection (NonEmpty c) Source # |

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 #

type Item (NonEmpty c) |
type Item (NonEmpty c) = Item c
type Element (NonEmpty a) Source # |
type Element (NonEmpty a) = Element a

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

Minimal complete definition

foldl', foldr

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 # |
Methods foldl' :: (a -> Element Bitmap -> a) -> a -> Bitmap -> a Source # foldr :: (Element Bitmap -> a -> a) -> a -> Bitmap -> a Source # foldr' :: (Element Bitmap -> a -> a) -> a -> Bitmap -> a Source #
Foldable [a] Source # |
Methods foldl' :: (a -> Element [a] -> a) -> a -> [a] -> a Source # foldr :: (Element [a] -> a -> a) -> a -> [a] -> a Source # foldr' :: (Element [a] -> a -> a) -> a -> [a] -> a Source #
Foldable (Array ty) Source # |
Methods foldl' :: (a -> Element (Array ty) -> a) -> a -> Array ty -> a Source # foldr :: (Element (Array ty) -> a -> a) -> a -> Array ty -> a Source # foldr' :: (Element (Array ty) -> a -> a) -> a -> Array ty -> a Source #
PrimType ty => Foldable (UArray ty) Source # |
Methods foldl' :: (a -> Element (UArray ty) -> a) -> a -> UArray ty -> a Source # foldr :: (Element (UArray ty) -> a -> a) -> a -> UArray ty -> a Source # foldr' :: (Element (UArray ty) -> a -> a) -> a -> UArray ty -> a Source #
PrimType ty => Foldable (Block ty) Source # |
Methods foldl' :: (a -> Element (Block ty) -> a) -> a -> Block ty -> a Source # foldr :: (Element (Block ty) -> a -> a) -> a -> Block ty -> a Source # foldr' :: (Element (Block ty) -> a -> a) -> a -> Block ty -> a Source #
Foldable (DList a) Source # |
Methods foldl' :: (a -> Element (DList a) -> a) -> a -> DList a -> a Source # foldr :: (Element (DList a) -> a -> a) -> a -> DList a -> a Source # foldr' :: (Element (DList a) -> a -> a) -> a -> DList a -> a Source #
PrimType ty => Foldable (ChunkedUArray ty) Source # |
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 #

## Maybe

mapMaybe :: (a -> Maybe b) -> [a] -> [b] #

The `mapMaybe` function is a version of `map` which can throw out elements. In particular, the functional argument returns something of type ``Maybe` b`. If this is `Nothing`, no element is added on to the result list. If it is ``Just` b`, then `b` is included in the result list.

#### Examples

Using ``mapMaybe` f x` is a shortcut for ``catMaybes` $ `map` f x` in most cases:

    >>> import Text.Read ( readMaybe )
    >>> let readMaybeInt = readMaybe :: String -> Maybe Int
    >>> mapMaybe readMaybeInt ["1", "Foo", "3"]
    [1,3]
    >>> catMaybes $ map readMaybeInt ["1", "Foo", "3"]
    [1,3]

If we map the `Just` constructor, the entire list should be returned:

    >>> mapMaybe Just [1,2,3]
    [1,2,3]

catMaybes :: [Maybe a] -> [a] #

The `catMaybes` function takes a list of `Maybe`s and returns a list of all the `Just` values.

#### Examples

Basic usage:

    >>> catMaybes [Just 1, Nothing, Just 3]
    [1,3]

When constructing a list of `Maybe` values, `catMaybes` can be used to return all of the "success" results (if the list is the result of a `map`, then `mapMaybe` would be more appropriate):

    >>> import Text.Read ( readMaybe )
    >>> [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ]
    [Just 1,Nothing,Just 3]
    >>> catMaybes $ [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ]
    [1,3]

fromMaybe :: a -> Maybe a -> a #

The `fromMaybe` function takes a default value and and `Maybe` value. If the `Maybe` is `Nothing`, it returns the default values; otherwise, it returns the value contained in the `Maybe`.

#### Examples

Basic usage:

    >>> fromMaybe "" (Just "Hello, World!")
    "Hello, World!"

    >>> fromMaybe "" Nothing
    ""

Read an integer from a string using `readMaybe`. If we fail to parse an integer, we want to return `0` by default:

    >>> import Text.Read ( readMaybe )
    >>> fromMaybe 0 (readMaybe "5")
    5
    >>> fromMaybe 0 (readMaybe "")
    0

isJust :: Maybe a -> Bool #

The `isJust` function returns `True` iff its argument is of the form `Just _`.

#### Examples

Basic usage:

    >>> isJust (Just 3)
    True

    >>> isJust (Just ())
    True

    >>> isJust Nothing
    False

Only the outer constructor is taken into consideration:

    >>> isJust (Just Nothing)
    True

isNothing :: Maybe a -> Bool #

The `isNothing` function returns `True` iff its argument is `Nothing`.

#### Examples

Basic usage:

    >>> isNothing (Just 3)
    False

    >>> isNothing (Just ())
    False

    >>> isNothing Nothing
    True

Only the outer constructor is taken into consideration:

    >>> isNothing (Just Nothing)
    False

listToMaybe :: [a] -> Maybe a #

The `listToMaybe` function returns `Nothing` on an empty list or ``Just` a` where `a` is the first element of the list.

#### Examples

Basic usage:

    >>> listToMaybe []
    Nothing

    >>> listToMaybe [9]
    Just 9

    >>> listToMaybe [1,2,3]
    Just 1

Composing `maybeToList` with `listToMaybe` should be the identity on singleton/empty lists:

    >>> maybeToList $ listToMaybe [5]
    [5]
    >>> maybeToList $ listToMaybe []
    []

But not on lists with more than one element:

    >>> maybeToList $ listToMaybe [1,2,3]
    [1]

maybeToList :: Maybe a -> [a] #

The `maybeToList` function returns an empty list when given `Nothing` or a singleton list when not given `Nothing`.

#### Examples

Basic usage:

    >>> maybeToList (Just 7)
    [7]

    >>> maybeToList Nothing
    []

One can use `maybeToList` to avoid pattern matching when combined with a function that (safely) works on lists:

    >>> import Text.Read ( readMaybe )
    >>> sum $ maybeToList (readMaybe "3")
    3
    >>> sum $ maybeToList (readMaybe "")
    0

## Either

partitionEithers :: [Either a b] -> ([a], [b]) #

Partitions a list of `Either` into two lists. All the `Left` elements are extracted, in order, to the first component of the output. Similarly the `Right` elements are extracted to the second component of the output.

#### Examples

Basic usage:

    >>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
    >>> partitionEithers list
    (["foo","bar","baz"],[3,7])

The pair returned by ``partitionEithers` x` should be the same pair as `(`lefts` x, `rights` x)`:

    >>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
    >>> partitionEithers list == (lefts list, rights list)
    True

lefts :: [Either a b] -> [a] #

Extracts from a list of `Either` all the `Left` elements. All the `Left` elements are extracted in order.

#### Examples

Basic usage:

    >>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
    >>> lefts list
    ["foo","bar","baz"]

rights :: [Either a b] -> [b] #

Extracts from a list of `Either` all the `Right` elements. All the `Right` elements are extracted in order.

#### Examples

Basic usage:

    >>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
    >>> rights list
    [3,7]

## Function

on :: (b -> b -> c) -> (a -> b) -> a -> a -> c infixl 0 #

`(*) `on` f = \x y -> f x * f y`.

Typical usage: ``sortBy` (`compare` `on` `fst`)`.

Algebraic properties:

- `(*) `on` `id` = (*)` (if `(*) ∉ {⊥, `const` ⊥}`)

-     ((*) `on` f) `on` g = (*) `on` (f . g)

-     flip on f . flip on g = flip on (g . f)

## Applicative

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 #

An infix synonym for `fmap`.

The name of this operator is an allusion to `$`. Note the similarities between their types:

     ($)  ::              (a -> b) ->   a ->   b
    (<$>) :: Functor f => (a -> b) -> f a -> f b

Whereas `$` is function application, `<$>` is function application lifted over a `Functor`.

#### Examples

Convert from a ``Maybe` `Int`` to a ``Maybe` `String`` using `show`:

    >>> show <$> Nothing
    Nothing
    >>> show <$> Just 3
    Just "3"

Convert from an ``Either` `Int` `Int`` to an ``Either` `Int`` `String` using `show`:

    >>> show <$> Left 17
    Left 17
    >>> show <$> Right 17
    Right "17"

Double each element of a list:

    >>> (*2) <$> [1,2,3]
    [2,4,6]

Apply `even` to the second element of a pair:

    >>> even <$> (2,2)
    (2,True)

(<|>) :: Alternative f => forall a. f a -> f a -> f a #

An associative binary operation

## Monad

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 #

Left-to-right Kleisli composition of monads.

## Exceptions

class (Typeable * e, Show e) => Exception e where #

Any type that you wish to throw or catch as an exception must be an instance of the `Exception` class. The simplest case is a new exception type directly below the root:

    data MyException = ThisException | ThatException
        deriving (Show, Typeable)

    instance Exception MyException

The default method definitions in the `Exception` class do what we need in this case. You can now throw and catch `ThisException` and `ThatException` as exceptions:

    *Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException))
    Caught ThisException

In more complicated examples, you may wish to define a whole hierarchy of exceptions:

    ---------------------------------------------------------------------
    -- Make the root exception type for all the exceptions in a compiler

    data SomeCompilerException = forall e . Exception e => SomeCompilerException e
        deriving Typeable

    instance Show SomeCompilerException where
        show (SomeCompilerException e) = show e

    instance Exception SomeCompilerException

    compilerExceptionToException :: Exception e => e -> SomeException
    compilerExceptionToException = toException . SomeCompilerException

    compilerExceptionFromException :: Exception e => SomeException -> Maybe e
    compilerExceptionFromException x = do
        SomeCompilerException a <- fromException x
        cast a

    ---------------------------------------------------------------------
    -- Make a subhierarchy for exceptions in the frontend of the compiler

    data SomeFrontendException = forall e . Exception e => SomeFrontendException e
        deriving Typeable

    instance Show SomeFrontendException where
        show (SomeFrontendException e) = show e

    instance Exception SomeFrontendException where
        toException = compilerExceptionToException
        fromException = compilerExceptionFromException

    frontendExceptionToException :: Exception e => e -> SomeException
    frontendExceptionToException = toException . SomeFrontendException

    frontendExceptionFromException :: Exception e => SomeException -> Maybe e
    frontendExceptionFromException x = do
        SomeFrontendException a <- fromException x
        cast a

    ---------------------------------------------------------------------
    -- Make an exception type for a particular frontend compiler exception

    data MismatchedParentheses = MismatchedParentheses
        deriving (Typeable, Show)

    instance Exception MismatchedParentheses where
        toException   = frontendExceptionToException
        fromException = frontendExceptionFromException

We can now catch a `MismatchedParentheses` exception as `MismatchedParentheses`, `SomeFrontendException` or `SomeCompilerException`, but not other types, e.g. `IOException`:

    *Main> throw MismatchedParentheses catch e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
    Caught MismatchedParentheses
    *Main> throw MismatchedParentheses catch e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException))
    Caught MismatchedParentheses
    *Main> throw MismatchedParentheses catch e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException))
    Caught MismatchedParentheses
    *Main> throw MismatchedParentheses catch e -> putStrLn ("Caught " ++ show (e :: IOException))
    *** Exception: MismatchedParentheses

Methods

toException :: e -> SomeException #

fromException :: SomeException -> Maybe e #

displayException :: e -> String #

Render this exception value in a human-friendly manner.

Default implementation: ``show``.

Since: 4.8.0.0

Instances

Exception Void |
Methods toException :: Void -> SomeException # fromException :: SomeException -> Maybe Void # displayException :: Void -> String #
Exception PatternMatchFail |
Methods toException :: PatternMatchFail -> SomeException # fromException :: SomeException -> Maybe PatternMatchFail # displayException :: PatternMatchFail -> String #
Exception RecSelError |
Methods toException :: RecSelError -> SomeException # fromException :: SomeException -> Maybe RecSelError # displayException :: RecSelError -> String #
Exception RecConError |
Methods toException :: RecConError -> SomeException # fromException :: SomeException -> Maybe RecConError # displayException :: RecConError -> String #
Exception RecUpdError |
Methods toException :: RecUpdError -> SomeException # fromException :: SomeException -> Maybe RecUpdError # displayException :: RecUpdError -> String #
Exception NoMethodError |
Methods toException :: NoMethodError -> SomeException # fromException :: SomeException -> Maybe NoMethodError # displayException :: NoMethodError -> String #
Exception TypeError |
Methods toException :: TypeError -> SomeException # fromException :: SomeException -> Maybe TypeError # displayException :: TypeError -> String #
Exception NonTermination |
Methods toException :: NonTermination -> SomeException # fromException :: SomeException -> Maybe NonTermination # displayException :: NonTermination -> String #
Exception NestedAtomically |
Methods toException :: NestedAtomically -> SomeException # fromException :: SomeException -> Maybe NestedAtomically # displayException :: NestedAtomically -> String #
Exception BlockedIndefinitelyOnMVar |
Methods toException :: BlockedIndefinitelyOnMVar -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar # displayException :: BlockedIndefinitelyOnMVar -> String #
Exception BlockedIndefinitelyOnSTM |
Methods toException :: BlockedIndefinitelyOnSTM -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM # displayException :: BlockedIndefinitelyOnSTM -> String #
Exception Deadlock |
Methods toException :: Deadlock -> SomeException # fromException :: SomeException -> Maybe Deadlock # displayException :: Deadlock -> String #
Exception AllocationLimitExceeded |
Methods toException :: AllocationLimitExceeded -> SomeException # fromException :: SomeException -> Maybe AllocationLimitExceeded # displayException :: AllocationLimitExceeded -> String #
Exception AssertionFailed |
Methods toException :: AssertionFailed -> SomeException # fromException :: SomeException -> Maybe AssertionFailed # displayException :: AssertionFailed -> String #
Exception SomeAsyncException |
Methods toException :: SomeAsyncException -> SomeException # fromException :: SomeException -> Maybe SomeAsyncException # displayException :: SomeAsyncException -> String #
Exception AsyncException |
Methods toException :: AsyncException -> SomeException # fromException :: SomeException -> Maybe AsyncException # displayException :: AsyncException -> String #
Exception ArrayException |
Methods toException :: ArrayException -> SomeException # fromException :: SomeException -> Maybe ArrayException # displayException :: ArrayException -> String #
Exception ExitCode |
Methods toException :: ExitCode -> SomeException # fromException :: SomeException -> Maybe ExitCode # displayException :: ExitCode -> String #
Exception IOException |
Methods toException :: IOException -> SomeException # fromException :: SomeException -> Maybe IOException # displayException :: IOException -> String #
Exception ErrorCall |
Methods toException :: ErrorCall -> SomeException # fromException :: SomeException -> Maybe ErrorCall # displayException :: ErrorCall -> String #
Exception ArithException |
Methods toException :: ArithException -> SomeException # fromException :: SomeException -> Maybe ArithException # displayException :: ArithException -> String #
Exception SomeException |
Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String #
Exception UTF32_Invalid |
Methods toException :: UTF32_Invalid -> SomeException # fromException :: SomeException -> Maybe UTF32_Invalid # displayException :: UTF32_Invalid -> String #
Exception UTF16_Invalid |
Methods toException :: UTF16_Invalid -> SomeException # fromException :: SomeException -> Maybe UTF16_Invalid # displayException :: UTF16_Invalid -> String #
Exception ISO_8859_1_Invalid |
Methods toException :: ISO_8859_1_Invalid -> SomeException # fromException :: SomeException -> Maybe ISO_8859_1_Invalid # displayException :: ISO_8859_1_Invalid -> String #
Exception ASCII7_Invalid |
Methods toException :: ASCII7_Invalid -> SomeException # fromException :: SomeException -> Maybe ASCII7_Invalid # displayException :: ASCII7_Invalid -> String #
Exception ValidationFailure |
Methods toException :: ValidationFailure -> SomeException # fromException :: SomeException -> Maybe ValidationFailure # displayException :: ValidationFailure -> String #
Exception OutOfBound |
Methods toException :: OutOfBound -> SomeException # fromException :: SomeException -> Maybe OutOfBound # displayException :: OutOfBound -> String #
Exception InvalidRecast |
Methods toException :: InvalidRecast -> SomeException # fromException :: SomeException -> Maybe InvalidRecast # displayException :: InvalidRecast -> String #
Exception NonEmptyCollectionIsEmpty |
Methods toException :: NonEmptyCollectionIsEmpty -> SomeException # fromException :: SomeException -> Maybe NonEmptyCollectionIsEmpty # displayException :: NonEmptyCollectionIsEmpty -> String #
Exception PartialError # |
Methods toException :: PartialError -> SomeException # fromException :: SomeException -> Maybe PartialError # displayException :: PartialError -> String #
Typeable * input => Exception (ParseError input) # |
Methods toException :: ParseError input -> SomeException # fromException :: SomeException -> Maybe (ParseError input) # displayException :: ParseError input -> String #

class Typeable k a #

The class `Typeable` allows a concrete representation of a type to be calculated.

Minimal complete definition

typeRep#

data SomeException :: * #

The `SomeException` type is the root of the exception type hierarchy. When an exception of type `e` is thrown, behind the scenes it is encapsulated in a `SomeException`.

Instances

Show SomeException |
Methods showsPrec :: Int -> SomeException -> ShowS # show :: SomeException -> String # showList :: [SomeException] -> ShowS #
Exception SomeException |
Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String #

data IOException :: * #

Exceptions that occur in the `IO` monad. An `IOException` records a more specific error type, a descriptive string and maybe the handle that was used when the error was flagged.

Instances

Eq IOException |
Methods (==) :: IOException -> IOException -> Bool # (/=) :: IOException -> IOException -> Bool #
Show IOException |
Methods showsPrec :: Int -> IOException -> ShowS # show :: IOException -> String # showList :: [IOException] -> ShowS #
Exception IOException |
Methods toException :: IOException -> SomeException # fromException :: SomeException -> Maybe IOException # displayException :: IOException -> String #

## Proxy

data Proxy k t :: forall k. k -> * #

A concrete, poly-kinded proxy type

Constructors

Proxy |

Instances

Monad (Proxy *) |
Methods (>>=) :: Proxy * a -> (a -> Proxy * b) -> Proxy * b # (>>) :: Proxy * a -> Proxy * b -> Proxy * b # return :: a -> Proxy * a # fail :: String -> Proxy * a #
Functor (Proxy *) |
Methods fmap :: (a -> b) -> Proxy * a -> Proxy * b # (<$) :: a -> Proxy * b -> Proxy * a #
Applicative (Proxy *) |
Methods pure :: a -> Proxy * a # (<*>) :: Proxy * (a -> b) -> Proxy * a -> Proxy * b # (*>) :: Proxy * a -> Proxy * b -> Proxy * b # (<*) :: Proxy * a -> Proxy * b -> Proxy * a #
Foldable (Proxy *) |

Methods

fold :: Monoid m => Proxy * m -> 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 #

toList :: Proxy * a -> [a] #

null :: Proxy * a -> Bool #

length :: Proxy * a -> Int #

elem :: Eq a => a -> Proxy * a -> Bool #

maximum :: Ord a => Proxy * a -> a #

minimum :: Ord a => Proxy * a -> a #

sum :: Num a => Proxy * a -> a #

product :: Num a => Proxy * a -> a #

Traversable (Proxy *) |
Methods traverse :: Applicative f => (a -> f b) -> Proxy * a -> f (Proxy * b) # sequenceA :: Applicative f => Proxy * (f a) -> f (Proxy * a) # mapM :: Monad m => (a -> m b) -> Proxy * a -> m (Proxy * b) # sequence :: Monad m => Proxy * (m a) -> m (Proxy * a) #
Generic1 (Proxy *) |
Associated Types type Rep1 (Proxy * :: * -> *) :: * -> * # Methods from1 :: Proxy * a -> Rep1 (Proxy *) a # to1 :: Rep1 (Proxy *) a -> Proxy * a #
Alternative (Proxy *) |
Methods empty :: Proxy * a # (<|>) :: Proxy * a -> Proxy * a -> Proxy * a # some :: Proxy * a -> Proxy * [a] # many :: Proxy * a -> Proxy * [a] #
MonadPlus (Proxy *) |
Methods mzero :: Proxy * a # mplus :: Proxy * a -> Proxy * a -> Proxy * a #
Bounded (Proxy k s) |
Methods minBound :: Proxy k s # maxBound :: Proxy k s #
Enum (Proxy k s) |
Methods succ :: Proxy k s -> Proxy k s # pred :: Proxy k s -> Proxy k s # toEnum :: Int -> Proxy k s # fromEnum :: Proxy k s -> Int # enumFrom :: Proxy k s -> [Proxy k s] # enumFromThen :: Proxy k s -> Proxy k s -> [Proxy k s] # enumFromTo :: Proxy k s -> Proxy k s -> [Proxy k s] # enumFromThenTo :: Proxy k s -> Proxy k s -> Proxy k s -> [Proxy k s] #
Eq (Proxy k s) |
Methods (==) :: Proxy k s -> Proxy k s -> Bool # (/=) :: Proxy k s -> Proxy k s -> Bool #
Data t => Data (Proxy * t) |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Proxy * t -> c (Proxy * t) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Proxy * t) #

toConstr :: Proxy * t -> Constr #

dataTypeOf :: Proxy * t -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Proxy * t)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t 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 :: (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) #

Ord (Proxy k s) |
Methods compare :: Proxy k s -> Proxy k s -> Ordering # (<) :: Proxy k s -> Proxy k s -> Bool # (<=) :: Proxy k s -> Proxy k s -> Bool # (>) :: Proxy k s -> Proxy k s -> Bool # (>=) :: Proxy k s -> Proxy k s -> Bool # max :: Proxy k s -> Proxy k s -> Proxy k s # min :: Proxy k s -> Proxy k s -> Proxy k s #
Read (Proxy k s) |
Methods readsPrec :: Int -> ReadS (Proxy k s) # readList :: ReadS [Proxy k s] # readPrec :: ReadPrec (Proxy k s) # readListPrec :: ReadPrec [Proxy k s] #
Show (Proxy k s) |
Methods showsPrec :: Int -> Proxy k s -> ShowS # show :: Proxy k s -> String # showList :: [Proxy k s] -> ShowS #
Ix (Proxy k s) |
Methods range :: (Proxy k s, Proxy k s) -> [Proxy k s] # index :: (Proxy k s, Proxy k s) -> Proxy k s -> Int # unsafeIndex :: (Proxy k s, Proxy k s) -> Proxy k s -> Int inRange :: (Proxy k s, Proxy k s) -> Proxy k s -> Bool # rangeSize :: (Proxy k s, Proxy k s) -> Int # unsafeRangeSize :: (Proxy k s, Proxy k s) -> Int
Generic (Proxy k t) |
Associated Types type Rep (Proxy k t) :: * -> * # Methods from :: Proxy k t -> Rep (Proxy k t) x # to :: Rep (Proxy k t) x -> Proxy k t #
Semigroup (Proxy k s) |
Methods (<>) :: Proxy k s -> Proxy k s -> Proxy k s # sconcat :: NonEmpty (Proxy k s) -> Proxy k s # stimes :: Integral b => b -> Proxy k s -> Proxy k s #
Monoid (Proxy k s) |
Methods mempty :: Proxy k s # mappend :: Proxy k s -> Proxy k s -> Proxy k s # mconcat :: [Proxy k s] -> Proxy k s #
type Rep1 (Proxy *) |
type Rep1 (Proxy *) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) U1)
type Rep (Proxy k t) |
type Rep (Proxy k t) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) U1)

asProxyTypeOf :: a -> Proxy * a -> a #

`asProxyTypeOf` is a type-restricted version of `const`. It is usually used as an infix operator, and its typing forces its first argument (which is usually overloaded) to have the same type as the tag of the second.

## Partial

data Partial a Source #

Partialiality wrapper.

Instances

Monad Partial Source # |
Methods (>>=) :: Partial a -> (a -> Partial b) -> Partial b # (>>) :: Partial a -> Partial b -> Partial b # return :: a -> Partial a # fail :: String -> Partial a #
Functor Partial Source # |
Methods fmap :: (a -> b) -> Partial a -> Partial b # (<$) :: a -> Partial b -> Partial a #
Applicative Partial Source # |
Methods pure :: a -> Partial a # (<*>) :: Partial (a -> b) -> Partial a -> Partial b # (*>) :: Partial a -> Partial b -> Partial b # (<*) :: Partial a -> Partial b -> Partial a #

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

Eq PartialError Source # |
Methods (==) :: PartialError -> PartialError -> Bool # (/=) :: PartialError -> PartialError -> Bool #
Show PartialError Source # |
Methods showsPrec :: Int -> PartialError -> ShowS # show :: PartialError -> String # showList :: [PartialError] -> ShowS #
Exception PartialError Source # |
Methods toException :: PartialError -> SomeException # fromException :: SomeException -> Maybe PartialError # displayException :: PartialError -> String #

fromPartial :: Partial a -> a Source #

Dewrap a possible partial value

ifThenElse :: Bool -> a -> a -> a #

for support of if .. then .. else

## Old Prelude Strings as [Char] with bridge back and forth

type LString = String Source #

Alias to Prelude String ([Char]) for compatibility purpose