Copyright | Copyright (C) 2006-2018 Bjorn Buckwalter |
---|---|
License | BSD3 |
Maintainer | bjorn@buckwalter.se |
Stability | Stable |
Portability | GHC only |
Safe Haskell | None |
Language | Haskell2010 |
Numeric.Units.Dimensional.Prelude
Description
Summary
This module supplies a convenient set of imports for working with the dimensional package, including aliases for common Quantity
s and Dimension
s,
and a comprehensive set of SI units and units accepted for use with the SI.
It re-exports the Prelude, hiding arithmetic functions whose names collide with the dimensionally-typed versions supplied by this package.
Synopsis
- class HasDynamicDimension a => HasDimension a where
- dimension :: a -> Dimension'
- data Dimension' = Dim' !Int !Int !Int !Int !Int !Int !Int
- type KnownDimension (d :: Dimension) = HasDimension (Proxy d)
- type Cbrt d = NRoot d 'Pos3
- type Sqrt d = NRoot d 'Pos2
- type family NRoot (d :: Dimension) (x :: TypeInt) where ...
- type family (d :: Dimension) ^ (x :: TypeInt) where ...
- type Recip (d :: Dimension) = DOne / d
- type family (a :: Dimension) / (d :: Dimension) where ...
- type family (a :: Dimension) * (b :: Dimension) where ...
- type DLuminousIntensity = 'Dim 'Zero 'Zero 'Zero 'Zero 'Zero 'Zero 'Pos1
- type DAmountOfSubstance = 'Dim 'Zero 'Zero 'Zero 'Zero 'Zero 'Pos1 'Zero
- type DThermodynamicTemperature = 'Dim 'Zero 'Zero 'Zero 'Zero 'Pos1 'Zero 'Zero
- type DElectricCurrent = 'Dim 'Zero 'Zero 'Zero 'Pos1 'Zero 'Zero 'Zero
- type DTime = 'Dim 'Zero 'Zero 'Pos1 'Zero 'Zero 'Zero 'Zero
- type DMass = 'Dim 'Zero 'Pos1 'Zero 'Zero 'Zero 'Zero 'Zero
- type DLength = 'Dim 'Pos1 'Zero 'Zero 'Zero 'Zero 'Zero 'Zero
- type DOne = 'Dim 'Zero 'Zero 'Zero 'Zero 'Zero 'Zero 'Zero
- data Dimension = Dim TypeInt TypeInt TypeInt TypeInt TypeInt TypeInt TypeInt
- data Metricality
- class KnownVariant (v :: Variant) where
- data Dimensional v :: Dimension -> Type -> Type
- type Quantity = SQuantity One
- type Unit (m :: Metricality) = Dimensional ('DUnit m)
- siUnit :: forall d a. (KnownDimension d, Num a) => Unit 'NonMetric d a
- showIn :: (Show a, Fractional a) => Unit m d a -> Quantity d a -> String
- type LuminousIntensity = Quantity DLuminousIntensity
- type AmountOfSubstance = Quantity DAmountOfSubstance
- type ThermodynamicTemperature = Quantity DThermodynamicTemperature
- type ElectricCurrent = Quantity DElectricCurrent
- type Time = Quantity DTime
- type Mass = Quantity DMass
- type Length = Quantity DLength
- type Dimensionless = Quantity DOne
- name :: Unit m d a -> UnitName m
- exactValue :: Unit m d a -> ExactPi
- weaken :: Unit m d a -> Unit 'NonMetric d a
- strengthen :: Unit m d a -> Maybe (Unit 'Metric d a)
- exactify :: Unit m d a -> Unit m d ExactPi
- (*~) :: Num a => a -> Unit m d a -> Quantity d a
- (/~) :: Fractional a => Quantity d a -> Unit m d a -> a
- (*) :: (KnownVariant v1, KnownVariant v2, KnownVariant (v1 * v2), Num a) => Dimensional v1 d1 a -> Dimensional v2 d2 a -> Dimensional (v1 * v2) (d1 * d2) a
- (/) :: (KnownVariant v1, KnownVariant v2, KnownVariant (v1 / v2), Fractional a) => Dimensional v1 d1 a -> Dimensional v2 d2 a -> Dimensional (v1 / v2) (d1 / d2) a
- recip :: Fractional a => Quantity d a -> Quantity (Recip d) a
- (^) :: (Fractional a, KnownTypeInt i, KnownVariant v, KnownVariant (Weaken v)) => Dimensional v d1 a -> Proxy i -> Dimensional (Weaken v) (d1 ^ i) a
- negate :: Num a => Quantity d a -> Quantity d a
- (+) :: Num a => Quantity d a -> Quantity d a -> Quantity d a
- (-) :: Num a => Quantity d a -> Quantity d a -> Quantity d a
- abs :: Num a => Quantity d a -> Quantity d a
- signum :: Num a => Quantity d a -> Dimensionless a
- nroot :: (KnownTypeInt n, Floating a) => Proxy n -> Quantity d a -> Quantity (NRoot d n) a
- sqrt :: Floating a => Quantity d a -> Quantity (Sqrt d) a
- cbrt :: Floating a => Quantity d a -> Quantity (Cbrt d) a
- (^/) :: (KnownTypeInt n, Floating a) => Quantity d a -> Proxy n -> Quantity (NRoot d n) a
- (*~~) :: (Functor f, Num a) => f a -> Unit m d a -> f (Quantity d a)
- (/~~) :: forall f m d a. (Functor f, Fractional a) => f (Quantity d a) -> Unit m d a -> f a
- sum :: (Num a, Foldable f) => f (Quantity d a) -> Quantity d a
- product :: (Num a, Foldable f) => f (Dimensionless a) -> Dimensionless a
- mean :: (Fractional a, Foldable f) => f (Quantity d a) -> Quantity d a
- dimensionlessLength :: (Num a, Foldable f) => f b -> Dimensionless a
- nFromTo :: (Fractional a, Integral b) => Quantity d a -> Quantity d a -> b -> [Quantity d a]
- exp :: Floating a => Dimensionless a -> Dimensionless a
- log :: Floating a => Dimensionless a -> Dimensionless a
- sin :: Floating a => Dimensionless a -> Dimensionless a
- cos :: Floating a => Dimensionless a -> Dimensionless a
- tan :: Floating a => Dimensionless a -> Dimensionless a
- asin :: Floating a => Dimensionless a -> Dimensionless a
- acos :: Floating a => Dimensionless a -> Dimensionless a
- atan :: Floating a => Dimensionless a -> Dimensionless a
- sinh :: Floating a => Dimensionless a -> Dimensionless a
- cosh :: Floating a => Dimensionless a -> Dimensionless a
- tanh :: Floating a => Dimensionless a -> Dimensionless a
- asinh :: Floating a => Dimensionless a -> Dimensionless a
- acosh :: Floating a => Dimensionless a -> Dimensionless a
- atanh :: Floating a => Dimensionless a -> Dimensionless a
- log1p :: Floating a => Dimensionless a -> Dimensionless a
- expm1 :: Floating a => Dimensionless a -> Dimensionless a
- log1pexp :: Floating a => Dimensionless a -> Dimensionless a
- log1mexp :: Floating a => Dimensionless a -> Dimensionless a
- (**) :: Floating a => Dimensionless a -> Dimensionless a -> Dimensionless a
- logBase :: Floating a => Dimensionless a -> Dimensionless a -> Dimensionless a
- atan2 :: RealFloat a => Quantity d a -> Quantity d a -> Dimensionless a
- one :: Num a => Unit 'NonMetric DOne a
- _0 :: Num a => Quantity d a
- _1 :: Num a => Dimensionless a
- _2 :: Num a => Dimensionless a
- _3 :: Num a => Dimensionless a
- _4 :: Num a => Dimensionless a
- _5 :: Num a => Dimensionless a
- _6 :: Num a => Dimensionless a
- _7 :: Num a => Dimensionless a
- _8 :: Num a => Dimensionless a
- _9 :: Num a => Dimensionless a
- pi :: Floating a => Dimensionless a
- tau :: Floating a => Dimensionless a
- changeRep :: (KnownVariant v, Real a, Fractional b) => Dimensional v d a -> Dimensional v d b
- changeRepApproximate :: (KnownVariant v, Floating b) => Dimensional v d ExactPi -> Dimensional v d b
- asLens :: Fractional a => Unit m d a -> forall f. Functor f => (a -> f a) -> Quantity d a -> f (Quantity d a)
- mkUnitR :: Floating a => UnitName m -> ExactPi -> Unit m1 d a -> Unit m d a
- mkUnitQ :: Fractional a => UnitName m -> Rational -> Unit m1 d a -> Unit m d a
- mkUnitZ :: Num a => UnitName m -> Integer -> Unit m1 d a -> Unit m d a
- module Numeric.Units.Dimensional.Quantities
- module Numeric.Units.Dimensional.SIUnits
- pos5 :: Proxy 'Pos5
- pos4 :: Proxy 'Pos4
- pos3 :: Proxy 'Pos3
- pos2 :: Proxy 'Pos2
- pos1 :: Proxy 'Pos1
- zero :: Proxy 'Zero
- neg1 :: Proxy 'Neg1
- neg2 :: Proxy 'Neg2
- neg3 :: Proxy 'Neg3
- neg4 :: Proxy 'Neg4
- neg5 :: Proxy 'Neg5
- class Category (cat :: k -> k -> Type) where
- maximum :: (Foldable t, Ord a) => t a -> a
- minimum :: (Foldable t, Ord a) => t a -> a
- (++) :: [a] -> [a] -> [a]
- seq :: a -> b -> b
- filter :: (a -> Bool) -> [a] -> [a]
- zip :: [a] -> [b] -> [(a, b)]
- print :: Show a => a -> IO ()
- fst :: (a, b) -> a
- snd :: (a, b) -> b
- otherwise :: Bool
- map :: (a -> b) -> [a] -> [b]
- ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- fromIntegral :: (Integral a, Num b) => a -> b
- realToFrac :: (Real a, Fractional b) => a -> b
- class Bounded a where
- class Enum a where
- succ :: a -> a
- pred :: a -> a
- toEnum :: Int -> a
- fromEnum :: a -> Int
- enumFrom :: a -> [a]
- enumFromThen :: a -> a -> [a]
- enumFromTo :: a -> a -> [a]
- enumFromThenTo :: a -> a -> a -> [a]
- class Eq a where
- class Fractional a => Floating a
- class Num a => Fractional a where
- fromRational :: Rational -> a
- class (Real a, Enum a) => Integral a where
- class Applicative m => Monad (m :: Type -> Type) where
- class Functor (f :: Type -> Type) where
- class Num a where
- fromInteger :: Integer -> a
- class Eq a => Ord a where
- class Read a where
- class (Num a, Ord a) => Real a where
- toRational :: a -> Rational
- class (RealFrac a, Floating a) => RealFloat a where
- floatRadix :: a -> Integer
- floatDigits :: a -> Int
- floatRange :: a -> (Int, Int)
- decodeFloat :: a -> (Integer, Int)
- encodeFloat :: Integer -> Int -> a
- exponent :: a -> Int
- significand :: a -> a
- scaleFloat :: Int -> a -> a
- isNaN :: a -> Bool
- isInfinite :: a -> Bool
- isDenormalized :: a -> Bool
- isNegativeZero :: a -> Bool
- isIEEE :: a -> Bool
- class (Real a, Fractional a) => RealFrac a where
- class Show a where
- class Monad m => MonadFail (m :: Type -> Type) where
- class Functor f => Applicative (f :: Type -> Type) where
- class Foldable (t :: Type -> Type) where
- class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where
- traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
- sequenceA :: Applicative f => t (f a) -> f (t a)
- mapM :: Monad m => (a -> m b) -> t a -> m (t b)
- sequence :: Monad m => t (m a) -> m (t a)
- class Semigroup a where
- (<>) :: a -> a -> a
- class Semigroup a => Monoid a where
- data Bool
- data Char
- data Double
- data Float
- data Int
- data Integer
- data Maybe a
- data Ordering
- type Rational = Ratio Integer
- data IO a
- data Word
- data Either a b
- type ReadS a = String -> [(a, String)]
- replicate :: Int -> a -> [a]
- errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a
- type String = [Char]
- type ShowS = String -> String
- maybe :: b -> (a -> b) -> Maybe a -> b
- const :: a -> b -> a
- either :: (a -> c) -> (b -> c) -> Either a b -> c
- all :: Foldable t => (a -> Bool) -> t a -> Bool
- and :: Foldable t => t Bool -> Bool
- any :: Foldable t => (a -> Bool) -> t a -> Bool
- concat :: Foldable t => t [a] -> [a]
- concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
- mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- notElem :: (Foldable t, Eq a) => a -> t a -> Bool
- or :: Foldable t => t Bool -> Bool
- sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- lines :: String -> [String]
- unlines :: [String] -> String
- unwords :: [String] -> String
- words :: String -> [String]
- curry :: ((a, b) -> c) -> a -> b -> c
- uncurry :: (a -> b -> c) -> (a, b) -> c
- ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- asTypeOf :: a -> a -> a
- flip :: (a -> b -> c) -> b -> a -> c
- until :: (a -> Bool) -> (a -> a) -> a -> a
- error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a
- undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
- ioError :: IOError -> IO a
- userError :: String -> IOError
- (!!) :: [a] -> Int -> a
- break :: (a -> Bool) -> [a] -> ([a], [a])
- cycle :: [a] -> [a]
- drop :: Int -> [a] -> [a]
- dropWhile :: (a -> Bool) -> [a] -> [a]
- head :: [a] -> a
- init :: [a] -> [a]
- iterate :: (a -> a) -> a -> [a]
- last :: [a] -> a
- lookup :: Eq a => a -> [(a, b)] -> Maybe b
- repeat :: a -> [a]
- reverse :: [a] -> [a]
- scanl :: (b -> a -> b) -> b -> [a] -> [b]
- scanl1 :: (a -> a -> a) -> [a] -> [a]
- scanr :: (a -> b -> b) -> b -> [a] -> [b]
- scanr1 :: (a -> a -> a) -> [a] -> [a]
- span :: (a -> Bool) -> [a] -> ([a], [a])
- splitAt :: Int -> [a] -> ([a], [a])
- tail :: [a] -> [a]
- take :: Int -> [a] -> [a]
- takeWhile :: (a -> Bool) -> [a] -> [a]
- unzip :: [(a, b)] -> ([a], [b])
- unzip3 :: [(a, b, c)] -> ([a], [b], [c])
- zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
- zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
- subtract :: Num a => a -> a -> a
- lex :: ReadS String
- readParen :: Bool -> ReadS a -> ReadS a
- (^^) :: (Fractional a, Integral b) => a -> b -> a
- even :: Integral a => a -> Bool
- gcd :: Integral a => a -> a -> a
- lcm :: Integral a => a -> a -> a
- odd :: Integral a => a -> Bool
- showChar :: Char -> ShowS
- showParen :: Bool -> ShowS -> ShowS
- showString :: String -> ShowS
- shows :: Show a => a -> ShowS
- appendFile :: FilePath -> String -> IO ()
- getChar :: IO Char
- getContents :: IO String
- getLine :: IO String
- interact :: (String -> String) -> IO ()
- putChar :: Char -> IO ()
- putStr :: String -> IO ()
- putStrLn :: String -> IO ()
- readFile :: FilePath -> IO String
- readIO :: Read a => String -> IO a
- readLn :: Read a => IO a
- writeFile :: FilePath -> String -> IO ()
- read :: Read a => String -> a
- reads :: Read a => ReadS a
- (&&) :: Bool -> Bool -> Bool
- not :: Bool -> Bool
- (||) :: Bool -> Bool -> Bool
- type FilePath = String
- type IOError = IOException
Documentation
class HasDynamicDimension a => HasDimension a where Source #
Dimensional values inhabit this class, which allows access to a term-level representation of their dimension.
Methods
dimension :: a -> Dimension' Source #
Obtains a term-level representation of a value's dimension.
Instances
HasDimension Dimension' Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel Methods dimension :: Dimension' -> Dimension' Source # | |
HasDimension AnyUnit Source # | |
Defined in Numeric.Units.Dimensional.Dynamic Methods dimension :: AnyUnit -> Dimension' Source # | |
HasDimension (AnyQuantity a) Source # | |
Defined in Numeric.Units.Dimensional.Dynamic Methods dimension :: AnyQuantity a -> Dimension' Source # | |
(KnownTypeInt l, KnownTypeInt m, KnownTypeInt t, KnownTypeInt i, KnownTypeInt th, KnownTypeInt n, KnownTypeInt j) => HasDimension (Proxy ('Dim l m t i th n j)) Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TypeLevel Methods dimension :: Proxy ('Dim l m t i th n j) -> Dimension' Source # | |
KnownDimension d => HasDimension (Dimensional v d a) Source # | |
Defined in Numeric.Units.Dimensional.Internal Methods dimension :: Dimensional v d a -> Dimension' Source # |
data Dimension' Source #
A physical dimension, encoded as 7 integers, representing a factorization of the dimension into the
7 SI base dimensions. By convention they are stored in the same order as
in the Dimension
data kind.
Instances
Eq Dimension' Source # | |
Data Dimension' Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dimension' -> c Dimension' gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Dimension' toConstr :: Dimension' -> Constr dataTypeOf :: Dimension' -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Dimension') dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dimension') gmapT :: (forall b. Data b => b -> b) -> Dimension' -> Dimension' gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dimension' -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dimension' -> r gmapQ :: (forall d. Data d => d -> u) -> Dimension' -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Dimension' -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dimension' -> m Dimension' gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dimension' -> m Dimension' gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dimension' -> m Dimension' | |
Ord Dimension' Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel Methods compare :: Dimension' -> Dimension' -> Ordering # (<) :: Dimension' -> Dimension' -> Bool # (<=) :: Dimension' -> Dimension' -> Bool # (>) :: Dimension' -> Dimension' -> Bool # (>=) :: Dimension' -> Dimension' -> Bool # max :: Dimension' -> Dimension' -> Dimension' # min :: Dimension' -> Dimension' -> Dimension' # | |
Show Dimension' Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel Methods showsPrec :: Int -> Dimension' -> ShowS # show :: Dimension' -> String # showList :: [Dimension'] -> ShowS # | |
Generic Dimension' Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel Associated Types type Rep Dimension' :: Type -> Type | |
Semigroup Dimension' Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel Methods (<>) :: Dimension' -> Dimension' -> Dimension' # sconcat :: NonEmpty Dimension' -> Dimension' stimes :: Integral b => b -> Dimension' -> Dimension' | |
Monoid Dimension' Source # | The monoid of dimensions under multiplication. |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel Methods mempty :: Dimension' # mappend :: Dimension' -> Dimension' -> Dimension' # mconcat :: [Dimension'] -> Dimension' # | |
NFData Dimension' Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel Methods rnf :: Dimension' -> () | |
HasDimension Dimension' Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel Methods dimension :: Dimension' -> Dimension' Source # | |
HasDynamicDimension Dimension' Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel Methods | |
type Rep Dimension' Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel type Rep Dimension' = D1 ('MetaData "Dimension'" "Numeric.Units.Dimensional.Dimensions.TermLevel" "dimensional-1.3-C8v0k83E9Py18UKTdF1oLh" 'False) (C1 ('MetaCons "Dim'" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Int) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Int))) :*: ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Int)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Int))))) |
type KnownDimension (d :: Dimension) = HasDimension (Proxy d) Source #
A KnownDimension is one for which we can construct a term-level representation.
Each validly constructed type of kind Dimension
has a KnownDimension
instance.
While KnownDimension
is a constraint synonym, the presence of
in
a context allows use of KnownDimension
d
.dimension
:: Proxy
d -> Dimension'
type family NRoot (d :: Dimension) (x :: TypeInt) where ... Source #
Roots of dimensions corresponds to division of the base dimensions' exponents by the order of the root.
type family (d :: Dimension) ^ (x :: TypeInt) where ... infixr 8 Source #
Powers of dimensions corresponds to multiplication of the base dimensions' exponents by the exponent.
We limit ourselves to integer powers of Dimensionals as fractional powers make little physical sense.
type Recip (d :: Dimension) = DOne / d Source #
The reciprocal of a dimension is defined as the result of dividing DOne
by it,
or of negating each of the base dimensions' exponents.
type family (a :: Dimension) / (d :: Dimension) where ... infixl 7 Source #
Division of dimensions corresponds to subtraction of the base dimensions' exponents.
type family (a :: Dimension) * (b :: Dimension) where ... infixl 7 Source #
Multiplication of dimensions corresponds to adding of the base dimensions' exponents.
type DOne = 'Dim 'Zero 'Zero 'Zero 'Zero 'Zero 'Zero 'Zero Source #
The type-level dimension of dimensionless values.
Represents a physical dimension in the basis of the 7 SI base dimensions, where the respective dimensions are represented by type variables using the following convention:
- l: Length
- m: Mass
- t: Time
- i: Electric current
- th: Thermodynamic temperature
- n: Amount of substance
- j: Luminous intensity
For the equivalent term-level representation, see Dimension'
Instances
(KnownTypeInt l, KnownTypeInt m, KnownTypeInt t, KnownTypeInt i, KnownTypeInt th, KnownTypeInt n, KnownTypeInt j) => HasDimension (Proxy ('Dim l m t i th n j)) Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TypeLevel Methods dimension :: Proxy ('Dim l m t i th n j) -> Dimension' Source # | |
(KnownTypeInt l, KnownTypeInt m, KnownTypeInt t, KnownTypeInt i, KnownTypeInt th, KnownTypeInt n, KnownTypeInt j) => HasDynamicDimension (Proxy ('Dim l m t i th n j)) Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TypeLevel Methods dynamicDimension :: Proxy ('Dim l m t i th n j) -> DynamicDimension Source # |
data Metricality Source #
Encodes whether a unit is a metric unit, that is, whether it can be combined with a metric prefix to form a related unit.
Constructors
Metric | Capable of receiving a metric prefix. |
NonMetric | Incapable of receiving a metric prefix. |
Instances
Eq Metricality Source # | |
Defined in Numeric.Units.Dimensional.Variants | |
Data Metricality Source # | |
Defined in Numeric.Units.Dimensional.Variants Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Metricality -> c Metricality gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Metricality toConstr :: Metricality -> Constr dataTypeOf :: Metricality -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Metricality) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Metricality) gmapT :: (forall b. Data b => b -> b) -> Metricality -> Metricality gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Metricality -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Metricality -> r gmapQ :: (forall d. Data d => d -> u) -> Metricality -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Metricality -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Metricality -> m Metricality gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Metricality -> m Metricality gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Metricality -> m Metricality | |
Ord Metricality Source # | |
Defined in Numeric.Units.Dimensional.Variants Methods compare :: Metricality -> Metricality -> Ordering # (<) :: Metricality -> Metricality -> Bool # (<=) :: Metricality -> Metricality -> Bool # (>) :: Metricality -> Metricality -> Bool # (>=) :: Metricality -> Metricality -> Bool # max :: Metricality -> Metricality -> Metricality # min :: Metricality -> Metricality -> Metricality # | |
Generic Metricality Source # | |
Defined in Numeric.Units.Dimensional.Variants Associated Types type Rep Metricality :: Type -> Type | |
NFData Metricality Source # | |
Defined in Numeric.Units.Dimensional.Variants Methods rnf :: Metricality -> () | |
type Rep Metricality Source # | |
Defined in Numeric.Units.Dimensional.Variants type Rep Metricality = D1 ('MetaData "Metricality" "Numeric.Units.Dimensional.Variants" "dimensional-1.3-C8v0k83E9Py18UKTdF1oLh" 'False) (C1 ('MetaCons "Metric" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NonMetric" 'PrefixI 'False) (U1 :: Type -> Type)) |
class KnownVariant (v :: Variant) Source #
A KnownVariant is one whose term-level Dimensional
values we can represent with an associated data family instance
and manipulate with certain functions, not all of which are exported from the package.
Each validly constructed type of kind Variant
has a KnownVariant
instance.
Minimal complete definition
extractValue, extractName, injectValue, dmap
Associated Types
data Dimensional v :: Dimension -> Type -> Type Source #
Instances
type Unit (m :: Metricality) = Dimensional ('DUnit m) Source #
A unit of measurement.
siUnit :: forall d a. (KnownDimension d, Num a) => Unit 'NonMetric d a Source #
A polymorphic Unit
which can be used in place of the coherent
SI base unit of any dimension. This allows polymorphic quantity
creation and destruction without exposing the Dimensional
constructor.
type Dimensionless = Quantity DOne Source #
exactValue :: Unit m d a -> ExactPi Source #
weaken :: Unit m d a -> Unit 'NonMetric d a Source #
Discards potentially unwanted type level information about a Unit
.
(*~) :: Num a => a -> Unit m d a -> Quantity d a infixl 7 Source #
Forms a Quantity
by multipliying a number and a unit.
(*) :: (KnownVariant v1, KnownVariant v2, KnownVariant (v1 * v2), Num a) => Dimensional v1 d1 a -> Dimensional v2 d2 a -> Dimensional (v1 * v2) (d1 * d2) a infixl 7 Source #
(/) :: (KnownVariant v1, KnownVariant v2, KnownVariant (v1 / v2), Fractional a) => Dimensional v1 d1 a -> Dimensional v2 d2 a -> Dimensional (v1 / v2) (d1 / d2) a infixl 7 Source #
recip :: Fractional a => Quantity d a -> Quantity (Recip d) a Source #
Forms the reciprocal of a Quantity
, which has the reciprocal dimension.
>>>
recip $ 47 *~ hertz
2.127659574468085e-2 s
(^) :: (Fractional a, KnownTypeInt i, KnownVariant v, KnownVariant (Weaken v)) => Dimensional v d1 a -> Proxy i -> Dimensional (Weaken v) (d1 ^ i) a infixr 8 Source #
Raises a Quantity
or Unit
to an integer power.
Because the power chosen impacts the Dimension
of the result, it is necessary to supply a type-level representation
of the exponent in the form of a Proxy
to some TypeInt
. Convenience values pos1
, pos2
, neg1
, ...
are supplied by the Numeric.NumType.DK.Integers module. The most commonly used ones are
also reexported by Numeric.Units.Dimensional.Prelude.
The intimidating type signature captures the similarity between these operations
and ensures that composite Unit
s are NotPrefixable
.
(-) :: Num a => Quantity d a -> Quantity d a -> Quantity d a infixl 6 Source #
Subtracts one Quantity
from another.
nroot :: (KnownTypeInt n, Floating a) => Proxy n -> Quantity d a -> Quantity (NRoot d n) a Source #
Computes the nth root of a Quantity
using **
.
The NRoot
type family will prevent application of this operator where the result would have a fractional dimension or where n is zero.
Because the root chosen impacts the Dimension
of the result, it is necessary to supply a type-level representation
of the root in the form of a Proxy
to some TypeInt
. Convenience values pos1
, pos2
, neg1
, ...
are supplied by the Numeric.NumType.DK.Integers module. The most commonly used ones are
also reexported by Numeric.Units.Dimensional.Prelude.
n must not be zero. Negative roots are defined such that nroot (Proxy :: Proxy (Negate n)) x == nroot (Proxy :: Proxy n) (recip x)
.
Also available in operator form, see ^/
.
(^/) :: (KnownTypeInt n, Floating a) => Quantity d a -> Proxy n -> Quantity (NRoot d n) a infixr 8 Source #
Computes the nth root of a Quantity
using **
.
The NRoot
type family will prevent application of this operator where the result would have a fractional dimension or where n is zero.
Because the root chosen impacts the Dimension
of the result, it is necessary to supply a type-level representation
of the root in the form of a Proxy
to some TypeInt
. Convenience values pos1
, pos2
, neg1
, ...
are supplied by the Numeric.NumType.DK.Integers module. The most commonly used ones are
also reexported by Numeric.Units.Dimensional.Prelude.
Also available in prefix form, see nroot
.
(*~~) :: (Functor f, Num a) => f a -> Unit m d a -> f (Quantity d a) infixl 7 Source #
Applies *~
to all values in a functor.
(/~~) :: forall f m d a. (Functor f, Fractional a) => f (Quantity d a) -> Unit m d a -> f a infixl 7 Source #
Applies /~
to all values in a functor.
sum :: (Num a, Foldable f) => f (Quantity d a) -> Quantity d a Source #
The sum of all elements in a foldable structure.
>>>
sum ([] :: [Mass Double])
0.0 kg
>>>
sum [12.4 *~ meter, 1 *~ foot]
12.7048 m
product :: (Num a, Foldable f) => f (Dimensionless a) -> Dimensionless a Source #
The product of all elements in a foldable structure.
>>>
product ([] :: [Dimensionless Double])
1.0
>>>
product [pi, _4, 0.36 *~ one]
4.523893421169302
mean :: (Fractional a, Foldable f) => f (Quantity d a) -> Quantity d a Source #
The arithmetic mean of all elements in a foldable structure.
>>>
mean [pi, _7]
5.070796326794897
dimensionlessLength :: (Num a, Foldable f) => f b -> Dimensionless a Source #
The length of the foldable data structure as a Dimensionless
.
This can be useful for purposes of e.g. calculating averages.
>>>
dimensionlessLength ["foo", "bar"]
2
Arguments
:: (Fractional a, Integral b) | |
=> Quantity d a | The initial value. |
-> Quantity d a | The final value. |
-> b | The number of intermediate values. If less than one, no intermediate values will result. |
-> [Quantity d a] |
Returns a list of quantities between given bounds.
n <= 0 ==> nFromTo (x :: Mass Double) (y :: Mass Double) n == [x, y]
(x :: Length Double) <= (y :: Length Double) ==> all (\z -> x <= z && z <= y) (nFromTo x y n)
>>>
nFromTo _0 _3 2
[0.0,1.0,2.0,3.0]
>>>
nFromTo _1 _0 7
[1.0,0.875,0.75,0.625,0.5,0.375,0.25,0.125,0.0]
>>>
nFromTo _0 _1 (-5)
[0.0,1.0]
exp :: Floating a => Dimensionless a -> Dimensionless a Source #
log :: Floating a => Dimensionless a -> Dimensionless a Source #
sin :: Floating a => Dimensionless a -> Dimensionless a Source #
cos :: Floating a => Dimensionless a -> Dimensionless a Source #
tan :: Floating a => Dimensionless a -> Dimensionless a Source #
asin :: Floating a => Dimensionless a -> Dimensionless a Source #
acos :: Floating a => Dimensionless a -> Dimensionless a Source #
atan :: Floating a => Dimensionless a -> Dimensionless a Source #
sinh :: Floating a => Dimensionless a -> Dimensionless a Source #
cosh :: Floating a => Dimensionless a -> Dimensionless a Source #
tanh :: Floating a => Dimensionless a -> Dimensionless a Source #
asinh :: Floating a => Dimensionless a -> Dimensionless a Source #
acosh :: Floating a => Dimensionless a -> Dimensionless a Source #
atanh :: Floating a => Dimensionless a -> Dimensionless a Source #
log1p :: Floating a => Dimensionless a -> Dimensionless a Source #
expm1 :: Floating a => Dimensionless a -> Dimensionless a Source #
log1pexp :: Floating a => Dimensionless a -> Dimensionless a Source #
log1mexp :: Floating a => Dimensionless a -> Dimensionless a Source #
(**) :: Floating a => Dimensionless a -> Dimensionless a -> Dimensionless a infixr 8 Source #
Raises a dimensionless quantity to a dimensionless power.
logBase :: Floating a => Dimensionless a -> Dimensionless a -> Dimensionless a Source #
Takes the logarithm of the second argument in the base of the first.
>>>
logBase _2 _8
3.0
atan2 :: RealFloat a => Quantity d a -> Quantity d a -> Dimensionless a Source #
The standard two argument arctangent function. Since it interprets its two arguments in comparison with one another, the input may have any dimension.
>>>
atan2 _0 _1
0.0
>>>
atan2 _1 _0
1.5707963267948966
>>>
atan2 _0 (negate _1)
3.141592653589793
>>>
atan2 (negate _1) _0
-1.5707963267948966
one :: Num a => Unit 'NonMetric DOne a Source #
The unit one
has dimension DOne
and is the base unit of dimensionless values.
As detailed in 7.10 "Values of quantities expressed simply as numbers:
the unit one, symbol 1" of [1] the unit one generally does not
appear in expressions. However, for us it is necessary to use one
as we would any other unit to perform the "boxing" of dimensionless values.
_0 :: Num a => Quantity d a Source #
The constant for zero is polymorphic, allowing it to express zero Length
or
Capacitance
or Velocity
etc,
in addition to the Dimensionless
value zero.
_1 :: Num a => Dimensionless a Source #
_2 :: Num a => Dimensionless a Source #
_3 :: Num a => Dimensionless a Source #
_4 :: Num a => Dimensionless a Source #
_5 :: Num a => Dimensionless a Source #
_6 :: Num a => Dimensionless a Source #
_7 :: Num a => Dimensionless a Source #
_8 :: Num a => Dimensionless a Source #
_9 :: Num a => Dimensionless a Source #
pi :: Floating a => Dimensionless a Source #
tau :: Floating a => Dimensionless a Source #
Twice pi
.
For background on tau
see http://tauday.com/tau-manifesto (but also
feel free to review http://www.thepimanifesto.com).
changeRep :: (KnownVariant v, Real a, Fractional b) => Dimensional v d a -> Dimensional v d b Source #
Convenient conversion between numerical types while retaining dimensional information.
>>>
let x = (37 :: Rational) *~ poundMass
>>>
changeRep x :: Mass Double
16.78291769 kg
changeRepApproximate :: (KnownVariant v, Floating b) => Dimensional v d ExactPi -> Dimensional v d b Source #
Convenient conversion from exactly represented values while retaining dimensional information.
asLens :: Fractional a => Unit m d a -> forall f. Functor f => (a -> f a) -> Quantity d a -> f (Quantity d a) Source #
mkUnitR :: Floating a => UnitName m -> ExactPi -> Unit m1 d a -> Unit m d a Source #
Forms a new atomic Unit
by specifying its UnitName
and its definition as a multiple of another Unit
.
Use this variant when the scale factor of the resulting unit is irrational or Approximate
. See mkUnitQ
for when it is rational
and mkUnitZ
for when it is an integer.
Note that supplying zero as a definining quantity is invalid, as the library relies upon units forming a group under multiplication.
Supplying negative defining quantities is allowed and handled gracefully, but is discouraged on the grounds that it may be unexpected by other readers.
class Category (cat :: k -> k -> Type) where #
Methods
id :: forall (a :: k). cat a a #
(.) :: forall (b :: k) (c :: k) (a :: k). cat b c -> cat a b -> cat a c #
Instances
Category (Coercion :: k -> k -> Type) | |
Defined in Control.Category | |
Category ((:~:) :: k -> k -> Type) | |
Defined in Control.Category | |
Category ((:~~:) :: k -> k -> Type) | |
Defined in Control.Category | |
Category ((->) :: Type -> Type -> Type) | |
Defined in Control.Category |
fromIntegral :: (Integral a, Num b) => a -> b #
realToFrac :: (Real a, Fractional b) => a -> b #
Instances
Methods
enumFromThen :: a -> a -> [a] #
enumFromTo :: a -> a -> [a] #
enumFromThenTo :: a -> a -> a -> [a] #
Instances
Enum Bool | |
Enum Char | |
Enum Int | |
Enum Int8 | |
Enum Int16 | |
Enum Int32 | |
Enum Int64 | |
Enum Integer | |
Enum Natural | |
Defined in GHC.Enum Methods enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] # | |
Enum Ordering | |
Enum Word | |
Enum Word8 | |
Enum Word16 | |
Defined in GHC.Word | |
Enum Word32 | |
Defined in GHC.Word | |
Enum Word64 | |
Defined in GHC.Word | |
Enum VecCount | |
Defined in GHC.Enum Methods succ :: VecCount -> VecCount # pred :: VecCount -> VecCount # enumFrom :: VecCount -> [VecCount] # enumFromThen :: VecCount -> VecCount -> [VecCount] # enumFromTo :: VecCount -> VecCount -> [VecCount] # enumFromThenTo :: VecCount -> VecCount -> VecCount -> [VecCount] # | |
Enum VecElem | |
Defined in GHC.Enum Methods enumFrom :: VecElem -> [VecElem] # enumFromThen :: VecElem -> VecElem -> [VecElem] # enumFromTo :: VecElem -> VecElem -> [VecElem] # enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem] # | |
Enum () | |
Enum CBool | |
Defined in Foreign.C.Types | |
Enum CChar | |
Defined in Foreign.C.Types | |
Enum CClock | |
Defined in Foreign.C.Types | |
Enum CDouble | |
Defined in Foreign.C.Types Methods enumFrom :: CDouble -> [CDouble] # enumFromThen :: CDouble -> CDouble -> [CDouble] # enumFromTo :: CDouble -> CDouble -> [CDouble] # enumFromThenTo :: CDouble -> CDouble -> CDouble -> [CDouble] # | |
Enum CFloat | |
Defined in Foreign.C.Types | |
Enum CInt | |
Defined in Foreign.C.Types | |
Enum CIntMax | |
Defined in Foreign.C.Types Methods enumFrom :: CIntMax -> [CIntMax] # enumFromThen :: CIntMax -> CIntMax -> [CIntMax] # enumFromTo :: CIntMax -> CIntMax -> [CIntMax] # enumFromThenTo :: CIntMax -> CIntMax -> CIntMax -> [CIntMax] # | |
Enum CIntPtr | |
Defined in Foreign.C.Types Methods enumFrom :: CIntPtr -> [CIntPtr] # enumFromThen :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromTo :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromThenTo :: CIntPtr -> CIntPtr -> CIntPtr -> [CIntPtr] # | |
Enum CLLong | |
Defined in Foreign.C.Types | |
Enum CLong | |
Defined in Foreign.C.Types | |
Enum CPtrdiff | |
Defined in Foreign.C.Types Methods succ :: CPtrdiff -> CPtrdiff # pred :: CPtrdiff -> CPtrdiff # enumFrom :: CPtrdiff -> [CPtrdiff] # enumFromThen :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromTo :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromThenTo :: CPtrdiff -> CPtrdiff -> CPtrdiff -> [CPtrdiff] # | |
Enum CSChar | |
Defined in Foreign.C.Types | |
Enum CSUSeconds | |
Defined in Foreign.C.Types Methods succ :: CSUSeconds -> CSUSeconds # pred :: CSUSeconds -> CSUSeconds # fromEnum :: CSUSeconds -> Int # enumFrom :: CSUSeconds -> [CSUSeconds] # enumFromThen :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromTo :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromThenTo :: CSUSeconds -> CSUSeconds -> CSUSeconds -> [CSUSeconds] # | |
Enum CShort | |
Defined in Foreign.C.Types | |
Enum CSigAtomic | |
Defined in Foreign.C.Types Methods succ :: CSigAtomic -> CSigAtomic # pred :: CSigAtomic -> CSigAtomic # fromEnum :: CSigAtomic -> Int # enumFrom :: CSigAtomic -> [CSigAtomic] # enumFromThen :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromTo :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromThenTo :: CSigAtomic -> CSigAtomic -> CSigAtomic -> [CSigAtomic] # | |
Enum CSize | |
Defined in Foreign.C.Types | |
Enum CTime | |
Defined in Foreign.C.Types | |
Enum CUChar | |
Defined in Foreign.C.Types | |
Enum CUInt | |
Defined in Foreign.C.Types | |
Enum CUIntMax | |
Defined in Foreign.C.Types Methods succ :: CUIntMax -> CUIntMax # pred :: CUIntMax -> CUIntMax # enumFrom :: CUIntMax -> [CUIntMax] # enumFromThen :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromTo :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromThenTo :: CUIntMax -> CUIntMax -> CUIntMax -> [CUIntMax] # | |
Enum CUIntPtr | |
Defined in Foreign.C.Types Methods succ :: CUIntPtr -> CUIntPtr # pred :: CUIntPtr -> CUIntPtr # enumFrom :: CUIntPtr -> [CUIntPtr] # enumFromThen :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromTo :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromThenTo :: CUIntPtr -> CUIntPtr -> CUIntPtr -> [CUIntPtr] # | |
Enum CULLong | |
Defined in Foreign.C.Types Methods enumFrom :: CULLong -> [CULLong] # enumFromThen :: CULLong -> CULLong -> [CULLong] # enumFromTo :: CULLong -> CULLong -> [CULLong] # enumFromThenTo :: CULLong -> CULLong -> CULLong -> [CULLong] # | |
Enum CULong | |
Defined in Foreign.C.Types | |
Enum CUSeconds | |
Defined in Foreign.C.Types Methods succ :: CUSeconds -> CUSeconds # pred :: CUSeconds -> CUSeconds # fromEnum :: CUSeconds -> Int # enumFrom :: CUSeconds -> [CUSeconds] # enumFromThen :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromTo :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromThenTo :: CUSeconds -> CUSeconds -> CUSeconds -> [CUSeconds] # | |
Enum CUShort | |
Defined in Foreign.C.Types Methods enumFrom :: CUShort -> [CUShort] # enumFromThen :: CUShort -> CUShort -> [CUShort] # enumFromTo :: CUShort -> CUShort -> [CUShort] # enumFromThenTo :: CUShort -> CUShort -> CUShort -> [CUShort] # | |
Enum CWchar | |
Defined in Foreign.C.Types | |
Enum Associativity | |
Defined in GHC.Generics Methods succ :: Associativity -> Associativity # pred :: Associativity -> Associativity # toEnum :: Int -> Associativity # fromEnum :: Associativity -> Int # enumFrom :: Associativity -> [Associativity] # enumFromThen :: Associativity -> Associativity -> [Associativity] # enumFromTo :: Associativity -> Associativity -> [Associativity] # enumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity] # | |
Enum DecidedStrictness | |
Defined in GHC.Generics Methods succ :: DecidedStrictness -> DecidedStrictness # pred :: DecidedStrictness -> DecidedStrictness # toEnum :: Int -> DecidedStrictness # fromEnum :: DecidedStrictness -> Int # enumFrom :: DecidedStrictness -> [DecidedStrictness] # enumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromThenTo :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # | |
Enum IntPtr | |
Defined in Foreign.Ptr | |
Enum SourceStrictness | |
Defined in GHC.Generics Methods succ :: SourceStrictness -> SourceStrictness # pred :: SourceStrictness -> SourceStrictness # toEnum :: Int -> SourceStrictness # fromEnum :: SourceStrictness -> Int # enumFrom :: SourceStrictness -> [SourceStrictness] # enumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromThenTo :: SourceStrictness -> SourceStrictness -> SourceStrictness -> [SourceStrictness] # | |
Enum SourceUnpackedness | |
Defined in GHC.Generics Methods succ :: SourceUnpackedness -> SourceUnpackedness # pred :: SourceUnpackedness -> SourceUnpackedness # toEnum :: Int -> SourceUnpackedness # fromEnum :: SourceUnpackedness -> Int # enumFrom :: SourceUnpackedness -> [SourceUnpackedness] # enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromThenTo :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # | |
Enum WordPtr | |
Defined in Foreign.Ptr Methods enumFrom :: WordPtr -> [WordPtr] # enumFromThen :: WordPtr -> WordPtr -> [WordPtr] # enumFromTo :: WordPtr -> WordPtr -> [WordPtr] # enumFromThenTo :: WordPtr -> WordPtr -> WordPtr -> [WordPtr] # | |
Integral a => Enum (Ratio a) | |
Defined in GHC.Real Methods enumFrom :: Ratio a -> [Ratio a] # enumFromThen :: Ratio a -> Ratio a -> [Ratio a] # enumFromTo :: Ratio a -> Ratio a -> [Ratio a] # enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a] # | |
Enum a => Enum (First a) | |
Defined in Data.Semigroup Methods enumFrom :: First a -> [First a] # enumFromThen :: First a -> First a -> [First a] # enumFromTo :: First a -> First a -> [First a] # enumFromThenTo :: First a -> First a -> First a -> [First a] # | |
Enum (Fixed a) | |
Defined in Data.Fixed Methods enumFrom :: Fixed a -> [Fixed a] # enumFromThen :: Fixed a -> Fixed a -> [Fixed a] # enumFromTo :: Fixed a -> Fixed a -> [Fixed a] # enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a] # | |
Enum a => Enum (Identity a) | |
Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] # | |
Enum a => Enum (Last a) | |
Defined in Data.Semigroup | |
Enum a => Enum (Max a) | |
Defined in Data.Semigroup | |
Enum a => Enum (Min a) | |
Defined in Data.Semigroup | |
Enum a => Enum (WrappedMonoid a) | |
Defined in Data.Semigroup Methods succ :: WrappedMonoid a -> WrappedMonoid a # pred :: WrappedMonoid a -> WrappedMonoid a # toEnum :: Int -> WrappedMonoid a # fromEnum :: WrappedMonoid a -> Int # enumFrom :: WrappedMonoid a -> [WrappedMonoid a] # enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # | |
Enum (Proxy s) | |
Defined in Data.Proxy Methods enumFrom :: Proxy s -> [Proxy s] # enumFromThen :: Proxy s -> Proxy s -> [Proxy s] # enumFromTo :: Proxy s -> Proxy s -> [Proxy s] # enumFromThenTo :: Proxy s -> Proxy s -> Proxy s -> [Proxy s] # | |
a ~ b => Enum (a :~: b) | |
Defined in Data.Type.Equality Methods succ :: (a :~: b) -> a :~: b # pred :: (a :~: b) -> a :~: b # fromEnum :: (a :~: b) -> Int # enumFrom :: (a :~: b) -> [a :~: b] # enumFromThen :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromTo :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromThenTo :: (a :~: b) -> (a :~: b) -> (a :~: b) -> [a :~: b] # | |
Enum a => Enum (Const a b) | |
Defined in Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> Const a b # fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] # | |
Enum (f a) => Enum (Alt f a) | |
Defined in Data.Semigroup.Internal Methods enumFrom :: Alt f a -> [Alt f a] # enumFromThen :: Alt f a -> Alt f a -> [Alt f a] # enumFromTo :: Alt f a -> Alt f a -> [Alt f a] # enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [Alt f a] # | |
Enum (f a) => Enum (Ap f a) | |
Defined in Data.Monoid | |
Coercible a b => Enum (Coercion a b) | |
Defined in Data.Type.Coercion Methods succ :: Coercion a b -> Coercion a b # pred :: Coercion a b -> Coercion a b # toEnum :: Int -> Coercion a b # fromEnum :: Coercion a b -> Int # enumFrom :: Coercion a b -> [Coercion a b] # enumFromThen :: Coercion a b -> Coercion a b -> [Coercion a b] # enumFromTo :: Coercion a b -> Coercion a b -> [Coercion a b] # enumFromThenTo :: Coercion a b -> Coercion a b -> Coercion a b -> [Coercion a b] # | |
a ~~ b => Enum (a :~~: b) | |
Defined in Data.Type.Equality Methods succ :: (a :~~: b) -> a :~~: b # pred :: (a :~~: b) -> a :~~: b # fromEnum :: (a :~~: b) -> Int # enumFrom :: (a :~~: b) -> [a :~~: b] # enumFromThen :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] # enumFromTo :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] # enumFromThenTo :: (a :~~: b) -> (a :~~: b) -> (a :~~: b) -> [a :~~: b] # |
Instances
Eq Bool | |
Eq Char | |
Eq Double | |
Eq Float | |
Eq Int | |
Eq Int8 | |
Eq Int16 | |
Eq Int32 | |
Eq Int64 | |
Eq Integer | |
Eq Natural | |
Eq Ordering | |
Eq Word | |
Eq Word8 | |
Eq Word16 | |
Eq Word32 | |
Eq Word64 | |
Eq SomeTypeRep | |
Eq () | |
Eq TyCon | |
Eq Module | |
Eq TrName | |
Eq All | |
Eq Any | |
Eq CBool | |
Eq CChar | |
Eq CClock | |
Eq CDouble | |
Eq CFloat | |
Eq CInt | |
Eq CIntMax | |
Eq CIntPtr | |
Eq CLLong | |
Eq CLong | |
Eq CPtrdiff | |
Eq CSChar | |
Eq CSUSeconds | |
Eq CShort | |
Eq CSigAtomic | |
Eq CSize | |
Eq CTime | |
Eq CUChar | |
Eq CUInt | |
Eq CUIntMax | |
Eq CUIntPtr | |
Eq CULLong | |
Eq CULong | |
Eq CUSeconds | |
Eq CUShort | |
Eq CWchar | |
Eq ExitCode | |
Eq Fingerprint | |
Eq MaskingState | |
Eq SrcLoc | |
Eq ThreadId | |
Eq Unique | |
Eq Version | |
Eq Void | |
Eq Constr | |
Eq ConstrRep | |
Eq DataRep | |
Eq Fixity | |
Eq Associativity | |
Eq DecidedStrictness | |
Eq Fixity | |
Eq IntPtr | |
Eq SourceStrictness | |
Eq SourceUnpackedness | |
Eq WordPtr | |
Eq DynamicDimension Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel Methods (==) :: DynamicDimension -> DynamicDimension -> Bool # (/=) :: DynamicDimension -> DynamicDimension -> Bool # | |
Eq Dimension' Source # | |
Eq ArrayException | |
Eq AsyncException | |
Eq IOErrorType | |
Eq IOException | |
Eq BigNat | |
Eq InterchangeName Source # | |
Defined in Numeric.Units.Dimensional.UnitNames.InterchangeNames Methods (==) :: InterchangeName -> InterchangeName -> Bool # (/=) :: InterchangeName -> InterchangeName -> Bool # | |
Eq InterchangeNameAuthority Source # | |
Defined in Numeric.Units.Dimensional.UnitNames.InterchangeNames Methods (==) :: InterchangeNameAuthority -> InterchangeNameAuthority -> Bool # (/=) :: InterchangeNameAuthority -> InterchangeNameAuthority -> Bool # | |
Eq Metricality Source # | |
Defined in Numeric.Units.Dimensional.Variants | |
Eq Prefix Source # | |
Eq ByteArray | |
Eq SpecConstrAnnotation | |
Eq SomeNat | |
Eq SomeSymbol | |
Eq BlockReason | |
Eq ThreadStatus | |
Eq a => Eq [a] | |
Eq a => Eq (Maybe a) | |
Eq a => Eq (Ratio a) | |
Eq (StablePtr a) | |
Eq (Ptr a) | |
Eq (FunPtr a) | |
Eq p => Eq (Par1 p) | |
Eq (ForeignPtr a) | |
(Prim a, Eq a) => Eq (Vector a) | |
Eq a => Eq (Down a) | |
Eq a => Eq (Dual a) | |
Eq a => Eq (First a) | |
Eq a => Eq (First a) | |
Eq (Fixed a) | |
Eq (IORef a) | |
Eq a => Eq (Identity a) | |
Eq a => Eq (Last a) | |
Eq a => Eq (Last a) | |
Eq (MVar a) | |
Eq a => Eq (Max a) | |
Eq a => Eq (Min a) | |
Eq a => Eq (NonEmpty a) | |
Eq a => Eq (Option a) | |
Eq a => Eq (Product a) | |
Eq (StableName a) | |
Eq a => Eq (Sum a) | |
Eq m => Eq (WrappedMonoid m) | |
Eq a => Eq (ZipList a) | |
Eq a => Eq (Complex a) | |
Eq (NameAtom m) Source # | |
Eq (UnitName m) Source # | |
Eq a => Eq (Array a) | |
(Eq a, Prim a) => Eq (PrimArray a) | |
Eq a => Eq (SmallArray a) | |
Eq a => Eq (DynQuantity a) Source # | |
Defined in Numeric.Units.Dimensional.Dynamic Methods (==) :: DynQuantity a -> DynQuantity a -> Bool # (/=) :: DynQuantity a -> DynQuantity a -> Bool # | |
Eq a => Eq (AnyQuantity a) Source # | |
Defined in Numeric.Units.Dimensional.Dynamic Methods (==) :: AnyQuantity a -> AnyQuantity a -> Bool # (/=) :: AnyQuantity a -> AnyQuantity a -> Bool # | |
Eq (TVar a) | |
(Eq a, Eq b) => Eq (Either a b) | |
Eq (V1 p) | |
Eq (U1 p) | |
Eq (TypeRep a) | |
(Eq a, Eq b) => Eq (a, b) | |
Eq a => Eq (Arg a b) | |
(Ix i, Eq e) => Eq (Array i e) | |
Eq (Proxy s) | |
Eq (STRef s a) | |
(Eq1 m, Eq a) => Eq (ListT m a) | |
(Eq1 m, Eq a) => Eq (MaybeT m a) | |
Eq (MutableArray s a) | |
Eq (SmallMutableArray s a) | |
Eq (f p) => Eq (Rec1 f p) | |
Eq (URec (Ptr ()) p) | |
Eq (URec Char p) | |
Eq (URec Double p) | |
Eq (URec Float p) | |
Eq (URec Int p) | |
Eq (URec Word p) | |
(Eq a, Eq b, Eq c) => Eq (a, b, c) | |
Eq (a :~: b) | |
Eq a => Eq (Const a b) | |
Eq (f a) => Eq (Alt f a) | |
Eq (f a) => Eq (Ap f a) | |
Eq (Coercion a b) | |
(Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a) | |
(Eq1 f, Eq a) => Eq (IdentityT f a) | |
(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a) | |
(Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) | |
(Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) | |
Eq a => Eq (Dimensional ('DQuantity s) d a) Source # | |
Defined in Numeric.Units.Dimensional.Internal Methods (==) :: Dimensional ('DQuantity s) d a -> Dimensional ('DQuantity s) d a -> Bool # (/=) :: Dimensional ('DQuantity s) d a -> Dimensional ('DQuantity s) d a -> Bool # | |
Eq (STArray s i e) | |
Eq c => Eq (K1 i c p) | |
(Eq (f p), Eq (g p)) => Eq ((f :+: g) p) | |
(Eq (f p), Eq (g p)) => Eq ((f :*: g) p) | |
(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) | |
Eq (a :~~: b) | |
(Eq1 f, Eq1 g, Eq a) => Eq (Product f g a) | |
(Eq1 f, Eq1 g, Eq a) => Eq (Sum f g a) | |
Eq (f p) => Eq (M1 i c f p) | |
Eq (f (g p)) => Eq ((f :.: g) p) | |
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) | |
(Eq1 f, Eq1 g, Eq a) => Eq (Compose f g a) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
class Fractional a => Floating a #
Minimal complete definition
pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh
Instances
Floating Double | |
Floating Float | |
Floating ExactPi | |
Floating CDouble | |
Defined in Foreign.C.Types Methods pi :: CDouble exp :: CDouble -> CDouble log :: CDouble -> CDouble sqrt :: CDouble -> CDouble (**) :: CDouble -> CDouble -> CDouble logBase :: CDouble -> CDouble -> CDouble sin :: CDouble -> CDouble cos :: CDouble -> CDouble tan :: CDouble -> CDouble asin :: CDouble -> CDouble acos :: CDouble -> CDouble atan :: CDouble -> CDouble sinh :: CDouble -> CDouble cosh :: CDouble -> CDouble tanh :: CDouble -> CDouble asinh :: CDouble -> CDouble acosh :: CDouble -> CDouble atanh :: CDouble -> CDouble log1p :: CDouble -> CDouble expm1 :: CDouble -> CDouble log1pexp :: CDouble -> CDouble log1mexp :: CDouble -> CDouble | |
Floating CFloat | |
Defined in Foreign.C.Types Methods pi :: CFloat exp :: CFloat -> CFloat log :: CFloat -> CFloat sqrt :: CFloat -> CFloat (**) :: CFloat -> CFloat -> CFloat logBase :: CFloat -> CFloat -> CFloat sin :: CFloat -> CFloat cos :: CFloat -> CFloat tan :: CFloat -> CFloat asin :: CFloat -> CFloat acos :: CFloat -> CFloat atan :: CFloat -> CFloat sinh :: CFloat -> CFloat cosh :: CFloat -> CFloat tanh :: CFloat -> CFloat asinh :: CFloat -> CFloat acosh :: CFloat -> CFloat atanh :: CFloat -> CFloat log1p :: CFloat -> CFloat expm1 :: CFloat -> CFloat log1pexp :: CFloat -> CFloat log1mexp :: CFloat -> CFloat | |
KnownMinCtxt Floating | |
Defined in Data.ExactPi.TypeLevel | |
Floating a => Floating (Identity a) | |
Defined in Data.Functor.Identity Methods pi :: Identity a exp :: Identity a -> Identity a log :: Identity a -> Identity a sqrt :: Identity a -> Identity a (**) :: Identity a -> Identity a -> Identity a logBase :: Identity a -> Identity a -> Identity a sin :: Identity a -> Identity a cos :: Identity a -> Identity a tan :: Identity a -> Identity a asin :: Identity a -> Identity a acos :: Identity a -> Identity a atan :: Identity a -> Identity a sinh :: Identity a -> Identity a cosh :: Identity a -> Identity a tanh :: Identity a -> Identity a asinh :: Identity a -> Identity a acosh :: Identity a -> Identity a atanh :: Identity a -> Identity a log1p :: Identity a -> Identity a expm1 :: Identity a -> Identity a log1pexp :: Identity a -> Identity a log1mexp :: Identity a -> Identity a | |
RealFloat a => Floating (Complex a) | |
Defined in Data.Complex Methods pi :: Complex a exp :: Complex a -> Complex a log :: Complex a -> Complex a sqrt :: Complex a -> Complex a (**) :: Complex a -> Complex a -> Complex a logBase :: Complex a -> Complex a -> Complex a sin :: Complex a -> Complex a cos :: Complex a -> Complex a tan :: Complex a -> Complex a asin :: Complex a -> Complex a acos :: Complex a -> Complex a atan :: Complex a -> Complex a sinh :: Complex a -> Complex a cosh :: Complex a -> Complex a tanh :: Complex a -> Complex a asinh :: Complex a -> Complex a acosh :: Complex a -> Complex a atanh :: Complex a -> Complex a log1p :: Complex a -> Complex a expm1 :: Complex a -> Complex a log1pexp :: Complex a -> Complex a log1mexp :: Complex a -> Complex a | |
Floating a => Floating (DynQuantity a) Source # | |
Defined in Numeric.Units.Dimensional.Dynamic Methods pi :: DynQuantity a exp :: DynQuantity a -> DynQuantity a log :: DynQuantity a -> DynQuantity a sqrt :: DynQuantity a -> DynQuantity a (**) :: DynQuantity a -> DynQuantity a -> DynQuantity a logBase :: DynQuantity a -> DynQuantity a -> DynQuantity a sin :: DynQuantity a -> DynQuantity a cos :: DynQuantity a -> DynQuantity a tan :: DynQuantity a -> DynQuantity a asin :: DynQuantity a -> DynQuantity a acos :: DynQuantity a -> DynQuantity a atan :: DynQuantity a -> DynQuantity a sinh :: DynQuantity a -> DynQuantity a cosh :: DynQuantity a -> DynQuantity a tanh :: DynQuantity a -> DynQuantity a asinh :: DynQuantity a -> DynQuantity a acosh :: DynQuantity a -> DynQuantity a atanh :: DynQuantity a -> DynQuantity a log1p :: DynQuantity a -> DynQuantity a expm1 :: DynQuantity a -> DynQuantity a log1pexp :: DynQuantity a -> DynQuantity a log1mexp :: DynQuantity a -> DynQuantity a | |
Floating a => Floating (Const a b) | |
Defined in Data.Functor.Const Methods pi :: Const a b exp :: Const a b -> Const a b log :: Const a b -> Const a b sqrt :: Const a b -> Const a b (**) :: Const a b -> Const a b -> Const a b logBase :: Const a b -> Const a b -> Const a b sin :: Const a b -> Const a b cos :: Const a b -> Const a b tan :: Const a b -> Const a b asin :: Const a b -> Const a b acos :: Const a b -> Const a b atan :: Const a b -> Const a b sinh :: Const a b -> Const a b cosh :: Const a b -> Const a b tanh :: Const a b -> Const a b asinh :: Const a b -> Const a b acosh :: Const a b -> Const a b atanh :: Const a b -> Const a b log1p :: Const a b -> Const a b expm1 :: Const a b -> Const a b log1pexp :: Const a b -> Const a b log1mexp :: Const a b -> Const a b |
class Num a => Fractional a where #
Methods
fromRational :: Rational -> a #
Instances
Fractional ExactPi | |
Fractional CDouble | |
Defined in Foreign.C.Types Methods (/) :: CDouble -> CDouble -> CDouble recip :: CDouble -> CDouble fromRational :: Rational -> CDouble # | |
Fractional CFloat | |
Defined in Foreign.C.Types Methods (/) :: CFloat -> CFloat -> CFloat recip :: CFloat -> CFloat fromRational :: Rational -> CFloat # | |
KnownMinCtxt Fractional | |
Defined in Data.ExactPi.TypeLevel Methods inj :: Fractional a => Proxy Fractional -> ExactPi -> a | |
Integral a => Fractional (Ratio a) | |
HasResolution a => Fractional (Fixed a) | |
Defined in Data.Fixed Methods (/) :: Fixed a -> Fixed a -> Fixed a recip :: Fixed a -> Fixed a fromRational :: Rational -> Fixed a # | |
Fractional a => Fractional (Identity a) | |
Defined in Data.Functor.Identity Methods (/) :: Identity a -> Identity a -> Identity a recip :: Identity a -> Identity a fromRational :: Rational -> Identity a # | |
RealFloat a => Fractional (Complex a) | |
Defined in Data.Complex Methods (/) :: Complex a -> Complex a -> Complex a recip :: Complex a -> Complex a fromRational :: Rational -> Complex a # | |
Fractional a => Fractional (DynQuantity a) Source # | |
Defined in Numeric.Units.Dimensional.Dynamic Methods (/) :: DynQuantity a -> DynQuantity a -> DynQuantity a recip :: DynQuantity a -> DynQuantity a fromRational :: Rational -> DynQuantity a # | |
Fractional a => Fractional (Const a b) | |
Defined in Data.Functor.Const Methods (/) :: Const a b -> Const a b -> Const a b recip :: Const a b -> Const a b fromRational :: Rational -> Const a b # |
class (Real a, Enum a) => Integral a where #
Methods
Instances
Integral Int | |
Integral Int8 | |
Integral Int16 | |
Integral Int32 | |
Integral Int64 | |
Integral Integer | |
Defined in GHC.Real | |
Integral Natural | |
Defined in GHC.Real | |
Integral Word | |
Integral Word8 | |
Integral Word16 | |
Integral Word32 | |
Integral Word64 | |
Integral CBool | |
Integral CChar | |
Integral CInt | |
Integral CIntMax | |
Defined in Foreign.C.Types | |
Integral CIntPtr | |
Defined in Foreign.C.Types | |
Integral CLLong | |
Defined in Foreign.C.Types | |
Integral CLong | |
Integral CPtrdiff | |
Defined in Foreign.C.Types | |
Integral CSChar | |
Defined in Foreign.C.Types | |
Integral CShort | |
Defined in Foreign.C.Types | |
Integral CSigAtomic | |
Defined in Foreign.C.Types Methods quot :: CSigAtomic -> CSigAtomic -> CSigAtomic # rem :: CSigAtomic -> CSigAtomic -> CSigAtomic # div :: CSigAtomic -> CSigAtomic -> CSigAtomic # mod :: CSigAtomic -> CSigAtomic -> CSigAtomic # quotRem :: CSigAtomic -> CSigAtomic -> (CSigAtomic, CSigAtomic) # divMod :: CSigAtomic -> CSigAtomic -> (CSigAtomic, CSigAtomic) # | |
Integral CSize | |
Integral CUChar | |
Defined in Foreign.C.Types | |
Integral CUInt | |
Integral CUIntMax | |
Defined in Foreign.C.Types | |
Integral CUIntPtr | |
Defined in Foreign.C.Types | |
Integral CULLong | |
Defined in Foreign.C.Types | |
Integral CULong | |
Defined in Foreign.C.Types | |
Integral CUShort | |
Defined in Foreign.C.Types | |
Integral CWchar | |
Defined in Foreign.C.Types | |
Integral IntPtr | |
Defined in Foreign.Ptr | |
Integral WordPtr | |
Defined in Foreign.Ptr | |
Integral a => Integral (Identity a) | |
Defined in Data.Functor.Identity Methods quot :: Identity a -> Identity a -> Identity a # rem :: Identity a -> Identity a -> Identity a # div :: Identity a -> Identity a -> Identity a # mod :: Identity a -> Identity a -> Identity a # quotRem :: Identity a -> Identity a -> (Identity a, Identity a) # divMod :: Identity a -> Identity a -> (Identity a, Identity a) # | |
Integral a => Integral (Const a b) | |
Defined in Data.Functor.Const Methods quot :: Const a b -> Const a b -> Const a b # rem :: Const a b -> Const a b -> Const a b # div :: Const a b -> Const a b -> Const a b # mod :: Const a b -> Const a b -> Const a b # quotRem :: Const a b -> Const a b -> (Const a b, Const a b) # divMod :: Const a b -> Const a b -> (Const a b, Const a b) # |
class Applicative m => Monad (m :: Type -> Type) where #
Minimal complete definition
Instances
Monad [] | |
Monad Maybe | |
Monad IO | |
Monad Par1 | |
Monad Id | |
Monad Box | |
Monad Down | |
Monad Dual | |
Monad First | |
Monad First | |
Monad Identity | |
Monad Last | |
Monad Last | |
Monad Max | |
Monad Min | |
Monad NonEmpty | |
Monad Option | |
Monad Product | |
Monad Sum | |
Monad Complex | |
Monad P | |
Monad ReadP | |
Monad Array | |
Monad SmallArray | |
Monad STM | |
Monad (Either e) | |
Monad (U1 :: Type -> Type) | |
Monoid a => Monad ((,) a) | |
Monad (Proxy :: Type -> Type) | |
Monad m => Monad (WrappedMonad m) | |
Monad (ST s) | |
Monad m => Monad (ListT m) | |
Monad m => Monad (MaybeT m) | |
Monad f => Monad (Rec1 f) | |
Monad f => Monad (Alt f) | |
Monad f => Monad (Ap f) | |
(Monad m, Error e) => Monad (ErrorT e m) | |
Monad m => Monad (IdentityT m) | |
(Monoid w, Functor m, Monad m) => Monad (AccumT w m) | |
Monad m => Monad (ExceptT e m) | |
Monad m => Monad (ReaderT r m) | |
Monad m => Monad (SelectT r m) | |
Monad m => Monad (StateT s m) | |
Monad m => Monad (StateT s m) | |
(Monoid w, Monad m) => Monad (WriterT w m) | |
Monad m => Monad (WriterT w m) | |
(Monoid w, Monad m) => Monad (WriterT w m) | |
Monad ((->) r :: Type -> Type) | |
(Monad f, Monad g) => Monad (f :*: g) | |
(Monad f, Monad g) => Monad (Product f g) | |
Monad (ContT r m) | |
Monad f => Monad (M1 i c f) | |
(Monoid w, Monad m) => Monad (RWST r w s m) | |
Monad m => Monad (RWST r w s m) | |
(Monoid w, Monad m) => Monad (RWST r w s m) | |
class Functor (f :: Type -> Type) where #
Minimal complete definition
Instances
Functor [] | |
Functor Maybe | |
Functor IO | |
Functor Par1 | |
Defined in GHC.Generics | |
Functor Id | |
Functor Box | |
Functor Down | |
Functor Dual | |
Defined in Data.Semigroup.Internal | |
Functor First | |
Defined in Data.Semigroup | |
Functor First | |
Defined in Data.Monoid | |
Functor Identity | |
Defined in Data.Functor.Identity | |
Functor Last | |
Defined in Data.Semigroup | |
Functor Last | |
Defined in Data.Monoid | |
Functor Max | |
Defined in Data.Semigroup | |
Functor Min | |
Defined in Data.Semigroup | |
Functor NonEmpty | |
Functor Option | |
Defined in Data.Semigroup | |
Functor Product | |
Defined in Data.Semigroup.Internal | |
Functor Sum | |
Defined in Data.Semigroup.Internal | |
Functor ZipList | |
Defined in Control.Applicative | |
Functor Complex | |
Defined in Data.Complex | |
Functor P | |
Defined in Text.ParserCombinators.ReadP | |
Functor ReadP | |
Defined in Text.ParserCombinators.ReadP | |
Functor Array | |
Defined in Data.Primitive.Array | |
Functor SmallArray | |
Defined in Data.Primitive.SmallArray | |
Functor STM | |
Defined in GHC.Conc.Sync | |
Functor (Either a) | |
Functor (V1 :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (U1 :: Type -> Type) | |
Defined in GHC.Generics | |
Functor ((,) a) | |
Functor (Arg a) | |
Defined in Data.Semigroup | |
Functor (Array i) | |
Functor (Proxy :: Type -> Type) | |
Defined in Data.Proxy | |
Monad m => Functor (WrappedMonad m) | |
Defined in Control.Applicative | |
Functor (ST s) | |
Functor m => Functor (ListT m) | |
Defined in Control.Monad.Trans.List | |
Functor m => Functor (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
Functor f => Functor (Rec1 f) | |
Defined in GHC.Generics | |
Functor (URec Char :: Type -> Type) | |
Functor (URec Double :: Type -> Type) | |
Functor (URec Float :: Type -> Type) | |
Functor (URec Int :: Type -> Type) | |
Functor (URec Word :: Type -> Type) | |
Functor (URec (Ptr ()) :: Type -> Type) | |
Defined in GHC.Generics | |
Monad m => Functor (Bundle m v) | |
Functor (Const m :: Type -> Type) | |
Defined in Data.Functor.Const | |
Functor f => Functor (Alt f) | |
Defined in Data.Semigroup.Internal | |
Functor f => Functor (Ap f) | |
Defined in Data.Monoid | |
Arrow a => Functor (WrappedArrow a b) | |
Defined in Control.Applicative | |
Functor m => Functor (ErrorT e m) | |
Defined in Control.Monad.Trans.Error | |
Functor m => Functor (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
Functor m => Functor (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
Functor m => Functor (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
Functor m => Functor (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
Functor m => Functor (SelectT r m) | |
Defined in Control.Monad.Trans.Select | |
Functor m => Functor (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
Functor m => Functor (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
Functor m => Functor (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
Functor m => Functor (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
Functor m => Functor (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
KnownVariant v => Functor (Dimensional v d) Source # | A Note that this instance is dubious, because it allows you to break the dimensional abstraction. See Note that, while this instance overlaps with that given for Note that this is an orphan instance. |
Defined in Numeric.Units.Dimensional.Functor Methods fmap :: (a -> b) -> Dimensional v d a -> Dimensional v d b # (<$) :: a -> Dimensional v d b -> Dimensional v d a # | |
Functor (SQuantity s DOne) Source # | |
Functor ((->) r :: Type -> Type) | |
Functor (K1 i c :: Type -> Type) | |
Defined in GHC.Generics | |
(Functor f, Functor g) => Functor (f :+: g) | |
Defined in GHC.Generics | |
(Functor f, Functor g) => Functor (f :*: g) | |
Defined in GHC.Generics | |
(Functor f, Functor g) => Functor (Product f g) | |
Defined in Data.Functor.Product | |
(Functor f, Functor g) => Functor (Sum f g) | |
Defined in Data.Functor.Sum | |
Functor (ContT r m) | |
Defined in Control.Monad.Trans.Cont | |
Functor f => Functor (M1 i c f) | |
Defined in GHC.Generics | |
(Functor f, Functor g) => Functor (f :.: g) | |
Defined in GHC.Generics | |
(Functor f, Functor g) => Functor (Compose f g) | |
Defined in Data.Functor.Compose | |
Functor m => Functor (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict | |
Functor m => Functor (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
Functor m => Functor (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy |
Minimal complete definition
(+), (*), abs, signum, fromInteger, (negate | (-))
Methods
fromInteger :: Integer -> a #
Instances
Num Int | |
Num Int8 | |
Num Int16 | |
Num Int32 | |
Num Int64 | |
Num Integer | |
Num Natural | |
Num Word | |
Num Word8 | |
Num Word16 | |
Num Word32 | |
Num Word64 | |
Num ExactPi | |
Num CBool | |
Defined in Foreign.C.Types | |
Num CChar | |
Defined in Foreign.C.Types | |
Num CClock | |
Defined in Foreign.C.Types | |
Num CDouble | |
Defined in Foreign.C.Types | |
Num CFloat | |
Defined in Foreign.C.Types | |
Num CInt | |
Defined in Foreign.C.Types | |
Num CIntMax | |
Defined in Foreign.C.Types | |
Num CIntPtr | |
Defined in Foreign.C.Types | |
Num CLLong | |
Defined in Foreign.C.Types | |
Num CLong | |
Defined in Foreign.C.Types | |
Num CPtrdiff | |
Defined in Foreign.C.Types | |
Num CSChar | |
Defined in Foreign.C.Types | |
Num CSUSeconds | |
Defined in Foreign.C.Types | |
Num CShort | |
Defined in Foreign.C.Types | |
Num CSigAtomic | |
Defined in Foreign.C.Types | |
Num CSize | |
Defined in Foreign.C.Types | |
Num CTime | |
Defined in Foreign.C.Types | |
Num CUChar | |
Defined in Foreign.C.Types | |
Num CUInt | |
Defined in Foreign.C.Types | |
Num CUIntMax | |
Defined in Foreign.C.Types | |
Num CUIntPtr | |
Defined in Foreign.C.Types | |
Num CULLong | |
Defined in Foreign.C.Types | |
Num CULong | |
Defined in Foreign.C.Types | |
Num CUSeconds | |
Defined in Foreign.C.Types | |
Num CUShort | |
Defined in Foreign.C.Types | |
Num CWchar | |
Defined in Foreign.C.Types | |
Num IntPtr | |
Defined in Foreign.Ptr | |
Num WordPtr | |
Defined in Foreign.Ptr | |
KnownMinCtxt Num | |
Defined in Data.ExactPi.TypeLevel | |
Integral a => Num (Ratio a) | |
Num a => Num (Down a) | |
HasResolution a => Num (Fixed a) | |
Defined in Data.Fixed | |
Num a => Num (Identity a) | |
Defined in Data.Functor.Identity | |
Num a => Num (Max a) | |
Defined in Data.Semigroup | |
Num a => Num (Min a) | |
Defined in Data.Semigroup | |
Num a => Num (Product a) | |
Defined in Data.Semigroup.Internal | |
Num a => Num (Sum a) | |
Defined in Data.Semigroup.Internal | |
RealFloat a => Num (Complex a) | |
Defined in Data.Complex | |
Num a => Num (DynQuantity a) Source # | |
Defined in Numeric.Units.Dimensional.Dynamic Methods (+) :: DynQuantity a -> DynQuantity a -> DynQuantity a (-) :: DynQuantity a -> DynQuantity a -> DynQuantity a (*) :: DynQuantity a -> DynQuantity a -> DynQuantity a negate :: DynQuantity a -> DynQuantity a abs :: DynQuantity a -> DynQuantity a signum :: DynQuantity a -> DynQuantity a fromInteger :: Integer -> DynQuantity a # | |
Num a => Num (Const a b) | |
Defined in Data.Functor.Const | |
Num (f a) => Num (Alt f a) | |
Defined in Data.Semigroup.Internal | |
(Applicative f, Num a) => Num (Ap f a) | |
Defined in Data.Monoid |
Instances
Ord Bool | |
Ord Char | |
Ord Double | |
Ord Float | |
Ord Int | |
Ord Int8 | |
Ord Int16 | |
Ord Int32 | |
Ord Int64 | |
Ord Integer | |
Ord Natural | |
Ord Ordering | |
Defined in GHC.Classes | |
Ord Word | |
Ord Word8 | |
Ord Word16 | |
Ord Word32 | |
Ord Word64 | |
Ord SomeTypeRep | |
Defined in Data.Typeable.Internal | |
Ord () | |
Ord TyCon | |
Ord All | |
Ord Any | |
Ord CBool | |
Ord CChar | |
Ord CClock | |
Ord CDouble | |
Ord CFloat | |
Ord CInt | |
Ord CIntMax | |
Ord CIntPtr | |
Ord CLLong | |
Ord CLong | |
Ord CPtrdiff | |
Defined in Foreign.C.Types | |
Ord CSChar | |
Ord CSUSeconds | |
Ord CShort | |
Ord CSigAtomic | |
Ord CSize | |
Ord CTime | |
Ord CUChar | |
Ord CUInt | |
Ord CUIntMax | |
Defined in Foreign.C.Types | |
Ord CUIntPtr | |
Defined in Foreign.C.Types | |
Ord CULLong | |
Ord CULong | |
Ord CUSeconds | |
Ord CUShort | |
Ord CWchar | |
Ord ExitCode | |
Defined in GHC.IO.Exception | |
Ord Fingerprint | |
Defined in GHC.Fingerprint.Type | |
Ord ThreadId | |
Defined in GHC.Conc.Sync | |
Ord Unique | |
Ord Version | |
Ord Void | |
Ord Associativity | |
Defined in GHC.Generics Methods compare :: Associativity -> Associativity -> Ordering # (<) :: Associativity -> Associativity -> Bool # (<=) :: Associativity -> Associativity -> Bool # (>) :: Associativity -> Associativity -> Bool # (>=) :: Associativity -> Associativity -> Bool # | |
Ord DecidedStrictness | |
Defined in GHC.Generics Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering # (<) :: DecidedStrictness -> DecidedStrictness -> Bool # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool # (>) :: DecidedStrictness -> DecidedStrictness -> Bool # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # | |
Ord Fixity | |
Ord IntPtr | |
Ord SourceStrictness | |
Defined in GHC.Generics Methods compare :: SourceStrictness -> SourceStrictness -> Ordering # (<) :: SourceStrictness -> SourceStrictness -> Bool # (<=) :: SourceStrictness -> SourceStrictness -> Bool # (>) :: SourceStrictness -> SourceStrictness -> Bool # (>=) :: SourceStrictness -> SourceStrictness -> Bool # max :: SourceStrictness -> SourceStrictness -> SourceStrictness # min :: SourceStrictness -> SourceStrictness -> SourceStrictness # | |
Ord SourceUnpackedness | |
Defined in GHC.Generics Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # | |
Ord WordPtr | |
Ord DynamicDimension Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel Methods compare :: DynamicDimension -> DynamicDimension -> Ordering # (<) :: DynamicDimension -> DynamicDimension -> Bool # (<=) :: DynamicDimension -> DynamicDimension -> Bool # (>) :: DynamicDimension -> DynamicDimension -> Bool # (>=) :: DynamicDimension -> DynamicDimension -> Bool # max :: DynamicDimension -> DynamicDimension -> DynamicDimension # min :: DynamicDimension -> DynamicDimension -> DynamicDimension # | |
Ord Dimension' Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel Methods compare :: Dimension' -> Dimension' -> Ordering # (<) :: Dimension' -> Dimension' -> Bool # (<=) :: Dimension' -> Dimension' -> Bool # (>) :: Dimension' -> Dimension' -> Bool # (>=) :: Dimension' -> Dimension' -> Bool # max :: Dimension' -> Dimension' -> Dimension' # min :: Dimension' -> Dimension' -> Dimension' # | |
Ord ArrayException | |
Defined in GHC.IO.Exception Methods compare :: ArrayException -> ArrayException -> Ordering # (<) :: ArrayException -> ArrayException -> Bool # (<=) :: ArrayException -> ArrayException -> Bool # (>) :: ArrayException -> ArrayException -> Bool # (>=) :: ArrayException -> ArrayException -> Bool # | |
Ord AsyncException | |
Defined in GHC.IO.Exception Methods compare :: AsyncException -> AsyncException -> Ordering # (<) :: AsyncException -> AsyncException -> Bool # (<=) :: AsyncException -> AsyncException -> Bool # (>) :: AsyncException -> AsyncException -> Bool # (>=) :: AsyncException -> AsyncException -> Bool # | |
Ord BigNat | |
Ord InterchangeName Source # | |
Defined in Numeric.Units.Dimensional.UnitNames.InterchangeNames Methods compare :: InterchangeName -> InterchangeName -> Ordering # (<) :: InterchangeName -> InterchangeName -> Bool # (<=) :: InterchangeName -> InterchangeName -> Bool # (>) :: InterchangeName -> InterchangeName -> Bool # (>=) :: InterchangeName -> InterchangeName -> Bool # max :: InterchangeName -> InterchangeName -> InterchangeName # min :: InterchangeName -> InterchangeName -> InterchangeName # | |
Ord InterchangeNameAuthority Source # | |
Defined in Numeric.Units.Dimensional.UnitNames.InterchangeNames Methods compare :: InterchangeNameAuthority -> InterchangeNameAuthority -> Ordering # (<) :: InterchangeNameAuthority -> InterchangeNameAuthority -> Bool # (<=) :: InterchangeNameAuthority -> InterchangeNameAuthority -> Bool # (>) :: InterchangeNameAuthority -> InterchangeNameAuthority -> Bool # (>=) :: InterchangeNameAuthority -> InterchangeNameAuthority -> Bool # max :: InterchangeNameAuthority -> InterchangeNameAuthority -> InterchangeNameAuthority # min :: InterchangeNameAuthority -> InterchangeNameAuthority -> InterchangeNameAuthority # | |
Ord Metricality Source # | |
Defined in Numeric.Units.Dimensional.Variants Methods compare :: Metricality -> Metricality -> Ordering # (<) :: Metricality -> Metricality -> Bool # (<=) :: Metricality -> Metricality -> Bool # (>) :: Metricality -> Metricality -> Bool # (>=) :: Metricality -> Metricality -> Bool # max :: Metricality -> Metricality -> Metricality # min :: Metricality -> Metricality -> Metricality # | |
Ord Prefix Source # | |
Defined in Numeric.Units.Dimensional.UnitNames.Internal | |
Ord ByteArray | |
Ord SomeNat | |
Ord SomeSymbol | |
Ord BlockReason | |
Defined in GHC.Conc.Sync | |
Ord ThreadStatus | |
Defined in GHC.Conc.Sync | |
Ord a => Ord [a] | |
Ord a => Ord (Maybe a) | |
Integral a => Ord (Ratio a) | |
Ord (Ptr a) | |
Ord (FunPtr a) | |
Defined in GHC.Ptr | |
Ord p => Ord (Par1 p) | |
Ord (ForeignPtr a) | |
Defined in GHC.ForeignPtr | |
(Prim a, Ord a) => Ord (Vector a) | |
Defined in Data.Vector.Primitive | |
Ord a => Ord (Down a) | |
Ord a => Ord (Dual a) | |
Ord a => Ord (First a) | |
Ord a => Ord (First a) | |
Ord (Fixed a) | |
Ord a => Ord (Identity a) | |
Defined in Data.Functor.Identity | |
Ord a => Ord (Last a) | |
Ord a => Ord (Last a) | |
Ord a => Ord (Max a) | |
Ord a => Ord (Min a) | |
Ord a => Ord (NonEmpty a) | |
Ord a => Ord (Option a) | |
Defined in Data.Semigroup | |
Ord a => Ord (Product a) | |
Ord a => Ord (Sum a) | |
Ord m => Ord (WrappedMonoid m) | |
Defined in Data.Semigroup Methods compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering # (<) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # | |
Ord a => Ord (ZipList a) | |
Ord (NameAtom m) Source # | |
Defined in Numeric.Units.Dimensional.UnitNames.Internal | |
Ord a => Ord (Array a) | |
Defined in Data.Primitive.Array | |
(Ord a, Prim a) => Ord (PrimArray a) | |
Defined in Data.Primitive.PrimArray | |
Ord a => Ord (SmallArray a) | |
Defined in Data.Primitive.SmallArray | |
(Ord a, Ord b) => Ord (Either a b) | |
Ord (V1 p) | |
Ord (U1 p) | |
Ord (TypeRep a) | |
(Ord a, Ord b) => Ord (a, b) | |
Ord a => Ord (Arg a b) | |
(Ix i, Ord e) => Ord (Array i e) | |
Ord (Proxy s) | |
(Ord1 m, Ord a) => Ord (ListT m a) | |
(Ord1 m, Ord a) => Ord (MaybeT m a) | |
Defined in Control.Monad.Trans.Maybe | |
Ord (f p) => Ord (Rec1 f p) | |
Defined in GHC.Generics | |
Ord (URec (Ptr ()) p) | |
Defined in GHC.Generics Methods compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering # (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # | |
Ord (URec Char p) | |
Defined in GHC.Generics | |
Ord (URec Double p) | |
Defined in GHC.Generics Methods compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # | |
Ord (URec Float p) | |
Defined in GHC.Generics | |
Ord (URec Int p) | |
Ord (URec Word p) | |
Defined in GHC.Generics | |
(Ord a, Ord b, Ord c) => Ord (a, b, c) | |
Ord (a :~: b) | |
Defined in Data.Type.Equality | |
Ord a => Ord (Const a b) | |
Ord (f a) => Ord (Alt f a) | |
Defined in Data.Semigroup.Internal | |
Ord (f a) => Ord (Ap f a) | |
Ord (Coercion a b) | |
Defined in Data.Type.Coercion | |
(Ord e, Ord1 m, Ord a) => Ord (ErrorT e m a) | |
Defined in Control.Monad.Trans.Error | |
(Ord1 f, Ord a) => Ord (IdentityT f a) | |
Defined in Control.Monad.Trans.Identity Methods compare :: IdentityT f a -> IdentityT f a -> Ordering # (<) :: IdentityT f a -> IdentityT f a -> Bool # (<=) :: IdentityT f a -> IdentityT f a -> Bool # (>) :: IdentityT f a -> IdentityT f a -> Bool # (>=) :: IdentityT f a -> IdentityT f a -> Bool # | |
(Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a) | |
Defined in Control.Monad.Trans.Except Methods compare :: ExceptT e m a -> ExceptT e m a -> Ordering # (<) :: ExceptT e m a -> ExceptT e m a -> Bool # (<=) :: ExceptT e m a -> ExceptT e m a -> Bool # (>) :: ExceptT e m a -> ExceptT e m a -> Bool # (>=) :: ExceptT e m a -> ExceptT e m a -> Bool # | |
(Ord w, Ord1 m, Ord a) => Ord (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Strict Methods compare :: WriterT w m a -> WriterT w m a -> Ordering # (<) :: WriterT w m a -> WriterT w m a -> Bool # (<=) :: WriterT w m a -> WriterT w m a -> Bool # (>) :: WriterT w m a -> WriterT w m a -> Bool # (>=) :: WriterT w m a -> WriterT w m a -> Bool # | |
(Ord w, Ord1 m, Ord a) => Ord (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Lazy Methods compare :: WriterT w m a -> WriterT w m a -> Ordering # (<) :: WriterT w m a -> WriterT w m a -> Bool # (<=) :: WriterT w m a -> WriterT w m a -> Bool # (>) :: WriterT w m a -> WriterT w m a -> Bool # (>=) :: WriterT w m a -> WriterT w m a -> Bool # | |
Ord a => Ord (Dimensional ('DQuantity s) d a) Source # | |
Defined in Numeric.Units.Dimensional.Internal Methods compare :: Dimensional ('DQuantity s) d a -> Dimensional ('DQuantity s) d a -> Ordering # (<) :: Dimensional ('DQuantity s) d a -> Dimensional ('DQuantity s) d a -> Bool # (<=) :: Dimensional ('DQuantity s) d a -> Dimensional ('DQuantity s) d a -> Bool # (>) :: Dimensional ('DQuantity s) d a -> Dimensional ('DQuantity s) d a -> Bool # (>=) :: Dimensional ('DQuantity s) d a -> Dimensional ('DQuantity s) d a -> Bool # max :: Dimensional ('DQuantity s) d a -> Dimensional ('DQuantity s) d a -> Dimensional ('DQuantity s) d a # min :: Dimensional ('DQuantity s) d a -> Dimensional ('DQuantity s) d a -> Dimensional ('DQuantity s) d a # | |
Ord c => Ord (K1 i c p) | |
Defined in GHC.Generics | |
(Ord (f p), Ord (g p)) => Ord ((f :+: g) p) | |
Defined in GHC.Generics | |
(Ord (f p), Ord (g p)) => Ord ((f :*: g) p) | |
Defined in GHC.Generics | |
(Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) | |
Defined in GHC.Classes | |
Ord (a :~~: b) | |
(Ord1 f, Ord1 g, Ord a) => Ord (Product f g a) | |
Defined in Data.Functor.Product Methods compare :: Product f g a -> Product f g a -> Ordering # (<) :: Product f g a -> Product f g a -> Bool # (<=) :: Product f g a -> Product f g a -> Bool # (>) :: Product f g a -> Product f g a -> Bool # (>=) :: Product f g a -> Product f g a -> Bool # | |
(Ord1 f, Ord1 g, Ord a) => Ord (Sum f g a) | |
Ord (f p) => Ord (M1 i c f p) | |
Ord (f (g p)) => Ord ((f :.: g) p) | |
Defined in GHC.Generics | |
(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e) -> (a, b, c, d, e) -> Ordering # (<) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (<=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (>=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # max :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # min :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # | |
(Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a) | |
Defined in Data.Functor.Compose Methods compare :: Compose f g a -> Compose f g a -> Ordering # (<) :: Compose f g a -> Compose f g a -> Bool # (<=) :: Compose f g a -> Compose f g a -> Bool # (>) :: Compose f g a -> Compose f g a -> Bool # (>=) :: Compose f g a -> Compose f g a -> Bool # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Ordering # (<) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (<=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (>) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (>=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # max :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # min :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Ordering # (<) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (<=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (>) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (>=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # max :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # min :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Ordering # (<) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (<=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (>) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (>=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # max :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # min :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # max :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # min :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # min :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # min :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # min :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # |
Minimal complete definition
readsPrec | readPrec
Instances
Read Bool | |
Read Char | |
Read Double | |
Read Float | |
Read Int | |
Read Int8 | |
Read Int16 | |
Read Int32 | |
Read Int64 | |
Read Integer | |
Read Natural | |
Read Ordering | |
Read Word | |
Read Word8 | |
Read Word16 | |
Read Word32 | |
Read Word64 | |
Read () | |
Read All | |
Defined in Data.Semigroup.Internal | |
Read Any | |
Defined in Data.Semigroup.Internal | |
Read CBool | |
Defined in Foreign.C.Types | |
Read CChar | |
Defined in Foreign.C.Types | |
Read CClock | |
Defined in Foreign.C.Types | |
Read CDouble | |
Defined in Foreign.C.Types | |
Read CFloat | |
Defined in Foreign.C.Types | |
Read CInt | |
Defined in Foreign.C.Types | |
Read CIntMax | |
Defined in Foreign.C.Types | |
Read CIntPtr | |
Defined in Foreign.C.Types | |
Read CLLong | |
Defined in Foreign.C.Types | |
Read CLong | |
Defined in Foreign.C.Types | |
Read CPtrdiff | |
Defined in Foreign.C.Types | |
Read CSChar | |
Defined in Foreign.C.Types | |
Read CSUSeconds | |
Defined in Foreign.C.Types | |
Read CShort | |
Defined in Foreign.C.Types | |
Read CSigAtomic | |
Defined in Foreign.C.Types | |
Read CSize | |
Defined in Foreign.C.Types | |
Read CTime | |
Defined in Foreign.C.Types | |
Read CUChar | |
Defined in Foreign.C.Types | |
Read CUInt | |
Defined in Foreign.C.Types | |
Read CUIntMax | |
Defined in Foreign.C.Types | |
Read CUIntPtr | |
Defined in Foreign.C.Types | |
Read CULLong | |
Defined in Foreign.C.Types | |
Read CULong | |
Defined in Foreign.C.Types | |
Read CUSeconds | |
Defined in Foreign.C.Types | |
Read CUShort | |
Defined in Foreign.C.Types | |
Read CWchar | |
Defined in Foreign.C.Types | |
Read ExitCode | |
Defined in GHC.IO.Exception | |
Read Version | |
Defined in Data.Version | |
Read Void | |
Read Associativity | |
Defined in GHC.Generics | |
Read DecidedStrictness | |
Defined in GHC.Generics | |
Read Fixity | |
Defined in GHC.Generics | |
Read IntPtr | |
Defined in Foreign.Ptr | |
Read SourceStrictness | |
Defined in GHC.Generics | |
Read SourceUnpackedness | |
Defined in GHC.Generics | |
Read WordPtr | |
Defined in Foreign.Ptr | |
Read Lexeme | |
Read SomeNat | |
Defined in GHC.TypeNats | |
Read GeneralCategory | |
Read SomeSymbol | |
Defined in GHC.TypeLits | |
Read a => Read [a] | |
Read a => Read (Maybe a) | |
(Integral a, Read a) => Read (Ratio a) | |
Read p => Read (Par1 p) | |
Defined in GHC.Generics | |
(Read a, Prim a) => Read (Vector a) | |
Read a => Read (Down a) | |
Read a => Read (Dual a) | |
Defined in Data.Semigroup.Internal | |
Read a => Read (First a) | |
Defined in Data.Semigroup | |
Read a => Read (First a) | |
Defined in Data.Monoid | |
HasResolution a => Read (Fixed a) | |
Defined in Data.Fixed | |
Read a => Read (Identity a) | |
Defined in Data.Functor.Identity | |
Read a => Read (Last a) | |
Defined in Data.Semigroup | |
Read a => Read (Last a) | |
Defined in Data.Monoid | |
Read a => Read (Max a) | |
Defined in Data.Semigroup | |
Read a => Read (Min a) | |
Defined in Data.Semigroup | |
Read a => Read (NonEmpty a) | |
Read a => Read (Option a) | |
Defined in Data.Semigroup | |
Read a => Read (Product a) | |
Defined in Data.Semigroup.Internal | |
Read a => Read (Sum a) | |
Defined in Data.Semigroup.Internal | |
Read m => Read (WrappedMonoid m) | |
Defined in Data.Semigroup | |
Read a => Read (ZipList a) | |
Defined in Control.Applicative | |
Read a => Read (Complex a) | |
Defined in Data.Complex | |
Read a => Read (Array a) | |
Defined in Data.Primitive.Array | |
Read a => Read (SmallArray a) | |
Defined in Data.Primitive.SmallArray | |
(Read a, Read b) => Read (Either a b) | |
Read (V1 p) | |
Defined in GHC.Generics | |
Read (U1 p) | |
Defined in GHC.Generics | |
(Read a, Read b) => Read (a, b) | |
(Read a, Read b) => Read (Arg a b) | |
Defined in Data.Semigroup | |
(Ix a, Read a, Read b) => Read (Array a b) | |
Read (Proxy t) | |
Defined in Data.Proxy | |
(Read1 m, Read a) => Read (ListT m a) | |
Defined in Control.Monad.Trans.List | |
(Read1 m, Read a) => Read (MaybeT m a) | |
Defined in Control.Monad.Trans.Maybe | |
Read (f p) => Read (Rec1 f p) | |
Defined in GHC.Generics | |
(Read a, Read b, Read c) => Read (a, b, c) | |
a ~ b => Read (a :~: b) | |
Defined in Data.Type.Equality | |
Read a => Read (Const a b) | |
Defined in Data.Functor.Const | |
Read (f a) => Read (Alt f a) | |
Defined in Data.Semigroup.Internal | |
Read (f a) => Read (Ap f a) | |
Defined in Data.Monoid | |
Coercible a b => Read (Coercion a b) | |
Defined in Data.Type.Coercion | |
(Read e, Read1 m, Read a) => Read (ErrorT e m a) | |
Defined in Control.Monad.Trans.Error | |
(Read1 f, Read a) => Read (IdentityT f a) | |
Defined in Control.Monad.Trans.Identity | |
(Read e, Read1 m, Read a) => Read (ExceptT e m a) | |
Defined in Control.Monad.Trans.Except | |
(Read w, Read1 m, Read a) => Read (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Strict | |
(Read w, Read1 m, Read a) => Read (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
Read c => Read (K1 i c p) | |
Defined in GHC.Generics | |
(Read (f p), Read (g p)) => Read ((f :+: g) p) | |
Defined in GHC.Generics | |
(Read (f p), Read (g p)) => Read ((f :*: g) p) | |
Defined in GHC.Generics | |
(Read a, Read b, Read c, Read d) => Read (a, b, c, d) | |
a ~~ b => Read (a :~~: b) | |
Defined in Data.Type.Equality | |
(Read1 f, Read1 g, Read a) => Read (Product f g a) | |
Defined in Data.Functor.Product | |
(Read1 f, Read1 g, Read a) => Read (Sum f g a) | |
Defined in Data.Functor.Sum | |
Read (f p) => Read (M1 i c f p) | |
Defined in GHC.Generics | |
Read (f (g p)) => Read ((f :.: g) p) | |
Defined in GHC.Generics | |
(Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) | |
(Read1 f, Read1 g, Read a) => Read (Compose f g a) | |
Defined in Data.Functor.Compose | |
(Read a, Read b, Read c, Read d, Read e, Read f) => Read (a, b, c, d, e, f) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read (a, b, c, d, e, f, g) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) => Read (a, b, c, d, e, f, g, h) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i) => Read (a, b, c, d, e, f, g, h, i) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j) => Read (a, b, c, d, e, f, g, h, i, j) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k) => Read (a, b, c, d, e, f, g, h, i, j, k) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l) => Read (a, b, c, d, e, f, g, h, i, j, k, l) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n, Read o) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Defined in GHC.Read |
class (Num a, Ord a) => Real a where #
Methods
toRational :: a -> Rational #
Instances
Real Int | |
Defined in GHC.Real Methods toRational :: Int -> Rational # | |
Real Int8 | |
Defined in GHC.Int Methods toRational :: Int8 -> Rational # | |
Real Int16 | |
Defined in GHC.Int Methods toRational :: Int16 -> Rational # | |
Real Int32 | |
Defined in GHC.Int Methods toRational :: Int32 -> Rational # | |
Real Int64 | |
Defined in GHC.Int Methods toRational :: Int64 -> Rational # | |
Real Integer | |
Defined in GHC.Real Methods toRational :: Integer -> Rational # | |
Real Natural | |
Defined in GHC.Real Methods toRational :: Natural -> Rational # | |
Real Word | |
Defined in GHC.Real Methods toRational :: Word -> Rational # | |
Real Word8 | |
Defined in GHC.Word Methods toRational :: Word8 -> Rational # | |
Real Word16 | |
Defined in GHC.Word Methods toRational :: Word16 -> Rational # | |
Real Word32 | |
Defined in GHC.Word Methods toRational :: Word32 -> Rational # | |
Real Word64 | |
Defined in GHC.Word Methods toRational :: Word64 -> Rational # | |
Real CBool | |
Defined in Foreign.C.Types Methods toRational :: CBool -> Rational # | |
Real CChar | |
Defined in Foreign.C.Types Methods toRational :: CChar -> Rational # | |
Real CClock | |
Defined in Foreign.C.Types Methods toRational :: CClock -> Rational # | |
Real CDouble | |
Defined in Foreign.C.Types Methods toRational :: CDouble -> Rational # | |
Real CFloat | |
Defined in Foreign.C.Types Methods toRational :: CFloat -> Rational # | |
Real CInt | |
Defined in Foreign.C.Types Methods toRational :: CInt -> Rational # | |
Real CIntMax | |
Defined in Foreign.C.Types Methods toRational :: CIntMax -> Rational # | |
Real CIntPtr | |
Defined in Foreign.C.Types Methods toRational :: CIntPtr -> Rational # | |
Real CLLong | |
Defined in Foreign.C.Types Methods toRational :: CLLong -> Rational # | |
Real CLong | |
Defined in Foreign.C.Types Methods toRational :: CLong -> Rational # | |
Real CPtrdiff | |
Defined in Foreign.C.Types Methods toRational :: CPtrdiff -> Rational # | |
Real CSChar | |
Defined in Foreign.C.Types Methods toRational :: CSChar -> Rational # | |
Real CSUSeconds | |
Defined in Foreign.C.Types Methods toRational :: CSUSeconds -> Rational # | |
Real CShort | |
Defined in Foreign.C.Types Methods toRational :: CShort -> Rational # | |
Real CSigAtomic | |
Defined in Foreign.C.Types Methods toRational :: CSigAtomic -> Rational # | |
Real CSize | |
Defined in Foreign.C.Types Methods toRational :: CSize -> Rational # | |
Real CTime | |
Defined in Foreign.C.Types Methods toRational :: CTime -> Rational # | |
Real CUChar | |
Defined in Foreign.C.Types Methods toRational :: CUChar -> Rational # | |
Real CUInt | |
Defined in Foreign.C.Types Methods toRational :: CUInt -> Rational # | |
Real CUIntMax | |
Defined in Foreign.C.Types Methods toRational :: CUIntMax -> Rational # | |
Real CUIntPtr | |
Defined in Foreign.C.Types Methods toRational :: CUIntPtr -> Rational # | |
Real CULLong | |
Defined in Foreign.C.Types Methods toRational :: CULLong -> Rational # | |
Real CULong | |
Defined in Foreign.C.Types Methods toRational :: CULong -> Rational # | |
Real CUSeconds | |
Defined in Foreign.C.Types Methods toRational :: CUSeconds -> Rational # | |
Real CUShort | |
Defined in Foreign.C.Types Methods toRational :: CUShort -> Rational # | |
Real CWchar | |
Defined in Foreign.C.Types Methods toRational :: CWchar -> Rational # | |
Real IntPtr | |
Defined in Foreign.Ptr Methods toRational :: IntPtr -> Rational # | |
Real WordPtr | |
Defined in Foreign.Ptr Methods toRational :: WordPtr -> Rational # | |
Integral a => Real (Ratio a) | |
Defined in GHC.Real Methods toRational :: Ratio a -> Rational # | |
HasResolution a => Real (Fixed a) | |
Defined in Data.Fixed Methods toRational :: Fixed a -> Rational # | |
Real a => Real (Identity a) | |
Defined in Data.Functor.Identity Methods toRational :: Identity a -> Rational # | |
Real a => Real (Const a b) | |
Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational # |
class (RealFrac a, Floating a) => RealFloat a where #
Minimal complete definition
floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE
Methods
floatRadix :: a -> Integer #
floatDigits :: a -> Int #
floatRange :: a -> (Int, Int) #
decodeFloat :: a -> (Integer, Int) #
encodeFloat :: Integer -> Int -> a #
significand :: a -> a #
scaleFloat :: Int -> a -> a #
isInfinite :: a -> Bool #
isDenormalized :: a -> Bool #
isNegativeZero :: a -> Bool #
Instances
RealFloat Double | |
Defined in GHC.Float Methods floatRadix :: Double -> Integer # floatDigits :: Double -> Int # floatRange :: Double -> (Int, Int) # decodeFloat :: Double -> (Integer, Int) # encodeFloat :: Integer -> Int -> Double # significand :: Double -> Double # scaleFloat :: Int -> Double -> Double # isInfinite :: Double -> Bool # isDenormalized :: Double -> Bool # isNegativeZero :: Double -> Bool # | |
RealFloat Float | |
Defined in GHC.Float Methods floatRadix :: Float -> Integer # floatDigits :: Float -> Int # floatRange :: Float -> (Int, Int) # decodeFloat :: Float -> (Integer, Int) # encodeFloat :: Integer -> Int -> Float # significand :: Float -> Float # scaleFloat :: Int -> Float -> Float # isInfinite :: Float -> Bool # isDenormalized :: Float -> Bool # isNegativeZero :: Float -> Bool # | |
RealFloat CDouble | |
Defined in Foreign.C.Types Methods floatRadix :: CDouble -> Integer # floatDigits :: CDouble -> Int # floatRange :: CDouble -> (Int, Int) # decodeFloat :: CDouble -> (Integer, Int) # encodeFloat :: Integer -> Int -> CDouble # significand :: CDouble -> CDouble # scaleFloat :: Int -> CDouble -> CDouble # isInfinite :: CDouble -> Bool # isDenormalized :: CDouble -> Bool # isNegativeZero :: CDouble -> Bool # atan2 :: CDouble -> CDouble -> CDouble | |
RealFloat CFloat | |
Defined in Foreign.C.Types Methods floatRadix :: CFloat -> Integer # floatDigits :: CFloat -> Int # floatRange :: CFloat -> (Int, Int) # decodeFloat :: CFloat -> (Integer, Int) # encodeFloat :: Integer -> Int -> CFloat # significand :: CFloat -> CFloat # scaleFloat :: Int -> CFloat -> CFloat # isInfinite :: CFloat -> Bool # isDenormalized :: CFloat -> Bool # isNegativeZero :: CFloat -> Bool # atan2 :: CFloat -> CFloat -> CFloat | |
RealFloat a => RealFloat (Identity a) | |
Defined in Data.Functor.Identity Methods floatRadix :: Identity a -> Integer # floatDigits :: Identity a -> Int # floatRange :: Identity a -> (Int, Int) # decodeFloat :: Identity a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Identity a # exponent :: Identity a -> Int # significand :: Identity a -> Identity a # scaleFloat :: Int -> Identity a -> Identity a # isInfinite :: Identity a -> Bool # isDenormalized :: Identity a -> Bool # isNegativeZero :: Identity a -> Bool # isIEEE :: Identity a -> Bool # atan2 :: Identity a -> Identity a -> Identity a | |
RealFloat a => RealFloat (Const a b) | |
Defined in Data.Functor.Const Methods floatRadix :: Const a b -> Integer # floatDigits :: Const a b -> Int # floatRange :: Const a b -> (Int, Int) # decodeFloat :: Const a b -> (Integer, Int) # encodeFloat :: Integer -> Int -> Const a b # exponent :: Const a b -> Int # significand :: Const a b -> Const a b # scaleFloat :: Int -> Const a b -> Const a b # isInfinite :: Const a b -> Bool # isDenormalized :: Const a b -> Bool # isNegativeZero :: Const a b -> Bool # atan2 :: Const a b -> Const a b -> Const a b |
class (Real a, Fractional a) => RealFrac a where #
Minimal complete definition
Methods
properFraction :: Integral b => a -> (b, a) #
truncate :: Integral b => a -> b #
round :: Integral b => a -> b #
Instances
Show Bool | |
Show Char | |
Show Int | |
Show Int8 | |
Show Int16 | |
Show Int32 | |
Show Int64 | |
Show Integer | |
Show Natural | |
Show Ordering | |
Show Word | |
Show Word8 | |
Show Word16 | |
Show Word32 | |
Show Word64 | |
Show RuntimeRep | |
Show VecCount | |
Show VecElem | |
Show CallStack | |
Show SomeTypeRep | |
Show () | |
Show TyCon | |
Show Module | |
Show TrName | |
Show KindRep | |
Show TypeLitSort | |
Show ExactPi | |
Show All | |
Show Any | |
Show CBool | |
Show CChar | |
Show CClock | |
Show CDouble | |
Show CFloat | |
Show CInt | |
Show CIntMax | |
Show CIntPtr | |
Show CLLong | |
Show CLong | |
Show CPtrdiff | |
Show CSChar | |
Show CSUSeconds | |
Show CShort | |
Show CSigAtomic | |
Show CSize | |
Show CTime | |
Show CUChar | |
Show CUInt | |
Show CUIntMax | |
Show CUIntPtr | |
Show CULLong | |
Show CULong | |
Show CUSeconds | |
Show CUShort | |
Show CWchar | |
Show ExitCode | |
Show Fingerprint | |
Show MaskingState | |
Show SrcLoc | |
Show ThreadId | |
Show Version | |
Show Void | |
Show Constr | |
Show ConstrRep | |
Show DataRep | |
Show DataType | |
Show Fixity | |
Show Associativity | |
Show DecidedStrictness | |
Show Fixity | |
Show IntPtr | |
Show SourceStrictness | |
Show SourceUnpackedness | |
Show WordPtr | |
Show DynamicDimension Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel Methods showsPrec :: Int -> DynamicDimension -> ShowS # show :: DynamicDimension -> String # showList :: [DynamicDimension] -> ShowS # | |
Show Dimension' Source # | |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel Methods showsPrec :: Int -> Dimension' -> ShowS # show :: Dimension' -> String # showList :: [Dimension'] -> ShowS # | |
Show AllocationLimitExceeded | |
Show ArrayException | |
Show AssertionFailed | |
Show AsyncException | |
Show BlockedIndefinitelyOnMVar | |
Show BlockedIndefinitelyOnSTM | |
Show CompactionFailed | |
Show Deadlock | |
Show FixIOException | |
Show IOErrorType | |
Show IOException | |
Show SomeAsyncException | |
Show InterchangeName Source # | |
Defined in Numeric.Units.Dimensional.UnitNames.InterchangeNames Methods showsPrec :: Int -> InterchangeName -> ShowS # show :: InterchangeName -> String # showList :: [InterchangeName] -> ShowS # | |
Show InterchangeNameAuthority Source # | |
Defined in Numeric.Units.Dimensional.UnitNames.InterchangeNames Methods showsPrec :: Int -> InterchangeNameAuthority -> ShowS # show :: InterchangeNameAuthority -> String # showList :: [InterchangeNameAuthority] -> ShowS # | |
Show ByteArray | |
Show SomeNat | |
Show SomeSymbol | |
Show AnyUnit Source # | |
Show BlockReason | |
Show ThreadStatus | |
Show a => Show [a] | |
Show a => Show (Maybe a) | |
Show a => Show (Ratio a) | |
Show (Ptr a) | |
Show (FunPtr a) | |
Show p => Show (Par1 p) | |
Show (ForeignPtr a) | |
(Show a, Prim a) => Show (Vector a) | |
Show a => Show (Down a) | |
Show a => Show (Dual a) | |
Show a => Show (First a) | |
Show a => Show (First a) | |
HasResolution a => Show (Fixed a) | |
Show a => Show (Identity a) | |
Show a => Show (Last a) | |
Show a => Show (Last a) | |
Show a => Show (Max a) | |
Show a => Show (Min a) | |
Show a => Show (NonEmpty a) | |
Show a => Show (Option a) | |
Show a => Show (Product a) | |
Show a => Show (Sum a) | |
Show m => Show (WrappedMonoid m) | |
Show a => Show (ZipList a) | |
Show a => Show (Complex a) | |
Show (UnitName m) Source # |
|
Show a => Show (Array a) | |
(Show a, Prim a) => Show (PrimArray a) | |
Show a => Show (SmallArray a) | |
Show a => Show (DynQuantity a) Source # | |
Defined in Numeric.Units.Dimensional.Dynamic Methods showsPrec :: Int -> DynQuantity a -> ShowS # show :: DynQuantity a -> String # showList :: [DynQuantity a] -> ShowS # | |
Show a => Show (AnyQuantity a) Source # | |
Defined in Numeric.Units.Dimensional.Dynamic Methods showsPrec :: Int -> AnyQuantity a -> ShowS # show :: AnyQuantity a -> String # showList :: [AnyQuantity a] -> ShowS # | |
(Show a, Show b) => Show (Either a b) | |
Show (V1 p) | |
Show (U1 p) | |
Show (TypeRep a) | |
(Show a, Show b) => Show (a, b) | |
(Show a, Show b) => Show (Arg a b) | |
(Ix a, Show a, Show b) => Show (Array a b) | |
Show (Proxy s) | |
Show (ST s a) | |
(Show1 m, Show a) => Show (ListT m a) | |
(Show1 m, Show a) => Show (MaybeT m a) | |
Show (f p) => Show (Rec1 f p) | |
Show (URec Char p) | |
Show (URec Double p) | |
Show (URec Float p) | |
Show (URec Int p) | |
Show (URec Word p) | |
(Show a, Show b, Show c) => Show (a, b, c) | |
Show (a :~: b) | |
Show a => Show (Const a b) | |
Show (f a) => Show (Alt f a) | |
Show (f a) => Show (Ap f a) | |
Show (Coercion a b) | |
(Show e, Show1 m, Show a) => Show (ErrorT e m a) | |
(Show1 f, Show a) => Show (IdentityT f a) | |
(Show e, Show1 m, Show a) => Show (ExceptT e m a) | |
(Show w, Show1 m, Show a) => Show (WriterT w m a) | |
(Show w, Show1 m, Show a) => Show (WriterT w m a) | |
(KnownDimension d, KnownExactPi s, Show a, Real a) => Show (SQuantity s d a) Source # | Uses non-breaking spaces between the value and the unit, and within the unit name. |
Show a => Show (Unit m d a) Source # | Unit names are shown with non-breaking spaces. |
Show c => Show (K1 i c p) | |
(Show (f p), Show (g p)) => Show ((f :+: g) p) | |
(Show (f p), Show (g p)) => Show ((f :*: g) p) | |
(Show a, Show b, Show c, Show d) => Show (a, b, c, d) | |
Show (a :~~: b) | |
(Show1 f, Show1 g, Show a) => Show (Product f g a) | |
(Show1 f, Show1 g, Show a) => Show (Sum f g a) | |
Show (f p) => Show (M1 i c f p) | |
Show (f (g p)) => Show ((f :.: g) p) | |
(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) | |
(Show1 f, Show1 g, Show a) => Show (Compose f g a) | |
(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
class Monad m => MonadFail (m :: Type -> Type) where #
Instances
class Functor f => Applicative (f :: Type -> Type) where #
Instances
Applicative [] | |
Applicative Maybe | |
Applicative IO | |
Applicative Par1 | |
Applicative Id | |
Applicative Box | |
Applicative Down | |
Applicative Dual | |
Applicative First | |
Applicative First | |
Applicative Identity | |
Applicative Last | |
Applicative Last | |
Applicative Max | |
Applicative Min | |
Applicative NonEmpty | |
Applicative Option | |
Applicative Product | |
Applicative Sum | |
Applicative ZipList | |
Applicative Complex | |
Applicative P | |
Applicative ReadP | |
Applicative Array | |
Applicative SmallArray | |
Defined in Data.Primitive.SmallArray | |
Applicative STM | |
Applicative (Either e) | |
Applicative (U1 :: Type -> Type) | |
Monoid a => Applicative ((,) a) | |
Applicative (Proxy :: Type -> Type) | |
Monad m => Applicative (WrappedMonad m) | |
Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a # | |
Applicative (ST s) | |
Applicative m => Applicative (ListT m) | |
(Functor m, Monad m) => Applicative (MaybeT m) | |
Applicative f => Applicative (Rec1 f) | |
Monoid m => Applicative (Const m :: Type -> Type) | |
Applicative f => Applicative (Alt f) | |
Applicative f => Applicative (Ap f) | |
Arrow a => Applicative (WrappedArrow a b) | |
Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # | |
(Functor m, Monad m) => Applicative (ErrorT e m) | |
Defined in Control.Monad.Trans.Error | |
Applicative m => Applicative (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
(Monoid w, Functor m, Monad m) => Applicative (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
(Functor m, Monad m) => Applicative (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
Applicative m => Applicative (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
(Functor m, Monad m) => Applicative (SelectT r m) | |
Defined in Control.Monad.Trans.Select | |
(Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
(Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
(Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
(Functor m, Monad m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
(Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
Applicative ((->) a :: Type -> Type) | |
Monoid c => Applicative (K1 i c :: Type -> Type) | |
(Applicative f, Applicative g) => Applicative (f :*: g) | |
(Applicative f, Applicative g) => Applicative (Product f g) | |
Defined in Data.Functor.Product | |
Applicative (ContT r m) | |
Applicative f => Applicative (M1 i c f) | |
(Applicative f, Applicative g) => Applicative (f :.: g) | |
(Applicative f, Applicative g) => Applicative (Compose f g) | |
Defined in Data.Functor.Compose | |
(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict | |
(Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy |
class Foldable (t :: Type -> Type) where #
Methods
foldMap :: Monoid m => (a -> m) -> t a -> m #
foldr :: (a -> b -> b) -> b -> t a -> b #
foldl :: (b -> a -> b) -> b -> t a -> b #
foldr1 :: (a -> a -> a) -> t a -> a #
Instances
Foldable [] | |
Defined in Data.Foldable Methods foldMap :: Monoid m => (a -> m) -> [a] -> m # foldMap' :: Monoid m => (a -> m) -> [a] -> m foldr :: (a -> b -> b) -> b -> [a] -> b # foldr' :: (a -> b -> b) -> b -> [a] -> b foldl :: (b -> a -> b) -> b -> [a] -> b # foldl' :: (b -> a -> b) -> b -> [a] -> b foldr1 :: (a -> a -> a) -> [a] -> a # foldl1 :: (a -> a -> a) -> [a] -> a # toList :: [a] -> [a] elem :: Eq a => a -> [a] -> Bool # maximum :: Ord a => [a] -> a # | |
Foldable Maybe | |
Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # | |
Foldable Par1 | |
Defined in Data.Foldable Methods fold :: Monoid m => Par1 m -> m foldMap :: Monoid m => (a -> m) -> Par1 a -> m # foldMap' :: Monoid m => (a -> m) -> Par1 a -> m foldr :: (a -> b -> b) -> b -> Par1 a -> b # foldr' :: (a -> b -> b) -> b -> Par1 a -> b foldl :: (b -> a -> b) -> b -> Par1 a -> b # foldl' :: (b -> a -> b) -> b -> Par1 a -> b foldr1 :: (a -> a -> a) -> Par1 a -> a # foldl1 :: (a -> a -> a) -> Par1 a -> a # toList :: Par1 a -> [a] elem :: Eq a => a -> Par1 a -> Bool # maximum :: Ord a => Par1 a -> a # | |
Foldable Down | |
Defined in Data.Foldable Methods fold :: Monoid m => Down m -> m foldMap :: Monoid m => (a -> m) -> Down a -> m # foldMap' :: Monoid m => (a -> m) -> Down a -> m foldr :: (a -> b -> b) -> b -> Down a -> b # foldr' :: (a -> b -> b) -> b -> Down a -> b foldl :: (b -> a -> b) -> b -> Down a -> b # foldl' :: (b -> a -> b) -> b -> Down a -> b foldr1 :: (a -> a -> a) -> Down a -> a # foldl1 :: (a -> a -> a) -> Down a -> a # toList :: Down a -> [a] elem :: Eq a => a -> Down a -> Bool # maximum :: Ord a => Down a -> a # | |
Foldable Dual | |
Defined in Data.Foldable Methods fold :: Monoid m => Dual m -> m foldMap :: Monoid m => (a -> m) -> Dual a -> m # foldMap' :: Monoid m => (a -> m) -> Dual a -> m foldr :: (a -> b -> b) -> b -> Dual a -> b # foldr' :: (a -> b -> b) -> b -> Dual a -> b foldl :: (b -> a -> b) -> b -> Dual a -> b # foldl' :: (b -> a -> b) -> b -> Dual a -> b foldr1 :: (a -> a -> a) -> Dual a -> a # foldl1 :: (a -> a -> a) -> Dual a -> a # toList :: Dual a -> [a] elem :: Eq a => a -> Dual a -> Bool # maximum :: Ord a => Dual a -> a # | |
Foldable First | |
Defined in Data.Semigroup Methods fold :: Monoid m => First m -> m foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # toList :: First a -> [a] elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # | |
Foldable First | |
Defined in Data.Foldable Methods fold :: Monoid m => First m -> m foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # toList :: First a -> [a] elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # | |
Foldable Identity | |
Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m foldMap :: Monoid m => (a -> m) -> Identity a -> m # foldMap' :: Monoid m => (a -> m) -> Identity a -> m foldr :: (a -> b -> b) -> b -> Identity a -> b # foldr' :: (a -> b -> b) -> b -> Identity a -> b foldl :: (b -> a -> b) -> b -> Identity a -> b # foldl' :: (b -> a -> b) -> b -> Identity a -> b foldr1 :: (a -> a -> a) -> Identity a -> a # foldl1 :: (a -> a -> a) -> Identity a -> a # toList :: Identity a -> [a] elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # | |
Foldable Last | |
Defined in Data.Semigroup Methods fold :: Monoid m => Last m -> m foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # toList :: Last a -> [a] elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
Foldable Last | |
Defined in Data.Foldable Methods fold :: Monoid m => Last m -> m foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # toList :: Last a -> [a] elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
Foldable Max | |
Defined in Data.Semigroup Methods fold :: Monoid m => Max m -> m foldMap :: Monoid m => (a -> m) -> Max a -> m # foldMap' :: Monoid m => (a -> m) -> Max a -> m foldr :: (a -> b -> b) -> b -> Max a -> b # foldr' :: (a -> b -> b) -> b -> Max a -> b foldl :: (b -> a -> b) -> b -> Max a -> b # foldl' :: (b -> a -> b) -> b -> Max a -> b foldr1 :: (a -> a -> a) -> Max a -> a # foldl1 :: (a -> a -> a) -> Max a -> a # toList :: Max a -> [a] elem :: Eq a => a -> Max a -> Bool # maximum :: Ord a => Max a -> a # | |
Foldable Min | |
Defined in Data.Semigroup Methods fold :: Monoid m => Min m -> m foldMap :: Monoid m => (a -> m) -> Min a -> m # foldMap' :: Monoid m => (a -> m) -> Min a -> m foldr :: (a -> b -> b) -> b -> Min a -> b # foldr' :: (a -> b -> b) -> b -> Min a -> b foldl :: (b -> a -> b) -> b -> Min a -> b # foldl' :: (b -> a -> b) -> b -> Min a -> b foldr1 :: (a -> a -> a) -> Min a -> a # foldl1 :: (a -> a -> a) -> Min a -> a # toList :: Min a -> [a] elem :: Eq a => a -> Min a -> Bool # maximum :: Ord a => Min a -> a # | |
Foldable NonEmpty | |
Defined in Data.Foldable Methods fold :: Monoid m => NonEmpty m -> m foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m # foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m foldr :: (a -> b -> b) -> b -> NonEmpty a -> b # foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b foldl :: (b -> a -> b) -> b -> NonEmpty a -> b # foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b foldr1 :: (a -> a -> a) -> NonEmpty a -> a # foldl1 :: (a -> a -> a) -> NonEmpty a -> a # toList :: NonEmpty a -> [a] elem :: Eq a => a -> NonEmpty a -> Bool # maximum :: Ord a => NonEmpty a -> a # minimum :: Ord a => NonEmpty a -> a # | |
Foldable Option | |
Defined in Data.Semigroup Methods fold :: Monoid m => Option m -> m foldMap :: Monoid m => (a -> m) -> Option a -> m # foldMap' :: Monoid m => (a -> m) -> Option a -> m foldr :: (a -> b -> b) -> b -> Option a -> b # foldr' :: (a -> b -> b) -> b -> Option a -> b foldl :: (b -> a -> b) -> b -> Option a -> b # foldl' :: (b -> a -> b) -> b -> Option a -> b foldr1 :: (a -> a -> a) -> Option a -> a # foldl1 :: (a -> a -> a) -> Option a -> a # toList :: Option a -> [a] elem :: Eq a => a -> Option a -> Bool # maximum :: Ord a => Option a -> a # | |
Foldable Product | |
Defined in Data.Foldable Methods fold :: Monoid m => Product m -> m foldMap :: Monoid m => (a -> m) -> Product a -> m # foldMap' :: Monoid m => (a -> m) -> Product a -> m foldr :: (a -> b -> b) -> b -> Product a -> b # foldr' :: (a -> b -> b) -> b -> Product a -> b foldl :: (b -> a -> b) -> b -> Product a -> b # foldl' :: (b -> a -> b) -> b -> Product a -> b foldr1 :: (a -> a -> a) -> Product a -> a # foldl1 :: (a -> a -> a) -> Product a -> a # toList :: Product a -> [a] elem :: Eq a => a -> Product a -> Bool # maximum :: Ord a => Product a -> a # minimum :: Ord a => Product a -> a # | |
Foldable Sum | |
Defined in Data.Foldable Methods fold :: Monoid m => Sum m -> m foldMap :: Monoid m => (a -> m) -> Sum a -> m # foldMap' :: Monoid m => (a -> m) -> Sum a -> m foldr :: (a -> b -> b) -> b -> Sum a -> b # foldr' :: (a -> b -> b) -> b -> Sum a -> b foldl :: (b -> a -> b) -> b -> Sum a -> b # foldl' :: (b -> a -> b) -> b -> Sum a -> b foldr1 :: (a -> a -> a) -> Sum a -> a # foldl1 :: (a -> a -> a) -> Sum a -> a # toList :: Sum a -> [a] elem :: Eq a => a -> Sum a -> Bool # maximum :: Ord a => Sum a -> a # | |
Foldable ZipList | |
Defined in Control.Applicative Methods fold :: Monoid m => ZipList m -> m foldMap :: Monoid m => (a -> m) -> ZipList a -> m # foldMap' :: Monoid m => (a -> m) -> ZipList a -> m foldr :: (a -> b -> b) -> b -> ZipList a -> b # foldr' :: (a -> b -> b) -> b -> ZipList a -> b foldl :: (b -> a -> b) -> b -> ZipList a -> b # foldl' :: (b -> a -> b) -> b -> ZipList a -> b foldr1 :: (a -> a -> a) -> ZipList a -> a # foldl1 :: (a -> a -> a) -> ZipList a -> a # toList :: ZipList a -> [a] elem :: Eq a => a -> ZipList a -> Bool # maximum :: Ord a => ZipList a -> a # minimum :: Ord a => ZipList a -> a # | |
Foldable Complex | |
Defined in Data.Complex Methods fold :: Monoid m => Complex m -> m foldMap :: Monoid m => (a -> m) -> Complex a -> m # foldMap' :: Monoid m => (a -> m) -> Complex a -> m foldr :: (a -> b -> b) -> b -> Complex a -> b # foldr' :: (a -> b -> b) -> b -> Complex a -> b foldl :: (b -> a -> b) -> b -> Complex a -> b # foldl' :: (b -> a -> b) -> b -> Complex a -> b foldr1 :: (a -> a -> a) -> Complex a -> a # foldl1 :: (a -> a -> a) -> Complex a -> a # toList :: Complex a -> [a] elem :: Eq a => a -> Complex a -> Bool # maximum :: Ord a => Complex a -> a # minimum :: Ord a => Complex a -> a # | |
Foldable Array | |
Defined in Data.Primitive.Array Methods fold :: Monoid m => Array m -> m foldMap :: Monoid m => (a -> m) -> Array a -> m # foldMap' :: Monoid m => (a -> m) -> Array a -> m foldr :: (a -> b -> b) -> b -> Array a -> b # foldr' :: (a -> b -> b) -> b -> Array a -> b foldl :: (b -> a -> b) -> b -> Array a -> b # foldl' :: (b -> a -> b) -> b -> Array a -> b foldr1 :: (a -> a -> a) -> Array a -> a # foldl1 :: (a -> a -> a) -> Array a -> a # toList :: Array a -> [a] elem :: Eq a => a -> Array a -> Bool # maximum :: Ord a => Array a -> a # | |
Foldable SmallArray | |
Defined in Data.Primitive.SmallArray Methods fold :: Monoid m => SmallArray m -> m foldMap :: Monoid m => (a -> m) -> SmallArray a -> m # foldMap' :: Monoid m => (a -> m) -> SmallArray a -> m foldr :: (a -> b -> b) -> b -> SmallArray a -> b # foldr' :: (a -> b -> b) -> b -> SmallArray a -> b foldl :: (b -> a -> b) -> b -> SmallArray a -> b # foldl' :: (b -> a -> b) -> b -> SmallArray a -> b foldr1 :: (a -> a -> a) -> SmallArray a -> a # foldl1 :: (a -> a -> a) -> SmallArray a -> a # toList :: SmallArray a -> [a] null :: SmallArray a -> Bool # length :: SmallArray a -> Int # elem :: Eq a => a -> SmallArray a -> Bool # maximum :: Ord a => SmallArray a -> a # minimum :: Ord a => SmallArray a -> a # | |
Foldable (Either a) | |
Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> m foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # | |
Foldable (V1 :: Type -> Type) | |
Defined in Data.Foldable Methods foldMap :: Monoid m => (a -> m) -> V1 a -> m # foldMap' :: Monoid m => (a -> m) -> V1 a -> m foldr :: (a -> b -> b) -> b -> V1 a -> b # foldr' :: (a -> b -> b) -> b -> V1 a -> b foldl :: (b -> a -> b) -> b -> V1 a -> b # foldl' :: (b -> a -> b) -> b -> V1 a -> b foldr1 :: (a -> a -> a) -> V1 a -> a # foldl1 :: (a -> a -> a) -> V1 a -> a # toList :: V1 a -> [a] elem :: Eq a => a -> V1 a -> Bool # maximum :: Ord a => V1 a -> a # | |
Foldable (U1 :: Type -> Type) | |
Defined in Data.Foldable Methods foldMap :: Monoid m => (a -> m) -> U1 a -> m # foldMap' :: Monoid m => (a -> m) -> U1 a -> m foldr :: (a -> b -> b) -> b -> U1 a -> b # foldr' :: (a -> b -> b) -> b -> U1 a -> b foldl :: (b -> a -> b) -> b -> U1 a -> b # foldl' :: (b -> a -> b) -> b -> U1 a -> b foldr1 :: (a -> a -> a) -> U1 a -> a # foldl1 :: (a -> a -> a) -> U1 a -> a # toList :: U1 a -> [a] elem :: Eq a => a -> U1 a -> Bool # maximum :: Ord a => U1 a -> a # | |
Foldable ((,) a) | |
Defined in Data.Foldable Methods fold :: Monoid m => (a, m) -> m foldMap :: Monoid m => (a0 -> m) -> (a, a0) -> m # foldMap' :: Monoid m => (a0 -> m) -> (a, a0) -> m foldr :: (a0 -> b -> b) -> b -> (a, a0) -> b # foldr' :: (a0 -> b -> b) -> b -> (a, a0) -> b foldl :: (b -> a0 -> b) -> b -> (a, a0) -> b # foldl' :: (b -> a0 -> b) -> b -> (a, a0) -> b foldr1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # foldl1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # toList :: (a, a0) -> [a0] elem :: Eq a0 => a0 -> (a, a0) -> Bool # maximum :: Ord a0 => (a, a0) -> a0 # minimum :: Ord a0 => (a, a0) -> a0 # | |
Foldable (Arg a) | |
Defined in Data.Semigroup Methods fold :: Monoid m => Arg a m -> m foldMap :: Monoid m => (a0 -> m) -> Arg a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Arg a a0 -> m foldr :: (a0 -> b -> b) -> b -> Arg a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Arg a a0 -> b foldl :: (b -> a0 -> b) -> b -> Arg a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Arg a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # toList :: Arg a a0 -> [a0] elem :: Eq a0 => a0 -> Arg a a0 -> Bool # maximum :: Ord a0 => Arg a a0 -> a0 # minimum :: Ord a0 => Arg a a0 -> a0 # | |
Foldable (Array i) | |
Defined in Data.Foldable Methods fold :: Monoid m => Array i m -> m foldMap :: Monoid m => (a -> m) -> Array i a -> m # foldMap' :: Monoid m => (a -> m) -> Array i a -> m foldr :: (a -> b -> b) -> b -> Array i a -> b # foldr' :: (a -> b -> b) -> b -> Array i a -> b foldl :: (b -> a -> b) -> b -> Array i a -> b # foldl' :: (b -> a -> b) -> b -> Array i a -> b foldr1 :: (a -> a -> a) -> Array i a -> a # foldl1 :: (a -> a -> a) -> Array i a -> a # toList :: Array i a -> [a] elem :: Eq a => a -> Array i a -> Bool # maximum :: Ord a => Array i a -> a # minimum :: Ord a => Array i a -> a # | |
Foldable (Proxy :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => Proxy m -> m foldMap :: Monoid m => (a -> m) -> Proxy a -> m # foldMap' :: Monoid m => (a -> m) -> Proxy a -> m foldr :: (a -> b -> b) -> b -> Proxy a -> b # foldr' :: (a -> b -> b) -> b -> Proxy a -> b foldl :: (b -> a -> b) -> b -> Proxy a -> b # foldl' :: (b -> a -> b) -> b -> Proxy a -> b foldr1 :: (a -> a -> a) -> Proxy a -> a # foldl1 :: (a -> a -> a) -> Proxy a -> a # toList :: Proxy a -> [a] elem :: Eq a => a -> Proxy a -> Bool # maximum :: Ord a => Proxy a -> a # | |
Foldable f => Foldable (ListT f) | |
Defined in Control.Monad.Trans.List Methods fold :: Monoid m => ListT f m -> m foldMap :: Monoid m => (a -> m) -> ListT f a -> m # foldMap' :: Monoid m => (a -> m) -> ListT f a -> m foldr :: (a -> b -> b) -> b -> ListT f a -> b # foldr' :: (a -> b -> b) -> b -> ListT f a -> b foldl :: (b -> a -> b) -> b -> ListT f a -> b # foldl' :: (b -> a -> b) -> b -> ListT f a -> b foldr1 :: (a -> a -> a) -> ListT f a -> a # foldl1 :: (a -> a -> a) -> ListT f a -> a # toList :: ListT f a -> [a] elem :: Eq a => a -> ListT f a -> Bool # maximum :: Ord a => ListT f a -> a # minimum :: Ord a => ListT f a -> a # | |
Foldable f => Foldable (MaybeT f) | |
Defined in Control.Monad.Trans.Maybe Methods fold :: Monoid m => MaybeT f m -> m foldMap :: Monoid m => (a -> m) -> MaybeT f a -> m # foldMap' :: Monoid m => (a -> m) -> MaybeT f a -> m foldr :: (a -> b -> b) -> b -> MaybeT f a -> b # foldr' :: (a -> b -> b) -> b -> MaybeT f a -> b foldl :: (b -> a -> b) -> b -> MaybeT f a -> b # foldl' :: (b -> a -> b) -> b -> MaybeT f a -> b foldr1 :: (a -> a -> a) -> MaybeT f a -> a # foldl1 :: (a -> a -> a) -> MaybeT f a -> a # toList :: MaybeT f a -> [a] elem :: Eq a => a -> MaybeT f a -> Bool # maximum :: Ord a => MaybeT f a -> a # minimum :: Ord a => MaybeT f a -> a # | |
Foldable f => Foldable (Rec1 f) | |
Defined in Data.Foldable Methods fold :: Monoid m => Rec1 f m -> m foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m # foldMap' :: Monoid m => (a -> m) -> Rec1 f a -> m foldr :: (a -> b -> b) -> b -> Rec1 f a -> b # foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b foldl :: (b -> a -> b) -> b -> Rec1 f a -> b # foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b foldr1 :: (a -> a -> a) -> Rec1 f a -> a # foldl1 :: (a -> a -> a) -> Rec1 f a -> a # toList :: Rec1 f a -> [a] elem :: Eq a => a -> Rec1 f a -> Bool # maximum :: Ord a => Rec1 f a -> a # | |
Foldable (URec Char :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Char m -> m foldMap :: Monoid m => (a -> m) -> URec Char a -> 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 # 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 # | |
Foldable (URec Double :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Double m -> m foldMap :: Monoid m => (a -> m) -> URec Double a -> 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 # | |
Foldable (URec Float :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Float m -> m foldMap :: Monoid m => (a -> m) -> URec Float a -> 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 # 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 # | |
Foldable (URec Int :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Int m -> m foldMap :: Monoid m => (a -> m) -> URec Int a -> 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 # elem :: Eq a => a -> URec Int a -> Bool # maximum :: Ord a => URec Int a -> a # minimum :: Ord a => URec Int a -> a # | |
Foldable (URec Word :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Word m -> m foldMap :: Monoid m => (a -> m) -> URec Word a -> 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 # 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 # | |
Foldable (URec (Ptr ()) :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec (Ptr ()) m -> m foldMap :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m # foldMap' :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m foldr :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b # foldr' :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b foldl :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b # foldl' :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b foldr1 :: (a -> a -> a) -> URec (Ptr ()) a -> a # foldl1 :: (a -> a -> a) -> URec (Ptr ()) a -> a # toList :: URec (Ptr ()) a -> [a] null :: URec (Ptr ()) a -> Bool # length :: URec (Ptr ()) a -> Int # elem :: Eq a => a -> URec (Ptr ()) a -> Bool # maximum :: Ord a => URec (Ptr ()) a -> a # minimum :: Ord a => URec (Ptr ()) a -> a # | |
Foldable (Const m :: Type -> Type) | |
Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 foldr :: (a -> b -> b) -> b -> Const m a -> b # foldr' :: (a -> b -> b) -> b -> Const m a -> b foldl :: (b -> a -> b) -> b -> Const m a -> b # foldl' :: (b -> a -> b) -> b -> Const m a -> b foldr1 :: (a -> a -> a) -> Const m a -> a # foldl1 :: (a -> a -> a) -> Const m a -> a # toList :: Const m a -> [a] elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # | |
Foldable f => Foldable (Alt f) | |
Defined in Data.Foldable Methods fold :: Monoid m => Alt f m -> m foldMap :: Monoid m => (a -> m) -> Alt f a -> m # foldMap' :: Monoid m => (a -> m) -> Alt f a -> m foldr :: (a -> b -> b) -> b -> Alt f a -> b # foldr' :: (a -> b -> b) -> b -> Alt f a -> b foldl :: (b -> a -> b) -> b -> Alt f a -> b # foldl' :: (b -> a -> b) -> b -> Alt f a -> b foldr1 :: (a -> a -> a) -> Alt f a -> a # foldl1 :: (a -> a -> a) -> Alt f a -> a # toList :: Alt f a -> [a] elem :: Eq a => a -> Alt f a -> Bool # maximum :: Ord a => Alt f a -> a # | |
Foldable f => Foldable (Ap f) | |
Defined in Data.Foldable Methods fold :: Monoid m => Ap f m -> m foldMap :: Monoid m => (a -> m) -> Ap f a -> m # foldMap' :: Monoid m => (a -> m) -> Ap f a -> m foldr :: (a -> b -> b) -> b -> Ap f a -> b # foldr' :: (a -> b -> b) -> b -> Ap f a -> b foldl :: (b -> a -> b) -> b -> Ap f a -> b # foldl' :: (b -> a -> b) -> b -> Ap f a -> b foldr1 :: (a -> a -> a) -> Ap f a -> a # foldl1 :: (a -> a -> a) -> Ap f a -> a # toList :: Ap f a -> [a] elem :: Eq a => a -> Ap f a -> Bool # maximum :: Ord a => Ap f a -> a # | |
Foldable f => Foldable (ErrorT e f) | |
Defined in Control.Monad.Trans.Error Methods fold :: Monoid m => ErrorT e f m -> m foldMap :: Monoid m => (a -> m) -> ErrorT e f a -> m # foldMap' :: Monoid m => (a -> m) -> ErrorT e f a -> m foldr :: (a -> b -> b) -> b -> ErrorT e f a -> b # foldr' :: (a -> b -> b) -> b -> ErrorT e f a -> b foldl :: (b -> a -> b) -> b -> ErrorT e f a -> b # foldl' :: (b -> a -> b) -> b -> ErrorT e f a -> b foldr1 :: (a -> a -> a) -> ErrorT e f a -> a # foldl1 :: (a -> a -> a) -> ErrorT e f a -> a # toList :: ErrorT e f a -> [a] null :: ErrorT e f a -> Bool # length :: ErrorT e f a -> Int # elem :: Eq a => a -> ErrorT e f a -> Bool # maximum :: Ord a => ErrorT e f a -> a # minimum :: Ord a => ErrorT e f a -> a # | |
Foldable f => Foldable (IdentityT f) | |
Defined in Control.Monad.Trans.Identity Methods fold :: Monoid m => IdentityT f m -> m foldMap :: Monoid m => (a -> m) -> IdentityT f a -> m # foldMap' :: Monoid m => (a -> m) -> IdentityT f a -> m foldr :: (a -> b -> b) -> b -> IdentityT f a -> b # foldr' :: (a -> b -> b) -> b -> IdentityT f a -> b foldl :: (b -> a -> b) -> b -> IdentityT f a -> b # foldl' :: (b -> a -> b) -> b -> IdentityT f a -> b foldr1 :: (a -> a -> a) -> IdentityT f a -> a # foldl1 :: (a -> a -> a) -> IdentityT f a -> a # toList :: IdentityT f a -> [a] null :: IdentityT f a -> Bool # length :: IdentityT f a -> Int # elem :: Eq a => a -> IdentityT f a -> Bool # maximum :: Ord a => IdentityT f a -> a # minimum :: Ord a => IdentityT f a -> a # | |
Foldable f => Foldable (ExceptT e f) | |
Defined in Control.Monad.Trans.Except Methods fold :: Monoid m => ExceptT e f m -> m foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldMap' :: Monoid m => (a -> m) -> ExceptT e f a -> m foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b foldr1 :: (a -> a -> a) -> ExceptT e f a -> a # foldl1 :: (a -> a -> a) -> ExceptT e f a -> a # toList :: ExceptT e f a -> [a] null :: ExceptT e f a -> Bool # length :: ExceptT e f a -> Int # elem :: Eq a => a -> ExceptT e f a -> Bool # maximum :: Ord a => ExceptT e f a -> a # minimum :: Ord a => ExceptT e f a -> a # | |
Foldable f => Foldable (WriterT w f) | |
Defined in Control.Monad.Trans.Writer.Strict Methods fold :: Monoid m => WriterT w f m -> m foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m # foldMap' :: Monoid m => (a -> m) -> WriterT w f a -> m foldr :: (a -> b -> b) -> b -> WriterT w f a -> b # foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b foldl :: (b -> a -> b) -> b -> WriterT w f a -> b # foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b foldr1 :: (a -> a -> a) -> WriterT w f a -> a # foldl1 :: (a -> a -> a) -> WriterT w f a -> a # toList :: WriterT w f a -> [a] null :: WriterT w f a -> Bool # length :: WriterT w f a -> Int # elem :: Eq a => a -> WriterT w f a -> Bool # maximum :: Ord a => WriterT w f a -> a # minimum :: Ord a => WriterT w f a -> a # | |
Foldable f => Foldable (WriterT w f) | |
Defined in Control.Monad.Trans.Writer.Lazy Methods fold :: Monoid m => WriterT w f m -> m foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m # foldMap' :: Monoid m => (a -> m) -> WriterT w f a -> m foldr :: (a -> b -> b) -> b -> WriterT w f a -> b # foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b foldl :: (b -> a -> b) -> b -> WriterT w f a -> b # foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b foldr1 :: (a -> a -> a) -> WriterT w f a -> a # foldl1 :: (a -> a -> a) -> WriterT w f a -> a # toList :: WriterT w f a -> [a] null :: WriterT w f a -> Bool # length :: WriterT w f a -> Int # elem :: Eq a => a -> WriterT w f a -> Bool # maximum :: Ord a => WriterT w f a -> a # minimum :: Ord a => WriterT w f a -> a # | |
Foldable (K1 i c :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => K1 i c m -> m foldMap :: Monoid m => (a -> m) -> K1 i c a -> m # foldMap' :: Monoid m => (a -> m) -> K1 i c a -> m foldr :: (a -> b -> b) -> b -> K1 i c a -> b # foldr' :: (a -> b -> b) -> b -> K1 i c a -> b foldl :: (b -> a -> b) -> b -> K1 i c a -> b # foldl' :: (b -> a -> b) -> b -> K1 i c a -> b foldr1 :: (a -> a -> a) -> K1 i c a -> a # foldl1 :: (a -> a -> a) -> K1 i c a -> a # toList :: K1 i c a -> [a] elem :: Eq a => a -> K1 i c a -> Bool # maximum :: Ord a => K1 i c a -> a # | |
(Foldable f, Foldable g) => Foldable (f :+: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :+: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :+: g) a -> m foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b foldr1 :: (a -> a -> a) -> (f :+: g) a -> a # foldl1 :: (a -> a -> a) -> (f :+: g) a -> a # toList :: (f :+: g) a -> [a] length :: (f :+: g) a -> Int # elem :: Eq a => a -> (f :+: g) a -> Bool # maximum :: Ord a => (f :+: g) a -> a # minimum :: Ord a => (f :+: g) a -> a # | |
(Foldable f, Foldable g) => Foldable (f :*: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :*: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :*: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :*: g) a -> m foldr :: (a -> b -> b) -> b -> (f :*: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :*: g) a -> b foldl :: (b -> a -> b) -> b -> (f :*: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :*: g) a -> b foldr1 :: (a -> a -> a) -> (f :*: g) a -> a # foldl1 :: (a -> a -> a) -> (f :*: g) a -> a # toList :: (f :*: g) a -> [a] length :: (f :*: g) a -> Int # elem :: Eq a => a -> (f :*: g) a -> Bool # maximum :: Ord a => (f :*: g) a -> a # minimum :: Ord a => (f :*: g) a -> a # | |
(Foldable f, Foldable g) => Foldable (Product f g) | |
Defined in Data.Functor.Product Methods fold :: Monoid m => Product f g m -> m foldMap :: Monoid m => (a -> m) -> Product f g a -> m # foldMap' :: Monoid m => (a -> m) -> Product f g a -> m foldr :: (a -> b -> b) -> b -> Product f g a -> b # foldr' :: (a -> b -> b) -> b -> Product f g a -> b foldl :: (b -> a -> b) -> b -> Product f g a -> b # foldl' :: (b -> a -> b) -> b -> Product f g a -> b foldr1 :: (a -> a -> a) -> Product f g a -> a # foldl1 :: (a -> a -> a) -> Product f g a -> a # toList :: Product f g a -> [a] null :: Product f g a -> Bool # length :: Product f g a -> Int # elem :: Eq a => a -> Product f g a -> Bool # maximum :: Ord a => Product f g a -> a # minimum :: Ord a => Product f g a -> a # | |
(Foldable f, Foldable g) => Foldable (Sum f g) | |
Defined in Data.Functor.Sum Methods fold :: Monoid m => Sum f g m -> m foldMap :: Monoid m => (a -> m) -> Sum f g a -> m # foldMap' :: Monoid m => (a -> m) -> Sum f g a -> m foldr :: (a -> b -> b) -> b -> Sum f g a -> b # foldr' :: (a -> b -> b) -> b -> Sum f g a -> b foldl :: (b -> a -> b) -> b -> Sum f g a -> b # foldl' :: (b -> a -> b) -> b -> Sum f g a -> b foldr1 :: (a -> a -> a) -> Sum f g a -> a # foldl1 :: (a -> a -> a) -> Sum f g a -> a # toList :: Sum f g a -> [a] elem :: Eq a => a -> Sum f g a -> Bool # maximum :: Ord a => Sum f g a -> a # minimum :: Ord a => Sum f g a -> a # | |
Foldable f => Foldable (M1 i c f) | |
Defined in Data.Foldable Methods fold :: Monoid m => M1 i c f m -> m foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m # foldMap' :: Monoid m => (a -> m) -> M1 i c f a -> m foldr :: (a -> b -> b) -> b -> M1 i c f a -> b # foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b foldl :: (b -> a -> b) -> b -> M1 i c f a -> b # foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b foldr1 :: (a -> a -> a) -> M1 i c f a -> a # foldl1 :: (a -> a -> a) -> M1 i c f a -> a # toList :: M1 i c f a -> [a] elem :: Eq a => a -> M1 i c f a -> Bool # maximum :: Ord a => M1 i c f a -> a # minimum :: Ord a => M1 i c f a -> a # | |
(Foldable f, Foldable g) => Foldable (f :.: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :.: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :.: g) a -> m foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b foldr1 :: (a -> a -> a) -> (f :.: g) a -> a # foldl1 :: (a -> a -> a) -> (f :.: g) a -> a # toList :: (f :.: g) a -> [a] length :: (f :.: g) a -> Int # elem :: Eq a => a -> (f :.: g) a -> Bool # maximum :: Ord a => (f :.: g) a -> a # minimum :: Ord a => (f :.: g) a -> a # | |
(Foldable f, Foldable g) => Foldable (Compose f g) | |
Defined in Data.Functor.Compose Methods fold :: Monoid m => Compose f g m -> m foldMap :: Monoid m => (a -> m) -> Compose f g a -> m # foldMap' :: Monoid m => (a -> m) -> Compose f g a -> m foldr :: (a -> b -> b) -> b -> Compose f g a -> b # foldr' :: (a -> b -> b) -> b -> Compose f g a -> b foldl :: (b -> a -> b) -> b -> Compose f g a -> b # foldl' :: (b -> a -> b) -> b -> Compose f g a -> b foldr1 :: (a -> a -> a) -> Compose f g a -> a # foldl1 :: (a -> a -> a) -> Compose f g a -> a # toList :: Compose f g a -> [a] null :: Compose f g a -> Bool # length :: Compose f g a -> Int # elem :: Eq a => a -> Compose f g a -> Bool # maximum :: Ord a => Compose f g a -> a # minimum :: Ord a => Compose f g a -> a # |
class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where #
Methods
traverse :: Applicative f => (a -> f b) -> t a -> f (t b) #
sequenceA :: Applicative f => t (f a) -> f (t a) #
Instances
Instances
class Semigroup a => Monoid a where #
Minimal complete definition
Instances
Monoid Ordering | |
Monoid () | |
Monoid ExactPi | The multiplicative monoid over |
Monoid All | |
Monoid Any | |
Monoid Dimension' Source # | The monoid of dimensions under multiplication. |
Defined in Numeric.Units.Dimensional.Dimensions.TermLevel Methods mempty :: Dimension' # mappend :: Dimension' -> Dimension' -> Dimension' # mconcat :: [Dimension'] -> Dimension' # | |
Monoid ByteArray | |
Monoid AnyUnit Source # | |
Monoid [a] | |
Semigroup a => Monoid (Maybe a) | |
Monoid a => Monoid (IO a) | |
Monoid p => Monoid (Par1 p) | |
Prim a => Monoid (Vector a) | |
Monoid a => Monoid (Down a) | |
Monoid a => Monoid (Dual a) | |
Monoid (First a) | |
Monoid a => Monoid (Identity a) | |
Monoid (Last a) | |
(Ord a, Bounded a) => Monoid (Max a) | |
(Ord a, Bounded a) => Monoid (Min a) | |
Semigroup a => Monoid (Option a) | |
Num a => Monoid (Product a) | |
Num a => Monoid (Sum a) | |
Monoid m => Monoid (WrappedMonoid m) | |
Monoid (Endo a) | |
Monoid (Array a) | |
Monoid (PrimArray a) | |
Monoid (SmallArray a) | |
Num a => Monoid (DynQuantity a) Source # |
|
Defined in Numeric.Units.Dimensional.Dynamic Methods mempty :: DynQuantity a # mappend :: DynQuantity a -> DynQuantity a -> DynQuantity a # mconcat :: [DynQuantity a] -> DynQuantity a # | |
Num a => Monoid (AnyQuantity a) Source # |
|
Defined in Numeric.Units.Dimensional.Dynamic Methods mempty :: AnyQuantity a # mappend :: AnyQuantity a -> AnyQuantity a -> AnyQuantity a # mconcat :: [AnyQuantity a] -> AnyQuantity a # | |
Monoid b => Monoid (a -> b) | |
Monoid (U1 p) | |
(Monoid a, Monoid b) => Monoid (a, b) | |
Monoid (Proxy s) | |
Monoid a => Monoid (ST s a) | |
Monoid (f p) => Monoid (Rec1 f p) | |
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) | |
Monoid a => Monoid (Const a b) | |
Alternative f => Monoid (Alt f a) | |
(Applicative f, Monoid a) => Monoid (Ap f a) | |
Num a => Monoid (SQuantity s d a) Source # |
|
Monoid c => Monoid (K1 i c p) | |
(Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) | |
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) | |
Monoid (f p) => Monoid (M1 i c f p) | |
Monoid (f (g p)) => Monoid ((f :.: g) p) | |
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) | |
Instances
Bounded Bool | |
Enum Bool | |
Eq Bool | |
Data Bool | |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool dataTypeOf :: Bool -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bool) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bool) gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool | |
Ord Bool | |
Read Bool | |
Show Bool | |
Ix Bool | |
Generic Bool | |
AEq Bool | |
Unbox Bool | |
Defined in Data.Vector.Unboxed.Base | |
Storable Bool | |
Defined in Foreign.Storable | |
NFData Bool | |
Defined in Control.DeepSeq | |
SingKind Bool | |
Defined in GHC.Generics Associated Types type DemoteRep Bool | |
Bits Bool | |
Defined in Data.Bits | |
FiniteBits Bool | |
Defined in Data.Bits Methods finiteBitSize :: Bool -> Int countLeadingZeros :: Bool -> Int countTrailingZeros :: Bool -> Int | |
Vector Vector Bool | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Bool -> m (Vector Bool) Source # basicUnsafeThaw :: PrimMonad m => Vector Bool -> m (Mutable Vector (PrimState m) Bool) Source # basicLength :: Vector Bool -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool Source # basicUnsafeIndexM :: Monad m => Vector Bool -> Int -> m Bool Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Bool -> Vector Bool -> m () Source # | |
MVector MVector Bool | |
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Bool -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool Source # basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Bool) Source # basicInitialize :: PrimMonad m => MVector (PrimState m) Bool -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Bool -> m (MVector (PrimState m) Bool) Source # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m Bool Source # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Bool -> Int -> Bool -> m () Source # basicClear :: PrimMonad m => MVector (PrimState m) Bool -> m () Source # basicSet :: PrimMonad m => MVector (PrimState m) Bool -> Bool -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () Source # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m (MVector (PrimState m) Bool) Source # | |
SingI 'False | |
Defined in GHC.Generics | |
SingI 'True | |
Defined in GHC.Generics | |
type Rep Bool | |
Defined in GHC.Generics | |
newtype Vector Bool | |
Defined in Data.Vector.Unboxed.Base | |
type DemoteRep Bool | |
Defined in GHC.Generics | |
data Sing (a :: Bool) | |
newtype MVector s Bool | |
Defined in Data.Vector.Unboxed.Base |
Instances
Bounded Char | |
Enum Char | |
Eq Char | |
Data Char | |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char dataTypeOf :: Char -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) gmapT :: (forall b. Data b => b -> b) -> Char -> Char gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char | |
Ord Char | |
Read Char | |
Show Char | |
Ix Char | |
AEq Char | |
Unbox Char | |
Defined in Data.Vector.Unboxed.Base | |
Prim Char | |
Defined in Data.Primitive.Types Methods alignment# :: Char -> Int# indexByteArray# :: ByteArray# -> Int# -> Char readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Char #) writeByteArray# :: MutableByteArray# s -> Int# -> Char -> State# s -> State# s setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Char -> State# s -> State# s indexOffAddr# :: Addr# -> Int# -> Char readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Char #) writeOffAddr# :: Addr# -> Int# -> Char -> State# s -> State# s setOffAddr# :: Addr# -> Int# -> Int# -> Char -> State# s -> State# s | |
Storable Char | |
Defined in Foreign.Storable | |
NFData Char | |
Defined in Control.DeepSeq | |
ErrorList Char | |
Defined in Control.Monad.Trans.Error | |
Vector Vector Char | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Char -> m (Vector Char) Source # basicUnsafeThaw :: PrimMonad m => Vector Char -> m (Mutable Vector (PrimState m) Char) Source # basicLength :: Vector Char -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char Source # basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Char -> Vector Char -> m () Source # | |
MVector MVector Char | |
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Char -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char Source # basicOverlaps :: MVector s Char -> MVector s Char -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Char) Source # basicInitialize :: PrimMonad m => MVector (PrimState m) Char -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Char -> m (MVector (PrimState m) Char) Source # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Char -> Int -> m Char Source # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Char -> Int -> Char -> m () Source # basicClear :: PrimMonad m => MVector (PrimState m) Char -> m () Source # basicSet :: PrimMonad m => MVector (PrimState m) Char -> Char -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () Source # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Char -> Int -> m (MVector (PrimState m) Char) Source # | |
Generic1 (URec Char :: k -> Type) | |
Functor (URec Char :: Type -> Type) | |
Foldable (URec Char :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Char m -> m foldMap :: Monoid m => (a -> m) -> URec Char a -> 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 # 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 # | |
Traversable (URec Char :: Type -> Type) | |
Defined in Data.Traversable | |
Eq (URec Char p) | |
Ord (URec Char p) | |
Defined in GHC.Generics | |
Show (URec Char p) | |
Generic (URec Char p) | |
newtype Vector Char | |
data URec Char (p :: k) | |
Defined in GHC.Generics | |
newtype MVector s Char | |
type Rep1 (URec Char :: k -> Type) | |
Defined in GHC.Generics | |
type Rep (URec Char p) | |
Defined in GHC.Generics |
Instances
Eq Double | |
Floating Double | |
Data Double | |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double dataTypeOf :: Double -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Double) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) gmapT :: (forall b. Data b => b -> b) -> Double -> Double gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double | |
Ord Double | |
Read Double | |
RealFloat Double | |
Defined in GHC.Float Methods floatRadix :: Double -> Integer # floatDigits :: Double -> Int # floatRange :: Double -> (Int, Int) # decodeFloat :: Double -> (Integer, Int) # encodeFloat :: Integer -> Int -> Double # significand :: Double -> Double # scaleFloat :: Int -> Double -> Double # isInfinite :: Double -> Bool # isDenormalized :: Double -> Bool # isNegativeZero :: Double -> Bool # | |
AEq Double | |
IEEE Double | |
Defined in Numeric.IEEE Methods minDenormal :: Double Source # copySign :: Double -> Double -> Double Source # identicalIEEE :: Double -> Double -> Bool Source # succIEEE :: Double -> Double Source # predIEEE :: Double -> Double Source # bisectIEEE :: Double -> Double -> Double Source # sameSignificandBits :: Double -> Double -> Int Source # nanWithPayload :: Word64 -> Double Source # maxNaNPayload :: Double -> Word64 Source # nanPayload :: Double -> Word64 Source # | |
Unbox Double | |
Defined in Data.Vector.Unboxed.Base | |
Prim Double | |
Defined in Data.Primitive.Types Methods alignment# :: Double -> Int# indexByteArray# :: ByteArray# -> Int# -> Double readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Double #) writeByteArray# :: MutableByteArray# s -> Int# -> Double -> State# s -> State# s setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Double -> State# s -> State# s indexOffAddr# :: Addr# -> Int# -> Double readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Double #) writeOffAddr# :: Addr# -> Int# -> Double -> State# s -> State# s setOffAddr# :: Addr# -> Int# -> Int# -> Double -> State# s -> State# s | |
Storable Double | |
Defined in Foreign.Storable | |
NFData Double | |
Defined in Control.DeepSeq | |
Vector Vector Double | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Double -> m (Vector Double) Source # basicUnsafeThaw :: PrimMonad m => Vector Double -> m (Mutable Vector (PrimState m) Double) Source # basicLength :: Vector Double -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double Source # basicUnsafeIndexM :: Monad m => Vector Double -> Int -> m Double Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Double -> Vector Double -> m () Source # | |
MVector MVector Double | |
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Double -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Double -> MVector s Double Source # basicOverlaps :: MVector s Double -> MVector s Double -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Double) Source # basicInitialize :: PrimMonad m => MVector (PrimState m) Double -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Double -> m (MVector (PrimState m) Double) Source # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Double -> Int -> m Double Source # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Double -> Int -> Double -> m () Source # basicClear :: PrimMonad m => MVector (PrimState m) Double -> m () Source # basicSet :: PrimMonad m => MVector (PrimState m) Double -> Double -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m () Source # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Double -> Int -> m (MVector (PrimState m) Double) Source # | |
Generic1 (URec Double :: k -> Type) | |
AEq (Complex Double) | |
Functor (URec Double :: Type -> Type) | |
Foldable (URec Double :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Double m -> m foldMap :: Monoid m => (a -> m) -> URec Double a -> 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 # | |
Traversable (URec Double :: Type -> Type) | |
Defined in Data.Traversable | |
Eq (URec Double p) | |
Ord (URec Double p) | |
Defined in GHC.Generics Methods compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # | |
Show (URec Double p) | |
Generic (URec Double p) | |
newtype Vector Double | |
data URec Double (p :: k) | |
Defined in GHC.Generics | |
newtype MVector s Double | |
type Rep1 (URec Double :: k -> Type) | |
Defined in GHC.Generics | |
type Rep (URec Double p) | |
Defined in GHC.Generics |
Instances
Eq Float | |
Floating Float | |
Data Float | |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float dataTypeOf :: Float -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) gmapT :: (forall b. Data b => b -> b) -> Float -> Float gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float | |
Ord Float | |
Read Float | |
RealFloat Float | |
Defined in GHC.Float Methods floatRadix :: Float -> Integer # floatDigits :: Float -> Int # floatRange :: Float -> (Int, Int) # decodeFloat :: Float -> (Integer, Int) # encodeFloat :: Integer -> Int -> Float # significand :: Float -> Float # scaleFloat :: Int -> Float -> Float # isInfinite :: Float -> Bool # isDenormalized :: Float -> Bool # isNegativeZero :: Float -> Bool # | |
AEq Float | |
IEEE Float | |
Defined in Numeric.IEEE Methods minDenormal :: Float Source # copySign :: Float -> Float -> Float Source # identicalIEEE :: Float -> Float -> Bool Source # succIEEE :: Float -> Float Source # predIEEE :: Float -> Float Source # bisectIEEE :: Float -> Float -> Float Source # sameSignificandBits :: Float -> Float -> Int Source # nanWithPayload :: Word64 -> Float Source # maxNaNPayload :: Float -> Word64 Source # nanPayload :: Float -> Word64 Source # | |
Unbox Float | |
Defined in Data.Vector.Unboxed.Base | |
Prim Float | |
Defined in Data.Primitive.Types Methods alignment# :: Float -> Int# indexByteArray# :: ByteArray# -> Int# -> Float readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Float #) writeByteArray# :: MutableByteArray# s -> Int# -> Float -> State# s -> State# s setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Float -> State# s -> State# s indexOffAddr# :: Addr# -> Int# -> Float readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Float #) writeOffAddr# :: Addr# -> Int# -> Float -> State# s -> State# s setOffAddr# :: Addr# -> Int# -> Int# -> Float -> State# s -> State# s | |
Storable Float | |
Defined in Foreign.Storable | |
NFData Float | |
Defined in Control.DeepSeq | |
Vector Vector Float | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Float -> m (Vector Float) Source # basicUnsafeThaw :: PrimMonad m => Vector Float -> m (Mutable Vector (PrimState m) Float) Source # basicLength :: Vector Float -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float Source # basicUnsafeIndexM :: Monad m => Vector Float -> Int -> m Float Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Float -> Vector Float -> m () Source # | |
MVector MVector Float | |
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Float -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Float -> MVector s Float Source # basicOverlaps :: MVector s Float -> MVector s Float -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Float) Source # basicInitialize :: PrimMonad m => MVector (PrimState m) Float -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Float -> m (MVector (PrimState m) Float) Source # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Float -> Int -> m Float Source # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Float -> Int -> Float -> m () Source # basicClear :: PrimMonad m => MVector (PrimState m) Float -> m () Source # basicSet :: PrimMonad m => MVector (PrimState m) Float -> Float -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m () Source # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Float -> Int -> m (MVector (PrimState m) Float) Source # | |
Generic1 (URec Float :: k -> Type) | |
AEq (Complex Float) | |
Functor (URec Float :: Type -> Type) | |
Foldable (URec Float :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Float m -> m foldMap :: Monoid m => (a -> m) -> URec Float a -> 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 # 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 # | |
Traversable (URec Float :: Type -> Type) | |
Defined in Data.Traversable | |
Eq (URec Float p) | |
Ord (URec Float p) | |
Defined in GHC.Generics | |
Show (URec Float p) | |
Generic (URec Float p) | |
newtype Vector Float | |
data URec Float (p :: k) | |
Defined in GHC.Generics | |
newtype MVector s Float | |
type Rep1 (URec Float :: k -> Type) | |
Defined in GHC.Generics | |
type Rep (URec Float p) | |
Defined in GHC.Generics |
Instances
Bounded Int | |
Enum Int | |
Eq Int | |
Integral Int | |
Data Int | |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int dataTypeOf :: Int -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) gmapT :: (forall b. Data b => b -> b) -> Int -> Int gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int | |
Num Int | |
Ord Int | |
Read Int | |
Real Int | |
Defined in GHC.Real Methods toRational :: Int -> Rational # | |
Show Int | |
Ix Int | |
AEq Int | |
Unbox Int | |
Defined in Data.Vector.Unboxed.Base | |
Prim Int | |
Defined in Data.Primitive.Types Methods alignment# :: Int -> Int# indexByteArray# :: ByteArray# -> Int# -> Int readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int #) writeByteArray# :: MutableByteArray# s -> Int# -> Int -> State# s -> State# s setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int -> State# s -> State# s indexOffAddr# :: Addr# -> Int# -> Int readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int #) writeOffAddr# :: Addr# -> Int# -> Int -> State# s -> State# s setOffAddr# :: Addr# -> Int# -> Int# -> Int -> State# s -> State# s | |
Storable Int | |
NFData Int | |
Defined in Control.DeepSeq | |
Bits Int | |
Defined in Data.Bits Methods complement :: Int -> Int complementBit :: Int -> Int -> Int bitSizeMaybe :: Int -> Maybe Int unsafeShiftL :: Int -> Int -> Int unsafeShiftR :: Int -> Int -> Int | |
FiniteBits Int | |
Defined in Data.Bits | |
Vector Vector Int | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int -> m (Vector Int) Source # basicUnsafeThaw :: PrimMonad m => Vector Int -> m (Mutable Vector (PrimState m) Int) Source # basicLength :: Vector Int -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int Source # basicUnsafeIndexM :: Monad m => Vector Int -> Int -> m Int Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int -> Vector Int -> m () Source # | |
MVector MVector Int | |
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Int -> MVector s Int Source # basicOverlaps :: MVector s Int -> MVector s Int -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int) Source # basicInitialize :: PrimMonad m => MVector (PrimState m) Int -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Int -> m (MVector (PrimState m) Int) Source # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int -> Int -> m Int Source # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int -> Int -> Int -> m () Source # basicClear :: PrimMonad m => MVector (PrimState m) Int -> m () Source # basicSet :: PrimMonad m => MVector (PrimState m) Int -> Int -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m () Source # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int -> Int -> m (MVector (PrimState m) Int) Source # | |
Generic1 (URec Int :: k -> Type) | |
Functor (URec Int :: Type -> Type) | |
Foldable (URec Int :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Int m -> m foldMap :: Monoid m => (a -> m) -> URec Int a -> 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 # elem :: Eq a => a -> URec Int a -> Bool # maximum :: Ord a => URec Int a -> a # minimum :: Ord a => URec Int a -> a # | |
Traversable (URec Int :: Type -> Type) | |
Eq (URec Int p) | |
Ord (URec Int p) | |
Show (URec Int p) | |
Generic (URec Int p) | |
newtype Vector Int | |
data URec Int (p :: k) | |
Defined in GHC.Generics | |
newtype MVector s Int | |
type Rep1 (URec Int :: k -> Type) | |
Defined in GHC.Generics | |
type Rep (URec Int p) | |
Defined in GHC.Generics |
Instances
Enum Integer | |
Eq Integer | |
Integral Integer | |
Defined in GHC.Real | |
Data Integer | |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Integer -> c Integer gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Integer dataTypeOf :: Integer -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Integer) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Integer) gmapT :: (forall b. Data b => b -> b) -> Integer -> Integer gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r gmapQ :: (forall d. Data d => d -> u) -> Integer -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Integer -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Integer -> m Integer gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer | |
Num Integer | |
Ord Integer | |
Read Integer | |
Real Integer | |
Defined in GHC.Real Methods toRational :: Integer -> Rational # | |
Show Integer | |
Ix Integer | |
AEq Integer | |
NFData Integer | |
Defined in Control.DeepSeq | |
Bits Integer | |
Defined in Data.Bits Methods (.&.) :: Integer -> Integer -> Integer (.|.) :: Integer -> Integer -> Integer xor :: Integer -> Integer -> Integer complement :: Integer -> Integer shift :: Integer -> Int -> Integer rotate :: Integer -> Int -> Integer setBit :: Integer -> Int -> Integer clearBit :: Integer -> Int -> Integer complementBit :: Integer -> Int -> Integer testBit :: Integer -> Int -> Bool bitSizeMaybe :: Integer -> Maybe Int shiftL :: Integer -> Int -> Integer unsafeShiftL :: Integer -> Int -> Integer shiftR :: Integer -> Int -> Integer unsafeShiftR :: Integer -> Int -> Integer rotateL :: Integer -> Int -> Integer |
Instances
Monad Maybe | |
Functor Maybe | |
MonadFail Maybe | |
Defined in Control.Monad.Fail | |
Applicative Maybe | |
Foldable Maybe | |
Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # | |
Traversable Maybe | |
NFData1 Maybe | |
Defined in Control.DeepSeq | |
MonadPlus Maybe | |
Alternative Maybe | |
Eq1 Maybe | |
Ord1 Maybe | |
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering | |
Read1 Maybe | |
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Maybe a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Maybe a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Maybe a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Maybe a] | |
Show1 Maybe | |
Defined in Data.Functor.Classes | |
Eq a => Eq (Maybe a) | |
Data a => Data (Maybe a) | |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) dataTypeOf :: Maybe a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) | |
Ord a => Ord (Maybe a) | |
Read a => Read (Maybe a) | |
Show a => Show (Maybe a) | |
Generic (Maybe a) | |
Semigroup a => Semigroup (Maybe a) | |
Semigroup a => Monoid (Maybe a) | |
AEq a => AEq (Maybe a) | |
NFData a => NFData (Maybe a) | |
Defined in Control.DeepSeq | |
SingKind a => SingKind (Maybe a) | |
Defined in GHC.Generics Associated Types type DemoteRep (Maybe a) | |
Generic1 Maybe | |
SingI ('Nothing :: Maybe a) | |
Defined in GHC.Generics | |
SingI a2 => SingI ('Just a2 :: Maybe a1) | |
Defined in GHC.Generics | |
type Rep (Maybe a) | |
Defined in GHC.Generics | |
type DemoteRep (Maybe a) | |
Defined in GHC.Generics | |
data Sing (b :: Maybe a) | |
type Rep1 Maybe | |
Instances
Bounded Ordering | |
Enum Ordering | |
Eq Ordering | |
Data Ordering | |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering toConstr :: Ordering -> Constr dataTypeOf :: Ordering -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering | |
Ord Ordering | |
Defined in GHC.Classes | |
Read Ordering | |
Show Ordering | |
Ix Ordering | |
Defined in GHC.Arr | |
Generic Ordering | |
Semigroup Ordering | |
Monoid Ordering | |
AEq Ordering | |
NFData Ordering | |
Defined in Control.DeepSeq | |
type Rep Ordering | |
Instances
Monad IO | |
Functor IO | |
MonadFail IO | |
Defined in Control.Monad.Fail | |
Applicative IO | |
MonadPlus IO | |
Alternative IO | |
PrimMonad IO | |
PrimBase IO | |
Defined in Control.Monad.Primitive | |
Semigroup a => Semigroup (IO a) | |
Monoid a => Monoid (IO a) | |
type PrimState IO | |
Defined in Control.Monad.Primitive type PrimState IO = RealWorld |
Instances
Bounded Word | |
Enum Word | |
Eq Word | |
Integral Word | |
Data Word | |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word dataTypeOf :: Word -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) gmapT :: (forall b. Data b => b -> b) -> Word -> Word gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word | |
Num Word | |
Ord Word | |
Read Word | |
Real Word | |
Defined in GHC.Real Methods toRational :: Word -> Rational # | |
Show Word | |
Ix Word | |
AEq Word | |
Unbox Word | |
Defined in Data.Vector.Unboxed.Base | |
Prim Word | |
Defined in Data.Primitive.Types Methods alignment# :: Word -> Int# indexByteArray# :: ByteArray# -> Int# -> Word readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word #) writeByteArray# :: MutableByteArray# s -> Int# -> Word -> State# s -> State# s setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word -> State# s -> State# s indexOffAddr# :: Addr# -> Int# -> Word readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word #) writeOffAddr# :: Addr# -> Int# -> Word -> State# s -> State# s setOffAddr# :: Addr# -> Int# -> Int# -> Word -> State# s -> State# s | |
Storable Word | |
Defined in Foreign.Storable | |
NFData Word | |
Defined in Control.DeepSeq | |
Bits Word | |
Defined in Data.Bits | |
FiniteBits Word | |
Defined in Data.Bits Methods finiteBitSize :: Word -> Int countLeadingZeros :: Word -> Int countTrailingZeros :: Word -> Int | |
Vector Vector Word | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word -> m (Vector Word) Source # basicUnsafeThaw :: PrimMonad m => Vector Word -> m (Mutable Vector (PrimState m) Word) Source # basicLength :: Vector Word -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word Source # basicUnsafeIndexM :: Monad m => Vector Word -> Int -> m Word Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word -> Vector Word -> m () Source # | |
MVector MVector Word | |
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Word -> MVector s Word Source # basicOverlaps :: MVector s Word -> MVector s Word -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word) Source # basicInitialize :: PrimMonad m => MVector (PrimState m) Word -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Word -> m (MVector (PrimState m) Word) Source # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word -> Int -> m Word Source # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word -> Int -> Word -> m () Source # basicClear :: PrimMonad m => MVector (PrimState m) Word -> m () Source # basicSet :: PrimMonad m => MVector (PrimState m) Word -> Word -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m () Source # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word -> Int -> m (MVector (PrimState m) Word) Source # | |
Generic1 (URec Word :: k -> Type) | |
Functor (URec Word :: Type -> Type) | |
Foldable (URec Word :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Word m -> m foldMap :: Monoid m => (a -> m) -> URec Word a -> 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 # 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 # | |
Traversable (URec Word :: Type -> Type) | |
Defined in Data.Traversable | |
Eq (URec Word p) | |
Ord (URec Word p) | |
Defined in GHC.Generics | |
Show (URec Word p) | |
Generic (URec Word p) | |
newtype Vector Word | |
data URec Word (p :: k) | |
Defined in GHC.Generics | |
newtype MVector s Word | |
type Rep1 (URec Word :: k -> Type) | |
Defined in GHC.Generics | |
type Rep (URec Word p) | |
Defined in GHC.Generics |
Instances
NFData2 Either | |
Defined in Control.DeepSeq | |
Eq2 Either | |
Ord2 Either | |
Defined in Data.Functor.Classes | |
Read2 Either | |
Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Either a b) liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Either a b] liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Either a b) liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Either a b] | |
Show2 Either | |
Monad (Either e) | |
Functor (Either a) | |
Applicative (Either e) | |
Foldable (Either a) | |
Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> m foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # | |
Traversable (Either a) | |
Defined in Data.Traversable | |
NFData a => NFData1 (Either a) | |
Defined in Control.DeepSeq | |
Eq a => Eq1 (Either a) | |
Ord a => Ord1 (Either a) | |
Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b -> Ordering) -> Either a a0 -> Either a b -> Ordering | |
Read a => Read1 (Either a) | |
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Either a a0) liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Either a a0] liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Either a a0) liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Either a a0] | |
Show a => Show1 (Either a) | |
Defined in Data.Functor.Classes | |
Generic1 (Either a :: Type -> Type) | |
(Eq a, Eq b) => Eq (Either a b) | |
(Data a, Data b) => Data (Either a b) | |
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Either a b -> c (Either a b) gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b) toConstr :: Either a b -> Constr dataTypeOf :: Either a b -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Either a b)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Either a b)) gmapT :: (forall b0. Data b0 => b0 -> b0) -> Either a b -> Either a b gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) | |
(Ord a, Ord b) => Ord (Either a b) | |
(Read a, Read b) => Read (Either a b) | |
(Show a, Show b) => Show (Either a b) | |
Generic (Either a b) | |
Semigroup (Either a b) | |
(AEq a, AEq b) => AEq (Either a b) | |
(NFData a, NFData b) => NFData (Either a b) | |
Defined in Control.DeepSeq | |
type Rep1 (Either a :: Type -> Type) | |
Defined in GHC.Generics type Rep1 (Either a :: Type -> Type) = D1 ('MetaData "Either" "Data.Either" "base" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1)) | |
type Rep (Either a b) | |
Defined in GHC.Generics type Rep (Either a b) = D1 ('MetaData "Either" "Data.Either" "base" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 b))) |
errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a #
(^^) :: (Fractional a, Integral b) => a -> b -> a #
showString :: String -> ShowS #
appendFile :: FilePath -> String -> IO () #
getContents :: IO String #