-- -*- coding: utf-8 -*-
 {-# LANGUAGE CPP, Trustworthy, TypeOperators, DataKinds, KindSignatures, PolyKinds #-}
 {-# LANGUAGE FlexibleInstances, TypeFamilyDependencies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving, DerivingStrategies #-}
 {-# LANGUAGE ExistentialQuantification, TypeFamilies,GADTs, RankNTypes, UnicodeSyntax #-}
 {-# LANGUAGE ScopedTypeVariables, StandaloneDeriving, FlexibleContexts, DeriveGeneric, DeriveDataTypeable, DeriveAnyClass #-}

#if __GLASGOW_HASKELL__ >= 806

 {-# LANGUAGE DerivingVia #-}

#endif

  
 -- | This module contains auxiliary definitions related to dimensional analysis.
 --   This is based on the SI system of units.
 --   This module supports compile-time checking for dimensional units.
 --   This is accomplished by a set of newtype wrappers of Double.
 --
 --   It is not necessarily a good idea to make the checking in compile-time.
 --   In particular, this can prevent operations to be available, e.g. Num 
 --   class is not supported for compile-time checked quantities. Num because it has
 --   wrong type for the multiplication and division. Instead of Num, VectorSpace operations
 --   and operations defined in this module should be used.
 -- 
 --   However, these types can distinguish quantities even in cases where the dimensions
 --   match, e.g. radians and steradians. Explicit conversions are nonetheless available
 --   when dimensions match.
 --
 --   Read operations are pretty strict in that they require exactly
 --   the syntax "<double> <unit>", where <unit> is the result of
 --   @unitOf (fromAmount 0 :: T)@. Example: @(read "3 m^2" :: SquareLength)@
 --   This can sometimes be unintuitive and is sensitive to the algorithm
 --   used to print units.
 --   For example: @unitOf (fromAmount 0 :: Mass :/ Length) == "m^-1 kg"@.
 --   If in doubt, it's possible to use the read algorithm handling all units
 --   from DimensionalAnalysis module.
 --
 --   However, it's very much likely that compile-time checked newtypes
 --   are faster at run-time than using the run-time checked quantities. This is probably
 --   the primary reason for wanting this module instead of run-time checked version.
 -- 
 --   Also it's not possible to cast input data directly without run-time check
 --   to a compile-time checked quantity.
 --
 --   See "Barton&Nackman: Scientific and Engineering C++" for C++ approach
 --   to dimensional analysis.
 --  
 --   <https://en.wikipedia.org/wiki/International_System_of_Units>
 module Math.Number.Units where
 import safe Control.Monad (guard)
 import safe Control.Applicative
 import safe Data.Typeable
 import safe Data.Data
 import safe GHC.Generics hiding (R)
 import safe Data.Binary
 import safe Data.Ratio
 import safe Data.Complex
 import Math.Matrix.Interface
 import Math.Number.DimensionalAnalysis
 import Math.Number.TypeRational
 import safe Data.Ratio
 import Math.Number.Real (R)
 import safe qualified Text.ParserCombinators.ReadPrec
 import safe GHC.Read (readPrec)
 import safe Text.ParserCombinators.ReadPrec (lift)
 import safe Text.ParserCombinators.ReadP (skipSpaces, string)
 import Math.Tools.Isomorphism
 import Math.Tools.Arrow
 import qualified Data.Ratio

 -- | Notice that 'Math.Number.DimensionalAnalysis.fromAmount' from Unit class
 -- has type @(Unit u) => UnitName u@.
 -- However usually a concrete constructor of one of the newtypes is used as value.
 type UnitName u = Scalar u -> u

 (*%%) :: (Scalar u ~ Scalar u') => UnitName u -> UnitName u' -> UnitName (u :* u')
 *%% :: forall u u'.
(Scalar u ~ Scalar u') =>
UnitName u -> UnitName u' -> UnitName (u :* u')
(*%%) UnitName u
a UnitName u'
b = \Scalar (u :* u')
v -> Scalar u -> UnitName u -> UnitName u' -> u :* u'
forall a b. Scalar a -> UnitName a -> UnitName b -> a :* b
QProduct Scalar u
Scalar (u :* u')
v UnitName u
a UnitName u'
b

 (/%%) :: (Scalar u ~ Scalar u') => UnitName u -> UnitName u' -> UnitName (u :/ u')
 /%% :: forall u u'.
(Scalar u ~ Scalar u') =>
UnitName u -> UnitName u' -> UnitName (u :/ u')
(/%%) UnitName u
a UnitName u'
b = \Scalar (u :/ u')
v -> Scalar u -> UnitName u -> UnitName u' -> u :/ u'
forall a b. Scalar a -> UnitName a -> UnitName b -> a :/ b
QDivide Scalar u
Scalar (u :/ u')
v UnitName u
a UnitName u'
b

 -- | heterogeneous product respecting units
 -- It may be necessary to use 'Math.Number.Units.quantity' operation
 -- to convert to run-time representation after using this, because the result type
 -- accumulates new parts with each use without considering what the total
 -- dimension of the result is. This can produce excessively complicated types, because
 -- the type represents the structure of the expression rather than structure of
 -- the result.
 (*%) :: (LiteralUnit u, LiteralUnit w, Num (Scalar u), Scalar u ~ Scalar w)
      => u -> w -> u :* w
 u
a *% :: forall u w.
(LiteralUnit u, LiteralUnit w, Num (Scalar u),
 Scalar u ~ Scalar w) =>
u -> w -> u :* w
*% w
b = Scalar u -> UnitName u -> UnitName w -> u :* w
forall a b. Scalar a -> UnitName a -> UnitName b -> a :* b
QProduct (u -> Scalar u
forall u. Unit u => u -> Scalar u
amount u
a Scalar w -> Scalar w -> Scalar w
forall a. Num a => a -> a -> a
* w -> Scalar w
forall u. Unit u => u -> Scalar u
amount w
b) UnitName u
forall u. LiteralUnit u => Scalar u -> u
fromAmount UnitName w
forall u. LiteralUnit u => Scalar u -> u
fromAmount


 -- | heterogeneous division respecting units.
 -- These simply accumulate type information about the units.
 -- It may be necessary to use 'Math.Number.Units.quantity' operation
 -- to convert to run-time representation after using this, because the result type
 -- accumulates new parts with each use without considering what the total
 -- dimension of the result is. This can produce excessively complicated types, because
 -- the type represents the structure of the expression rather than the structure of
 -- the result.
 (/%) :: (Fractional (Scalar u), LiteralUnit u, LiteralUnit w, Scalar u ~ Scalar w)
      => u -> w -> u :/ w
 u
a /% :: forall u w.
(Fractional (Scalar u), LiteralUnit u, LiteralUnit w,
 Scalar u ~ Scalar w) =>
u -> w -> u :/ w
/% w
b = Scalar u -> UnitName u -> UnitName w -> u :/ w
forall a b. Scalar a -> UnitName a -> UnitName b -> a :/ b
QDivide (u -> Scalar u
forall u. Unit u => u -> Scalar u
amount u
a Scalar w -> Scalar w -> Scalar w
forall a. Fractional a => a -> a -> a
/ w -> Scalar w
forall u. Unit u => u -> Scalar u
amount w
b) UnitName u
forall u. LiteralUnit u => Scalar u -> u
fromAmount UnitName w
forall u. LiteralUnit u => Scalar u -> u
fromAmount

 unitNameToDimension :: (Num (Scalar u), Unit u) => UnitName u -> Dimension
 unitNameToDimension :: forall u. (Num (Scalar u), Unit u) => UnitName u -> Dimension
unitNameToDimension UnitName u
f = u -> Dimension
forall u. Unit u => u -> Dimension
dimension (UnitName u
f Scalar u
0)

 mapAmount :: (LiteralUnit a) => (Scalar a -> Scalar a) -> a -> a
 mapAmount :: forall a. LiteralUnit a => (Scalar a -> Scalar a) -> a -> a
mapAmount Scalar a -> Scalar a
f = Scalar a -> a
forall u. LiteralUnit u => Scalar u -> u
fromAmount (Scalar a -> a) -> (a -> Scalar a) -> a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scalar a -> Scalar a
f (Scalar a -> Scalar a) -> (a -> Scalar a) -> a -> Scalar a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Scalar a
forall u. Unit u => u -> Scalar u
amount

 mapAmount2 :: (LiteralUnit a) => (Scalar a -> Scalar a -> Scalar a) -> a -> a -> a
 mapAmount2 :: forall a.
LiteralUnit a =>
(Scalar a -> Scalar a -> Scalar a) -> a -> a -> a
mapAmount2 Scalar a -> Scalar a -> Scalar a
f a
x a
y = Scalar a -> a
forall u. LiteralUnit u => Scalar u -> u
fromAmount (Scalar a -> Scalar a -> Scalar a
f (a -> Scalar a
forall u. Unit u => u -> Scalar u
amount a
x) (a -> Scalar a
forall u. Unit u => u -> Scalar u
amount a
y))

 -- | Conversion from "Quantity a" to a unit-specific type.
 -- The second argument is the constructor for the newtype specific to the unit.
 -- 
 -- Example:  @(3 %* meter) `asUnit` Meters == return (Meters 3)@
 --           @0.3 `asUnit` Radians == return (Radians 0.3)@
 --  
 -- If the dimensions don't match, this raises an exception.
 asUnit :: (MonadFail m, Show (Scalar u), Show u, LiteralUnit u, Fractional (Scalar u))
        => Quantity (Scalar u) -> UnitName u -> m u
 asUnit :: forall (m :: * -> *) u.
(MonadFail m, Show (Scalar u), Show u, LiteralUnit u,
 Fractional (Scalar u)) =>
Quantity (Scalar u) -> UnitName u -> m u
asUnit (Scalar u
x `As` Dimension
d) UnitName u
f = let v :: u
v = UnitName u
f (Scalar u
x Scalar u -> Scalar u -> Scalar u
forall a. Fractional a => a -> a -> a
/ UnitName u -> Scalar u
forall u. LiteralUnit u => (Scalar u -> u) -> Scalar u
conversionFactor UnitName u
f Scalar u -> Scalar u -> Scalar u
forall a. Num a => a -> a -> a
- UnitName u -> Scalar u
forall u. LiteralUnit u => (Scalar u -> u) -> Scalar u
zeroAmount UnitName u
f)
  in if Dimension
d Dimension -> Dimension -> Bool
forall a. Eq a => a -> a -> Bool
== u -> Dimension
forall u. Unit u => u -> Dimension
dimension u
v then u -> m u
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return u
v
                         else String -> Dimension -> Dimension -> Scalar u -> Scalar u -> m u
forall (m :: * -> *) b c a.
(MonadFail m, Show b, Show c) =>
String -> Dimension -> Dimension -> b -> c -> m a
invalidDimensionsM String
"asUnit" Dimension
d (u -> Dimension
forall u. Unit u => u -> Dimension
dimension u
v) Scalar u
x (u -> Scalar u
forall u. Unit u => u -> Scalar u
amount u
v)

 -- | Converts a compile-time checked dimensional unit to run-time checked version
 -- This often has the effect of reducing the complexity in types.
 quantity :: (LiteralUnit u) => u -> Quantity (Scalar u)
 quantity :: forall u. LiteralUnit u => u -> Quantity (Scalar u)
quantity (u
x :: u) = ((Scalar u -> u) -> Scalar u
forall u. LiteralUnit u => (Scalar u -> u) -> Scalar u
conversionFactor (Scalar u -> u
forall u. LiteralUnit u => Scalar u -> u
fromAmount :: Scalar u -> u) Scalar u -> Scalar u -> Scalar u
forall a. Num a => a -> a -> a
* (u -> Scalar u
forall u. Unit u => u -> Scalar u
amount u
x
                     Scalar u -> Scalar u -> Scalar u
forall a. Num a => a -> a -> a
+ (Scalar u -> u) -> Scalar u
forall u. LiteralUnit u => (Scalar u -> u) -> Scalar u
zeroAmount (Scalar u -> u
forall u. LiteralUnit u => Scalar u -> u
fromAmount :: Scalar u -> u))) Scalar u -> Dimension -> Quantity (Scalar u)
forall r. r -> Dimension -> Quantity r
@@ u -> Dimension
forall u. Unit u => u -> Dimension
dimension u
x

 data a :/ b  = QDivide { forall a b. (a :/ b) -> Scalar a
qdivideAmount :: !(Scalar a),
                          forall a b. (a :/ b) -> UnitName a
qdivideDividendUnit :: UnitName a,
                          forall a b. (a :/ b) -> UnitName b
qdivideDivisorUnit  :: UnitName b }
    deriving (Typeable, (forall x. (a :/ b) -> Rep (a :/ b) x)
-> (forall x. Rep (a :/ b) x -> a :/ b) -> Generic (a :/ b)
forall x. Rep (a :/ b) x -> a :/ b
forall x. (a :/ b) -> Rep (a :/ b) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a b x. Rep (a :/ b) x -> a :/ b
forall a b x. (a :/ b) -> Rep (a :/ b) x
$cfrom :: forall a b x. (a :/ b) -> Rep (a :/ b) x
from :: forall x. (a :/ b) -> Rep (a :/ b) x
$cto :: forall a b x. Rep (a :/ b) x -> a :/ b
to :: forall x. Rep (a :/ b) x -> a :/ b
Generic)

 data a :* b = QProduct { forall a b. (a :* b) -> Scalar a
qproductAmount :: !(Scalar a),
                          forall a b. (a :* b) -> UnitName a
qproduct_firstUnit :: UnitName a,
                          forall a b. (a :* b) -> UnitName b
qproduct_secondUnit :: UnitName b
                        }
    deriving (Typeable, (forall x. (a :* b) -> Rep (a :* b) x)
-> (forall x. Rep (a :* b) x -> a :* b) -> Generic (a :* b)
forall x. Rep (a :* b) x -> a :* b
forall x. (a :* b) -> Rep (a :* b) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a b x. Rep (a :* b) x -> a :* b
forall a b x. (a :* b) -> Rep (a :* b) x
$cfrom :: forall a b x. (a :* b) -> Rep (a :* b) x
from :: forall x. (a :* b) -> Rep (a :* b) x
$cto :: forall a b x. Rep (a :* b) x -> a :* b
to :: forall x. Rep (a :* b) x -> a :* b
Generic)
 
 instance (LiteralUnit a, LiteralUnit b, Scalar a ~ Scalar b) => VectorSpace (a :* b) where
    type Scalar (a :* b) = Scalar a
    vzero :: a :* b
vzero = Scalar a -> UnitName a -> UnitName b -> a :* b
forall a b. Scalar a -> UnitName a -> UnitName b -> a :* b
QProduct Scalar a
Scalar b
0 UnitName a
forall u. LiteralUnit u => Scalar u -> u
fromAmount UnitName b
forall u. LiteralUnit u => Scalar u -> u
fromAmount
    vnegate :: (a :* b) -> a :* b
vnegate (QProduct Scalar a
x UnitName a
s UnitName b
t) = Scalar a -> UnitName a -> UnitName b -> a :* b
forall a b. Scalar a -> UnitName a -> UnitName b -> a :* b
QProduct (Scalar b -> Scalar b
forall a. Num a => a -> a
negate Scalar a
Scalar b
x) UnitName a
s UnitName b
t
    (QProduct Scalar a
d UnitName a
s UnitName b
t) %+ :: (a :* b) -> (a :* b) -> a :* b
%+ (QProduct Scalar a
d' UnitName a
_ UnitName b
_) = Scalar a -> UnitName a -> UnitName b -> a :* b
forall a b. Scalar a -> UnitName a -> UnitName b -> a :* b
QProduct (Scalar a
Scalar b
d Scalar b -> Scalar b -> Scalar b
forall a. Num a => a -> a -> a
+ Scalar a
Scalar b
d') UnitName a
s UnitName b
t
    Scalar (a :* b)
k %* :: Scalar (a :* b) -> (a :* b) -> a :* b
%* (QProduct Scalar a
d UnitName a
s UnitName b
t) = Scalar a -> UnitName a -> UnitName b -> a :* b
forall a b. Scalar a -> UnitName a -> UnitName b -> a :* b
QProduct (Scalar b
Scalar (a :* b)
k Scalar b -> Scalar b -> Scalar b
forall a. Num a => a -> a -> a
* Scalar a
Scalar b
d) UnitName a
s UnitName b
t

 instance (LiteralUnit a, LiteralUnit b, Scalar a ~ Scalar b) => VectorSpace (a :/ b) where
    type Scalar (a :/ b) = Scalar a
    vzero :: a :/ b
vzero = Scalar a -> UnitName a -> UnitName b -> a :/ b
forall a b. Scalar a -> UnitName a -> UnitName b -> a :/ b
QDivide Scalar a
Scalar b
0 UnitName a
forall u. LiteralUnit u => Scalar u -> u
fromAmount UnitName b
forall u. LiteralUnit u => Scalar u -> u
fromAmount
    vnegate :: (a :/ b) -> a :/ b
vnegate (QDivide Scalar a
x UnitName a
a UnitName b
b) = Scalar a -> UnitName a -> UnitName b -> a :/ b
forall a b. Scalar a -> UnitName a -> UnitName b -> a :/ b
QDivide (Scalar b -> Scalar b
forall a. Num a => a -> a
negate Scalar a
Scalar b
x) UnitName a
a UnitName b
b
    (QDivide Scalar a
x UnitName a
a UnitName b
b) %+ :: (a :/ b) -> (a :/ b) -> a :/ b
%+ (QDivide Scalar a
x' UnitName a
_ UnitName b
_) = Scalar a -> UnitName a -> UnitName b -> a :/ b
forall a b. Scalar a -> UnitName a -> UnitName b -> a :/ b
QDivide (Scalar a
Scalar b
x Scalar b -> Scalar b -> Scalar b
forall a. Num a => a -> a -> a
+ Scalar a
Scalar b
x') UnitName a
a UnitName b
b
    Scalar (a :/ b)
k %* :: Scalar (a :/ b) -> (a :/ b) -> a :/ b
%* (QDivide Scalar a
d UnitName a
s UnitName b
t) = Scalar a -> UnitName a -> UnitName b -> a :/ b
forall a b. Scalar a -> UnitName a -> UnitName b -> a :/ b
QDivide (Scalar b
Scalar (a :/ b)
k Scalar b -> Scalar b -> Scalar b
forall a. Num a => a -> a -> a
* Scalar a
Scalar b
d) UnitName a
s UnitName b
t

 instance (LiteralUnit a, LiteralUnit b, Show (Scalar a), Scalar a ~ Scalar b) => Unit (a :* b) where
    amount :: (a :* b) -> Scalar (a :* b)
amount = (a :* b) -> Scalar a
(a :* b) -> Scalar (a :* b)
forall a b. (a :* b) -> Scalar a
qproductAmount
    unitOf :: (a :* b) -> String
unitOf z :: a :* b
z@(QProduct Scalar a
x UnitName a
_ UnitName b
_) = Dimension -> String
forall a. Show a => a -> String
show ((a :* b) -> Dimension
forall u. Unit u => u -> Dimension
dimension a :* b
z)
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (a :* b)) -> m (a :* b)
fromQuantity Quantity (Scalar (a :* b))
q = do
      let res :: a :* b
res = Scalar a -> UnitName a -> UnitName b -> a :* b
forall a b. Scalar a -> UnitName a -> UnitName b -> a :* b
QProduct (Quantity (Scalar b) -> Scalar b
forall r. Quantity r -> r
valueAmount Quantity (Scalar b)
Quantity (Scalar (a :* b))
q) UnitName a
forall u. LiteralUnit u => Scalar u -> u
fromAmount UnitName b
forall u. LiteralUnit u => Scalar u -> u
fromAmount
      Bool -> m ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Quantity (Scalar b) -> Dimension
forall r. Quantity r -> Dimension
valueDimension Quantity (Scalar b)
Quantity (Scalar (a :* b))
q Dimension -> Dimension -> Bool
forall a. Eq a => a -> a -> Bool
== (a :* b) -> Dimension
forall u. Unit u => u -> Dimension
dimension a :* b
res)
        m () -> m () -> m ()
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Dimension -> Dimension -> Scalar b -> Scalar b -> m ()
forall b c a.
(Show b, Show c) =>
String -> Dimension -> Dimension -> b -> c -> a
invalidDimensions String
"fromQuantity" (Quantity (Scalar b) -> Dimension
forall r. Quantity r -> Dimension
valueDimension Quantity (Scalar b)
Quantity (Scalar (a :* b))
q) ((a :* b) -> Dimension
forall u. Unit u => u -> Dimension
dimension a :* b
res)
                                            (Quantity (Scalar b) -> Scalar b
forall r. Quantity r -> r
valueAmount Quantity (Scalar b)
Quantity (Scalar (a :* b))
q) (Quantity (Scalar b) -> Scalar b
forall r. Quantity r -> r
valueAmount Quantity (Scalar b)
Quantity (Scalar (a :* b))
q)
      (a :* b) -> m (a :* b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a :* b
res
    dimension :: (a :* b) -> Dimension
dimension (QProduct Scalar a
x UnitName a
s UnitName b
t) = UnitName a -> Dimension
forall u. (Num (Scalar u), Unit u) => UnitName u -> Dimension
unitNameToDimension UnitName a
s Dimension -> Dimension -> Dimension
forall a. Num a => a -> a -> a
+ UnitName b -> Dimension
forall u. (Num (Scalar u), Unit u) => UnitName u -> Dimension
unitNameToDimension UnitName b
t

 instance (Scalar a ~ Scalar b, Show (Scalar a), LiteralUnit a, LiteralUnit b) => LiteralUnit (a :* b) where
    fromAmount :: Scalar (a :* b) -> a :* b
fromAmount Scalar (a :* b)
d = Scalar a -> UnitName a -> UnitName b -> a :* b
forall a b. Scalar a -> UnitName a -> UnitName b -> a :* b
QProduct Scalar a
Scalar (a :* b)
d UnitName a
forall u. LiteralUnit u => Scalar u -> u
fromAmount UnitName b
forall u. LiteralUnit u => Scalar u -> u
fromAmount 

 instance (LiteralUnit a, LiteralUnit b, Show (Scalar a), Scalar a ~ Scalar b) => Unit (a :/ b) where
    amount :: (a :/ b) -> Scalar (a :/ b)
amount = (a :/ b) -> Scalar a
(a :/ b) -> Scalar (a :/ b)
forall a b. (a :/ b) -> Scalar a
qdivideAmount
    unitOf :: (a :/ b) -> String
unitOf z :: a :/ b
z@(QDivide Scalar a
x UnitName a
_ UnitName b
_) = Dimension -> String
forall a. Show a => a -> String
show ((a :/ b) -> Dimension
forall u. Unit u => u -> Dimension
dimension a :/ b
z)
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (a :/ b)) -> m (a :/ b)
fromQuantity Quantity (Scalar (a :/ b))
q = do
       let res :: a :/ b
res = Scalar a -> UnitName a -> UnitName b -> a :/ b
forall a b. Scalar a -> UnitName a -> UnitName b -> a :/ b
QDivide (Quantity (Scalar b) -> Scalar b
forall r. Quantity r -> r
valueAmount Quantity (Scalar b)
Quantity (Scalar (a :/ b))
q) UnitName a
forall u. LiteralUnit u => Scalar u -> u
fromAmount UnitName b
forall u. LiteralUnit u => Scalar u -> u
fromAmount 
       Bool -> m ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Quantity (Scalar b) -> Dimension
forall r. Quantity r -> Dimension
valueDimension Quantity (Scalar b)
Quantity (Scalar (a :/ b))
q Dimension -> Dimension -> Bool
forall a. Eq a => a -> a -> Bool
== (a :/ b) -> Dimension
forall u. Unit u => u -> Dimension
dimension a :/ b
res)
         m () -> m () -> m ()
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Dimension -> Dimension -> Scalar b -> Scalar b -> m ()
forall b c a.
(Show b, Show c) =>
String -> Dimension -> Dimension -> b -> c -> a
invalidDimensions String
"fromQuantity" (Quantity (Scalar b) -> Dimension
forall r. Quantity r -> Dimension
valueDimension Quantity (Scalar b)
Quantity (Scalar (a :/ b))
q) ((a :/ b) -> Dimension
forall u. Unit u => u -> Dimension
dimension a :/ b
res)
                                             (Quantity (Scalar b) -> Scalar b
forall r. Quantity r -> r
valueAmount Quantity (Scalar b)
Quantity (Scalar (a :/ b))
q) (Quantity (Scalar b) -> Scalar b
forall r. Quantity r -> r
valueAmount Quantity (Scalar b)
Quantity (Scalar (a :/ b))
q)
       (a :/ b) -> m (a :/ b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ((a :/ b) -> m (a :/ b)) -> (a :/ b) -> m (a :/ b)
forall a b. (a -> b) -> a -> b
$ a :/ b
res
    dimension :: (a :/ b) -> Dimension
dimension (QDivide Scalar a
x UnitName a
a UnitName b
b) = UnitName a -> Dimension
forall u. (Num (Scalar u), Unit u) => UnitName u -> Dimension
unitNameToDimension UnitName a
a Dimension -> Dimension -> Dimension
forall a. Num a => a -> a -> a
- UnitName b -> Dimension
forall u. (Num (Scalar u), Unit u) => UnitName u -> Dimension
unitNameToDimension UnitName b
b

 instance (Scalar a ~ Scalar b, Show (Scalar a), LiteralUnit a, LiteralUnit b) => LiteralUnit (a :/ b) where
    fromAmount :: Scalar (a :/ b) -> a :/ b
fromAmount Scalar (a :/ b)
d = Scalar a -> UnitName a -> UnitName b -> a :/ b
forall a b. Scalar a -> UnitName a -> UnitName b -> a :/ b
QDivide Scalar a
Scalar (a :/ b)
d UnitName a
forall u. LiteralUnit u => Scalar u -> u
fromAmount UnitName b
forall u. LiteralUnit u => Scalar u -> u
fromAmount

 instance (Scalar a ~ Scalar b, LiteralUnit a, LiteralUnit b, Show (Scalar a)) => Show (a :* b) where
    show :: (a :* b) -> String
show z :: a :* b
z@(QProduct Scalar a
d UnitName a
s UnitName b
t) = Scalar b -> String
forall a. Show a => a -> String
show Scalar a
Scalar b
d String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Dimension -> String
forall a. Show a => a -> String
show ((a :* b) -> Dimension
forall u. Unit u => u -> Dimension
dimension a :* b
z)

 instance (Scalar a ~ Scalar b, LiteralUnit a, LiteralUnit b, Show (Scalar a)) => Show (a :/ b) where
    show :: (a :/ b) -> String
show z :: a :/ b
z@(QDivide Scalar a
d UnitName a
s UnitName b
t) = Scalar b -> String
forall a. Show a => a -> String
show Scalar a
Scalar b
d String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Dimension -> String
forall a. Show a => a -> String
show ((a :/ b) -> Dimension
forall u. Unit u => u -> Dimension
dimension a :/ b
z)
     -- show (unitNameToDimension s)
       --                             ++ "/(" ++ show (unitNameToDimension t) ++ ")"

 instance Unit Float where
    amount :: Float -> Scalar Float
amount Float
x = Float
Scalar Float
x
    unitOf :: Float -> String
unitOf Float
_ = String
""
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar Float) -> m Float
fromQuantity (Scalar Float
x `As` Dimension
d) = Bool -> m ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Dimension -> Bool
isDimensionless Dimension
d) m () -> m Float -> m Float
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Float -> m Float
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
Scalar Float
x
    dimension :: Float -> Dimension
dimension Float
_ = Dimension
dimensionless

 instance LiteralUnit Float where
    fromAmount :: Scalar Float -> Float
fromAmount Scalar Float
x = Float
Scalar Float
x

 instance Unit Double where
    amount :: Double -> Scalar Double
amount Double
x = Double
Scalar Double
x
    unitOf :: Double -> String
unitOf Double
_ = String
""
    dimension :: Double -> Dimension
dimension Double
_ = Dimension
dimensionless
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar Double) -> m Double
fromQuantity (Scalar Double
x `As` Dimension
d) = Bool -> m ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Dimension -> Bool
isDimensionless Dimension
d) m () -> m Double -> m Double
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Double -> m Double
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
Scalar Double
x

 instance LiteralUnit Double where
    fromAmount :: Scalar Double -> Double
fromAmount Scalar Double
x = Double
Scalar Double
x

 instance Unit R where
    amount :: R -> Scalar R
amount R
x = Scalar R
R
x
    unitOf :: R -> String
unitOf R
_ = String
""
    dimension :: R -> Dimension
dimension R
_ = Dimension
dimensionless
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar R) -> m R
fromQuantity (Scalar R
x `As` Dimension
d) = Bool -> m ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Dimension -> Bool
isDimensionless Dimension
d) m () -> m R -> m R
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> R -> m R
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Scalar R
R
x

 instance LiteralUnit R where
    fromAmount :: Scalar R -> R
fromAmount Scalar R
x = Scalar R
R
x

 newtype Dimensionless a = Dimensionless { forall a. Dimensionless a -> a
dimensionlessValue :: a }
  deriving (Dimensionless a -> Dimensionless a -> Bool
(Dimensionless a -> Dimensionless a -> Bool)
-> (Dimensionless a -> Dimensionless a -> Bool)
-> Eq (Dimensionless a)
forall a. Eq a => Dimensionless a -> Dimensionless a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Dimensionless a -> Dimensionless a -> Bool
== :: Dimensionless a -> Dimensionless a -> Bool
$c/= :: forall a. Eq a => Dimensionless a -> Dimensionless a -> Bool
/= :: Dimensionless a -> Dimensionless a -> Bool
Eq,Eq (Dimensionless a)
Eq (Dimensionless a) =>
(Dimensionless a -> Dimensionless a -> Ordering)
-> (Dimensionless a -> Dimensionless a -> Bool)
-> (Dimensionless a -> Dimensionless a -> Bool)
-> (Dimensionless a -> Dimensionless a -> Bool)
-> (Dimensionless a -> Dimensionless a -> Bool)
-> (Dimensionless a -> Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a -> Dimensionless a)
-> Ord (Dimensionless a)
Dimensionless a -> Dimensionless a -> Bool
Dimensionless a -> Dimensionless a -> Ordering
Dimensionless a -> Dimensionless a -> Dimensionless a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Dimensionless a)
forall a. Ord a => Dimensionless a -> Dimensionless a -> Bool
forall a. Ord a => Dimensionless a -> Dimensionless a -> Ordering
forall a.
Ord a =>
Dimensionless a -> Dimensionless a -> Dimensionless a
$ccompare :: forall a. Ord a => Dimensionless a -> Dimensionless a -> Ordering
compare :: Dimensionless a -> Dimensionless a -> Ordering
$c< :: forall a. Ord a => Dimensionless a -> Dimensionless a -> Bool
< :: Dimensionless a -> Dimensionless a -> Bool
$c<= :: forall a. Ord a => Dimensionless a -> Dimensionless a -> Bool
<= :: Dimensionless a -> Dimensionless a -> Bool
$c> :: forall a. Ord a => Dimensionless a -> Dimensionless a -> Bool
> :: Dimensionless a -> Dimensionless a -> Bool
$c>= :: forall a. Ord a => Dimensionless a -> Dimensionless a -> Bool
>= :: Dimensionless a -> Dimensionless a -> Bool
$cmax :: forall a.
Ord a =>
Dimensionless a -> Dimensionless a -> Dimensionless a
max :: Dimensionless a -> Dimensionless a -> Dimensionless a
$cmin :: forall a.
Ord a =>
Dimensionless a -> Dimensionless a -> Dimensionless a
min :: Dimensionless a -> Dimensionless a -> Dimensionless a
Ord, Typeable, Typeable (Dimensionless a)
Typeable (Dimensionless a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Dimensionless a -> c (Dimensionless a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Dimensionless a))
-> (Dimensionless a -> Constr)
-> (Dimensionless a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Dimensionless a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Dimensionless a)))
-> ((forall b. Data b => b -> b)
    -> Dimensionless a -> Dimensionless a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Dimensionless a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Dimensionless a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Dimensionless a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Dimensionless a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Dimensionless a -> m (Dimensionless a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Dimensionless a -> m (Dimensionless a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Dimensionless a -> m (Dimensionless a))
-> Data (Dimensionless a)
Dimensionless a -> Constr
Dimensionless a -> DataType
(forall b. Data b => b -> b) -> Dimensionless a -> Dimensionless a
forall a. Data a => Typeable (Dimensionless a)
forall a. Data a => Dimensionless a -> Constr
forall a. Data a => Dimensionless a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Dimensionless a -> Dimensionless a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Dimensionless a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Dimensionless a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Dimensionless a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Dimensionless a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Dimensionless a -> m (Dimensionless a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Dimensionless a -> m (Dimensionless a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Dimensionless a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Dimensionless a -> c (Dimensionless a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Dimensionless a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Dimensionless a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> Dimensionless a -> u
forall u. (forall d. Data d => d -> u) -> Dimensionless a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Dimensionless a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Dimensionless a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Dimensionless a -> m (Dimensionless a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Dimensionless a -> m (Dimensionless a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Dimensionless a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Dimensionless a -> c (Dimensionless a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Dimensionless a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Dimensionless a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Dimensionless a -> c (Dimensionless a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Dimensionless a -> c (Dimensionless a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Dimensionless a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Dimensionless a)
$ctoConstr :: forall a. Data a => Dimensionless a -> Constr
toConstr :: Dimensionless a -> Constr
$cdataTypeOf :: forall a. Data a => Dimensionless a -> DataType
dataTypeOf :: Dimensionless a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Dimensionless a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Dimensionless a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Dimensionless a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Dimensionless a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Dimensionless a -> Dimensionless a
gmapT :: (forall b. Data b => b -> b) -> Dimensionless a -> Dimensionless a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Dimensionless a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Dimensionless a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Dimensionless a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Dimensionless a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Dimensionless a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Dimensionless a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Dimensionless a -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> Dimensionless a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Dimensionless a -> m (Dimensionless a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Dimensionless a -> m (Dimensionless a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Dimensionless a -> m (Dimensionless a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Dimensionless a -> m (Dimensionless a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Dimensionless a -> m (Dimensionless a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Dimensionless a -> m (Dimensionless a)
Data, (forall x. Dimensionless a -> Rep (Dimensionless a) x)
-> (forall x. Rep (Dimensionless a) x -> Dimensionless a)
-> Generic (Dimensionless a)
forall x. Rep (Dimensionless a) x -> Dimensionless a
forall x. Dimensionless a -> Rep (Dimensionless a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Dimensionless a) x -> Dimensionless a
forall a x. Dimensionless a -> Rep (Dimensionless a) x
$cfrom :: forall a x. Dimensionless a -> Rep (Dimensionless a) x
from :: forall x. Dimensionless a -> Rep (Dimensionless a) x
$cto :: forall a x. Rep (Dimensionless a) x -> Dimensionless a
to :: forall x. Rep (Dimensionless a) x -> Dimensionless a
Generic)
  deriving newtype (Get (Dimensionless a)
[Dimensionless a] -> Put
Dimensionless a -> Put
(Dimensionless a -> Put)
-> Get (Dimensionless a)
-> ([Dimensionless a] -> Put)
-> Binary (Dimensionless a)
forall a. Binary a => Get (Dimensionless a)
forall a. Binary a => [Dimensionless a] -> Put
forall a. Binary a => Dimensionless a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Dimensionless a -> Put
put :: Dimensionless a -> Put
$cget :: forall a. Binary a => Get (Dimensionless a)
get :: Get (Dimensionless a)
$cputList :: forall a. Binary a => [Dimensionless a] -> Put
putList :: [Dimensionless a] -> Put
Binary, Integer -> Dimensionless a
Dimensionless a -> Dimensionless a
Dimensionless a -> Dimensionless a -> Dimensionless a
(Dimensionless a -> Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Integer -> Dimensionless a)
-> Num (Dimensionless a)
forall a. Num a => Integer -> Dimensionless a
forall a. Num a => Dimensionless a -> Dimensionless a
forall a.
Num a =>
Dimensionless a -> Dimensionless a -> Dimensionless a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: forall a.
Num a =>
Dimensionless a -> Dimensionless a -> Dimensionless a
+ :: Dimensionless a -> Dimensionless a -> Dimensionless a
$c- :: forall a.
Num a =>
Dimensionless a -> Dimensionless a -> Dimensionless a
- :: Dimensionless a -> Dimensionless a -> Dimensionless a
$c* :: forall a.
Num a =>
Dimensionless a -> Dimensionless a -> Dimensionless a
* :: Dimensionless a -> Dimensionless a -> Dimensionless a
$cnegate :: forall a. Num a => Dimensionless a -> Dimensionless a
negate :: Dimensionless a -> Dimensionless a
$cabs :: forall a. Num a => Dimensionless a -> Dimensionless a
abs :: Dimensionless a -> Dimensionless a
$csignum :: forall a. Num a => Dimensionless a -> Dimensionless a
signum :: Dimensionless a -> Dimensionless a
$cfromInteger :: forall a. Num a => Integer -> Dimensionless a
fromInteger :: Integer -> Dimensionless a
Num, Num (Dimensionless a)
Num (Dimensionless a) =>
(Dimensionless a -> Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Rational -> Dimensionless a)
-> Fractional (Dimensionless a)
Rational -> Dimensionless a
Dimensionless a -> Dimensionless a
Dimensionless a -> Dimensionless a -> Dimensionless a
forall a. Fractional a => Num (Dimensionless a)
forall a. Fractional a => Rational -> Dimensionless a
forall a. Fractional a => Dimensionless a -> Dimensionless a
forall a.
Fractional a =>
Dimensionless a -> Dimensionless a -> Dimensionless a
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
$c/ :: forall a.
Fractional a =>
Dimensionless a -> Dimensionless a -> Dimensionless a
/ :: Dimensionless a -> Dimensionless a -> Dimensionless a
$crecip :: forall a. Fractional a => Dimensionless a -> Dimensionless a
recip :: Dimensionless a -> Dimensionless a
$cfromRational :: forall a. Fractional a => Rational -> Dimensionless a
fromRational :: Rational -> Dimensionless a
Fractional, Num (Dimensionless a)
Ord (Dimensionless a)
(Num (Dimensionless a), Ord (Dimensionless a)) =>
(Dimensionless a -> Rational) -> Real (Dimensionless a)
Dimensionless a -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
forall a. Real a => Num (Dimensionless a)
forall a. Real a => Ord (Dimensionless a)
forall a. Real a => Dimensionless a -> Rational
$ctoRational :: forall a. Real a => Dimensionless a -> Rational
toRational :: Dimensionless a -> Rational
Real, Fractional (Dimensionless a)
Real (Dimensionless a)
(Real (Dimensionless a), Fractional (Dimensionless a)) =>
(forall b. Integral b => Dimensionless a -> (b, Dimensionless a))
-> (forall b. Integral b => Dimensionless a -> b)
-> (forall b. Integral b => Dimensionless a -> b)
-> (forall b. Integral b => Dimensionless a -> b)
-> (forall b. Integral b => Dimensionless a -> b)
-> RealFrac (Dimensionless a)
forall b. Integral b => Dimensionless a -> b
forall b. Integral b => Dimensionless a -> (b, Dimensionless a)
forall a.
(Real a, Fractional a) =>
(forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
forall a. RealFrac a => Fractional (Dimensionless a)
forall a. RealFrac a => Real (Dimensionless a)
forall a b. (RealFrac a, Integral b) => Dimensionless a -> b
forall a b.
(RealFrac a, Integral b) =>
Dimensionless a -> (b, Dimensionless a)
$cproperFraction :: forall a b.
(RealFrac a, Integral b) =>
Dimensionless a -> (b, Dimensionless a)
properFraction :: forall b. Integral b => Dimensionless a -> (b, Dimensionless a)
$ctruncate :: forall a b. (RealFrac a, Integral b) => Dimensionless a -> b
truncate :: forall b. Integral b => Dimensionless a -> b
$cround :: forall a b. (RealFrac a, Integral b) => Dimensionless a -> b
round :: forall b. Integral b => Dimensionless a -> b
$cceiling :: forall a b. (RealFrac a, Integral b) => Dimensionless a -> b
ceiling :: forall b. Integral b => Dimensionless a -> b
$cfloor :: forall a b. (RealFrac a, Integral b) => Dimensionless a -> b
floor :: forall b. Integral b => Dimensionless a -> b
RealFrac, Fractional (Dimensionless a)
Dimensionless a
Fractional (Dimensionless a) =>
Dimensionless a
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Dimensionless a)
-> Floating (Dimensionless a)
Dimensionless a -> Dimensionless a
Dimensionless a -> Dimensionless a -> Dimensionless a
forall a. Floating a => Fractional (Dimensionless a)
forall a. Floating a => Dimensionless a
forall a. Floating a => Dimensionless a -> Dimensionless a
forall a.
Floating a =>
Dimensionless a -> Dimensionless a -> Dimensionless a
forall a.
Fractional a =>
a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
$cpi :: forall a. Floating a => Dimensionless a
pi :: Dimensionless a
$cexp :: forall a. Floating a => Dimensionless a -> Dimensionless a
exp :: Dimensionless a -> Dimensionless a
$clog :: forall a. Floating a => Dimensionless a -> Dimensionless a
log :: Dimensionless a -> Dimensionless a
$csqrt :: forall a. Floating a => Dimensionless a -> Dimensionless a
sqrt :: Dimensionless a -> Dimensionless a
$c** :: forall a.
Floating a =>
Dimensionless a -> Dimensionless a -> Dimensionless a
** :: Dimensionless a -> Dimensionless a -> Dimensionless a
$clogBase :: forall a.
Floating a =>
Dimensionless a -> Dimensionless a -> Dimensionless a
logBase :: Dimensionless a -> Dimensionless a -> Dimensionless a
$csin :: forall a. Floating a => Dimensionless a -> Dimensionless a
sin :: Dimensionless a -> Dimensionless a
$ccos :: forall a. Floating a => Dimensionless a -> Dimensionless a
cos :: Dimensionless a -> Dimensionless a
$ctan :: forall a. Floating a => Dimensionless a -> Dimensionless a
tan :: Dimensionless a -> Dimensionless a
$casin :: forall a. Floating a => Dimensionless a -> Dimensionless a
asin :: Dimensionless a -> Dimensionless a
$cacos :: forall a. Floating a => Dimensionless a -> Dimensionless a
acos :: Dimensionless a -> Dimensionless a
$catan :: forall a. Floating a => Dimensionless a -> Dimensionless a
atan :: Dimensionless a -> Dimensionless a
$csinh :: forall a. Floating a => Dimensionless a -> Dimensionless a
sinh :: Dimensionless a -> Dimensionless a
$ccosh :: forall a. Floating a => Dimensionless a -> Dimensionless a
cosh :: Dimensionless a -> Dimensionless a
$ctanh :: forall a. Floating a => Dimensionless a -> Dimensionless a
tanh :: Dimensionless a -> Dimensionless a
$casinh :: forall a. Floating a => Dimensionless a -> Dimensionless a
asinh :: Dimensionless a -> Dimensionless a
$cacosh :: forall a. Floating a => Dimensionless a -> Dimensionless a
acosh :: Dimensionless a -> Dimensionless a
$catanh :: forall a. Floating a => Dimensionless a -> Dimensionless a
atanh :: Dimensionless a -> Dimensionless a
$clog1p :: forall a. Floating a => Dimensionless a -> Dimensionless a
log1p :: Dimensionless a -> Dimensionless a
$cexpm1 :: forall a. Floating a => Dimensionless a -> Dimensionless a
expm1 :: Dimensionless a -> Dimensionless a
$clog1pexp :: forall a. Floating a => Dimensionless a -> Dimensionless a
log1pexp :: Dimensionless a -> Dimensionless a
$clog1mexp :: forall a. Floating a => Dimensionless a -> Dimensionless a
log1mexp :: Dimensionless a -> Dimensionless a
Floating, Floating (Dimensionless a)
RealFrac (Dimensionless a)
(RealFrac (Dimensionless a), Floating (Dimensionless a)) =>
(Dimensionless a -> Integer)
-> (Dimensionless a -> Int)
-> (Dimensionless a -> (Int, Int))
-> (Dimensionless a -> (Integer, Int))
-> (Integer -> Int -> Dimensionless a)
-> (Dimensionless a -> Int)
-> (Dimensionless a -> Dimensionless a)
-> (Int -> Dimensionless a -> Dimensionless a)
-> (Dimensionless a -> Bool)
-> (Dimensionless a -> Bool)
-> (Dimensionless a -> Bool)
-> (Dimensionless a -> Bool)
-> (Dimensionless a -> Bool)
-> (Dimensionless a -> Dimensionless a -> Dimensionless a)
-> RealFloat (Dimensionless a)
Int -> Dimensionless a -> Dimensionless a
Integer -> Int -> Dimensionless a
Dimensionless a -> Bool
Dimensionless a -> Int
Dimensionless a -> Integer
Dimensionless a -> (Int, Int)
Dimensionless a -> (Integer, Int)
Dimensionless a -> Dimensionless a
Dimensionless a -> Dimensionless a -> Dimensionless a
forall a. RealFloat a => Floating (Dimensionless a)
forall a. RealFloat a => RealFrac (Dimensionless a)
forall a. RealFloat a => Int -> Dimensionless a -> Dimensionless a
forall a. RealFloat a => Integer -> Int -> Dimensionless a
forall a. RealFloat a => Dimensionless a -> Bool
forall a. RealFloat a => Dimensionless a -> Int
forall a. RealFloat a => Dimensionless a -> Integer
forall a. RealFloat a => Dimensionless a -> (Int, Int)
forall a. RealFloat a => Dimensionless a -> (Integer, Int)
forall a. RealFloat a => Dimensionless a -> Dimensionless a
forall a.
RealFloat a =>
Dimensionless a -> Dimensionless a -> Dimensionless a
forall a.
(RealFrac a, Floating a) =>
(a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
$cfloatRadix :: forall a. RealFloat a => Dimensionless a -> Integer
floatRadix :: Dimensionless a -> Integer
$cfloatDigits :: forall a. RealFloat a => Dimensionless a -> Int
floatDigits :: Dimensionless a -> Int
$cfloatRange :: forall a. RealFloat a => Dimensionless a -> (Int, Int)
floatRange :: Dimensionless a -> (Int, Int)
$cdecodeFloat :: forall a. RealFloat a => Dimensionless a -> (Integer, Int)
decodeFloat :: Dimensionless a -> (Integer, Int)
$cencodeFloat :: forall a. RealFloat a => Integer -> Int -> Dimensionless a
encodeFloat :: Integer -> Int -> Dimensionless a
$cexponent :: forall a. RealFloat a => Dimensionless a -> Int
exponent :: Dimensionless a -> Int
$csignificand :: forall a. RealFloat a => Dimensionless a -> Dimensionless a
significand :: Dimensionless a -> Dimensionless a
$cscaleFloat :: forall a. RealFloat a => Int -> Dimensionless a -> Dimensionless a
scaleFloat :: Int -> Dimensionless a -> Dimensionless a
$cisNaN :: forall a. RealFloat a => Dimensionless a -> Bool
isNaN :: Dimensionless a -> Bool
$cisInfinite :: forall a. RealFloat a => Dimensionless a -> Bool
isInfinite :: Dimensionless a -> Bool
$cisDenormalized :: forall a. RealFloat a => Dimensionless a -> Bool
isDenormalized :: Dimensionless a -> Bool
$cisNegativeZero :: forall a. RealFloat a => Dimensionless a -> Bool
isNegativeZero :: Dimensionless a -> Bool
$cisIEEE :: forall a. RealFloat a => Dimensionless a -> Bool
isIEEE :: Dimensionless a -> Bool
$catan2 :: forall a.
RealFloat a =>
Dimensionless a -> Dimensionless a -> Dimensionless a
atan2 :: Dimensionless a -> Dimensionless a -> Dimensionless a
RealFloat)
 
 instance (MetricSpace a) => MetricSpace (Dimensionless a) where
    type Distance (Dimensionless a) = Dimensionless (Distance a)
    distance :: Dimensionless a -> Dimensionless a -> Distance (Dimensionless a)
distance (Dimensionless a
x) (Dimensionless a
y) = Distance a -> Dimensionless (Distance a)
forall a. a -> Dimensionless a
Dimensionless (a -> a -> Distance a
forall s. MetricSpace s => s -> s -> Distance s
distance a
x a
y)
  
 instance (Num a, Show a) => Show (Dimensionless a) where { show :: Dimensionless a -> String
show = Dimensionless a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }
 instance (Show a, Read a) => Read (Dimensionless a) where
    readPrec :: ReadPrec (Dimensionless a)
readPrec = ReadPrec a
forall a. Read a => ReadPrec a
readPrec ReadPrec a
-> (a -> ReadPrec (Dimensionless a)) -> ReadPrec (Dimensionless a)
forall a b. ReadPrec a -> (a -> ReadPrec b) -> ReadPrec b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Dimensionless a -> ReadPrec (Dimensionless a)
forall a. a -> ReadPrec a
forall (m :: * -> *) a. Monad m => a -> m a
return (Dimensionless a -> ReadPrec (Dimensionless a))
-> (a -> Dimensionless a) -> a -> ReadPrec (Dimensionless a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Dimensionless a
forall a. a -> Dimensionless a
Dimensionless)
 instance (Num a) => VectorSpace (Dimensionless a) where
    type Scalar (Dimensionless a) = a
    vzero :: Dimensionless a
vzero = a -> Dimensionless a
forall a. a -> Dimensionless a
Dimensionless a
0
    vnegate :: Dimensionless a -> Dimensionless a
vnegate (Dimensionless a
x) = a -> Dimensionless a
forall a. a -> Dimensionless a
Dimensionless (a -> a
forall a. Num a => a -> a
negate a
x)
    (Dimensionless a
x) %+ :: Dimensionless a -> Dimensionless a -> Dimensionless a
%+ (Dimensionless a
y) = a -> Dimensionless a
forall a. a -> Dimensionless a
Dimensionless (a -> Dimensionless a) -> a -> Dimensionless a
forall a b. (a -> b) -> a -> b
$ a
x a -> a -> a
forall a. Num a => a -> a -> a
+ a
y
    Scalar (Dimensionless a)
k %* :: Scalar (Dimensionless a) -> Dimensionless a -> Dimensionless a
%* (Dimensionless a
x) = a -> Dimensionless a
forall a. a -> Dimensionless a
Dimensionless (a -> Dimensionless a) -> a -> Dimensionless a
forall a b. (a -> b) -> a -> b
$ a
Scalar (Dimensionless a)
k a -> a -> a
forall a. Num a => a -> a -> a
* a
x


 instance (Num a) => NormedSpace (Dimensionless a) where
    norm :: Dimensionless a -> Scalar (Dimensionless a)
norm = Dimensionless a -> Scalar (Dimensionless a)
forall u. Unit u => u -> Scalar u
amount
    normSquared :: Dimensionless a -> Scalar (Dimensionless a)
normSquared (Dimensionless a
x) = a
xa -> a -> a
forall a. Num a => a -> a -> a
*a
x

 instance (Num a) => Unit (Dimensionless a) where
    amount :: Dimensionless a -> Scalar (Dimensionless a)
amount = Dimensionless a -> a
Dimensionless a -> Scalar (Dimensionless a)
forall a. Dimensionless a -> a
dimensionlessValue
    unitOf :: Dimensionless a -> String
unitOf Dimensionless a
_ = String
""
    dimension :: Dimensionless a -> Dimension
dimension Dimensionless a
_ = Dimension
dimensionless
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Dimensionless a)) -> m (Dimensionless a)
fromQuantity (Scalar (Dimensionless a)
x `As` Dimension
d) = do
      Bool -> m ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Dimension -> Bool
isDimensionless Dimension
d)
      Dimensionless a -> m (Dimensionless a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Dimensionless a -> m (Dimensionless a))
-> Dimensionless a -> m (Dimensionless a)
forall a b. (a -> b) -> a -> b
$ a -> Dimensionless a
forall a. a -> Dimensionless a
Dimensionless a
Scalar (Dimensionless a)
x

 instance (Show a, Num a) => LiteralUnit (Dimensionless a) where
    fromAmount :: Scalar (Dimensionless a) -> Dimensionless a
fromAmount = a -> Dimensionless a
Scalar (Dimensionless a) -> Dimensionless a
forall a. a -> Dimensionless a
Dimensionless

 newtype Information a = Bits { forall a. Information a -> a
numberOfBits :: a }
   deriving (Information a -> Information a -> Bool
(Information a -> Information a -> Bool)
-> (Information a -> Information a -> Bool) -> Eq (Information a)
forall a. Eq a => Information a -> Information a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Information a -> Information a -> Bool
== :: Information a -> Information a -> Bool
$c/= :: forall a. Eq a => Information a -> Information a -> Bool
/= :: Information a -> Information a -> Bool
Eq,Eq (Information a)
Eq (Information a) =>
(Information a -> Information a -> Ordering)
-> (Information a -> Information a -> Bool)
-> (Information a -> Information a -> Bool)
-> (Information a -> Information a -> Bool)
-> (Information a -> Information a -> Bool)
-> (Information a -> Information a -> Information a)
-> (Information a -> Information a -> Information a)
-> Ord (Information a)
Information a -> Information a -> Bool
Information a -> Information a -> Ordering
Information a -> Information a -> Information a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Information a)
forall a. Ord a => Information a -> Information a -> Bool
forall a. Ord a => Information a -> Information a -> Ordering
forall a. Ord a => Information a -> Information a -> Information a
$ccompare :: forall a. Ord a => Information a -> Information a -> Ordering
compare :: Information a -> Information a -> Ordering
$c< :: forall a. Ord a => Information a -> Information a -> Bool
< :: Information a -> Information a -> Bool
$c<= :: forall a. Ord a => Information a -> Information a -> Bool
<= :: Information a -> Information a -> Bool
$c> :: forall a. Ord a => Information a -> Information a -> Bool
> :: Information a -> Information a -> Bool
$c>= :: forall a. Ord a => Information a -> Information a -> Bool
>= :: Information a -> Information a -> Bool
$cmax :: forall a. Ord a => Information a -> Information a -> Information a
max :: Information a -> Information a -> Information a
$cmin :: forall a. Ord a => Information a -> Information a -> Information a
min :: Information a -> Information a -> Information a
Ord, Typeable (Information a)
Typeable (Information a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Information a -> c (Information a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Information a))
-> (Information a -> Constr)
-> (Information a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Information a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Information a)))
-> ((forall b. Data b => b -> b) -> Information a -> Information a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Information a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Information a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Information a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Information a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Information a -> m (Information a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Information a -> m (Information a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Information a -> m (Information a))
-> Data (Information a)
Information a -> Constr
Information a -> DataType
(forall b. Data b => b -> b) -> Information a -> Information a
forall a. Data a => Typeable (Information a)
forall a. Data a => Information a -> Constr
forall a. Data a => Information a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Information a -> Information a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Information a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Information a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Information a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Information a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Information a -> m (Information a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Information a -> m (Information a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Information a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Information a -> c (Information a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Information a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Information a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Information a -> u
forall u. (forall d. Data d => d -> u) -> Information a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Information a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Information a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Information a -> m (Information a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Information a -> m (Information a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Information a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Information a -> c (Information a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Information a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Information a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Information a -> c (Information a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Information a -> c (Information a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Information a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Information a)
$ctoConstr :: forall a. Data a => Information a -> Constr
toConstr :: Information a -> Constr
$cdataTypeOf :: forall a. Data a => Information a -> DataType
dataTypeOf :: Information a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Information a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Information a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Information a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Information a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Information a -> Information a
gmapT :: (forall b. Data b => b -> b) -> Information a -> Information a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Information a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Information a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Information a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Information a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Information a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Information a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Information a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Information a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Information a -> m (Information a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Information a -> m (Information a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Information a -> m (Information a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Information a -> m (Information a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Information a -> m (Information a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Information a -> m (Information a)
Data,(forall x. Information a -> Rep (Information a) x)
-> (forall x. Rep (Information a) x -> Information a)
-> Generic (Information a)
forall x. Rep (Information a) x -> Information a
forall x. Information a -> Rep (Information a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Information a) x -> Information a
forall a x. Information a -> Rep (Information a) x
$cfrom :: forall a x. Information a -> Rep (Information a) x
from :: forall x. Information a -> Rep (Information a) x
$cto :: forall a x. Rep (Information a) x -> Information a
to :: forall x. Rep (Information a) x -> Information a
Generic, Typeable)
   deriving newtype (Get (Information a)
[Information a] -> Put
Information a -> Put
(Information a -> Put)
-> Get (Information a)
-> ([Information a] -> Put)
-> Binary (Information a)
forall a. Binary a => Get (Information a)
forall a. Binary a => [Information a] -> Put
forall a. Binary a => Information a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Information a -> Put
put :: Information a -> Put
$cget :: forall a. Binary a => Get (Information a)
get :: Get (Information a)
$cputList :: forall a. Binary a => [Information a] -> Put
putList :: [Information a] -> Put
Binary)
 instance (Num a, Show a) => Show ( Information  a) where { show :: Information a -> String
show = Information a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 instance (Num a, Show a) => Unit (Information a) where
    amount :: Information a -> Scalar (Information a)
amount = Information a -> a
Information a -> Scalar (Information a)
forall a. Information a -> a
numberOfBits
    dimension :: Information a -> Dimension
dimension Information a
_ = Dimension
dimensionless
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Information a)) -> m (Information a)
fromQuantity = Dimension
-> (a -> Information a) -> Quantity a -> m (Information a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
dimensionless a -> Information a
forall a. a -> Information a
Bits
    unitOf :: Information a -> String
unitOf Information a
_ = String
"b"
 instance (Show a, Num a) => LiteralUnit (Information a) where { fromAmount :: Scalar (Information a) -> Information a
fromAmount = a -> Information a
Scalar (Information a) -> Information a
forall a. a -> Information a
Bits }
  
 newtype SoundLevel a = SoundAmplitude { forall a. SoundLevel a -> a
soundAmplitude :: a }
   deriving (SoundLevel a -> SoundLevel a -> Bool
(SoundLevel a -> SoundLevel a -> Bool)
-> (SoundLevel a -> SoundLevel a -> Bool) -> Eq (SoundLevel a)
forall a. Eq a => SoundLevel a -> SoundLevel a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => SoundLevel a -> SoundLevel a -> Bool
== :: SoundLevel a -> SoundLevel a -> Bool
$c/= :: forall a. Eq a => SoundLevel a -> SoundLevel a -> Bool
/= :: SoundLevel a -> SoundLevel a -> Bool
Eq, Eq (SoundLevel a)
Eq (SoundLevel a) =>
(SoundLevel a -> SoundLevel a -> Ordering)
-> (SoundLevel a -> SoundLevel a -> Bool)
-> (SoundLevel a -> SoundLevel a -> Bool)
-> (SoundLevel a -> SoundLevel a -> Bool)
-> (SoundLevel a -> SoundLevel a -> Bool)
-> (SoundLevel a -> SoundLevel a -> SoundLevel a)
-> (SoundLevel a -> SoundLevel a -> SoundLevel a)
-> Ord (SoundLevel a)
SoundLevel a -> SoundLevel a -> Bool
SoundLevel a -> SoundLevel a -> Ordering
SoundLevel a -> SoundLevel a -> SoundLevel a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (SoundLevel a)
forall a. Ord a => SoundLevel a -> SoundLevel a -> Bool
forall a. Ord a => SoundLevel a -> SoundLevel a -> Ordering
forall a. Ord a => SoundLevel a -> SoundLevel a -> SoundLevel a
$ccompare :: forall a. Ord a => SoundLevel a -> SoundLevel a -> Ordering
compare :: SoundLevel a -> SoundLevel a -> Ordering
$c< :: forall a. Ord a => SoundLevel a -> SoundLevel a -> Bool
< :: SoundLevel a -> SoundLevel a -> Bool
$c<= :: forall a. Ord a => SoundLevel a -> SoundLevel a -> Bool
<= :: SoundLevel a -> SoundLevel a -> Bool
$c> :: forall a. Ord a => SoundLevel a -> SoundLevel a -> Bool
> :: SoundLevel a -> SoundLevel a -> Bool
$c>= :: forall a. Ord a => SoundLevel a -> SoundLevel a -> Bool
>= :: SoundLevel a -> SoundLevel a -> Bool
$cmax :: forall a. Ord a => SoundLevel a -> SoundLevel a -> SoundLevel a
max :: SoundLevel a -> SoundLevel a -> SoundLevel a
$cmin :: forall a. Ord a => SoundLevel a -> SoundLevel a -> SoundLevel a
min :: SoundLevel a -> SoundLevel a -> SoundLevel a
Ord, Typeable, Typeable (SoundLevel a)
Typeable (SoundLevel a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SoundLevel a -> c (SoundLevel a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (SoundLevel a))
-> (SoundLevel a -> Constr)
-> (SoundLevel a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (SoundLevel a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (SoundLevel a)))
-> ((forall b. Data b => b -> b) -> SoundLevel a -> SoundLevel a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SoundLevel a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SoundLevel a -> r)
-> (forall u. (forall d. Data d => d -> u) -> SoundLevel a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SoundLevel a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SoundLevel a -> m (SoundLevel a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SoundLevel a -> m (SoundLevel a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SoundLevel a -> m (SoundLevel a))
-> Data (SoundLevel a)
SoundLevel a -> Constr
SoundLevel a -> DataType
(forall b. Data b => b -> b) -> SoundLevel a -> SoundLevel a
forall a. Data a => Typeable (SoundLevel a)
forall a. Data a => SoundLevel a -> Constr
forall a. Data a => SoundLevel a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> SoundLevel a -> SoundLevel a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> SoundLevel a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> SoundLevel a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SoundLevel a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SoundLevel a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> SoundLevel a -> m (SoundLevel a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SoundLevel a -> m (SoundLevel a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SoundLevel a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SoundLevel a -> c (SoundLevel a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SoundLevel a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SoundLevel a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SoundLevel a -> u
forall u. (forall d. Data d => d -> u) -> SoundLevel a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SoundLevel a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SoundLevel a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SoundLevel a -> m (SoundLevel a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SoundLevel a -> m (SoundLevel a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SoundLevel a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SoundLevel a -> c (SoundLevel a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SoundLevel a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SoundLevel a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SoundLevel a -> c (SoundLevel a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SoundLevel a -> c (SoundLevel a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SoundLevel a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SoundLevel a)
$ctoConstr :: forall a. Data a => SoundLevel a -> Constr
toConstr :: SoundLevel a -> Constr
$cdataTypeOf :: forall a. Data a => SoundLevel a -> DataType
dataTypeOf :: SoundLevel a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SoundLevel a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SoundLevel a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SoundLevel a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SoundLevel a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> SoundLevel a -> SoundLevel a
gmapT :: (forall b. Data b => b -> b) -> SoundLevel a -> SoundLevel a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SoundLevel a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SoundLevel a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SoundLevel a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SoundLevel a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> SoundLevel a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SoundLevel a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> SoundLevel a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SoundLevel a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> SoundLevel a -> m (SoundLevel a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SoundLevel a -> m (SoundLevel a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SoundLevel a -> m (SoundLevel a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SoundLevel a -> m (SoundLevel a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SoundLevel a -> m (SoundLevel a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SoundLevel a -> m (SoundLevel a)
Data, (forall x. SoundLevel a -> Rep (SoundLevel a) x)
-> (forall x. Rep (SoundLevel a) x -> SoundLevel a)
-> Generic (SoundLevel a)
forall x. Rep (SoundLevel a) x -> SoundLevel a
forall x. SoundLevel a -> Rep (SoundLevel a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (SoundLevel a) x -> SoundLevel a
forall a x. SoundLevel a -> Rep (SoundLevel a) x
$cfrom :: forall a x. SoundLevel a -> Rep (SoundLevel a) x
from :: forall x. SoundLevel a -> Rep (SoundLevel a) x
$cto :: forall a x. Rep (SoundLevel a) x -> SoundLevel a
to :: forall x. Rep (SoundLevel a) x -> SoundLevel a
Generic)
   deriving newtype (Get (SoundLevel a)
[SoundLevel a] -> Put
SoundLevel a -> Put
(SoundLevel a -> Put)
-> Get (SoundLevel a)
-> ([SoundLevel a] -> Put)
-> Binary (SoundLevel a)
forall a. Binary a => Get (SoundLevel a)
forall a. Binary a => [SoundLevel a] -> Put
forall a. Binary a => SoundLevel a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => SoundLevel a -> Put
put :: SoundLevel a -> Put
$cget :: forall a. Binary a => Get (SoundLevel a)
get :: Get (SoundLevel a)
$cputList :: forall a. Binary a => [SoundLevel a] -> Put
putList :: [SoundLevel a] -> Put
Binary)

 instance (Floating a, Show a) => Show ( SoundLevel  a) where { show :: SoundLevel a -> String
show = SoundLevel a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }
 -- | NOTE: additive operations mapped to multiplicative.
 -- Notice this reduces the possible range of SoundLevel values
 -- to around -300..300 dB based on possible exponents in Double.
 instance (Floating a) => VectorSpace (SoundLevel a) where
    type Scalar (SoundLevel a) = a
    vzero :: SoundLevel a
vzero = a -> SoundLevel a
forall a. a -> SoundLevel a
SoundAmplitude a
1
    vnegate :: SoundLevel a -> SoundLevel a
vnegate (SoundAmplitude a
x) = a -> SoundLevel a
forall a. a -> SoundLevel a
SoundAmplitude (a
1a -> a -> a
forall a. Fractional a => a -> a -> a
/a
x)
    (SoundAmplitude a
x) %+ :: SoundLevel a -> SoundLevel a -> SoundLevel a
%+ (SoundAmplitude a
y) = a -> SoundLevel a
forall a. a -> SoundLevel a
SoundAmplitude (a
x a -> a -> a
forall a. Num a => a -> a -> a
* a
y)
    Scalar (SoundLevel a)
k %* :: Scalar (SoundLevel a) -> SoundLevel a -> SoundLevel a
%* (SoundAmplitude a
x) = a -> SoundLevel a
forall a. a -> SoundLevel a
SoundAmplitude (a
x a -> a -> a
forall a. Floating a => a -> a -> a
** a
Scalar (SoundLevel a)
k)

 instance (Floating a, Show a) => Unit (SoundLevel a) where
    amount :: SoundLevel a -> Scalar (SoundLevel a)
amount SoundLevel a
x = a -> a
forall a. Floating a => a -> a
log (SoundLevel a -> a
forall a. SoundLevel a -> a
soundAmplitude SoundLevel a
x) a -> a -> a
forall a. Fractional a => a -> a -> a
/ a -> a
forall a. Floating a => a -> a
log a
10
    dimension :: SoundLevel a -> Dimension
dimension SoundLevel a
_ = Dimension
dimensionless
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (SoundLevel a)) -> m (SoundLevel a)
fromQuantity = Dimension -> (a -> SoundLevel a) -> Quantity a -> m (SoundLevel a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
dimensionless a -> SoundLevel a
Scalar (SoundLevel a) -> SoundLevel a
forall u. LiteralUnit u => Scalar u -> u
fromAmount
    unitOf :: SoundLevel a -> String
unitOf SoundLevel a
_ = String
"dB"
 instance (Show a, Floating a) => LiteralUnit (SoundLevel a) where { fromAmount :: Scalar (SoundLevel a) -> SoundLevel a
fromAmount = a -> SoundLevel a
forall a. a -> SoundLevel a
SoundAmplitude (a -> SoundLevel a) -> (a -> a) -> a -> SoundLevel a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a
10.0 a -> a -> a
forall a. Floating a => a -> a -> a
**) }

 newtype Angle a = Radians { forall a. Angle a -> a
radians :: a }
    deriving (Angle a -> Angle a -> Bool
(Angle a -> Angle a -> Bool)
-> (Angle a -> Angle a -> Bool) -> Eq (Angle a)
forall a. Eq a => Angle a -> Angle a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Angle a -> Angle a -> Bool
== :: Angle a -> Angle a -> Bool
$c/= :: forall a. Eq a => Angle a -> Angle a -> Bool
/= :: Angle a -> Angle a -> Bool
Eq,Eq (Angle a)
Eq (Angle a) =>
(Angle a -> Angle a -> Ordering)
-> (Angle a -> Angle a -> Bool)
-> (Angle a -> Angle a -> Bool)
-> (Angle a -> Angle a -> Bool)
-> (Angle a -> Angle a -> Bool)
-> (Angle a -> Angle a -> Angle a)
-> (Angle a -> Angle a -> Angle a)
-> Ord (Angle a)
Angle a -> Angle a -> Bool
Angle a -> Angle a -> Ordering
Angle a -> Angle a -> Angle a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Angle a)
forall a. Ord a => Angle a -> Angle a -> Bool
forall a. Ord a => Angle a -> Angle a -> Ordering
forall a. Ord a => Angle a -> Angle a -> Angle a
$ccompare :: forall a. Ord a => Angle a -> Angle a -> Ordering
compare :: Angle a -> Angle a -> Ordering
$c< :: forall a. Ord a => Angle a -> Angle a -> Bool
< :: Angle a -> Angle a -> Bool
$c<= :: forall a. Ord a => Angle a -> Angle a -> Bool
<= :: Angle a -> Angle a -> Bool
$c> :: forall a. Ord a => Angle a -> Angle a -> Bool
> :: Angle a -> Angle a -> Bool
$c>= :: forall a. Ord a => Angle a -> Angle a -> Bool
>= :: Angle a -> Angle a -> Bool
$cmax :: forall a. Ord a => Angle a -> Angle a -> Angle a
max :: Angle a -> Angle a -> Angle a
$cmin :: forall a. Ord a => Angle a -> Angle a -> Angle a
min :: Angle a -> Angle a -> Angle a
Ord, Typeable, Typeable (Angle a)
Typeable (Angle a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Angle a -> c (Angle a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Angle a))
-> (Angle a -> Constr)
-> (Angle a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Angle a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Angle a)))
-> ((forall b. Data b => b -> b) -> Angle a -> Angle a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Angle a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Angle a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Angle a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Angle a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Angle a -> m (Angle a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Angle a -> m (Angle a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Angle a -> m (Angle a))
-> Data (Angle a)
Angle a -> Constr
Angle a -> DataType
(forall b. Data b => b -> b) -> Angle a -> Angle a
forall a. Data a => Typeable (Angle a)
forall a. Data a => Angle a -> Constr
forall a. Data a => Angle a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Angle a -> Angle a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Angle a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Angle a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Angle a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Angle a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Angle a -> m (Angle a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Angle a -> m (Angle a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Angle a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Angle a -> c (Angle a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Angle a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Angle a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Angle a -> u
forall u. (forall d. Data d => d -> u) -> Angle a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Angle a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Angle a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Angle a -> m (Angle a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Angle a -> m (Angle a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Angle a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Angle a -> c (Angle a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Angle a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Angle a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Angle a -> c (Angle a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Angle a -> c (Angle a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Angle a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Angle a)
$ctoConstr :: forall a. Data a => Angle a -> Constr
toConstr :: Angle a -> Constr
$cdataTypeOf :: forall a. Data a => Angle a -> DataType
dataTypeOf :: Angle a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Angle a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Angle a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Angle a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Angle a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Angle a -> Angle a
gmapT :: (forall b. Data b => b -> b) -> Angle a -> Angle a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Angle a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Angle a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Angle a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Angle a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Angle a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Angle a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Angle a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Angle a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Angle a -> m (Angle a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Angle a -> m (Angle a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Angle a -> m (Angle a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Angle a -> m (Angle a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Angle a -> m (Angle a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Angle a -> m (Angle a)
Data, (forall x. Angle a -> Rep (Angle a) x)
-> (forall x. Rep (Angle a) x -> Angle a) -> Generic (Angle a)
forall x. Rep (Angle a) x -> Angle a
forall x. Angle a -> Rep (Angle a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Angle a) x -> Angle a
forall a x. Angle a -> Rep (Angle a) x
$cfrom :: forall a x. Angle a -> Rep (Angle a) x
from :: forall x. Angle a -> Rep (Angle a) x
$cto :: forall a x. Rep (Angle a) x -> Angle a
to :: forall x. Rep (Angle a) x -> Angle a
Generic)
    deriving newtype (Get (Angle a)
[Angle a] -> Put
Angle a -> Put
(Angle a -> Put)
-> Get (Angle a) -> ([Angle a] -> Put) -> Binary (Angle a)
forall a. Binary a => Get (Angle a)
forall a. Binary a => [Angle a] -> Put
forall a. Binary a => Angle a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Angle a -> Put
put :: Angle a -> Put
$cget :: forall a. Binary a => Get (Angle a)
get :: Get (Angle a)
$cputList :: forall a. Binary a => [Angle a] -> Put
putList :: [Angle a] -> Put
Binary, Integer -> Angle a
Angle a -> Angle a
Angle a -> Angle a -> Angle a
(Angle a -> Angle a -> Angle a)
-> (Angle a -> Angle a -> Angle a)
-> (Angle a -> Angle a -> Angle a)
-> (Angle a -> Angle a)
-> (Angle a -> Angle a)
-> (Angle a -> Angle a)
-> (Integer -> Angle a)
-> Num (Angle a)
forall a. Num a => Integer -> Angle a
forall a. Num a => Angle a -> Angle a
forall a. Num a => Angle a -> Angle a -> Angle a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: forall a. Num a => Angle a -> Angle a -> Angle a
+ :: Angle a -> Angle a -> Angle a
$c- :: forall a. Num a => Angle a -> Angle a -> Angle a
- :: Angle a -> Angle a -> Angle a
$c* :: forall a. Num a => Angle a -> Angle a -> Angle a
* :: Angle a -> Angle a -> Angle a
$cnegate :: forall a. Num a => Angle a -> Angle a
negate :: Angle a -> Angle a
$cabs :: forall a. Num a => Angle a -> Angle a
abs :: Angle a -> Angle a
$csignum :: forall a. Num a => Angle a -> Angle a
signum :: Angle a -> Angle a
$cfromInteger :: forall a. Num a => Integer -> Angle a
fromInteger :: Integer -> Angle a
Num, Num (Angle a)
Num (Angle a) =>
(Angle a -> Angle a -> Angle a)
-> (Angle a -> Angle a)
-> (Rational -> Angle a)
-> Fractional (Angle a)
Rational -> Angle a
Angle a -> Angle a
Angle a -> Angle a -> Angle a
forall a. Fractional a => Num (Angle a)
forall a. Fractional a => Rational -> Angle a
forall a. Fractional a => Angle a -> Angle a
forall a. Fractional a => Angle a -> Angle a -> Angle a
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
$c/ :: forall a. Fractional a => Angle a -> Angle a -> Angle a
/ :: Angle a -> Angle a -> Angle a
$crecip :: forall a. Fractional a => Angle a -> Angle a
recip :: Angle a -> Angle a
$cfromRational :: forall a. Fractional a => Rational -> Angle a
fromRational :: Rational -> Angle a
Fractional)

 instance Functor Angle where
   fmap :: forall a b. (a -> b) -> Angle a -> Angle b
fmap a -> b
f (Radians a
x) = b -> Angle b
forall a. a -> Angle a
Radians (a -> b
f a
x)

 instance (Show a, Num a) => Show (Angle a) where { show :: Angle a -> String
show = Angle a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 class (Functor angle) => DimensionalFloating angle where
   halfRotation :: angle Double
   fullRotation :: angle Double
   fractionOfRotation :: Rational -> angle Double
   dimSin :: (Floating a) => angle a -> a
   dimCos :: (Floating a) => angle a -> a
   dimTan :: (Floating a) => angle a -> a
   dimAsin :: (Floating a) => a -> angle a
   dimAcos :: (Floating a) => a -> angle a
   dimAtan :: (Floating a) => a -> angle a
   dimLog :: (RealFloat a) => Complex a -> angle a
   dimExp :: (RealFloat a) => angle a -> Complex a
   dimFromPolar :: (RealFloat a) => a -> angle a -> Complex a
   dimToPolar :: (RealFloat a) => Complex a -> (a, angle a)
   fullRotation = Rational -> angle Double
forall (angle :: * -> *).
DimensionalFloating angle =>
Rational -> angle Double
fractionOfRotation (Integer
1 Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
1)
   halfRotation = Rational -> angle Double
forall (angle :: * -> *).
DimensionalFloating angle =>
Rational -> angle Double
fractionOfRotation (Integer
1 Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
2)

 instance DimensionalFloating Angle where
   halfRotation :: Angle Double
halfRotation = Angle Double
piAngle
   fullRotation :: Angle Double
fullRotation = Rational -> Double
forall a. Fractional a => Rational -> a
fromRational Rational
2 Scalar (Angle Double) -> Angle Double -> Angle Double
forall v. VectorSpace v => Scalar v -> v -> v
%* Angle Double
forall (angle :: * -> *). DimensionalFloating angle => angle Double
halfRotation
   fractionOfRotation :: Rational -> Angle Double
fractionOfRotation Rational
q = Rational -> Double
forall a. Fractional a => Rational -> a
fromRational Rational
q Scalar (Angle Double) -> Angle Double -> Angle Double
forall v. VectorSpace v => Scalar v -> v -> v
%* Angle Double
forall (angle :: * -> *). DimensionalFloating angle => angle Double
fullRotation
   dimSin :: forall a. Floating a => Angle a -> a
dimSin = Angle a -> a
forall a. Floating a => Angle a -> a
sinAngle
   dimCos :: forall a. Floating a => Angle a -> a
dimCos = Angle a -> a
forall a. Floating a => Angle a -> a
cosAngle
   dimTan :: forall a. Floating a => Angle a -> a
dimTan = Angle a -> a
forall a. Floating a => Angle a -> a
tanAngle
   dimAsin :: forall a. Floating a => a -> Angle a
dimAsin = a -> Angle a
forall a. Floating a => a -> Angle a
asinAngle
   dimAcos :: forall a. Floating a => a -> Angle a
dimAcos = a -> Angle a
forall a. Floating a => a -> Angle a
acosAngle
   dimAtan :: forall a. Floating a => a -> Angle a
dimAtan = a -> Angle a
forall a. Floating a => a -> Angle a
atanAngle
   dimLog :: forall a. RealFloat a => Complex a -> Angle a
dimLog = Complex a -> Angle a
forall a. RealFloat a => Complex a -> Angle a
logAngle
   dimExp :: forall a. RealFloat a => Angle a -> Complex a
dimExp = Angle a -> Complex a
forall a. Floating a => Angle a -> Complex a
expAngle
   dimFromPolar :: forall a. RealFloat a => a -> Angle a -> Complex a
dimFromPolar a
r (Radians a
alfa) = (a
r a -> a -> a
forall a. Num a => a -> a -> a
* a -> a
forall a. Floating a => a -> a
cos a
alfa) a -> a -> Complex a
forall a. a -> a -> Complex a
:+ (a
r a -> a -> a
forall a. Num a => a -> a -> a
* a -> a
forall a. Floating a => a -> a
sin a
alfa)
   dimToPolar :: forall a. RealFloat a => Complex a -> (a, Angle a)
dimToPolar (a
a :+ a
b) = (a -> a
forall a. Floating a => a -> a
sqrt (a
aa -> a -> a
forall a. Num a => a -> a -> a
*a
aa -> a -> a
forall a. Num a => a -> a -> a
+a
ba -> a -> a
forall a. Num a => a -> a -> a
*a
b), a -> Angle a
forall a. a -> Angle a
Radians (a -> a -> a
forall a. RealFloat a => a -> a -> a
atan2 a
b a
a))
  
 piAngle :: Angle Double
 piAngle :: Angle Double
piAngle = Double -> Angle Double
forall a. a -> Angle a
Radians Double
forall a. Floating a => a
pi

 fraction_of_circle :: Rational -> Angle Double
 fraction_of_circle :: Rational -> Angle Double
fraction_of_circle Rational
r = Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational
2Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
*Rational
r) Scalar (Angle Double) -> Angle Double -> Angle Double
forall v. VectorSpace v => Scalar v -> v -> v
%* Angle Double
piAngle

 asinAngle :: (Floating a) => a -> Angle a
 asinAngle :: forall a. Floating a => a -> Angle a
asinAngle = a -> Angle a
forall a. a -> Angle a
Radians (a -> Angle a) -> (a -> a) -> a -> Angle a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a
forall a. Floating a => a -> a
asin

 acosAngle :: (Floating a) => a -> Angle a
 acosAngle :: forall a. Floating a => a -> Angle a
acosAngle = a -> Angle a
forall a. a -> Angle a
Radians (a -> Angle a) -> (a -> a) -> a -> Angle a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a
forall a. Floating a => a -> a
acos
 
 atanAngle :: (Floating a) => a -> Angle a
 atanAngle :: forall a. Floating a => a -> Angle a
atanAngle = a -> Angle a
forall a. a -> Angle a
Radians (a -> Angle a) -> (a -> a) -> a -> Angle a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a
forall a. Floating a => a -> a
atan

 sinAngle :: (Floating a) => Angle a -> a
 sinAngle :: forall a. Floating a => Angle a -> a
sinAngle = a -> a
forall a. Floating a => a -> a
sin (a -> a) -> (Angle a -> a) -> Angle a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Angle a -> a
forall a. Angle a -> a
radians

 cosAngle :: (Floating a) => Angle a -> a
 cosAngle :: forall a. Floating a => Angle a -> a
cosAngle = a -> a
forall a. Floating a => a -> a
cos (a -> a) -> (Angle a -> a) -> Angle a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Angle a -> a
forall a. Angle a -> a
radians
 
 tanAngle :: (Floating a) => Angle a -> a
 tanAngle :: forall a. Floating a => Angle a -> a
tanAngle = a -> a
forall a. Floating a => a -> a
tan (a -> a) -> (Angle a -> a) -> Angle a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Angle a -> a
forall a. Angle a -> a
radians

 logAngle :: (RealFloat a) => Complex a -> Angle a
 logAngle :: forall a. RealFloat a => Complex a -> Angle a
logAngle = a -> Angle a
forall a. a -> Angle a
Radians (a -> Angle a) -> (Complex a -> a) -> Complex a -> Angle a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Complex a -> a
forall a. RealFloat a => Complex a -> a
phase

 expAngle :: (Floating a) => Angle a -> Complex a
 expAngle :: forall a. Floating a => Angle a -> Complex a
expAngle (Radians a
x) = (a -> a
forall a. Floating a => a -> a
cos a
x a -> a -> Complex a
forall a. a -> a -> Complex a
:+ a -> a
forall a. Floating a => a -> a
sin a
x)
 
 fromPolar :: (Unit u, Floating (Scalar u)) => u -> Angle (Scalar u) -> Complex u
 fromPolar :: forall u.
(Unit u, Floating (Scalar u)) =>
u -> Angle (Scalar u) -> Complex u
fromPolar u
r (Radians Scalar u
alfa) = (Scalar u -> Scalar u
forall a. Floating a => a -> a
cos Scalar u
alfa Scalar u -> u -> u
forall v. VectorSpace v => Scalar v -> v -> v
%* u
r u -> u -> Complex u
forall a. a -> a -> Complex a
:+ Scalar u -> Scalar u
forall a. Floating a => a -> a
sin Scalar u
alfa Scalar u -> u -> u
forall v. VectorSpace v => Scalar v -> v -> v
%* u
r)

 toPolar :: (LiteralUnit u, RealFloat (Scalar u)) => Complex u -> (u, Angle (Scalar u))
 toPolar :: forall u.
(LiteralUnit u, RealFloat (Scalar u)) =>
Complex u -> (u, Angle (Scalar u))
toPolar z :: Complex u
z@((u
a :: u) :+ u
b) = (Scalar u -> u
forall u. LiteralUnit u => Scalar u -> u
fromAmount (Scalar u -> Scalar u
forall a. Floating a => a -> a
sqrt (Scalar u
a'Scalar u -> Scalar u -> Scalar u
forall a. Num a => a -> a -> a
*Scalar u
a' Scalar u -> Scalar u -> Scalar u
forall a. Num a => a -> a -> a
+ Scalar u
b'Scalar u -> Scalar u -> Scalar u
forall a. Num a => a -> a -> a
*Scalar u
b')) :: u , Scalar u -> Angle (Scalar u)
forall a. a -> Angle a
Radians (Scalar u -> Angle (Scalar u)) -> Scalar u -> Angle (Scalar u)
forall a b. (a -> b) -> a -> b
$ Scalar u -> Scalar u -> Scalar u
forall a. RealFloat a => a -> a -> a
atan2 Scalar u
b' Scalar u
a')
    where a' :: Scalar u
a' = u -> Scalar u
forall u. Unit u => u -> Scalar u
amount u
a
          b' :: Scalar u
b' = u -> Scalar u
forall u. Unit u => u -> Scalar u
amount u
b

 newtype DegreesAngle a = Degrees { forall a. DegreesAngle a -> a
degrees :: a }
    deriving (DegreesAngle a -> DegreesAngle a -> Bool
(DegreesAngle a -> DegreesAngle a -> Bool)
-> (DegreesAngle a -> DegreesAngle a -> Bool)
-> Eq (DegreesAngle a)
forall a. Eq a => DegreesAngle a -> DegreesAngle a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => DegreesAngle a -> DegreesAngle a -> Bool
== :: DegreesAngle a -> DegreesAngle a -> Bool
$c/= :: forall a. Eq a => DegreesAngle a -> DegreesAngle a -> Bool
/= :: DegreesAngle a -> DegreesAngle a -> Bool
Eq,Eq (DegreesAngle a)
Eq (DegreesAngle a) =>
(DegreesAngle a -> DegreesAngle a -> Ordering)
-> (DegreesAngle a -> DegreesAngle a -> Bool)
-> (DegreesAngle a -> DegreesAngle a -> Bool)
-> (DegreesAngle a -> DegreesAngle a -> Bool)
-> (DegreesAngle a -> DegreesAngle a -> Bool)
-> (DegreesAngle a -> DegreesAngle a -> DegreesAngle a)
-> (DegreesAngle a -> DegreesAngle a -> DegreesAngle a)
-> Ord (DegreesAngle a)
DegreesAngle a -> DegreesAngle a -> Bool
DegreesAngle a -> DegreesAngle a -> Ordering
DegreesAngle a -> DegreesAngle a -> DegreesAngle a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (DegreesAngle a)
forall a. Ord a => DegreesAngle a -> DegreesAngle a -> Bool
forall a. Ord a => DegreesAngle a -> DegreesAngle a -> Ordering
forall a.
Ord a =>
DegreesAngle a -> DegreesAngle a -> DegreesAngle a
$ccompare :: forall a. Ord a => DegreesAngle a -> DegreesAngle a -> Ordering
compare :: DegreesAngle a -> DegreesAngle a -> Ordering
$c< :: forall a. Ord a => DegreesAngle a -> DegreesAngle a -> Bool
< :: DegreesAngle a -> DegreesAngle a -> Bool
$c<= :: forall a. Ord a => DegreesAngle a -> DegreesAngle a -> Bool
<= :: DegreesAngle a -> DegreesAngle a -> Bool
$c> :: forall a. Ord a => DegreesAngle a -> DegreesAngle a -> Bool
> :: DegreesAngle a -> DegreesAngle a -> Bool
$c>= :: forall a. Ord a => DegreesAngle a -> DegreesAngle a -> Bool
>= :: DegreesAngle a -> DegreesAngle a -> Bool
$cmax :: forall a.
Ord a =>
DegreesAngle a -> DegreesAngle a -> DegreesAngle a
max :: DegreesAngle a -> DegreesAngle a -> DegreesAngle a
$cmin :: forall a.
Ord a =>
DegreesAngle a -> DegreesAngle a -> DegreesAngle a
min :: DegreesAngle a -> DegreesAngle a -> DegreesAngle a
Ord, Typeable, Typeable (DegreesAngle a)
Typeable (DegreesAngle a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DegreesAngle a -> c (DegreesAngle a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DegreesAngle a))
-> (DegreesAngle a -> Constr)
-> (DegreesAngle a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DegreesAngle a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DegreesAngle a)))
-> ((forall b. Data b => b -> b)
    -> DegreesAngle a -> DegreesAngle a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DegreesAngle a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DegreesAngle a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DegreesAngle a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DegreesAngle a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DegreesAngle a -> m (DegreesAngle a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DegreesAngle a -> m (DegreesAngle a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DegreesAngle a -> m (DegreesAngle a))
-> Data (DegreesAngle a)
DegreesAngle a -> Constr
DegreesAngle a -> DataType
(forall b. Data b => b -> b) -> DegreesAngle a -> DegreesAngle a
forall a. Data a => Typeable (DegreesAngle a)
forall a. Data a => DegreesAngle a -> Constr
forall a. Data a => DegreesAngle a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> DegreesAngle a -> DegreesAngle a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> DegreesAngle a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> DegreesAngle a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesAngle a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesAngle a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> DegreesAngle a -> m (DegreesAngle a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DegreesAngle a -> m (DegreesAngle a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DegreesAngle a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DegreesAngle a -> c (DegreesAngle a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DegreesAngle a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DegreesAngle a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DegreesAngle a -> u
forall u. (forall d. Data d => d -> u) -> DegreesAngle a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesAngle a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesAngle a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DegreesAngle a -> m (DegreesAngle a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DegreesAngle a -> m (DegreesAngle a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DegreesAngle a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DegreesAngle a -> c (DegreesAngle a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DegreesAngle a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DegreesAngle a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DegreesAngle a -> c (DegreesAngle a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DegreesAngle a -> c (DegreesAngle a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DegreesAngle a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DegreesAngle a)
$ctoConstr :: forall a. Data a => DegreesAngle a -> Constr
toConstr :: DegreesAngle a -> Constr
$cdataTypeOf :: forall a. Data a => DegreesAngle a -> DataType
dataTypeOf :: DegreesAngle a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DegreesAngle a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DegreesAngle a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DegreesAngle a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DegreesAngle a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> DegreesAngle a -> DegreesAngle a
gmapT :: (forall b. Data b => b -> b) -> DegreesAngle a -> DegreesAngle a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesAngle a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesAngle a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesAngle a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesAngle a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> DegreesAngle a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DegreesAngle a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> DegreesAngle a -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DegreesAngle a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> DegreesAngle a -> m (DegreesAngle a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DegreesAngle a -> m (DegreesAngle a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DegreesAngle a -> m (DegreesAngle a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DegreesAngle a -> m (DegreesAngle a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DegreesAngle a -> m (DegreesAngle a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DegreesAngle a -> m (DegreesAngle a)
Data, (forall x. DegreesAngle a -> Rep (DegreesAngle a) x)
-> (forall x. Rep (DegreesAngle a) x -> DegreesAngle a)
-> Generic (DegreesAngle a)
forall x. Rep (DegreesAngle a) x -> DegreesAngle a
forall x. DegreesAngle a -> Rep (DegreesAngle a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (DegreesAngle a) x -> DegreesAngle a
forall a x. DegreesAngle a -> Rep (DegreesAngle a) x
$cfrom :: forall a x. DegreesAngle a -> Rep (DegreesAngle a) x
from :: forall x. DegreesAngle a -> Rep (DegreesAngle a) x
$cto :: forall a x. Rep (DegreesAngle a) x -> DegreesAngle a
to :: forall x. Rep (DegreesAngle a) x -> DegreesAngle a
Generic)
    deriving newtype (Get (DegreesAngle a)
[DegreesAngle a] -> Put
DegreesAngle a -> Put
(DegreesAngle a -> Put)
-> Get (DegreesAngle a)
-> ([DegreesAngle a] -> Put)
-> Binary (DegreesAngle a)
forall a. Binary a => Get (DegreesAngle a)
forall a. Binary a => [DegreesAngle a] -> Put
forall a. Binary a => DegreesAngle a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => DegreesAngle a -> Put
put :: DegreesAngle a -> Put
$cget :: forall a. Binary a => Get (DegreesAngle a)
get :: Get (DegreesAngle a)
$cputList :: forall a. Binary a => [DegreesAngle a] -> Put
putList :: [DegreesAngle a] -> Put
Binary, Integer -> DegreesAngle a
DegreesAngle a -> DegreesAngle a
DegreesAngle a -> DegreesAngle a -> DegreesAngle a
(DegreesAngle a -> DegreesAngle a -> DegreesAngle a)
-> (DegreesAngle a -> DegreesAngle a -> DegreesAngle a)
-> (DegreesAngle a -> DegreesAngle a -> DegreesAngle a)
-> (DegreesAngle a -> DegreesAngle a)
-> (DegreesAngle a -> DegreesAngle a)
-> (DegreesAngle a -> DegreesAngle a)
-> (Integer -> DegreesAngle a)
-> Num (DegreesAngle a)
forall a. Num a => Integer -> DegreesAngle a
forall a. Num a => DegreesAngle a -> DegreesAngle a
forall a.
Num a =>
DegreesAngle a -> DegreesAngle a -> DegreesAngle a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: forall a.
Num a =>
DegreesAngle a -> DegreesAngle a -> DegreesAngle a
+ :: DegreesAngle a -> DegreesAngle a -> DegreesAngle a
$c- :: forall a.
Num a =>
DegreesAngle a -> DegreesAngle a -> DegreesAngle a
- :: DegreesAngle a -> DegreesAngle a -> DegreesAngle a
$c* :: forall a.
Num a =>
DegreesAngle a -> DegreesAngle a -> DegreesAngle a
* :: DegreesAngle a -> DegreesAngle a -> DegreesAngle a
$cnegate :: forall a. Num a => DegreesAngle a -> DegreesAngle a
negate :: DegreesAngle a -> DegreesAngle a
$cabs :: forall a. Num a => DegreesAngle a -> DegreesAngle a
abs :: DegreesAngle a -> DegreesAngle a
$csignum :: forall a. Num a => DegreesAngle a -> DegreesAngle a
signum :: DegreesAngle a -> DegreesAngle a
$cfromInteger :: forall a. Num a => Integer -> DegreesAngle a
fromInteger :: Integer -> DegreesAngle a
Num, Num (DegreesAngle a)
Num (DegreesAngle a) =>
(DegreesAngle a -> DegreesAngle a -> DegreesAngle a)
-> (DegreesAngle a -> DegreesAngle a)
-> (Rational -> DegreesAngle a)
-> Fractional (DegreesAngle a)
Rational -> DegreesAngle a
DegreesAngle a -> DegreesAngle a
DegreesAngle a -> DegreesAngle a -> DegreesAngle a
forall a. Fractional a => Num (DegreesAngle a)
forall a. Fractional a => Rational -> DegreesAngle a
forall a. Fractional a => DegreesAngle a -> DegreesAngle a
forall a.
Fractional a =>
DegreesAngle a -> DegreesAngle a -> DegreesAngle a
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
$c/ :: forall a.
Fractional a =>
DegreesAngle a -> DegreesAngle a -> DegreesAngle a
/ :: DegreesAngle a -> DegreesAngle a -> DegreesAngle a
$crecip :: forall a. Fractional a => DegreesAngle a -> DegreesAngle a
recip :: DegreesAngle a -> DegreesAngle a
$cfromRational :: forall a. Fractional a => Rational -> DegreesAngle a
fromRational :: Rational -> DegreesAngle a
Fractional)


 instance (Show a, Floating a) => Show (DegreesAngle a) where { show :: DegreesAngle a -> String
show = DegreesAngle a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }


 degreesAngle :: (Floating a) => DegreesAngle a -> Angle a
 degreesAngle :: forall a. Floating a => DegreesAngle a -> Angle a
degreesAngle (Degrees a
d) = a -> Angle a
forall a. a -> Angle a
Radians (a -> Angle a) -> a -> Angle a
forall a b. (a -> b) -> a -> b
$ (a
d a -> a -> a
forall a. Num a => a -> a -> a
* a
forall a. Floating a => a
pi) a -> a -> a
forall a. Fractional a => a -> a -> a
/ a
180.0

 angleDegrees :: (Floating a) => Angle a -> DegreesAngle a
 angleDegrees :: forall a. Floating a => Angle a -> DegreesAngle a
angleDegrees (Radians a
r) = a -> DegreesAngle a
forall a. a -> DegreesAngle a
Degrees (a -> DegreesAngle a) -> a -> DegreesAngle a
forall a b. (a -> b) -> a -> b
$ a
r a -> a -> a
forall a. Num a => a -> a -> a
* a
180.0 a -> a -> a
forall a. Fractional a => a -> a -> a
/ a
forall a. Floating a => a
pi

 isoDegreesToAngle :: (Floating a) => DegreesAngle a :==: Angle a
 isoDegreesToAngle :: forall a. Floating a => DegreesAngle a :==: Angle a
isoDegreesToAngle = DegreesAngle a -> Angle a
forall a. Floating a => DegreesAngle a -> Angle a
degreesAngle (DegreesAngle a -> Angle a)
-> (Angle a -> DegreesAngle a) -> DegreesAngle a :==: Angle a
forall a b. (a -> b) -> (b -> a) -> a :==: b
forall (arr :: * -> * -> *) a b.
BiArrow arr =>
(a -> b) -> (b -> a) -> arr a b
<-> Angle a -> DegreesAngle a
forall a. Floating a => Angle a -> DegreesAngle a
angleDegrees

 instance (Show a, Floating a) => Unit (DegreesAngle a) where
    amount :: DegreesAngle a -> Scalar (DegreesAngle a)
amount = DegreesAngle a -> a
DegreesAngle a -> Scalar (DegreesAngle a)
forall a. DegreesAngle a -> a
degrees
    dimension :: DegreesAngle a -> Dimension
dimension DegreesAngle a
_ = Dimension
dimensionless
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (DegreesAngle a)) -> m (DegreesAngle a)
fromQuantity = Dimension
-> (a -> DegreesAngle a) -> Quantity a -> m (DegreesAngle a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
dimensionless a -> DegreesAngle a
forall a. a -> DegreesAngle a
Degrees
    unitOf :: DegreesAngle a -> String
unitOf DegreesAngle a
_ = String
"°"
 instance (Show a, Floating a) => LiteralUnit (DegreesAngle a) where
    fromAmount :: Scalar (DegreesAngle a) -> DegreesAngle a
fromAmount = a -> DegreesAngle a
Scalar (DegreesAngle a) -> DegreesAngle a
forall a. a -> DegreesAngle a
Degrees
    zeroAmount :: (Scalar (DegreesAngle a) -> DegreesAngle a)
-> Scalar (DegreesAngle a)
zeroAmount Scalar (DegreesAngle a) -> DegreesAngle a
_ = a
Scalar (DegreesAngle a)
0
    conversionFactor :: (Scalar (DegreesAngle a) -> DegreesAngle a)
-> Scalar (DegreesAngle a)
conversionFactor Scalar (DegreesAngle a) -> DegreesAngle a
_ = a
forall a. Floating a => a
pia -> a -> a
forall a. Fractional a => a -> a -> a
/a
180.0


 instance (Num a, Show a) => Unit (Angle a) where
    amount :: Angle a -> Scalar (Angle a)
amount = Angle a -> a
Angle a -> Scalar (Angle a)
forall a. Angle a -> a
radians
    dimension :: Angle a -> Dimension
dimension Angle a
_ = Dimension
dimensionless
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Angle a)) -> m (Angle a)
fromQuantity = Dimension -> (a -> Angle a) -> Quantity a -> m (Angle a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
dimensionless a -> Angle a
forall a. a -> Angle a
Radians
    unitOf :: Angle a -> String
unitOf Angle a
_ = String
"rad"

 instance (Num a, Show a) => LiteralUnit (Angle a) where { fromAmount :: Scalar (Angle a) -> Angle a
fromAmount = a -> Angle a
Scalar (Angle a) -> Angle a
forall a. a -> Angle a
Radians }

 -- | <https://en.wikipedia.org/wiki/Steradian>
 newtype SolidAngle a = Steradians { forall a. SolidAngle a -> a
steradians :: a }
    deriving (SolidAngle a -> SolidAngle a -> Bool
(SolidAngle a -> SolidAngle a -> Bool)
-> (SolidAngle a -> SolidAngle a -> Bool) -> Eq (SolidAngle a)
forall a. Eq a => SolidAngle a -> SolidAngle a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => SolidAngle a -> SolidAngle a -> Bool
== :: SolidAngle a -> SolidAngle a -> Bool
$c/= :: forall a. Eq a => SolidAngle a -> SolidAngle a -> Bool
/= :: SolidAngle a -> SolidAngle a -> Bool
Eq,Eq (SolidAngle a)
Eq (SolidAngle a) =>
(SolidAngle a -> SolidAngle a -> Ordering)
-> (SolidAngle a -> SolidAngle a -> Bool)
-> (SolidAngle a -> SolidAngle a -> Bool)
-> (SolidAngle a -> SolidAngle a -> Bool)
-> (SolidAngle a -> SolidAngle a -> Bool)
-> (SolidAngle a -> SolidAngle a -> SolidAngle a)
-> (SolidAngle a -> SolidAngle a -> SolidAngle a)
-> Ord (SolidAngle a)
SolidAngle a -> SolidAngle a -> Bool
SolidAngle a -> SolidAngle a -> Ordering
SolidAngle a -> SolidAngle a -> SolidAngle a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (SolidAngle a)
forall a. Ord a => SolidAngle a -> SolidAngle a -> Bool
forall a. Ord a => SolidAngle a -> SolidAngle a -> Ordering
forall a. Ord a => SolidAngle a -> SolidAngle a -> SolidAngle a
$ccompare :: forall a. Ord a => SolidAngle a -> SolidAngle a -> Ordering
compare :: SolidAngle a -> SolidAngle a -> Ordering
$c< :: forall a. Ord a => SolidAngle a -> SolidAngle a -> Bool
< :: SolidAngle a -> SolidAngle a -> Bool
$c<= :: forall a. Ord a => SolidAngle a -> SolidAngle a -> Bool
<= :: SolidAngle a -> SolidAngle a -> Bool
$c> :: forall a. Ord a => SolidAngle a -> SolidAngle a -> Bool
> :: SolidAngle a -> SolidAngle a -> Bool
$c>= :: forall a. Ord a => SolidAngle a -> SolidAngle a -> Bool
>= :: SolidAngle a -> SolidAngle a -> Bool
$cmax :: forall a. Ord a => SolidAngle a -> SolidAngle a -> SolidAngle a
max :: SolidAngle a -> SolidAngle a -> SolidAngle a
$cmin :: forall a. Ord a => SolidAngle a -> SolidAngle a -> SolidAngle a
min :: SolidAngle a -> SolidAngle a -> SolidAngle a
Ord, Typeable, Typeable (SolidAngle a)
Typeable (SolidAngle a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SolidAngle a -> c (SolidAngle a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (SolidAngle a))
-> (SolidAngle a -> Constr)
-> (SolidAngle a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (SolidAngle a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (SolidAngle a)))
-> ((forall b. Data b => b -> b) -> SolidAngle a -> SolidAngle a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SolidAngle a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SolidAngle a -> r)
-> (forall u. (forall d. Data d => d -> u) -> SolidAngle a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SolidAngle a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SolidAngle a -> m (SolidAngle a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SolidAngle a -> m (SolidAngle a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SolidAngle a -> m (SolidAngle a))
-> Data (SolidAngle a)
SolidAngle a -> Constr
SolidAngle a -> DataType
(forall b. Data b => b -> b) -> SolidAngle a -> SolidAngle a
forall a. Data a => Typeable (SolidAngle a)
forall a. Data a => SolidAngle a -> Constr
forall a. Data a => SolidAngle a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> SolidAngle a -> SolidAngle a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> SolidAngle a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> SolidAngle a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SolidAngle a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SolidAngle a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> SolidAngle a -> m (SolidAngle a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SolidAngle a -> m (SolidAngle a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SolidAngle a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SolidAngle a -> c (SolidAngle a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SolidAngle a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SolidAngle a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SolidAngle a -> u
forall u. (forall d. Data d => d -> u) -> SolidAngle a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SolidAngle a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SolidAngle a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SolidAngle a -> m (SolidAngle a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SolidAngle a -> m (SolidAngle a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SolidAngle a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SolidAngle a -> c (SolidAngle a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SolidAngle a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SolidAngle a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SolidAngle a -> c (SolidAngle a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SolidAngle a -> c (SolidAngle a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SolidAngle a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SolidAngle a)
$ctoConstr :: forall a. Data a => SolidAngle a -> Constr
toConstr :: SolidAngle a -> Constr
$cdataTypeOf :: forall a. Data a => SolidAngle a -> DataType
dataTypeOf :: SolidAngle a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SolidAngle a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SolidAngle a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SolidAngle a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SolidAngle a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> SolidAngle a -> SolidAngle a
gmapT :: (forall b. Data b => b -> b) -> SolidAngle a -> SolidAngle a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SolidAngle a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SolidAngle a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SolidAngle a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SolidAngle a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> SolidAngle a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SolidAngle a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> SolidAngle a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SolidAngle a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> SolidAngle a -> m (SolidAngle a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SolidAngle a -> m (SolidAngle a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SolidAngle a -> m (SolidAngle a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SolidAngle a -> m (SolidAngle a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SolidAngle a -> m (SolidAngle a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SolidAngle a -> m (SolidAngle a)
Data, (forall x. SolidAngle a -> Rep (SolidAngle a) x)
-> (forall x. Rep (SolidAngle a) x -> SolidAngle a)
-> Generic (SolidAngle a)
forall x. Rep (SolidAngle a) x -> SolidAngle a
forall x. SolidAngle a -> Rep (SolidAngle a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (SolidAngle a) x -> SolidAngle a
forall a x. SolidAngle a -> Rep (SolidAngle a) x
$cfrom :: forall a x. SolidAngle a -> Rep (SolidAngle a) x
from :: forall x. SolidAngle a -> Rep (SolidAngle a) x
$cto :: forall a x. Rep (SolidAngle a) x -> SolidAngle a
to :: forall x. Rep (SolidAngle a) x -> SolidAngle a
Generic)
    deriving newtype (Get (SolidAngle a)
[SolidAngle a] -> Put
SolidAngle a -> Put
(SolidAngle a -> Put)
-> Get (SolidAngle a)
-> ([SolidAngle a] -> Put)
-> Binary (SolidAngle a)
forall a. Binary a => Get (SolidAngle a)
forall a. Binary a => [SolidAngle a] -> Put
forall a. Binary a => SolidAngle a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => SolidAngle a -> Put
put :: SolidAngle a -> Put
$cget :: forall a. Binary a => Get (SolidAngle a)
get :: Get (SolidAngle a)
$cputList :: forall a. Binary a => [SolidAngle a] -> Put
putList :: [SolidAngle a] -> Put
Binary, Integer -> SolidAngle a
SolidAngle a -> SolidAngle a
SolidAngle a -> SolidAngle a -> SolidAngle a
(SolidAngle a -> SolidAngle a -> SolidAngle a)
-> (SolidAngle a -> SolidAngle a -> SolidAngle a)
-> (SolidAngle a -> SolidAngle a -> SolidAngle a)
-> (SolidAngle a -> SolidAngle a)
-> (SolidAngle a -> SolidAngle a)
-> (SolidAngle a -> SolidAngle a)
-> (Integer -> SolidAngle a)
-> Num (SolidAngle a)
forall a. Num a => Integer -> SolidAngle a
forall a. Num a => SolidAngle a -> SolidAngle a
forall a. Num a => SolidAngle a -> SolidAngle a -> SolidAngle a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: forall a. Num a => SolidAngle a -> SolidAngle a -> SolidAngle a
+ :: SolidAngle a -> SolidAngle a -> SolidAngle a
$c- :: forall a. Num a => SolidAngle a -> SolidAngle a -> SolidAngle a
- :: SolidAngle a -> SolidAngle a -> SolidAngle a
$c* :: forall a. Num a => SolidAngle a -> SolidAngle a -> SolidAngle a
* :: SolidAngle a -> SolidAngle a -> SolidAngle a
$cnegate :: forall a. Num a => SolidAngle a -> SolidAngle a
negate :: SolidAngle a -> SolidAngle a
$cabs :: forall a. Num a => SolidAngle a -> SolidAngle a
abs :: SolidAngle a -> SolidAngle a
$csignum :: forall a. Num a => SolidAngle a -> SolidAngle a
signum :: SolidAngle a -> SolidAngle a
$cfromInteger :: forall a. Num a => Integer -> SolidAngle a
fromInteger :: Integer -> SolidAngle a
Num, Num (SolidAngle a)
Num (SolidAngle a) =>
(SolidAngle a -> SolidAngle a -> SolidAngle a)
-> (SolidAngle a -> SolidAngle a)
-> (Rational -> SolidAngle a)
-> Fractional (SolidAngle a)
Rational -> SolidAngle a
SolidAngle a -> SolidAngle a
SolidAngle a -> SolidAngle a -> SolidAngle a
forall a. Fractional a => Num (SolidAngle a)
forall a. Fractional a => Rational -> SolidAngle a
forall a. Fractional a => SolidAngle a -> SolidAngle a
forall a.
Fractional a =>
SolidAngle a -> SolidAngle a -> SolidAngle a
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
$c/ :: forall a.
Fractional a =>
SolidAngle a -> SolidAngle a -> SolidAngle a
/ :: SolidAngle a -> SolidAngle a -> SolidAngle a
$crecip :: forall a. Fractional a => SolidAngle a -> SolidAngle a
recip :: SolidAngle a -> SolidAngle a
$cfromRational :: forall a. Fractional a => Rational -> SolidAngle a
fromRational :: Rational -> SolidAngle a
Fractional)

 instance (Num a, Show a) => Show ( SolidAngle  a) where { show :: SolidAngle a -> String
show = SolidAngle a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 instance (Num a, Show a) => Unit (SolidAngle a) where
    amount :: SolidAngle a -> Scalar (SolidAngle a)
amount = SolidAngle a -> a
SolidAngle a -> Scalar (SolidAngle a)
forall a. SolidAngle a -> a
steradians
    dimension :: SolidAngle a -> Dimension
dimension SolidAngle a
_ = Dimension
dimensionless
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (SolidAngle a)) -> m (SolidAngle a)
fromQuantity = Dimension -> (a -> SolidAngle a) -> Quantity a -> m (SolidAngle a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
dimensionless a -> SolidAngle a
forall a. a -> SolidAngle a
Steradians
    unitOf :: SolidAngle a -> String
unitOf SolidAngle a
_ = String
"sr"
 instance (Show a, Num a) => LiteralUnit (SolidAngle a) where { fromAmount :: Scalar (SolidAngle a) -> SolidAngle a
fromAmount = a -> SolidAngle a
Scalar (SolidAngle a) -> SolidAngle a
forall a. a -> SolidAngle a
Steradians }

 showUnit :: (Unit u, Show (Scalar u)) => u -> String
 showUnit :: forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit u
i = Scalar u -> String
forall a. Show a => a -> String
show (u -> Scalar u
forall u. Unit u => u -> Scalar u
amount u
i) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++ u -> String
forall u. Unit u => u -> String
unitOf u
i

 readUnit :: (Unit u, Read (Scalar u)) => UnitName u -> Text.ParserCombinators.ReadPrec.ReadPrec u
 readUnit :: forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName u
unitname = ReadPrec (Scalar u)
forall a. Read a => ReadPrec a
readPrec ReadPrec (Scalar u) -> (Scalar u -> ReadPrec u) -> ReadPrec u
forall a b. ReadPrec a -> (a -> ReadPrec b) -> ReadPrec b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Scalar u
d -> ReadP () -> ReadPrec ()
forall a. ReadP a -> ReadPrec a
lift ReadP ()
skipSpaces
  ReadPrec () -> ReadPrec String -> ReadPrec String
forall a b. ReadPrec a -> ReadPrec b -> ReadPrec b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ReadP String -> ReadPrec String
forall a. ReadP a -> ReadPrec a
lift (String -> ReadP String
string (String -> ReadP String) -> String -> ReadP String
forall a b. (a -> b) -> a -> b
$ u -> String
forall u. Unit u => u -> String
unitOf (u -> String) -> u -> String
forall a b. (a -> b) -> a -> b
$ UnitName u
unitname Scalar u
d)
  ReadPrec String -> ReadPrec u -> ReadPrec u
forall a b. ReadPrec a -> ReadPrec b -> ReadPrec b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> u -> ReadPrec u
forall a. a -> ReadPrec a
forall (m :: * -> *) a. Monad m => a -> m a
return (UnitName u
unitname Scalar u
d)

 newtype Percentage a = Percentages { forall a. Percentage a -> a
percentages :: a }
   deriving (Percentage a -> Percentage a -> Bool
(Percentage a -> Percentage a -> Bool)
-> (Percentage a -> Percentage a -> Bool) -> Eq (Percentage a)
forall a. Eq a => Percentage a -> Percentage a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Percentage a -> Percentage a -> Bool
== :: Percentage a -> Percentage a -> Bool
$c/= :: forall a. Eq a => Percentage a -> Percentage a -> Bool
/= :: Percentage a -> Percentage a -> Bool
Eq,Eq (Percentage a)
Eq (Percentage a) =>
(Percentage a -> Percentage a -> Ordering)
-> (Percentage a -> Percentage a -> Bool)
-> (Percentage a -> Percentage a -> Bool)
-> (Percentage a -> Percentage a -> Bool)
-> (Percentage a -> Percentage a -> Bool)
-> (Percentage a -> Percentage a -> Percentage a)
-> (Percentage a -> Percentage a -> Percentage a)
-> Ord (Percentage a)
Percentage a -> Percentage a -> Bool
Percentage a -> Percentage a -> Ordering
Percentage a -> Percentage a -> Percentage a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Percentage a)
forall a. Ord a => Percentage a -> Percentage a -> Bool
forall a. Ord a => Percentage a -> Percentage a -> Ordering
forall a. Ord a => Percentage a -> Percentage a -> Percentage a
$ccompare :: forall a. Ord a => Percentage a -> Percentage a -> Ordering
compare :: Percentage a -> Percentage a -> Ordering
$c< :: forall a. Ord a => Percentage a -> Percentage a -> Bool
< :: Percentage a -> Percentage a -> Bool
$c<= :: forall a. Ord a => Percentage a -> Percentage a -> Bool
<= :: Percentage a -> Percentage a -> Bool
$c> :: forall a. Ord a => Percentage a -> Percentage a -> Bool
> :: Percentage a -> Percentage a -> Bool
$c>= :: forall a. Ord a => Percentage a -> Percentage a -> Bool
>= :: Percentage a -> Percentage a -> Bool
$cmax :: forall a. Ord a => Percentage a -> Percentage a -> Percentage a
max :: Percentage a -> Percentage a -> Percentage a
$cmin :: forall a. Ord a => Percentage a -> Percentage a -> Percentage a
min :: Percentage a -> Percentage a -> Percentage a
Ord, Typeable, Typeable (Percentage a)
Typeable (Percentage a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Percentage a -> c (Percentage a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Percentage a))
-> (Percentage a -> Constr)
-> (Percentage a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Percentage a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Percentage a)))
-> ((forall b. Data b => b -> b) -> Percentage a -> Percentage a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Percentage a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Percentage a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Percentage a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Percentage a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Percentage a -> m (Percentage a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Percentage a -> m (Percentage a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Percentage a -> m (Percentage a))
-> Data (Percentage a)
Percentage a -> Constr
Percentage a -> DataType
(forall b. Data b => b -> b) -> Percentage a -> Percentage a
forall a. Data a => Typeable (Percentage a)
forall a. Data a => Percentage a -> Constr
forall a. Data a => Percentage a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Percentage a -> Percentage a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Percentage a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Percentage a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Percentage a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Percentage a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Percentage a -> m (Percentage a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Percentage a -> m (Percentage a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Percentage a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Percentage a -> c (Percentage a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Percentage a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Percentage a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Percentage a -> u
forall u. (forall d. Data d => d -> u) -> Percentage a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Percentage a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Percentage a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Percentage a -> m (Percentage a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Percentage a -> m (Percentage a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Percentage a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Percentage a -> c (Percentage a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Percentage a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Percentage a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Percentage a -> c (Percentage a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Percentage a -> c (Percentage a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Percentage a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Percentage a)
$ctoConstr :: forall a. Data a => Percentage a -> Constr
toConstr :: Percentage a -> Constr
$cdataTypeOf :: forall a. Data a => Percentage a -> DataType
dataTypeOf :: Percentage a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Percentage a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Percentage a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Percentage a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Percentage a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Percentage a -> Percentage a
gmapT :: (forall b. Data b => b -> b) -> Percentage a -> Percentage a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Percentage a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Percentage a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Percentage a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Percentage a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Percentage a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Percentage a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Percentage a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Percentage a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Percentage a -> m (Percentage a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Percentage a -> m (Percentage a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Percentage a -> m (Percentage a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Percentage a -> m (Percentage a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Percentage a -> m (Percentage a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Percentage a -> m (Percentage a)
Data, (forall x. Percentage a -> Rep (Percentage a) x)
-> (forall x. Rep (Percentage a) x -> Percentage a)
-> Generic (Percentage a)
forall x. Rep (Percentage a) x -> Percentage a
forall x. Percentage a -> Rep (Percentage a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Percentage a) x -> Percentage a
forall a x. Percentage a -> Rep (Percentage a) x
$cfrom :: forall a x. Percentage a -> Rep (Percentage a) x
from :: forall x. Percentage a -> Rep (Percentage a) x
$cto :: forall a x. Rep (Percentage a) x -> Percentage a
to :: forall x. Rep (Percentage a) x -> Percentage a
Generic)
   deriving newtype (Get (Percentage a)
[Percentage a] -> Put
Percentage a -> Put
(Percentage a -> Put)
-> Get (Percentage a)
-> ([Percentage a] -> Put)
-> Binary (Percentage a)
forall a. Binary a => Get (Percentage a)
forall a. Binary a => [Percentage a] -> Put
forall a. Binary a => Percentage a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Percentage a -> Put
put :: Percentage a -> Put
$cget :: forall a. Binary a => Get (Percentage a)
get :: Get (Percentage a)
$cputList :: forall a. Binary a => [Percentage a] -> Put
putList :: [Percentage a] -> Put
Binary, Integer -> Percentage a
Percentage a -> Percentage a
Percentage a -> Percentage a -> Percentage a
(Percentage a -> Percentage a -> Percentage a)
-> (Percentage a -> Percentage a -> Percentage a)
-> (Percentage a -> Percentage a -> Percentage a)
-> (Percentage a -> Percentage a)
-> (Percentage a -> Percentage a)
-> (Percentage a -> Percentage a)
-> (Integer -> Percentage a)
-> Num (Percentage a)
forall a. Num a => Integer -> Percentage a
forall a. Num a => Percentage a -> Percentage a
forall a. Num a => Percentage a -> Percentage a -> Percentage a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: forall a. Num a => Percentage a -> Percentage a -> Percentage a
+ :: Percentage a -> Percentage a -> Percentage a
$c- :: forall a. Num a => Percentage a -> Percentage a -> Percentage a
- :: Percentage a -> Percentage a -> Percentage a
$c* :: forall a. Num a => Percentage a -> Percentage a -> Percentage a
* :: Percentage a -> Percentage a -> Percentage a
$cnegate :: forall a. Num a => Percentage a -> Percentage a
negate :: Percentage a -> Percentage a
$cabs :: forall a. Num a => Percentage a -> Percentage a
abs :: Percentage a -> Percentage a
$csignum :: forall a. Num a => Percentage a -> Percentage a
signum :: Percentage a -> Percentage a
$cfromInteger :: forall a. Num a => Integer -> Percentage a
fromInteger :: Integer -> Percentage a
Num, Num (Percentage a)
Num (Percentage a) =>
(Percentage a -> Percentage a -> Percentage a)
-> (Percentage a -> Percentage a)
-> (Rational -> Percentage a)
-> Fractional (Percentage a)
Rational -> Percentage a
Percentage a -> Percentage a
Percentage a -> Percentage a -> Percentage a
forall a. Fractional a => Num (Percentage a)
forall a. Fractional a => Rational -> Percentage a
forall a. Fractional a => Percentage a -> Percentage a
forall a.
Fractional a =>
Percentage a -> Percentage a -> Percentage a
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
$c/ :: forall a.
Fractional a =>
Percentage a -> Percentage a -> Percentage a
/ :: Percentage a -> Percentage a -> Percentage a
$crecip :: forall a. Fractional a => Percentage a -> Percentage a
recip :: Percentage a -> Percentage a
$cfromRational :: forall a. Fractional a => Rational -> Percentage a
fromRational :: Rational -> Percentage a
Fractional)

 instance (Fractional a, Show a) => Show (Percentage a) where { show :: Percentage a -> String
show = Percentage a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }
 
 instance (Fractional a, Show a) => Unit (Percentage a) where
   amount :: Percentage a -> Scalar (Percentage a)
amount = Percentage a -> a
Percentage a -> Scalar (Percentage a)
forall a. Percentage a -> a
percentages
   fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Percentage a)) -> m (Percentage a)
fromQuantity = Dimension -> (a -> Percentage a) -> Quantity a -> m (Percentage a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
dimensionless (a -> Percentage a
forall a. a -> Percentage a
Percentages (a -> Percentage a) -> (a -> a) -> a -> Percentage a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a
100.0a -> a -> a
forall a. Num a => a -> a -> a
*))
   dimension :: Percentage a -> Dimension
dimension Percentage a
_ = Dimension
dimensionless
   unitOf :: Percentage a -> String
unitOf Percentage a
_ = String
"%"
 instance (Show a, Fractional a) => LiteralUnit (Percentage a) where
    fromAmount :: Scalar (Percentage a) -> Percentage a
fromAmount = a -> Percentage a
Scalar (Percentage a) -> Percentage a
forall a. a -> Percentage a
Percentages
    conversionFactor :: (Scalar (Percentage a) -> Percentage a) -> Scalar (Percentage a)
conversionFactor Scalar (Percentage a) -> Percentage a
_ = a
Scalar (Percentage a)
0.01
 
 newtype Acceleration a = MetersPerSquareSecond { forall a. Acceleration a -> a
metersPerSquareSecond :: a }
    deriving (Acceleration a -> Acceleration a -> Bool
(Acceleration a -> Acceleration a -> Bool)
-> (Acceleration a -> Acceleration a -> Bool)
-> Eq (Acceleration a)
forall a. Eq a => Acceleration a -> Acceleration a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Acceleration a -> Acceleration a -> Bool
== :: Acceleration a -> Acceleration a -> Bool
$c/= :: forall a. Eq a => Acceleration a -> Acceleration a -> Bool
/= :: Acceleration a -> Acceleration a -> Bool
Eq,Eq (Acceleration a)
Eq (Acceleration a) =>
(Acceleration a -> Acceleration a -> Ordering)
-> (Acceleration a -> Acceleration a -> Bool)
-> (Acceleration a -> Acceleration a -> Bool)
-> (Acceleration a -> Acceleration a -> Bool)
-> (Acceleration a -> Acceleration a -> Bool)
-> (Acceleration a -> Acceleration a -> Acceleration a)
-> (Acceleration a -> Acceleration a -> Acceleration a)
-> Ord (Acceleration a)
Acceleration a -> Acceleration a -> Bool
Acceleration a -> Acceleration a -> Ordering
Acceleration a -> Acceleration a -> Acceleration a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Acceleration a)
forall a. Ord a => Acceleration a -> Acceleration a -> Bool
forall a. Ord a => Acceleration a -> Acceleration a -> Ordering
forall a.
Ord a =>
Acceleration a -> Acceleration a -> Acceleration a
$ccompare :: forall a. Ord a => Acceleration a -> Acceleration a -> Ordering
compare :: Acceleration a -> Acceleration a -> Ordering
$c< :: forall a. Ord a => Acceleration a -> Acceleration a -> Bool
< :: Acceleration a -> Acceleration a -> Bool
$c<= :: forall a. Ord a => Acceleration a -> Acceleration a -> Bool
<= :: Acceleration a -> Acceleration a -> Bool
$c> :: forall a. Ord a => Acceleration a -> Acceleration a -> Bool
> :: Acceleration a -> Acceleration a -> Bool
$c>= :: forall a. Ord a => Acceleration a -> Acceleration a -> Bool
>= :: Acceleration a -> Acceleration a -> Bool
$cmax :: forall a.
Ord a =>
Acceleration a -> Acceleration a -> Acceleration a
max :: Acceleration a -> Acceleration a -> Acceleration a
$cmin :: forall a.
Ord a =>
Acceleration a -> Acceleration a -> Acceleration a
min :: Acceleration a -> Acceleration a -> Acceleration a
Ord, Typeable, Typeable (Acceleration a)
Typeable (Acceleration a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Acceleration a -> c (Acceleration a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Acceleration a))
-> (Acceleration a -> Constr)
-> (Acceleration a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Acceleration a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Acceleration a)))
-> ((forall b. Data b => b -> b)
    -> Acceleration a -> Acceleration a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Acceleration a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Acceleration a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Acceleration a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Acceleration a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Acceleration a -> m (Acceleration a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Acceleration a -> m (Acceleration a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Acceleration a -> m (Acceleration a))
-> Data (Acceleration a)
Acceleration a -> Constr
Acceleration a -> DataType
(forall b. Data b => b -> b) -> Acceleration a -> Acceleration a
forall a. Data a => Typeable (Acceleration a)
forall a. Data a => Acceleration a -> Constr
forall a. Data a => Acceleration a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Acceleration a -> Acceleration a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Acceleration a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Acceleration a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Acceleration a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Acceleration a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Acceleration a -> m (Acceleration a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Acceleration a -> m (Acceleration a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Acceleration a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Acceleration a -> c (Acceleration a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Acceleration a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Acceleration a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> Acceleration a -> u
forall u. (forall d. Data d => d -> u) -> Acceleration a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Acceleration a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Acceleration a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Acceleration a -> m (Acceleration a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Acceleration a -> m (Acceleration a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Acceleration a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Acceleration a -> c (Acceleration a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Acceleration a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Acceleration a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Acceleration a -> c (Acceleration a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Acceleration a -> c (Acceleration a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Acceleration a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Acceleration a)
$ctoConstr :: forall a. Data a => Acceleration a -> Constr
toConstr :: Acceleration a -> Constr
$cdataTypeOf :: forall a. Data a => Acceleration a -> DataType
dataTypeOf :: Acceleration a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Acceleration a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Acceleration a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Acceleration a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Acceleration a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Acceleration a -> Acceleration a
gmapT :: (forall b. Data b => b -> b) -> Acceleration a -> Acceleration a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Acceleration a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Acceleration a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Acceleration a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Acceleration a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Acceleration a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Acceleration a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Acceleration a -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> Acceleration a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Acceleration a -> m (Acceleration a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Acceleration a -> m (Acceleration a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Acceleration a -> m (Acceleration a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Acceleration a -> m (Acceleration a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Acceleration a -> m (Acceleration a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Acceleration a -> m (Acceleration a)
Data, (forall x. Acceleration a -> Rep (Acceleration a) x)
-> (forall x. Rep (Acceleration a) x -> Acceleration a)
-> Generic (Acceleration a)
forall x. Rep (Acceleration a) x -> Acceleration a
forall x. Acceleration a -> Rep (Acceleration a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Acceleration a) x -> Acceleration a
forall a x. Acceleration a -> Rep (Acceleration a) x
$cfrom :: forall a x. Acceleration a -> Rep (Acceleration a) x
from :: forall x. Acceleration a -> Rep (Acceleration a) x
$cto :: forall a x. Rep (Acceleration a) x -> Acceleration a
to :: forall x. Rep (Acceleration a) x -> Acceleration a
Generic)
    deriving newtype (Get (Acceleration a)
[Acceleration a] -> Put
Acceleration a -> Put
(Acceleration a -> Put)
-> Get (Acceleration a)
-> ([Acceleration a] -> Put)
-> Binary (Acceleration a)
forall a. Binary a => Get (Acceleration a)
forall a. Binary a => [Acceleration a] -> Put
forall a. Binary a => Acceleration a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Acceleration a -> Put
put :: Acceleration a -> Put
$cget :: forall a. Binary a => Get (Acceleration a)
get :: Get (Acceleration a)
$cputList :: forall a. Binary a => [Acceleration a] -> Put
putList :: [Acceleration a] -> Put
Binary)

 instance (Num a, Show a) => Show (Acceleration a) where { show :: Acceleration a -> String
show = Acceleration a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 instance (Num a, Show a) => Unit (Acceleration a) where
    amount :: Acceleration a -> Scalar (Acceleration a)
amount = Acceleration a -> a
Acceleration a -> Scalar (Acceleration a)
forall a. Acceleration a -> a
metersPerSquareSecond
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Acceleration a)) -> m (Acceleration a)
fromQuantity = Dimension
-> (a -> Acceleration a) -> Quantity a -> m (Acceleration a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef (Dimension
meterDimension Dimension -> Dimension -> Dimension
forall v. VectorSpace v => v -> v -> v
%- (Dimension
secondDimension Dimension -> Dimension -> Dimension
forall v. VectorSpace v => v -> v -> v
%+ Dimension
secondDimension)) a -> Acceleration a
forall a. a -> Acceleration a
MetersPerSquareSecond
    dimension :: Acceleration a -> Dimension
dimension Acceleration a
_ = Dimension
meterDimension Dimension -> Dimension -> Dimension
forall v. VectorSpace v => v -> v -> v
%- (Dimension
secondDimension Dimension -> Dimension -> Dimension
forall v. VectorSpace v => v -> v -> v
%+ Dimension
secondDimension)
    unitOf :: Acceleration a -> String
unitOf Acceleration a
_ = String
"m/s^2"
 instance (Show a, Num a) => LiteralUnit (Acceleration a) where { fromAmount :: Scalar (Acceleration a) -> Acceleration a
fromAmount = a -> Acceleration a
Scalar (Acceleration a) -> Acceleration a
forall a. a -> Acceleration a
MetersPerSquareSecond }
 newtype Velocity a = MetersPerSecond { forall a. Velocity a -> a
metersPerSecond :: a }
    deriving (Velocity a -> Velocity a -> Bool
(Velocity a -> Velocity a -> Bool)
-> (Velocity a -> Velocity a -> Bool) -> Eq (Velocity a)
forall a. Eq a => Velocity a -> Velocity a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Velocity a -> Velocity a -> Bool
== :: Velocity a -> Velocity a -> Bool
$c/= :: forall a. Eq a => Velocity a -> Velocity a -> Bool
/= :: Velocity a -> Velocity a -> Bool
Eq,Eq (Velocity a)
Eq (Velocity a) =>
(Velocity a -> Velocity a -> Ordering)
-> (Velocity a -> Velocity a -> Bool)
-> (Velocity a -> Velocity a -> Bool)
-> (Velocity a -> Velocity a -> Bool)
-> (Velocity a -> Velocity a -> Bool)
-> (Velocity a -> Velocity a -> Velocity a)
-> (Velocity a -> Velocity a -> Velocity a)
-> Ord (Velocity a)
Velocity a -> Velocity a -> Bool
Velocity a -> Velocity a -> Ordering
Velocity a -> Velocity a -> Velocity a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Velocity a)
forall a. Ord a => Velocity a -> Velocity a -> Bool
forall a. Ord a => Velocity a -> Velocity a -> Ordering
forall a. Ord a => Velocity a -> Velocity a -> Velocity a
$ccompare :: forall a. Ord a => Velocity a -> Velocity a -> Ordering
compare :: Velocity a -> Velocity a -> Ordering
$c< :: forall a. Ord a => Velocity a -> Velocity a -> Bool
< :: Velocity a -> Velocity a -> Bool
$c<= :: forall a. Ord a => Velocity a -> Velocity a -> Bool
<= :: Velocity a -> Velocity a -> Bool
$c> :: forall a. Ord a => Velocity a -> Velocity a -> Bool
> :: Velocity a -> Velocity a -> Bool
$c>= :: forall a. Ord a => Velocity a -> Velocity a -> Bool
>= :: Velocity a -> Velocity a -> Bool
$cmax :: forall a. Ord a => Velocity a -> Velocity a -> Velocity a
max :: Velocity a -> Velocity a -> Velocity a
$cmin :: forall a. Ord a => Velocity a -> Velocity a -> Velocity a
min :: Velocity a -> Velocity a -> Velocity a
Ord, Typeable, Typeable (Velocity a)
Typeable (Velocity a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Velocity a -> c (Velocity a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Velocity a))
-> (Velocity a -> Constr)
-> (Velocity a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Velocity a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Velocity a)))
-> ((forall b. Data b => b -> b) -> Velocity a -> Velocity a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Velocity a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Velocity a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Velocity a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Velocity a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Velocity a -> m (Velocity a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Velocity a -> m (Velocity a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Velocity a -> m (Velocity a))
-> Data (Velocity a)
Velocity a -> Constr
Velocity a -> DataType
(forall b. Data b => b -> b) -> Velocity a -> Velocity a
forall a. Data a => Typeable (Velocity a)
forall a. Data a => Velocity a -> Constr
forall a. Data a => Velocity a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Velocity a -> Velocity a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Velocity a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Velocity a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Velocity a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Velocity a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Velocity a -> m (Velocity a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Velocity a -> m (Velocity a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Velocity a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Velocity a -> c (Velocity a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Velocity a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Velocity a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Velocity a -> u
forall u. (forall d. Data d => d -> u) -> Velocity a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Velocity a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Velocity a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Velocity a -> m (Velocity a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Velocity a -> m (Velocity a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Velocity a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Velocity a -> c (Velocity a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Velocity a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Velocity a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Velocity a -> c (Velocity a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Velocity a -> c (Velocity a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Velocity a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Velocity a)
$ctoConstr :: forall a. Data a => Velocity a -> Constr
toConstr :: Velocity a -> Constr
$cdataTypeOf :: forall a. Data a => Velocity a -> DataType
dataTypeOf :: Velocity a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Velocity a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Velocity a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Velocity a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Velocity a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Velocity a -> Velocity a
gmapT :: (forall b. Data b => b -> b) -> Velocity a -> Velocity a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Velocity a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Velocity a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Velocity a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Velocity a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Velocity a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Velocity a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Velocity a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Velocity a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Velocity a -> m (Velocity a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Velocity a -> m (Velocity a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Velocity a -> m (Velocity a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Velocity a -> m (Velocity a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Velocity a -> m (Velocity a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Velocity a -> m (Velocity a)
Data, (forall x. Velocity a -> Rep (Velocity a) x)
-> (forall x. Rep (Velocity a) x -> Velocity a)
-> Generic (Velocity a)
forall x. Rep (Velocity a) x -> Velocity a
forall x. Velocity a -> Rep (Velocity a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Velocity a) x -> Velocity a
forall a x. Velocity a -> Rep (Velocity a) x
$cfrom :: forall a x. Velocity a -> Rep (Velocity a) x
from :: forall x. Velocity a -> Rep (Velocity a) x
$cto :: forall a x. Rep (Velocity a) x -> Velocity a
to :: forall x. Rep (Velocity a) x -> Velocity a
Generic)
    deriving newtype (Get (Velocity a)
[Velocity a] -> Put
Velocity a -> Put
(Velocity a -> Put)
-> Get (Velocity a) -> ([Velocity a] -> Put) -> Binary (Velocity a)
forall a. Binary a => Get (Velocity a)
forall a. Binary a => [Velocity a] -> Put
forall a. Binary a => Velocity a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Velocity a -> Put
put :: Velocity a -> Put
$cget :: forall a. Binary a => Get (Velocity a)
get :: Get (Velocity a)
$cputList :: forall a. Binary a => [Velocity a] -> Put
putList :: [Velocity a] -> Put
Binary)
 instance (Num a, Show a) => Show (Velocity a) where { show :: Velocity a -> String
show = Velocity a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }
 
 instance (Num a, Show a) => Unit (Velocity a) where
    amount :: Velocity a -> Scalar (Velocity a)
amount = Velocity a -> a
Velocity a -> Scalar (Velocity a)
forall a. Velocity a -> a
metersPerSecond
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Velocity a)) -> m (Velocity a)
fromQuantity = Dimension -> (a -> Velocity a) -> Quantity a -> m (Velocity a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef (Dimension
meterDimension Dimension -> Dimension -> Dimension
forall v. VectorSpace v => v -> v -> v
%- Dimension
secondDimension) a -> Velocity a
forall a. a -> Velocity a
MetersPerSecond
    dimension :: Velocity a -> Dimension
dimension Velocity a
_ = Dimension
meterDimension Dimension -> Dimension -> Dimension
forall v. VectorSpace v => v -> v -> v
%- Dimension
secondDimension
    unitOf :: Velocity a -> String
unitOf Velocity a
_ = String
"m/s"
 instance (Show a, Num a) => LiteralUnit (Velocity a) where { fromAmount :: Scalar (Velocity a) -> Velocity a
fromAmount = a -> Velocity a
Scalar (Velocity a) -> Velocity a
forall a. a -> Velocity a
MetersPerSecond }
 newtype SquareLength a = SquareMeters { forall a. SquareLength a -> a
squaremeters :: a }
  deriving (SquareLength a -> SquareLength a -> Bool
(SquareLength a -> SquareLength a -> Bool)
-> (SquareLength a -> SquareLength a -> Bool)
-> Eq (SquareLength a)
forall a. Eq a => SquareLength a -> SquareLength a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => SquareLength a -> SquareLength a -> Bool
== :: SquareLength a -> SquareLength a -> Bool
$c/= :: forall a. Eq a => SquareLength a -> SquareLength a -> Bool
/= :: SquareLength a -> SquareLength a -> Bool
Eq,Eq (SquareLength a)
Eq (SquareLength a) =>
(SquareLength a -> SquareLength a -> Ordering)
-> (SquareLength a -> SquareLength a -> Bool)
-> (SquareLength a -> SquareLength a -> Bool)
-> (SquareLength a -> SquareLength a -> Bool)
-> (SquareLength a -> SquareLength a -> Bool)
-> (SquareLength a -> SquareLength a -> SquareLength a)
-> (SquareLength a -> SquareLength a -> SquareLength a)
-> Ord (SquareLength a)
SquareLength a -> SquareLength a -> Bool
SquareLength a -> SquareLength a -> Ordering
SquareLength a -> SquareLength a -> SquareLength a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (SquareLength a)
forall a. Ord a => SquareLength a -> SquareLength a -> Bool
forall a. Ord a => SquareLength a -> SquareLength a -> Ordering
forall a.
Ord a =>
SquareLength a -> SquareLength a -> SquareLength a
$ccompare :: forall a. Ord a => SquareLength a -> SquareLength a -> Ordering
compare :: SquareLength a -> SquareLength a -> Ordering
$c< :: forall a. Ord a => SquareLength a -> SquareLength a -> Bool
< :: SquareLength a -> SquareLength a -> Bool
$c<= :: forall a. Ord a => SquareLength a -> SquareLength a -> Bool
<= :: SquareLength a -> SquareLength a -> Bool
$c> :: forall a. Ord a => SquareLength a -> SquareLength a -> Bool
> :: SquareLength a -> SquareLength a -> Bool
$c>= :: forall a. Ord a => SquareLength a -> SquareLength a -> Bool
>= :: SquareLength a -> SquareLength a -> Bool
$cmax :: forall a.
Ord a =>
SquareLength a -> SquareLength a -> SquareLength a
max :: SquareLength a -> SquareLength a -> SquareLength a
$cmin :: forall a.
Ord a =>
SquareLength a -> SquareLength a -> SquareLength a
min :: SquareLength a -> SquareLength a -> SquareLength a
Ord, Typeable, Typeable (SquareLength a)
Typeable (SquareLength a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SquareLength a -> c (SquareLength a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (SquareLength a))
-> (SquareLength a -> Constr)
-> (SquareLength a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (SquareLength a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (SquareLength a)))
-> ((forall b. Data b => b -> b)
    -> SquareLength a -> SquareLength a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SquareLength a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SquareLength a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SquareLength a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SquareLength a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SquareLength a -> m (SquareLength a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SquareLength a -> m (SquareLength a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SquareLength a -> m (SquareLength a))
-> Data (SquareLength a)
SquareLength a -> Constr
SquareLength a -> DataType
(forall b. Data b => b -> b) -> SquareLength a -> SquareLength a
forall a. Data a => Typeable (SquareLength a)
forall a. Data a => SquareLength a -> Constr
forall a. Data a => SquareLength a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> SquareLength a -> SquareLength a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> SquareLength a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> SquareLength a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SquareLength a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SquareLength a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> SquareLength a -> m (SquareLength a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> SquareLength a -> m (SquareLength a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SquareLength a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SquareLength a -> c (SquareLength a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SquareLength a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SquareLength a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> SquareLength a -> u
forall u. (forall d. Data d => d -> u) -> SquareLength a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SquareLength a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SquareLength a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SquareLength a -> m (SquareLength a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SquareLength a -> m (SquareLength a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SquareLength a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SquareLength a -> c (SquareLength a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SquareLength a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SquareLength a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SquareLength a -> c (SquareLength a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SquareLength a -> c (SquareLength a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SquareLength a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SquareLength a)
$ctoConstr :: forall a. Data a => SquareLength a -> Constr
toConstr :: SquareLength a -> Constr
$cdataTypeOf :: forall a. Data a => SquareLength a -> DataType
dataTypeOf :: SquareLength a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SquareLength a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SquareLength a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SquareLength a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SquareLength a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> SquareLength a -> SquareLength a
gmapT :: (forall b. Data b => b -> b) -> SquareLength a -> SquareLength a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SquareLength a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SquareLength a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SquareLength a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SquareLength a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> SquareLength a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SquareLength a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> SquareLength a -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SquareLength a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> SquareLength a -> m (SquareLength a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SquareLength a -> m (SquareLength a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> SquareLength a -> m (SquareLength a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SquareLength a -> m (SquareLength a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> SquareLength a -> m (SquareLength a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SquareLength a -> m (SquareLength a)
Data, (forall x. SquareLength a -> Rep (SquareLength a) x)
-> (forall x. Rep (SquareLength a) x -> SquareLength a)
-> Generic (SquareLength a)
forall x. Rep (SquareLength a) x -> SquareLength a
forall x. SquareLength a -> Rep (SquareLength a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (SquareLength a) x -> SquareLength a
forall a x. SquareLength a -> Rep (SquareLength a) x
$cfrom :: forall a x. SquareLength a -> Rep (SquareLength a) x
from :: forall x. SquareLength a -> Rep (SquareLength a) x
$cto :: forall a x. Rep (SquareLength a) x -> SquareLength a
to :: forall x. Rep (SquareLength a) x -> SquareLength a
Generic)
  deriving newtype (Get (SquareLength a)
[SquareLength a] -> Put
SquareLength a -> Put
(SquareLength a -> Put)
-> Get (SquareLength a)
-> ([SquareLength a] -> Put)
-> Binary (SquareLength a)
forall a. Binary a => Get (SquareLength a)
forall a. Binary a => [SquareLength a] -> Put
forall a. Binary a => SquareLength a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => SquareLength a -> Put
put :: SquareLength a -> Put
$cget :: forall a. Binary a => Get (SquareLength a)
get :: Get (SquareLength a)
$cputList :: forall a. Binary a => [SquareLength a] -> Put
putList :: [SquareLength a] -> Put
Binary)

 newtype CubicLength a = CubicMeters { forall a. CubicLength a -> a
cubicmeters :: a }
   deriving (CubicLength a -> CubicLength a -> Bool
(CubicLength a -> CubicLength a -> Bool)
-> (CubicLength a -> CubicLength a -> Bool) -> Eq (CubicLength a)
forall a. Eq a => CubicLength a -> CubicLength a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => CubicLength a -> CubicLength a -> Bool
== :: CubicLength a -> CubicLength a -> Bool
$c/= :: forall a. Eq a => CubicLength a -> CubicLength a -> Bool
/= :: CubicLength a -> CubicLength a -> Bool
Eq,Eq (CubicLength a)
Eq (CubicLength a) =>
(CubicLength a -> CubicLength a -> Ordering)
-> (CubicLength a -> CubicLength a -> Bool)
-> (CubicLength a -> CubicLength a -> Bool)
-> (CubicLength a -> CubicLength a -> Bool)
-> (CubicLength a -> CubicLength a -> Bool)
-> (CubicLength a -> CubicLength a -> CubicLength a)
-> (CubicLength a -> CubicLength a -> CubicLength a)
-> Ord (CubicLength a)
CubicLength a -> CubicLength a -> Bool
CubicLength a -> CubicLength a -> Ordering
CubicLength a -> CubicLength a -> CubicLength a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (CubicLength a)
forall a. Ord a => CubicLength a -> CubicLength a -> Bool
forall a. Ord a => CubicLength a -> CubicLength a -> Ordering
forall a. Ord a => CubicLength a -> CubicLength a -> CubicLength a
$ccompare :: forall a. Ord a => CubicLength a -> CubicLength a -> Ordering
compare :: CubicLength a -> CubicLength a -> Ordering
$c< :: forall a. Ord a => CubicLength a -> CubicLength a -> Bool
< :: CubicLength a -> CubicLength a -> Bool
$c<= :: forall a. Ord a => CubicLength a -> CubicLength a -> Bool
<= :: CubicLength a -> CubicLength a -> Bool
$c> :: forall a. Ord a => CubicLength a -> CubicLength a -> Bool
> :: CubicLength a -> CubicLength a -> Bool
$c>= :: forall a. Ord a => CubicLength a -> CubicLength a -> Bool
>= :: CubicLength a -> CubicLength a -> Bool
$cmax :: forall a. Ord a => CubicLength a -> CubicLength a -> CubicLength a
max :: CubicLength a -> CubicLength a -> CubicLength a
$cmin :: forall a. Ord a => CubicLength a -> CubicLength a -> CubicLength a
min :: CubicLength a -> CubicLength a -> CubicLength a
Ord, Typeable, Typeable (CubicLength a)
Typeable (CubicLength a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CubicLength a -> c (CubicLength a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CubicLength a))
-> (CubicLength a -> Constr)
-> (CubicLength a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (CubicLength a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CubicLength a)))
-> ((forall b. Data b => b -> b) -> CubicLength a -> CubicLength a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CubicLength a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CubicLength a -> r)
-> (forall u. (forall d. Data d => d -> u) -> CubicLength a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CubicLength a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CubicLength a -> m (CubicLength a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CubicLength a -> m (CubicLength a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CubicLength a -> m (CubicLength a))
-> Data (CubicLength a)
CubicLength a -> Constr
CubicLength a -> DataType
(forall b. Data b => b -> b) -> CubicLength a -> CubicLength a
forall a. Data a => Typeable (CubicLength a)
forall a. Data a => CubicLength a -> Constr
forall a. Data a => CubicLength a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> CubicLength a -> CubicLength a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CubicLength a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> CubicLength a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CubicLength a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CubicLength a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> CubicLength a -> m (CubicLength a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CubicLength a -> m (CubicLength a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CubicLength a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CubicLength a -> c (CubicLength a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CubicLength a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CubicLength a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CubicLength a -> u
forall u. (forall d. Data d => d -> u) -> CubicLength a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CubicLength a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CubicLength a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CubicLength a -> m (CubicLength a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CubicLength a -> m (CubicLength a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CubicLength a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CubicLength a -> c (CubicLength a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CubicLength a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CubicLength a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CubicLength a -> c (CubicLength a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CubicLength a -> c (CubicLength a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CubicLength a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CubicLength a)
$ctoConstr :: forall a. Data a => CubicLength a -> Constr
toConstr :: CubicLength a -> Constr
$cdataTypeOf :: forall a. Data a => CubicLength a -> DataType
dataTypeOf :: CubicLength a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CubicLength a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CubicLength a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CubicLength a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CubicLength a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> CubicLength a -> CubicLength a
gmapT :: (forall b. Data b => b -> b) -> CubicLength a -> CubicLength a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CubicLength a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CubicLength a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CubicLength a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CubicLength a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> CubicLength a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CubicLength a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CubicLength a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CubicLength a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> CubicLength a -> m (CubicLength a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CubicLength a -> m (CubicLength a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CubicLength a -> m (CubicLength a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CubicLength a -> m (CubicLength a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CubicLength a -> m (CubicLength a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CubicLength a -> m (CubicLength a)
Data, (forall x. CubicLength a -> Rep (CubicLength a) x)
-> (forall x. Rep (CubicLength a) x -> CubicLength a)
-> Generic (CubicLength a)
forall x. Rep (CubicLength a) x -> CubicLength a
forall x. CubicLength a -> Rep (CubicLength a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (CubicLength a) x -> CubicLength a
forall a x. CubicLength a -> Rep (CubicLength a) x
$cfrom :: forall a x. CubicLength a -> Rep (CubicLength a) x
from :: forall x. CubicLength a -> Rep (CubicLength a) x
$cto :: forall a x. Rep (CubicLength a) x -> CubicLength a
to :: forall x. Rep (CubicLength a) x -> CubicLength a
Generic)
   deriving newtype (Get (CubicLength a)
[CubicLength a] -> Put
CubicLength a -> Put
(CubicLength a -> Put)
-> Get (CubicLength a)
-> ([CubicLength a] -> Put)
-> Binary (CubicLength a)
forall a. Binary a => Get (CubicLength a)
forall a. Binary a => [CubicLength a] -> Put
forall a. Binary a => CubicLength a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => CubicLength a -> Put
put :: CubicLength a -> Put
$cget :: forall a. Binary a => Get (CubicLength a)
get :: Get (CubicLength a)
$cputList :: forall a. Binary a => [CubicLength a] -> Put
putList :: [CubicLength a] -> Put
Binary)
 
 sqrt_length :: (Floating a) => SquareLength a -> Length a
 sqrt_length :: forall a. Floating a => SquareLength a -> Length a
sqrt_length (SquareMeters a
m) = a -> Length a
forall a. a -> Length a
Meters (a -> a
forall a. Floating a => a -> a
sqrt a
m)

 square_length :: (Num a) => Length a -> SquareLength a
 square_length :: forall a. Num a => Length a -> SquareLength a
square_length (Meters a
m) = a -> SquareLength a
forall a. a -> SquareLength a
SquareMeters (a
m a -> a -> a
forall a. Num a => a -> a -> a
* a
m)

 times_length :: (Num a) => Length a -> Length a -> SquareLength a
 times_length :: forall a. Num a => Length a -> Length a -> SquareLength a
times_length (Meters a
m1) (Meters a
m2) = a -> SquareLength a
forall a. a -> SquareLength a
SquareMeters (a
m1 a -> a -> a
forall a. Num a => a -> a -> a
* a
m2)

 instance (Num a, Show a) => Show (CubicLength a) where { show :: CubicLength a -> String
show = CubicLength a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }
 instance (Num a, Show a) => Unit (CubicLength a) where
    amount :: CubicLength a -> Scalar (CubicLength a)
amount = CubicLength a -> a
CubicLength a -> Scalar (CubicLength a)
forall a. CubicLength a -> a
cubicmeters
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (CubicLength a)) -> m (CubicLength a)
fromQuantity = Dimension
-> (a -> CubicLength a) -> Quantity a -> m (CubicLength a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
cubicmeterDimension a -> CubicLength a
forall a. a -> CubicLength a
CubicMeters
    dimension :: CubicLength a -> Dimension
dimension CubicLength a
_ = Rational
Scalar Dimension
3 Scalar Dimension -> Dimension -> Dimension
forall v. VectorSpace v => Scalar v -> v -> v
%* Dimension
meterDimension
    unitOf :: CubicLength a -> String
unitOf CubicLength a
_ = String
"m^3"
 instance (Show a, Num a) => LiteralUnit (CubicLength a) where { fromAmount :: Scalar (CubicLength a) -> CubicLength a
fromAmount = a -> CubicLength a
Scalar (CubicLength a) -> CubicLength a
forall a. a -> CubicLength a
CubicMeters }
 instance (Num a, Show a) => Show (SquareLength a) where { show :: SquareLength a -> String
show = SquareLength a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }
 instance (Num a, Show a) => Unit (SquareLength a) where
    amount :: SquareLength a -> Scalar (SquareLength a)
amount = SquareLength a -> a
SquareLength a -> Scalar (SquareLength a)
forall a. SquareLength a -> a
squaremeters
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (SquareLength a)) -> m (SquareLength a)
fromQuantity = Dimension
-> (a -> SquareLength a) -> Quantity a -> m (SquareLength a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
squaremeterDimension a -> SquareLength a
forall a. a -> SquareLength a
SquareMeters
    dimension :: SquareLength a -> Dimension
dimension SquareLength a
_ = Dimension
meterDimension Dimension -> Dimension -> Dimension
forall v. VectorSpace v => v -> v -> v
%+ Dimension
meterDimension
    unitOf :: SquareLength a -> String
unitOf SquareLength a
_ = String
"m^2"
 instance (Show a, Num a) => LiteralUnit (SquareLength a) where { fromAmount :: Scalar (SquareLength a) -> SquareLength a
fromAmount = a -> SquareLength a
Scalar (SquareLength a) -> SquareLength a
forall a. a -> SquareLength a
SquareMeters }
 -- types for basic units <https://en.wikipedia.org/wiki/International_System_of_Units>
 newtype Length a = Meters { forall a. Length a -> a
meters :: a }
  deriving (Length a -> Length a -> Bool
(Length a -> Length a -> Bool)
-> (Length a -> Length a -> Bool) -> Eq (Length a)
forall a. Eq a => Length a -> Length a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Length a -> Length a -> Bool
== :: Length a -> Length a -> Bool
$c/= :: forall a. Eq a => Length a -> Length a -> Bool
/= :: Length a -> Length a -> Bool
Eq,Eq (Length a)
Eq (Length a) =>
(Length a -> Length a -> Ordering)
-> (Length a -> Length a -> Bool)
-> (Length a -> Length a -> Bool)
-> (Length a -> Length a -> Bool)
-> (Length a -> Length a -> Bool)
-> (Length a -> Length a -> Length a)
-> (Length a -> Length a -> Length a)
-> Ord (Length a)
Length a -> Length a -> Bool
Length a -> Length a -> Ordering
Length a -> Length a -> Length a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Length a)
forall a. Ord a => Length a -> Length a -> Bool
forall a. Ord a => Length a -> Length a -> Ordering
forall a. Ord a => Length a -> Length a -> Length a
$ccompare :: forall a. Ord a => Length a -> Length a -> Ordering
compare :: Length a -> Length a -> Ordering
$c< :: forall a. Ord a => Length a -> Length a -> Bool
< :: Length a -> Length a -> Bool
$c<= :: forall a. Ord a => Length a -> Length a -> Bool
<= :: Length a -> Length a -> Bool
$c> :: forall a. Ord a => Length a -> Length a -> Bool
> :: Length a -> Length a -> Bool
$c>= :: forall a. Ord a => Length a -> Length a -> Bool
>= :: Length a -> Length a -> Bool
$cmax :: forall a. Ord a => Length a -> Length a -> Length a
max :: Length a -> Length a -> Length a
$cmin :: forall a. Ord a => Length a -> Length a -> Length a
min :: Length a -> Length a -> Length a
Ord, Typeable, Typeable (Length a)
Typeable (Length a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Length a -> c (Length a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Length a))
-> (Length a -> Constr)
-> (Length a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Length a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Length a)))
-> ((forall b. Data b => b -> b) -> Length a -> Length a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Length a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Length a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Length a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Length a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Length a -> m (Length a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Length a -> m (Length a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Length a -> m (Length a))
-> Data (Length a)
Length a -> Constr
Length a -> DataType
(forall b. Data b => b -> b) -> Length a -> Length a
forall a. Data a => Typeable (Length a)
forall a. Data a => Length a -> Constr
forall a. Data a => Length a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Length a -> Length a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Length a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Length a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Length a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Length a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Length a -> m (Length a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Length a -> m (Length a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Length a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Length a -> c (Length a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Length a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Length a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Length a -> u
forall u. (forall d. Data d => d -> u) -> Length a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Length a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Length a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Length a -> m (Length a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Length a -> m (Length a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Length a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Length a -> c (Length a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Length a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Length a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Length a -> c (Length a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Length a -> c (Length a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Length a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Length a)
$ctoConstr :: forall a. Data a => Length a -> Constr
toConstr :: Length a -> Constr
$cdataTypeOf :: forall a. Data a => Length a -> DataType
dataTypeOf :: Length a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Length a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Length a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Length a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Length a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Length a -> Length a
gmapT :: (forall b. Data b => b -> b) -> Length a -> Length a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Length a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Length a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Length a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Length a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Length a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Length a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Length a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Length a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Length a -> m (Length a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Length a -> m (Length a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Length a -> m (Length a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Length a -> m (Length a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Length a -> m (Length a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Length a -> m (Length a)
Data, (forall x. Length a -> Rep (Length a) x)
-> (forall x. Rep (Length a) x -> Length a) -> Generic (Length a)
forall x. Rep (Length a) x -> Length a
forall x. Length a -> Rep (Length a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Length a) x -> Length a
forall a x. Length a -> Rep (Length a) x
$cfrom :: forall a x. Length a -> Rep (Length a) x
from :: forall x. Length a -> Rep (Length a) x
$cto :: forall a x. Rep (Length a) x -> Length a
to :: forall x. Rep (Length a) x -> Length a
Generic)
  deriving newtype (Get (Length a)
[Length a] -> Put
Length a -> Put
(Length a -> Put)
-> Get (Length a) -> ([Length a] -> Put) -> Binary (Length a)
forall a. Binary a => Get (Length a)
forall a. Binary a => [Length a] -> Put
forall a. Binary a => Length a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Length a -> Put
put :: Length a -> Put
$cget :: forall a. Binary a => Get (Length a)
get :: Get (Length a)
$cputList :: forall a. Binary a => [Length a] -> Put
putList :: [Length a] -> Put
Binary)
 instance (Num a, Show a) => Show (Length a) where { show :: Length a -> String
show = Length a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Mass a = Kilograms { forall a. Mass a -> a
kilograms :: a }
   deriving (Mass a -> Mass a -> Bool
(Mass a -> Mass a -> Bool)
-> (Mass a -> Mass a -> Bool) -> Eq (Mass a)
forall a. Eq a => Mass a -> Mass a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Mass a -> Mass a -> Bool
== :: Mass a -> Mass a -> Bool
$c/= :: forall a. Eq a => Mass a -> Mass a -> Bool
/= :: Mass a -> Mass a -> Bool
Eq,Eq (Mass a)
Eq (Mass a) =>
(Mass a -> Mass a -> Ordering)
-> (Mass a -> Mass a -> Bool)
-> (Mass a -> Mass a -> Bool)
-> (Mass a -> Mass a -> Bool)
-> (Mass a -> Mass a -> Bool)
-> (Mass a -> Mass a -> Mass a)
-> (Mass a -> Mass a -> Mass a)
-> Ord (Mass a)
Mass a -> Mass a -> Bool
Mass a -> Mass a -> Ordering
Mass a -> Mass a -> Mass a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Mass a)
forall a. Ord a => Mass a -> Mass a -> Bool
forall a. Ord a => Mass a -> Mass a -> Ordering
forall a. Ord a => Mass a -> Mass a -> Mass a
$ccompare :: forall a. Ord a => Mass a -> Mass a -> Ordering
compare :: Mass a -> Mass a -> Ordering
$c< :: forall a. Ord a => Mass a -> Mass a -> Bool
< :: Mass a -> Mass a -> Bool
$c<= :: forall a. Ord a => Mass a -> Mass a -> Bool
<= :: Mass a -> Mass a -> Bool
$c> :: forall a. Ord a => Mass a -> Mass a -> Bool
> :: Mass a -> Mass a -> Bool
$c>= :: forall a. Ord a => Mass a -> Mass a -> Bool
>= :: Mass a -> Mass a -> Bool
$cmax :: forall a. Ord a => Mass a -> Mass a -> Mass a
max :: Mass a -> Mass a -> Mass a
$cmin :: forall a. Ord a => Mass a -> Mass a -> Mass a
min :: Mass a -> Mass a -> Mass a
Ord, Typeable, Typeable (Mass a)
Typeable (Mass a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Mass a -> c (Mass a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Mass a))
-> (Mass a -> Constr)
-> (Mass a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Mass a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Mass a)))
-> ((forall b. Data b => b -> b) -> Mass a -> Mass a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Mass a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Mass a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Mass a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Mass a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Mass a -> m (Mass a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Mass a -> m (Mass a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Mass a -> m (Mass a))
-> Data (Mass a)
Mass a -> Constr
Mass a -> DataType
(forall b. Data b => b -> b) -> Mass a -> Mass a
forall a. Data a => Typeable (Mass a)
forall a. Data a => Mass a -> Constr
forall a. Data a => Mass a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Mass a -> Mass a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Mass a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> Mass a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mass a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mass a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Mass a -> m (Mass a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Mass a -> m (Mass a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Mass a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mass a -> c (Mass a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Mass a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Mass a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Mass a -> u
forall u. (forall d. Data d => d -> u) -> Mass a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mass a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mass a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mass a -> m (Mass a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mass a -> m (Mass a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Mass a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mass a -> c (Mass a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Mass a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Mass a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mass a -> c (Mass a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mass a -> c (Mass a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Mass a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Mass a)
$ctoConstr :: forall a. Data a => Mass a -> Constr
toConstr :: Mass a -> Constr
$cdataTypeOf :: forall a. Data a => Mass a -> DataType
dataTypeOf :: Mass a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Mass a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Mass a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Mass a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Mass a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Mass a -> Mass a
gmapT :: (forall b. Data b => b -> b) -> Mass a -> Mass a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mass a -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mass a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mass a -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mass a -> r
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Mass a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Mass a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Mass a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Mass a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Mass a -> m (Mass a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mass a -> m (Mass a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Mass a -> m (Mass a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mass a -> m (Mass a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Mass a -> m (Mass a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mass a -> m (Mass a)
Data, (forall x. Mass a -> Rep (Mass a) x)
-> (forall x. Rep (Mass a) x -> Mass a) -> Generic (Mass a)
forall x. Rep (Mass a) x -> Mass a
forall x. Mass a -> Rep (Mass a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Mass a) x -> Mass a
forall a x. Mass a -> Rep (Mass a) x
$cfrom :: forall a x. Mass a -> Rep (Mass a) x
from :: forall x. Mass a -> Rep (Mass a) x
$cto :: forall a x. Rep (Mass a) x -> Mass a
to :: forall x. Rep (Mass a) x -> Mass a
Generic)
   deriving newtype (Get (Mass a)
[Mass a] -> Put
Mass a -> Put
(Mass a -> Put)
-> Get (Mass a) -> ([Mass a] -> Put) -> Binary (Mass a)
forall a. Binary a => Get (Mass a)
forall a. Binary a => [Mass a] -> Put
forall a. Binary a => Mass a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Mass a -> Put
put :: Mass a -> Put
$cget :: forall a. Binary a => Get (Mass a)
get :: Get (Mass a)
$cputList :: forall a. Binary a => [Mass a] -> Put
putList :: [Mass a] -> Put
Binary)
 instance (Num a, Show a) => Show ( Mass  a) where { show :: Mass a -> String
show = Mass a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }
 newtype Time a = Seconds { forall a. Time a -> a
seconds :: a }
  deriving (Time a -> Time a -> Bool
(Time a -> Time a -> Bool)
-> (Time a -> Time a -> Bool) -> Eq (Time a)
forall a. Eq a => Time a -> Time a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Time a -> Time a -> Bool
== :: Time a -> Time a -> Bool
$c/= :: forall a. Eq a => Time a -> Time a -> Bool
/= :: Time a -> Time a -> Bool
Eq,Eq (Time a)
Eq (Time a) =>
(Time a -> Time a -> Ordering)
-> (Time a -> Time a -> Bool)
-> (Time a -> Time a -> Bool)
-> (Time a -> Time a -> Bool)
-> (Time a -> Time a -> Bool)
-> (Time a -> Time a -> Time a)
-> (Time a -> Time a -> Time a)
-> Ord (Time a)
Time a -> Time a -> Bool
Time a -> Time a -> Ordering
Time a -> Time a -> Time a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Time a)
forall a. Ord a => Time a -> Time a -> Bool
forall a. Ord a => Time a -> Time a -> Ordering
forall a. Ord a => Time a -> Time a -> Time a
$ccompare :: forall a. Ord a => Time a -> Time a -> Ordering
compare :: Time a -> Time a -> Ordering
$c< :: forall a. Ord a => Time a -> Time a -> Bool
< :: Time a -> Time a -> Bool
$c<= :: forall a. Ord a => Time a -> Time a -> Bool
<= :: Time a -> Time a -> Bool
$c> :: forall a. Ord a => Time a -> Time a -> Bool
> :: Time a -> Time a -> Bool
$c>= :: forall a. Ord a => Time a -> Time a -> Bool
>= :: Time a -> Time a -> Bool
$cmax :: forall a. Ord a => Time a -> Time a -> Time a
max :: Time a -> Time a -> Time a
$cmin :: forall a. Ord a => Time a -> Time a -> Time a
min :: Time a -> Time a -> Time a
Ord, Typeable, Typeable (Time a)
Typeable (Time a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Time a -> c (Time a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Time a))
-> (Time a -> Constr)
-> (Time a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Time a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Time a)))
-> ((forall b. Data b => b -> b) -> Time a -> Time a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Time a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Time a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Time a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Time a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Time a -> m (Time a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Time a -> m (Time a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Time a -> m (Time a))
-> Data (Time a)
Time a -> Constr
Time a -> DataType
(forall b. Data b => b -> b) -> Time a -> Time a
forall a. Data a => Typeable (Time a)
forall a. Data a => Time a -> Constr
forall a. Data a => Time a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Time a -> Time a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Time a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> Time a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Time a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Time a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Time a -> m (Time a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Time a -> m (Time a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Time a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Time a -> c (Time a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Time a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Time a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Time a -> u
forall u. (forall d. Data d => d -> u) -> Time a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Time a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Time a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Time a -> m (Time a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Time a -> m (Time a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Time a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Time a -> c (Time a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Time a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Time a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Time a -> c (Time a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Time a -> c (Time a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Time a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Time a)
$ctoConstr :: forall a. Data a => Time a -> Constr
toConstr :: Time a -> Constr
$cdataTypeOf :: forall a. Data a => Time a -> DataType
dataTypeOf :: Time a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Time a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Time a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Time a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Time a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Time a -> Time a
gmapT :: (forall b. Data b => b -> b) -> Time a -> Time a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Time a -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Time a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Time a -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Time a -> r
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Time a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Time a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Time a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Time a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Time a -> m (Time a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Time a -> m (Time a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Time a -> m (Time a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Time a -> m (Time a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Time a -> m (Time a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Time a -> m (Time a)
Data, (forall x. Time a -> Rep (Time a) x)
-> (forall x. Rep (Time a) x -> Time a) -> Generic (Time a)
forall x. Rep (Time a) x -> Time a
forall x. Time a -> Rep (Time a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Time a) x -> Time a
forall a x. Time a -> Rep (Time a) x
$cfrom :: forall a x. Time a -> Rep (Time a) x
from :: forall x. Time a -> Rep (Time a) x
$cto :: forall a x. Rep (Time a) x -> Time a
to :: forall x. Rep (Time a) x -> Time a
Generic)
  deriving newtype (Get (Time a)
[Time a] -> Put
Time a -> Put
(Time a -> Put)
-> Get (Time a) -> ([Time a] -> Put) -> Binary (Time a)
forall a. Binary a => Get (Time a)
forall a. Binary a => [Time a] -> Put
forall a. Binary a => Time a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Time a -> Put
put :: Time a -> Put
$cget :: forall a. Binary a => Get (Time a)
get :: Get (Time a)
$cputList :: forall a. Binary a => [Time a] -> Put
putList :: [Time a] -> Put
Binary)
 instance (Num a, Show a) => Show (Time a) where { show :: Time a -> String
show = Time a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Current a = Amperes { forall a. Current a -> a
amperes :: a }
   deriving (Current a -> Current a -> Bool
(Current a -> Current a -> Bool)
-> (Current a -> Current a -> Bool) -> Eq (Current a)
forall a. Eq a => Current a -> Current a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Current a -> Current a -> Bool
== :: Current a -> Current a -> Bool
$c/= :: forall a. Eq a => Current a -> Current a -> Bool
/= :: Current a -> Current a -> Bool
Eq,Eq (Current a)
Eq (Current a) =>
(Current a -> Current a -> Ordering)
-> (Current a -> Current a -> Bool)
-> (Current a -> Current a -> Bool)
-> (Current a -> Current a -> Bool)
-> (Current a -> Current a -> Bool)
-> (Current a -> Current a -> Current a)
-> (Current a -> Current a -> Current a)
-> Ord (Current a)
Current a -> Current a -> Bool
Current a -> Current a -> Ordering
Current a -> Current a -> Current a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Current a)
forall a. Ord a => Current a -> Current a -> Bool
forall a. Ord a => Current a -> Current a -> Ordering
forall a. Ord a => Current a -> Current a -> Current a
$ccompare :: forall a. Ord a => Current a -> Current a -> Ordering
compare :: Current a -> Current a -> Ordering
$c< :: forall a. Ord a => Current a -> Current a -> Bool
< :: Current a -> Current a -> Bool
$c<= :: forall a. Ord a => Current a -> Current a -> Bool
<= :: Current a -> Current a -> Bool
$c> :: forall a. Ord a => Current a -> Current a -> Bool
> :: Current a -> Current a -> Bool
$c>= :: forall a. Ord a => Current a -> Current a -> Bool
>= :: Current a -> Current a -> Bool
$cmax :: forall a. Ord a => Current a -> Current a -> Current a
max :: Current a -> Current a -> Current a
$cmin :: forall a. Ord a => Current a -> Current a -> Current a
min :: Current a -> Current a -> Current a
Ord, Typeable, Typeable (Current a)
Typeable (Current a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Current a -> c (Current a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Current a))
-> (Current a -> Constr)
-> (Current a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Current a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Current a)))
-> ((forall b. Data b => b -> b) -> Current a -> Current a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Current a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Current a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Current a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Current a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Current a -> m (Current a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Current a -> m (Current a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Current a -> m (Current a))
-> Data (Current a)
Current a -> Constr
Current a -> DataType
(forall b. Data b => b -> b) -> Current a -> Current a
forall a. Data a => Typeable (Current a)
forall a. Data a => Current a -> Constr
forall a. Data a => Current a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Current a -> Current a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Current a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Current a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Current a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Current a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Current a -> m (Current a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Current a -> m (Current a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Current a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Current a -> c (Current a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Current a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Current a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Current a -> u
forall u. (forall d. Data d => d -> u) -> Current a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Current a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Current a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Current a -> m (Current a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Current a -> m (Current a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Current a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Current a -> c (Current a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Current a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Current a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Current a -> c (Current a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Current a -> c (Current a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Current a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Current a)
$ctoConstr :: forall a. Data a => Current a -> Constr
toConstr :: Current a -> Constr
$cdataTypeOf :: forall a. Data a => Current a -> DataType
dataTypeOf :: Current a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Current a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Current a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Current a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Current a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Current a -> Current a
gmapT :: (forall b. Data b => b -> b) -> Current a -> Current a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Current a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Current a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Current a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Current a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Current a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Current a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Current a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Current a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Current a -> m (Current a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Current a -> m (Current a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Current a -> m (Current a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Current a -> m (Current a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Current a -> m (Current a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Current a -> m (Current a)
Data, (forall x. Current a -> Rep (Current a) x)
-> (forall x. Rep (Current a) x -> Current a)
-> Generic (Current a)
forall x. Rep (Current a) x -> Current a
forall x. Current a -> Rep (Current a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Current a) x -> Current a
forall a x. Current a -> Rep (Current a) x
$cfrom :: forall a x. Current a -> Rep (Current a) x
from :: forall x. Current a -> Rep (Current a) x
$cto :: forall a x. Rep (Current a) x -> Current a
to :: forall x. Rep (Current a) x -> Current a
Generic)
   deriving newtype (Get (Current a)
[Current a] -> Put
Current a -> Put
(Current a -> Put)
-> Get (Current a) -> ([Current a] -> Put) -> Binary (Current a)
forall a. Binary a => Get (Current a)
forall a. Binary a => [Current a] -> Put
forall a. Binary a => Current a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Current a -> Put
put :: Current a -> Put
$cget :: forall a. Binary a => Get (Current a)
get :: Get (Current a)
$cputList :: forall a. Binary a => [Current a] -> Put
putList :: [Current a] -> Put
Binary)
 instance (Num a, Show a) => Show (Current a) where { show :: Current a -> String
show = Current a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 -- | <https://en.wikipedia.org/wiki/Fahrenheit>
 newtype DegreesFahrenheit a = DegreesFahrenheit { forall a. DegreesFahrenheit a -> a
fahrenheits :: a }
  deriving (DegreesFahrenheit a -> DegreesFahrenheit a -> Bool
(DegreesFahrenheit a -> DegreesFahrenheit a -> Bool)
-> (DegreesFahrenheit a -> DegreesFahrenheit a -> Bool)
-> Eq (DegreesFahrenheit a)
forall a.
Eq a =>
DegreesFahrenheit a -> DegreesFahrenheit a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a.
Eq a =>
DegreesFahrenheit a -> DegreesFahrenheit a -> Bool
== :: DegreesFahrenheit a -> DegreesFahrenheit a -> Bool
$c/= :: forall a.
Eq a =>
DegreesFahrenheit a -> DegreesFahrenheit a -> Bool
/= :: DegreesFahrenheit a -> DegreesFahrenheit a -> Bool
Eq,Eq (DegreesFahrenheit a)
Eq (DegreesFahrenheit a) =>
(DegreesFahrenheit a -> DegreesFahrenheit a -> Ordering)
-> (DegreesFahrenheit a -> DegreesFahrenheit a -> Bool)
-> (DegreesFahrenheit a -> DegreesFahrenheit a -> Bool)
-> (DegreesFahrenheit a -> DegreesFahrenheit a -> Bool)
-> (DegreesFahrenheit a -> DegreesFahrenheit a -> Bool)
-> (DegreesFahrenheit a
    -> DegreesFahrenheit a -> DegreesFahrenheit a)
-> (DegreesFahrenheit a
    -> DegreesFahrenheit a -> DegreesFahrenheit a)
-> Ord (DegreesFahrenheit a)
DegreesFahrenheit a -> DegreesFahrenheit a -> Bool
DegreesFahrenheit a -> DegreesFahrenheit a -> Ordering
DegreesFahrenheit a -> DegreesFahrenheit a -> DegreesFahrenheit a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (DegreesFahrenheit a)
forall a.
Ord a =>
DegreesFahrenheit a -> DegreesFahrenheit a -> Bool
forall a.
Ord a =>
DegreesFahrenheit a -> DegreesFahrenheit a -> Ordering
forall a.
Ord a =>
DegreesFahrenheit a -> DegreesFahrenheit a -> DegreesFahrenheit a
$ccompare :: forall a.
Ord a =>
DegreesFahrenheit a -> DegreesFahrenheit a -> Ordering
compare :: DegreesFahrenheit a -> DegreesFahrenheit a -> Ordering
$c< :: forall a.
Ord a =>
DegreesFahrenheit a -> DegreesFahrenheit a -> Bool
< :: DegreesFahrenheit a -> DegreesFahrenheit a -> Bool
$c<= :: forall a.
Ord a =>
DegreesFahrenheit a -> DegreesFahrenheit a -> Bool
<= :: DegreesFahrenheit a -> DegreesFahrenheit a -> Bool
$c> :: forall a.
Ord a =>
DegreesFahrenheit a -> DegreesFahrenheit a -> Bool
> :: DegreesFahrenheit a -> DegreesFahrenheit a -> Bool
$c>= :: forall a.
Ord a =>
DegreesFahrenheit a -> DegreesFahrenheit a -> Bool
>= :: DegreesFahrenheit a -> DegreesFahrenheit a -> Bool
$cmax :: forall a.
Ord a =>
DegreesFahrenheit a -> DegreesFahrenheit a -> DegreesFahrenheit a
max :: DegreesFahrenheit a -> DegreesFahrenheit a -> DegreesFahrenheit a
$cmin :: forall a.
Ord a =>
DegreesFahrenheit a -> DegreesFahrenheit a -> DegreesFahrenheit a
min :: DegreesFahrenheit a -> DegreesFahrenheit a -> DegreesFahrenheit a
Ord, Typeable, Typeable (DegreesFahrenheit a)
Typeable (DegreesFahrenheit a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DegreesFahrenheit a
 -> c (DegreesFahrenheit a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DegreesFahrenheit a))
-> (DegreesFahrenheit a -> Constr)
-> (DegreesFahrenheit a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DegreesFahrenheit a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DegreesFahrenheit a)))
-> ((forall b. Data b => b -> b)
    -> DegreesFahrenheit a -> DegreesFahrenheit a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DegreesFahrenheit a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DegreesFahrenheit a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DegreesFahrenheit a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DegreesFahrenheit a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DegreesFahrenheit a -> m (DegreesFahrenheit a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DegreesFahrenheit a -> m (DegreesFahrenheit a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DegreesFahrenheit a -> m (DegreesFahrenheit a))
-> Data (DegreesFahrenheit a)
DegreesFahrenheit a -> Constr
DegreesFahrenheit a -> DataType
(forall b. Data b => b -> b)
-> DegreesFahrenheit a -> DegreesFahrenheit a
forall a. Data a => Typeable (DegreesFahrenheit a)
forall a. Data a => DegreesFahrenheit a -> Constr
forall a. Data a => DegreesFahrenheit a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b)
-> DegreesFahrenheit a -> DegreesFahrenheit a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> DegreesFahrenheit a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> DegreesFahrenheit a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesFahrenheit a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesFahrenheit a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> DegreesFahrenheit a -> m (DegreesFahrenheit a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DegreesFahrenheit a -> m (DegreesFahrenheit a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DegreesFahrenheit a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DegreesFahrenheit a
-> c (DegreesFahrenheit a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DegreesFahrenheit a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DegreesFahrenheit a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DegreesFahrenheit a -> u
forall u.
(forall d. Data d => d -> u) -> DegreesFahrenheit a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesFahrenheit a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesFahrenheit a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DegreesFahrenheit a -> m (DegreesFahrenheit a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DegreesFahrenheit a -> m (DegreesFahrenheit a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DegreesFahrenheit a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DegreesFahrenheit a
-> c (DegreesFahrenheit a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DegreesFahrenheit a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DegreesFahrenheit a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DegreesFahrenheit a
-> c (DegreesFahrenheit a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DegreesFahrenheit a
-> c (DegreesFahrenheit a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DegreesFahrenheit a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DegreesFahrenheit a)
$ctoConstr :: forall a. Data a => DegreesFahrenheit a -> Constr
toConstr :: DegreesFahrenheit a -> Constr
$cdataTypeOf :: forall a. Data a => DegreesFahrenheit a -> DataType
dataTypeOf :: DegreesFahrenheit a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DegreesFahrenheit a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DegreesFahrenheit a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DegreesFahrenheit a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DegreesFahrenheit a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b)
-> DegreesFahrenheit a -> DegreesFahrenheit a
gmapT :: (forall b. Data b => b -> b)
-> DegreesFahrenheit a -> DegreesFahrenheit a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesFahrenheit a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesFahrenheit a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesFahrenheit a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesFahrenheit a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> DegreesFahrenheit a -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> DegreesFahrenheit a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> DegreesFahrenheit a -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DegreesFahrenheit a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> DegreesFahrenheit a -> m (DegreesFahrenheit a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DegreesFahrenheit a -> m (DegreesFahrenheit a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DegreesFahrenheit a -> m (DegreesFahrenheit a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DegreesFahrenheit a -> m (DegreesFahrenheit a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DegreesFahrenheit a -> m (DegreesFahrenheit a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DegreesFahrenheit a -> m (DegreesFahrenheit a)
Data, (forall x. DegreesFahrenheit a -> Rep (DegreesFahrenheit a) x)
-> (forall x. Rep (DegreesFahrenheit a) x -> DegreesFahrenheit a)
-> Generic (DegreesFahrenheit a)
forall x. Rep (DegreesFahrenheit a) x -> DegreesFahrenheit a
forall x. DegreesFahrenheit a -> Rep (DegreesFahrenheit a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (DegreesFahrenheit a) x -> DegreesFahrenheit a
forall a x. DegreesFahrenheit a -> Rep (DegreesFahrenheit a) x
$cfrom :: forall a x. DegreesFahrenheit a -> Rep (DegreesFahrenheit a) x
from :: forall x. DegreesFahrenheit a -> Rep (DegreesFahrenheit a) x
$cto :: forall a x. Rep (DegreesFahrenheit a) x -> DegreesFahrenheit a
to :: forall x. Rep (DegreesFahrenheit a) x -> DegreesFahrenheit a
Generic)
  deriving newtype (Get (DegreesFahrenheit a)
[DegreesFahrenheit a] -> Put
DegreesFahrenheit a -> Put
(DegreesFahrenheit a -> Put)
-> Get (DegreesFahrenheit a)
-> ([DegreesFahrenheit a] -> Put)
-> Binary (DegreesFahrenheit a)
forall a. Binary a => Get (DegreesFahrenheit a)
forall a. Binary a => [DegreesFahrenheit a] -> Put
forall a. Binary a => DegreesFahrenheit a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => DegreesFahrenheit a -> Put
put :: DegreesFahrenheit a -> Put
$cget :: forall a. Binary a => Get (DegreesFahrenheit a)
get :: Get (DegreesFahrenheit a)
$cputList :: forall a. Binary a => [DegreesFahrenheit a] -> Put
putList :: [DegreesFahrenheit a] -> Put
Binary)
 instance (Fractional a, Show a) => Show (DegreesFahrenheit a) where { show :: DegreesFahrenheit a -> String
show = DegreesFahrenheit a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }
 instance (Fractional a, Show a) => Unit (DegreesFahrenheit a) where
    amount :: DegreesFahrenheit a -> Scalar (DegreesFahrenheit a)
amount = DegreesFahrenheit a -> a
DegreesFahrenheit a -> Scalar (DegreesFahrenheit a)
forall a. DegreesFahrenheit a -> a
fahrenheits
    dimension :: DegreesFahrenheit a -> Dimension
dimension DegreesFahrenheit a
_ = Dimension
kelvinDimension
    unitOf :: DegreesFahrenheit a -> String
unitOf DegreesFahrenheit a
_ = String
"°F"
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (DegreesFahrenheit a)) -> m (DegreesFahrenheit a)
fromQuantity Quantity (Scalar (DegreesFahrenheit a))
x
      | Quantity a -> Dimension
forall r. Quantity r -> Dimension
valueDimension Quantity a
Quantity (Scalar (DegreesFahrenheit a))
x Dimension -> Dimension -> Bool
forall a. Eq a => a -> a -> Bool
== Dimension
kelvinDimension = DegreesFahrenheit a -> m (DegreesFahrenheit a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (DegreesFahrenheit a -> m (DegreesFahrenheit a))
-> DegreesFahrenheit a -> m (DegreesFahrenheit a)
forall a b. (a -> b) -> a -> b
$ a -> DegreesFahrenheit a
forall a. a -> DegreesFahrenheit a
DegreesFahrenheit (a -> DegreesFahrenheit a) -> a -> DegreesFahrenheit a
forall a b. (a -> b) -> a -> b
$
                             (Quantity a -> a
forall r. Quantity r -> r
valueAmount Quantity a
Quantity (Scalar (DegreesFahrenheit a))
x a -> a -> a
forall a. Num a => a -> a -> a
* (a
9a -> a -> a
forall a. Fractional a => a -> a -> a
/a
5) a -> a -> a
forall a. Num a => a -> a -> a
- a
459.67)
      | Bool
otherwise = String
-> Dimension -> Dimension -> a -> a -> m (DegreesFahrenheit a)
forall b c a.
(Show b, Show c) =>
String -> Dimension -> Dimension -> b -> c -> a
invalidDimensions String
"fromQuantity:DegreesFahrenheit" (Quantity a -> Dimension
forall r. Quantity r -> Dimension
valueDimension Quantity a
Quantity (Scalar (DegreesFahrenheit a))
x) Dimension
kelvinDimension (Quantity a -> a
forall r. Quantity r -> r
valueAmount Quantity a
Quantity (Scalar (DegreesFahrenheit a))
x) (Quantity a -> a
forall r. Quantity r -> r
valueAmount Quantity a
Quantity (Scalar (DegreesFahrenheit a))
x)
 instance (Show a, Fractional a) => LiteralUnit (DegreesFahrenheit a) where
   fromAmount :: Scalar (DegreesFahrenheit a) -> DegreesFahrenheit a
fromAmount = a -> DegreesFahrenheit a
Scalar (DegreesFahrenheit a) -> DegreesFahrenheit a
forall a. a -> DegreesFahrenheit a
DegreesFahrenheit
   conversionFactor :: (Scalar (DegreesFahrenheit a) -> DegreesFahrenheit a)
-> Scalar (DegreesFahrenheit a)
conversionFactor Scalar (DegreesFahrenheit a) -> DegreesFahrenheit a
_ = a
5a -> a -> a
forall a. Fractional a => a -> a -> a
/a
9
   zeroAmount :: (Scalar (DegreesFahrenheit a) -> DegreesFahrenheit a)
-> Scalar (DegreesFahrenheit a)
zeroAmount Scalar (DegreesFahrenheit a) -> DegreesFahrenheit a
_ = a
Scalar (DegreesFahrenheit a)
459.67
 
 -- | <https://en.wikipedia.org/wiki/Rankine_scale>
 newtype DegreesRankine a = DegreesRankine { forall a. DegreesRankine a -> a
rankines :: a }
  deriving (DegreesRankine a -> DegreesRankine a -> Bool
(DegreesRankine a -> DegreesRankine a -> Bool)
-> (DegreesRankine a -> DegreesRankine a -> Bool)
-> Eq (DegreesRankine a)
forall a. Eq a => DegreesRankine a -> DegreesRankine a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => DegreesRankine a -> DegreesRankine a -> Bool
== :: DegreesRankine a -> DegreesRankine a -> Bool
$c/= :: forall a. Eq a => DegreesRankine a -> DegreesRankine a -> Bool
/= :: DegreesRankine a -> DegreesRankine a -> Bool
Eq, Eq (DegreesRankine a)
Eq (DegreesRankine a) =>
(DegreesRankine a -> DegreesRankine a -> Ordering)
-> (DegreesRankine a -> DegreesRankine a -> Bool)
-> (DegreesRankine a -> DegreesRankine a -> Bool)
-> (DegreesRankine a -> DegreesRankine a -> Bool)
-> (DegreesRankine a -> DegreesRankine a -> Bool)
-> (DegreesRankine a -> DegreesRankine a -> DegreesRankine a)
-> (DegreesRankine a -> DegreesRankine a -> DegreesRankine a)
-> Ord (DegreesRankine a)
DegreesRankine a -> DegreesRankine a -> Bool
DegreesRankine a -> DegreesRankine a -> Ordering
DegreesRankine a -> DegreesRankine a -> DegreesRankine a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (DegreesRankine a)
forall a. Ord a => DegreesRankine a -> DegreesRankine a -> Bool
forall a. Ord a => DegreesRankine a -> DegreesRankine a -> Ordering
forall a.
Ord a =>
DegreesRankine a -> DegreesRankine a -> DegreesRankine a
$ccompare :: forall a. Ord a => DegreesRankine a -> DegreesRankine a -> Ordering
compare :: DegreesRankine a -> DegreesRankine a -> Ordering
$c< :: forall a. Ord a => DegreesRankine a -> DegreesRankine a -> Bool
< :: DegreesRankine a -> DegreesRankine a -> Bool
$c<= :: forall a. Ord a => DegreesRankine a -> DegreesRankine a -> Bool
<= :: DegreesRankine a -> DegreesRankine a -> Bool
$c> :: forall a. Ord a => DegreesRankine a -> DegreesRankine a -> Bool
> :: DegreesRankine a -> DegreesRankine a -> Bool
$c>= :: forall a. Ord a => DegreesRankine a -> DegreesRankine a -> Bool
>= :: DegreesRankine a -> DegreesRankine a -> Bool
$cmax :: forall a.
Ord a =>
DegreesRankine a -> DegreesRankine a -> DegreesRankine a
max :: DegreesRankine a -> DegreesRankine a -> DegreesRankine a
$cmin :: forall a.
Ord a =>
DegreesRankine a -> DegreesRankine a -> DegreesRankine a
min :: DegreesRankine a -> DegreesRankine a -> DegreesRankine a
Ord, Typeable, Typeable (DegreesRankine a)
Typeable (DegreesRankine a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DegreesRankine a
 -> c (DegreesRankine a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DegreesRankine a))
-> (DegreesRankine a -> Constr)
-> (DegreesRankine a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DegreesRankine a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DegreesRankine a)))
-> ((forall b. Data b => b -> b)
    -> DegreesRankine a -> DegreesRankine a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DegreesRankine a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DegreesRankine a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DegreesRankine a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DegreesRankine a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DegreesRankine a -> m (DegreesRankine a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DegreesRankine a -> m (DegreesRankine a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DegreesRankine a -> m (DegreesRankine a))
-> Data (DegreesRankine a)
DegreesRankine a -> Constr
DegreesRankine a -> DataType
(forall b. Data b => b -> b)
-> DegreesRankine a -> DegreesRankine a
forall a. Data a => Typeable (DegreesRankine a)
forall a. Data a => DegreesRankine a -> Constr
forall a. Data a => DegreesRankine a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b)
-> DegreesRankine a -> DegreesRankine a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> DegreesRankine a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> DegreesRankine a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesRankine a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesRankine a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> DegreesRankine a -> m (DegreesRankine a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DegreesRankine a -> m (DegreesRankine a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DegreesRankine a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DegreesRankine a -> c (DegreesRankine a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DegreesRankine a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DegreesRankine a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DegreesRankine a -> u
forall u. (forall d. Data d => d -> u) -> DegreesRankine a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesRankine a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesRankine a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DegreesRankine a -> m (DegreesRankine a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DegreesRankine a -> m (DegreesRankine a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DegreesRankine a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DegreesRankine a -> c (DegreesRankine a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DegreesRankine a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DegreesRankine a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DegreesRankine a -> c (DegreesRankine a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DegreesRankine a -> c (DegreesRankine a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DegreesRankine a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DegreesRankine a)
$ctoConstr :: forall a. Data a => DegreesRankine a -> Constr
toConstr :: DegreesRankine a -> Constr
$cdataTypeOf :: forall a. Data a => DegreesRankine a -> DataType
dataTypeOf :: DegreesRankine a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DegreesRankine a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DegreesRankine a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DegreesRankine a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DegreesRankine a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b)
-> DegreesRankine a -> DegreesRankine a
gmapT :: (forall b. Data b => b -> b)
-> DegreesRankine a -> DegreesRankine a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesRankine a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesRankine a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesRankine a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesRankine a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> DegreesRankine a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DegreesRankine a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> DegreesRankine a -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DegreesRankine a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> DegreesRankine a -> m (DegreesRankine a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DegreesRankine a -> m (DegreesRankine a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DegreesRankine a -> m (DegreesRankine a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DegreesRankine a -> m (DegreesRankine a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DegreesRankine a -> m (DegreesRankine a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DegreesRankine a -> m (DegreesRankine a)
Data, (forall x. DegreesRankine a -> Rep (DegreesRankine a) x)
-> (forall x. Rep (DegreesRankine a) x -> DegreesRankine a)
-> Generic (DegreesRankine a)
forall x. Rep (DegreesRankine a) x -> DegreesRankine a
forall x. DegreesRankine a -> Rep (DegreesRankine a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (DegreesRankine a) x -> DegreesRankine a
forall a x. DegreesRankine a -> Rep (DegreesRankine a) x
$cfrom :: forall a x. DegreesRankine a -> Rep (DegreesRankine a) x
from :: forall x. DegreesRankine a -> Rep (DegreesRankine a) x
$cto :: forall a x. Rep (DegreesRankine a) x -> DegreesRankine a
to :: forall x. Rep (DegreesRankine a) x -> DegreesRankine a
Generic)
  deriving newtype (Get (DegreesRankine a)
[DegreesRankine a] -> Put
DegreesRankine a -> Put
(DegreesRankine a -> Put)
-> Get (DegreesRankine a)
-> ([DegreesRankine a] -> Put)
-> Binary (DegreesRankine a)
forall a. Binary a => Get (DegreesRankine a)
forall a. Binary a => [DegreesRankine a] -> Put
forall a. Binary a => DegreesRankine a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => DegreesRankine a -> Put
put :: DegreesRankine a -> Put
$cget :: forall a. Binary a => Get (DegreesRankine a)
get :: Get (DegreesRankine a)
$cputList :: forall a. Binary a => [DegreesRankine a] -> Put
putList :: [DegreesRankine a] -> Put
Binary)
 instance (Fractional a, Show a) => Show (DegreesRankine a) where { show :: DegreesRankine a -> String
show = DegreesRankine a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }
 instance (Fractional a, Show a) => Unit (DegreesRankine a) where
   amount :: DegreesRankine a -> Scalar (DegreesRankine a)
amount = DegreesRankine a -> a
DegreesRankine a -> Scalar (DegreesRankine a)
forall a. DegreesRankine a -> a
rankines
   dimension :: DegreesRankine a -> Dimension
dimension DegreesRankine a
_ = Dimension
kelvinDimension
   unitOf :: DegreesRankine a -> String
unitOf DegreesRankine a
_ = String
"°R"
   fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (DegreesRankine a)) -> m (DegreesRankine a)
fromQuantity Quantity (Scalar (DegreesRankine a))
x
     | Quantity a -> Dimension
forall r. Quantity r -> Dimension
valueDimension Quantity a
Quantity (Scalar (DegreesRankine a))
x Dimension -> Dimension -> Bool
forall a. Eq a => a -> a -> Bool
== Dimension
kelvinDimension = DegreesRankine a -> m (DegreesRankine a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (DegreesRankine a -> m (DegreesRankine a))
-> DegreesRankine a -> m (DegreesRankine a)
forall a b. (a -> b) -> a -> b
$ a -> DegreesRankine a
forall a. a -> DegreesRankine a
DegreesRankine (a -> DegreesRankine a) -> a -> DegreesRankine a
forall a b. (a -> b) -> a -> b
$ Quantity a -> a
forall a. (Fractional a, Show a) => Quantity a -> a
toRankine Quantity a
Quantity (Scalar (DegreesRankine a))
x
     | Bool
otherwise = String -> Dimension -> Dimension -> a -> a -> m (DegreesRankine a)
forall b c a.
(Show b, Show c) =>
String -> Dimension -> Dimension -> b -> c -> a
invalidDimensions String
"fromQuantity:DegreesRankine" (Quantity a -> Dimension
forall r. Quantity r -> Dimension
valueDimension Quantity a
Quantity (Scalar (DegreesRankine a))
x) Dimension
kelvinDimension (Quantity a -> a
forall r. Quantity r -> r
valueAmount Quantity a
Quantity (Scalar (DegreesRankine a))
x) (Quantity a -> a
forall r. Quantity r -> r
valueAmount Quantity a
Quantity (Scalar (DegreesRankine a))
x)

 instance (Fractional a, Show a) => LiteralUnit (DegreesRankine a) where
   fromAmount :: Scalar (DegreesRankine a) -> DegreesRankine a
fromAmount = a -> DegreesRankine a
Scalar (DegreesRankine a) -> DegreesRankine a
forall a. a -> DegreesRankine a
DegreesRankine
   conversionFactor :: (Scalar (DegreesRankine a) -> DegreesRankine a)
-> Scalar (DegreesRankine a)
conversionFactor Scalar (DegreesRankine a) -> DegreesRankine a
_ = a
5a -> a -> a
forall a. Fractional a => a -> a -> a
/a
9
   zeroAmount :: (Scalar (DegreesRankine a) -> DegreesRankine a)
-> Scalar (DegreesRankine a)
zeroAmount Scalar (DegreesRankine a) -> DegreesRankine a
_ = a
Scalar (DegreesRankine a)
0.0 

 newtype DegreesTemperature a = DegreesCelcius { forall a. DegreesTemperature a -> a
celciuses :: a }
  deriving (DegreesTemperature a -> DegreesTemperature a -> Bool
(DegreesTemperature a -> DegreesTemperature a -> Bool)
-> (DegreesTemperature a -> DegreesTemperature a -> Bool)
-> Eq (DegreesTemperature a)
forall a.
Eq a =>
DegreesTemperature a -> DegreesTemperature a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a.
Eq a =>
DegreesTemperature a -> DegreesTemperature a -> Bool
== :: DegreesTemperature a -> DegreesTemperature a -> Bool
$c/= :: forall a.
Eq a =>
DegreesTemperature a -> DegreesTemperature a -> Bool
/= :: DegreesTemperature a -> DegreesTemperature a -> Bool
Eq,Eq (DegreesTemperature a)
Eq (DegreesTemperature a) =>
(DegreesTemperature a -> DegreesTemperature a -> Ordering)
-> (DegreesTemperature a -> DegreesTemperature a -> Bool)
-> (DegreesTemperature a -> DegreesTemperature a -> Bool)
-> (DegreesTemperature a -> DegreesTemperature a -> Bool)
-> (DegreesTemperature a -> DegreesTemperature a -> Bool)
-> (DegreesTemperature a
    -> DegreesTemperature a -> DegreesTemperature a)
-> (DegreesTemperature a
    -> DegreesTemperature a -> DegreesTemperature a)
-> Ord (DegreesTemperature a)
DegreesTemperature a -> DegreesTemperature a -> Bool
DegreesTemperature a -> DegreesTemperature a -> Ordering
DegreesTemperature a
-> DegreesTemperature a -> DegreesTemperature a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (DegreesTemperature a)
forall a.
Ord a =>
DegreesTemperature a -> DegreesTemperature a -> Bool
forall a.
Ord a =>
DegreesTemperature a -> DegreesTemperature a -> Ordering
forall a.
Ord a =>
DegreesTemperature a
-> DegreesTemperature a -> DegreesTemperature a
$ccompare :: forall a.
Ord a =>
DegreesTemperature a -> DegreesTemperature a -> Ordering
compare :: DegreesTemperature a -> DegreesTemperature a -> Ordering
$c< :: forall a.
Ord a =>
DegreesTemperature a -> DegreesTemperature a -> Bool
< :: DegreesTemperature a -> DegreesTemperature a -> Bool
$c<= :: forall a.
Ord a =>
DegreesTemperature a -> DegreesTemperature a -> Bool
<= :: DegreesTemperature a -> DegreesTemperature a -> Bool
$c> :: forall a.
Ord a =>
DegreesTemperature a -> DegreesTemperature a -> Bool
> :: DegreesTemperature a -> DegreesTemperature a -> Bool
$c>= :: forall a.
Ord a =>
DegreesTemperature a -> DegreesTemperature a -> Bool
>= :: DegreesTemperature a -> DegreesTemperature a -> Bool
$cmax :: forall a.
Ord a =>
DegreesTemperature a
-> DegreesTemperature a -> DegreesTemperature a
max :: DegreesTemperature a
-> DegreesTemperature a -> DegreesTemperature a
$cmin :: forall a.
Ord a =>
DegreesTemperature a
-> DegreesTemperature a -> DegreesTemperature a
min :: DegreesTemperature a
-> DegreesTemperature a -> DegreesTemperature a
Ord, Typeable, Typeable (DegreesTemperature a)
Typeable (DegreesTemperature a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DegreesTemperature a
 -> c (DegreesTemperature a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DegreesTemperature a))
-> (DegreesTemperature a -> Constr)
-> (DegreesTemperature a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DegreesTemperature a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DegreesTemperature a)))
-> ((forall b. Data b => b -> b)
    -> DegreesTemperature a -> DegreesTemperature a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DegreesTemperature a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DegreesTemperature a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DegreesTemperature a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DegreesTemperature a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DegreesTemperature a -> m (DegreesTemperature a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DegreesTemperature a -> m (DegreesTemperature a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DegreesTemperature a -> m (DegreesTemperature a))
-> Data (DegreesTemperature a)
DegreesTemperature a -> Constr
DegreesTemperature a -> DataType
(forall b. Data b => b -> b)
-> DegreesTemperature a -> DegreesTemperature a
forall a. Data a => Typeable (DegreesTemperature a)
forall a. Data a => DegreesTemperature a -> Constr
forall a. Data a => DegreesTemperature a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b)
-> DegreesTemperature a -> DegreesTemperature a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> DegreesTemperature a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> DegreesTemperature a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesTemperature a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesTemperature a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> DegreesTemperature a -> m (DegreesTemperature a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DegreesTemperature a -> m (DegreesTemperature a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DegreesTemperature a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DegreesTemperature a
-> c (DegreesTemperature a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DegreesTemperature a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DegreesTemperature a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DegreesTemperature a -> u
forall u.
(forall d. Data d => d -> u) -> DegreesTemperature a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesTemperature a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesTemperature a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DegreesTemperature a -> m (DegreesTemperature a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DegreesTemperature a -> m (DegreesTemperature a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DegreesTemperature a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DegreesTemperature a
-> c (DegreesTemperature a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DegreesTemperature a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DegreesTemperature a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DegreesTemperature a
-> c (DegreesTemperature a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DegreesTemperature a
-> c (DegreesTemperature a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DegreesTemperature a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DegreesTemperature a)
$ctoConstr :: forall a. Data a => DegreesTemperature a -> Constr
toConstr :: DegreesTemperature a -> Constr
$cdataTypeOf :: forall a. Data a => DegreesTemperature a -> DataType
dataTypeOf :: DegreesTemperature a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DegreesTemperature a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DegreesTemperature a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DegreesTemperature a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DegreesTemperature a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b)
-> DegreesTemperature a -> DegreesTemperature a
gmapT :: (forall b. Data b => b -> b)
-> DegreesTemperature a -> DegreesTemperature a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesTemperature a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesTemperature a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesTemperature a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DegreesTemperature a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> DegreesTemperature a -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> DegreesTemperature a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> DegreesTemperature a -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DegreesTemperature a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> DegreesTemperature a -> m (DegreesTemperature a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DegreesTemperature a -> m (DegreesTemperature a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DegreesTemperature a -> m (DegreesTemperature a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DegreesTemperature a -> m (DegreesTemperature a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DegreesTemperature a -> m (DegreesTemperature a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DegreesTemperature a -> m (DegreesTemperature a)
Data, (forall x. DegreesTemperature a -> Rep (DegreesTemperature a) x)
-> (forall x. Rep (DegreesTemperature a) x -> DegreesTemperature a)
-> Generic (DegreesTemperature a)
forall x. Rep (DegreesTemperature a) x -> DegreesTemperature a
forall x. DegreesTemperature a -> Rep (DegreesTemperature a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (DegreesTemperature a) x -> DegreesTemperature a
forall a x. DegreesTemperature a -> Rep (DegreesTemperature a) x
$cfrom :: forall a x. DegreesTemperature a -> Rep (DegreesTemperature a) x
from :: forall x. DegreesTemperature a -> Rep (DegreesTemperature a) x
$cto :: forall a x. Rep (DegreesTemperature a) x -> DegreesTemperature a
to :: forall x. Rep (DegreesTemperature a) x -> DegreesTemperature a
Generic)
  deriving newtype (Get (DegreesTemperature a)
[DegreesTemperature a] -> Put
DegreesTemperature a -> Put
(DegreesTemperature a -> Put)
-> Get (DegreesTemperature a)
-> ([DegreesTemperature a] -> Put)
-> Binary (DegreesTemperature a)
forall a. Binary a => Get (DegreesTemperature a)
forall a. Binary a => [DegreesTemperature a] -> Put
forall a. Binary a => DegreesTemperature a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => DegreesTemperature a -> Put
put :: DegreesTemperature a -> Put
$cget :: forall a. Binary a => Get (DegreesTemperature a)
get :: Get (DegreesTemperature a)
$cputList :: forall a. Binary a => [DegreesTemperature a] -> Put
putList :: [DegreesTemperature a] -> Put
Binary)
 instance (Fractional a, Show a) => Show (DegreesTemperature a) where { show :: DegreesTemperature a -> String
show = DegreesTemperature a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }
 
 instance (Fractional a, Show a) => Unit (DegreesTemperature a) where
    amount :: DegreesTemperature a -> Scalar (DegreesTemperature a)
amount = DegreesTemperature a -> a
DegreesTemperature a -> Scalar (DegreesTemperature a)
forall a. DegreesTemperature a -> a
celciuses
    dimension :: DegreesTemperature a -> Dimension
dimension DegreesTemperature a
_ = Dimension
kelvinDimension
    unitOf :: DegreesTemperature a -> String
unitOf DegreesTemperature a
_ = String
"°C"
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (DegreesTemperature a))
-> m (DegreesTemperature a)
fromQuantity Quantity (Scalar (DegreesTemperature a))
x
      | Quantity a -> Dimension
forall r. Quantity r -> Dimension
valueDimension Quantity a
Quantity (Scalar (DegreesTemperature a))
x Dimension -> Dimension -> Bool
forall a. Eq a => a -> a -> Bool
== Dimension
kelvinDimension = DegreesTemperature a -> m (DegreesTemperature a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (DegreesTemperature a -> m (DegreesTemperature a))
-> DegreesTemperature a -> m (DegreesTemperature a)
forall a b. (a -> b) -> a -> b
$ a -> DegreesTemperature a
forall a. a -> DegreesTemperature a
DegreesCelcius (a -> DegreesTemperature a) -> a -> DegreesTemperature a
forall a b. (a -> b) -> a -> b
$ Quantity a -> a
forall r. Quantity r -> r
valueAmount (Quantity a
Quantity (Scalar (DegreesTemperature a))
x Quantity a -> Quantity a -> Quantity a
forall a. Num a => a -> a -> a
- (a
273.15 a -> Dimension -> Quantity a
forall r. r -> Dimension -> Quantity r
@@ Dimension
kelvinDimension))
      | Bool
otherwise = String
-> Dimension -> Dimension -> a -> a -> m (DegreesTemperature a)
forall b c a.
(Show b, Show c) =>
String -> Dimension -> Dimension -> b -> c -> a
invalidDimensions String
"fromQuantity:DegreesTemperature" (Quantity a -> Dimension
forall r. Quantity r -> Dimension
valueDimension Quantity a
Quantity (Scalar (DegreesTemperature a))
x) Dimension
kelvinDimension (Quantity a -> a
forall r. Quantity r -> r
valueAmount Quantity a
Quantity (Scalar (DegreesTemperature a))
x) (Quantity a -> a
forall r. Quantity r -> r
valueAmount Quantity a
Quantity (Scalar (DegreesTemperature a))
x)

 instance (Show a, Fractional a) => LiteralUnit (DegreesTemperature a) where
    fromAmount :: Scalar (DegreesTemperature a) -> DegreesTemperature a
fromAmount = a -> DegreesTemperature a
Scalar (DegreesTemperature a) -> DegreesTemperature a
forall a. a -> DegreesTemperature a
DegreesCelcius
    zeroAmount :: (Scalar (DegreesTemperature a) -> DegreesTemperature a)
-> Scalar (DegreesTemperature a)
zeroAmount Scalar (DegreesTemperature a) -> DegreesTemperature a
_ = a
Scalar (DegreesTemperature a)
273.15

 newtype Temperature a = DegreesKelvin { forall a. Temperature a -> a
kelvins :: a }
  deriving (Temperature a -> Temperature a -> Bool
(Temperature a -> Temperature a -> Bool)
-> (Temperature a -> Temperature a -> Bool) -> Eq (Temperature a)
forall a. Eq a => Temperature a -> Temperature a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Temperature a -> Temperature a -> Bool
== :: Temperature a -> Temperature a -> Bool
$c/= :: forall a. Eq a => Temperature a -> Temperature a -> Bool
/= :: Temperature a -> Temperature a -> Bool
Eq,Eq (Temperature a)
Eq (Temperature a) =>
(Temperature a -> Temperature a -> Ordering)
-> (Temperature a -> Temperature a -> Bool)
-> (Temperature a -> Temperature a -> Bool)
-> (Temperature a -> Temperature a -> Bool)
-> (Temperature a -> Temperature a -> Bool)
-> (Temperature a -> Temperature a -> Temperature a)
-> (Temperature a -> Temperature a -> Temperature a)
-> Ord (Temperature a)
Temperature a -> Temperature a -> Bool
Temperature a -> Temperature a -> Ordering
Temperature a -> Temperature a -> Temperature a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Temperature a)
forall a. Ord a => Temperature a -> Temperature a -> Bool
forall a. Ord a => Temperature a -> Temperature a -> Ordering
forall a. Ord a => Temperature a -> Temperature a -> Temperature a
$ccompare :: forall a. Ord a => Temperature a -> Temperature a -> Ordering
compare :: Temperature a -> Temperature a -> Ordering
$c< :: forall a. Ord a => Temperature a -> Temperature a -> Bool
< :: Temperature a -> Temperature a -> Bool
$c<= :: forall a. Ord a => Temperature a -> Temperature a -> Bool
<= :: Temperature a -> Temperature a -> Bool
$c> :: forall a. Ord a => Temperature a -> Temperature a -> Bool
> :: Temperature a -> Temperature a -> Bool
$c>= :: forall a. Ord a => Temperature a -> Temperature a -> Bool
>= :: Temperature a -> Temperature a -> Bool
$cmax :: forall a. Ord a => Temperature a -> Temperature a -> Temperature a
max :: Temperature a -> Temperature a -> Temperature a
$cmin :: forall a. Ord a => Temperature a -> Temperature a -> Temperature a
min :: Temperature a -> Temperature a -> Temperature a
Ord, Typeable, Typeable (Temperature a)
Typeable (Temperature a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Temperature a -> c (Temperature a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Temperature a))
-> (Temperature a -> Constr)
-> (Temperature a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Temperature a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Temperature a)))
-> ((forall b. Data b => b -> b) -> Temperature a -> Temperature a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Temperature a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Temperature a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Temperature a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Temperature a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Temperature a -> m (Temperature a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Temperature a -> m (Temperature a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Temperature a -> m (Temperature a))
-> Data (Temperature a)
Temperature a -> Constr
Temperature a -> DataType
(forall b. Data b => b -> b) -> Temperature a -> Temperature a
forall a. Data a => Typeable (Temperature a)
forall a. Data a => Temperature a -> Constr
forall a. Data a => Temperature a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Temperature a -> Temperature a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Temperature a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Temperature a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Temperature a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Temperature a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Temperature a -> m (Temperature a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Temperature a -> m (Temperature a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Temperature a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Temperature a -> c (Temperature a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Temperature a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Temperature a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Temperature a -> u
forall u. (forall d. Data d => d -> u) -> Temperature a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Temperature a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Temperature a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Temperature a -> m (Temperature a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Temperature a -> m (Temperature a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Temperature a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Temperature a -> c (Temperature a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Temperature a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Temperature a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Temperature a -> c (Temperature a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Temperature a -> c (Temperature a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Temperature a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Temperature a)
$ctoConstr :: forall a. Data a => Temperature a -> Constr
toConstr :: Temperature a -> Constr
$cdataTypeOf :: forall a. Data a => Temperature a -> DataType
dataTypeOf :: Temperature a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Temperature a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Temperature a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Temperature a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Temperature a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Temperature a -> Temperature a
gmapT :: (forall b. Data b => b -> b) -> Temperature a -> Temperature a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Temperature a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Temperature a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Temperature a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Temperature a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Temperature a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Temperature a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Temperature a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Temperature a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Temperature a -> m (Temperature a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Temperature a -> m (Temperature a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Temperature a -> m (Temperature a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Temperature a -> m (Temperature a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Temperature a -> m (Temperature a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Temperature a -> m (Temperature a)
Data, (forall x. Temperature a -> Rep (Temperature a) x)
-> (forall x. Rep (Temperature a) x -> Temperature a)
-> Generic (Temperature a)
forall x. Rep (Temperature a) x -> Temperature a
forall x. Temperature a -> Rep (Temperature a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Temperature a) x -> Temperature a
forall a x. Temperature a -> Rep (Temperature a) x
$cfrom :: forall a x. Temperature a -> Rep (Temperature a) x
from :: forall x. Temperature a -> Rep (Temperature a) x
$cto :: forall a x. Rep (Temperature a) x -> Temperature a
to :: forall x. Rep (Temperature a) x -> Temperature a
Generic)
  deriving newtype (Get (Temperature a)
[Temperature a] -> Put
Temperature a -> Put
(Temperature a -> Put)
-> Get (Temperature a)
-> ([Temperature a] -> Put)
-> Binary (Temperature a)
forall a. Binary a => Get (Temperature a)
forall a. Binary a => [Temperature a] -> Put
forall a. Binary a => Temperature a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Temperature a -> Put
put :: Temperature a -> Put
$cget :: forall a. Binary a => Get (Temperature a)
get :: Get (Temperature a)
$cputList :: forall a. Binary a => [Temperature a] -> Put
putList :: [Temperature a] -> Put
Binary)
 instance (Num a, Show a) => Show (Temperature a) where { show :: Temperature a -> String
show = Temperature a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 isoCelciusToKelvin :: (Fractional a) => DegreesTemperature a :==: Temperature a
 isoCelciusToKelvin :: forall a. Fractional a => DegreesTemperature a :==: Temperature a
isoCelciusToKelvin = DegreesTemperature a -> Temperature a
forall a. Fractional a => DegreesTemperature a -> Temperature a
celciusToKelvin (DegreesTemperature a -> Temperature a)
-> (Temperature a -> DegreesTemperature a)
-> DegreesTemperature a :==: Temperature a
forall a b. (a -> b) -> (b -> a) -> a :==: b
forall (arr :: * -> * -> *) a b.
BiArrow arr =>
(a -> b) -> (b -> a) -> arr a b
<-> Temperature a -> DegreesTemperature a
forall a. Fractional a => Temperature a -> DegreesTemperature a
kelvinToCelcius
 
 celciusToKelvin :: (Fractional a) => DegreesTemperature a -> Temperature a
 celciusToKelvin :: forall a. Fractional a => DegreesTemperature a -> Temperature a
celciusToKelvin (DegreesCelcius a
x) = a -> Temperature a
forall a. a -> Temperature a
DegreesKelvin (a
x a -> a -> a
forall a. Num a => a -> a -> a
+ a
273.15)

 kelvinToCelcius :: (Fractional a) => Temperature a -> DegreesTemperature a
 kelvinToCelcius :: forall a. Fractional a => Temperature a -> DegreesTemperature a
kelvinToCelcius (DegreesKelvin a
x) = a -> DegreesTemperature a
forall a. a -> DegreesTemperature a
DegreesCelcius (a
x a -> a -> a
forall a. Num a => a -> a -> a
- a
273.15)

 newtype Substance a = Moles { forall a. Substance a -> a
moles :: a }
  deriving (Substance a -> Substance a -> Bool
(Substance a -> Substance a -> Bool)
-> (Substance a -> Substance a -> Bool) -> Eq (Substance a)
forall a. Eq a => Substance a -> Substance a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Substance a -> Substance a -> Bool
== :: Substance a -> Substance a -> Bool
$c/= :: forall a. Eq a => Substance a -> Substance a -> Bool
/= :: Substance a -> Substance a -> Bool
Eq,Eq (Substance a)
Eq (Substance a) =>
(Substance a -> Substance a -> Ordering)
-> (Substance a -> Substance a -> Bool)
-> (Substance a -> Substance a -> Bool)
-> (Substance a -> Substance a -> Bool)
-> (Substance a -> Substance a -> Bool)
-> (Substance a -> Substance a -> Substance a)
-> (Substance a -> Substance a -> Substance a)
-> Ord (Substance a)
Substance a -> Substance a -> Bool
Substance a -> Substance a -> Ordering
Substance a -> Substance a -> Substance a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Substance a)
forall a. Ord a => Substance a -> Substance a -> Bool
forall a. Ord a => Substance a -> Substance a -> Ordering
forall a. Ord a => Substance a -> Substance a -> Substance a
$ccompare :: forall a. Ord a => Substance a -> Substance a -> Ordering
compare :: Substance a -> Substance a -> Ordering
$c< :: forall a. Ord a => Substance a -> Substance a -> Bool
< :: Substance a -> Substance a -> Bool
$c<= :: forall a. Ord a => Substance a -> Substance a -> Bool
<= :: Substance a -> Substance a -> Bool
$c> :: forall a. Ord a => Substance a -> Substance a -> Bool
> :: Substance a -> Substance a -> Bool
$c>= :: forall a. Ord a => Substance a -> Substance a -> Bool
>= :: Substance a -> Substance a -> Bool
$cmax :: forall a. Ord a => Substance a -> Substance a -> Substance a
max :: Substance a -> Substance a -> Substance a
$cmin :: forall a. Ord a => Substance a -> Substance a -> Substance a
min :: Substance a -> Substance a -> Substance a
Ord, Typeable, Typeable (Substance a)
Typeable (Substance a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Substance a -> c (Substance a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Substance a))
-> (Substance a -> Constr)
-> (Substance a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Substance a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Substance a)))
-> ((forall b. Data b => b -> b) -> Substance a -> Substance a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Substance a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Substance a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Substance a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Substance a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Substance a -> m (Substance a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Substance a -> m (Substance a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Substance a -> m (Substance a))
-> Data (Substance a)
Substance a -> Constr
Substance a -> DataType
(forall b. Data b => b -> b) -> Substance a -> Substance a
forall a. Data a => Typeable (Substance a)
forall a. Data a => Substance a -> Constr
forall a. Data a => Substance a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Substance a -> Substance a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Substance a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Substance a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Substance a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Substance a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Substance a -> m (Substance a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Substance a -> m (Substance a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Substance a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Substance a -> c (Substance a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Substance a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Substance a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Substance a -> u
forall u. (forall d. Data d => d -> u) -> Substance a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Substance a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Substance a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Substance a -> m (Substance a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Substance a -> m (Substance a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Substance a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Substance a -> c (Substance a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Substance a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Substance a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Substance a -> c (Substance a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Substance a -> c (Substance a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Substance a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Substance a)
$ctoConstr :: forall a. Data a => Substance a -> Constr
toConstr :: Substance a -> Constr
$cdataTypeOf :: forall a. Data a => Substance a -> DataType
dataTypeOf :: Substance a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Substance a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Substance a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Substance a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Substance a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Substance a -> Substance a
gmapT :: (forall b. Data b => b -> b) -> Substance a -> Substance a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Substance a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Substance a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Substance a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Substance a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Substance a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Substance a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Substance a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Substance a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Substance a -> m (Substance a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Substance a -> m (Substance a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Substance a -> m (Substance a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Substance a -> m (Substance a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Substance a -> m (Substance a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Substance a -> m (Substance a)
Data, (forall x. Substance a -> Rep (Substance a) x)
-> (forall x. Rep (Substance a) x -> Substance a)
-> Generic (Substance a)
forall x. Rep (Substance a) x -> Substance a
forall x. Substance a -> Rep (Substance a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Substance a) x -> Substance a
forall a x. Substance a -> Rep (Substance a) x
$cfrom :: forall a x. Substance a -> Rep (Substance a) x
from :: forall x. Substance a -> Rep (Substance a) x
$cto :: forall a x. Rep (Substance a) x -> Substance a
to :: forall x. Rep (Substance a) x -> Substance a
Generic)
  deriving newtype (Get (Substance a)
[Substance a] -> Put
Substance a -> Put
(Substance a -> Put)
-> Get (Substance a)
-> ([Substance a] -> Put)
-> Binary (Substance a)
forall a. Binary a => Get (Substance a)
forall a. Binary a => [Substance a] -> Put
forall a. Binary a => Substance a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Substance a -> Put
put :: Substance a -> Put
$cget :: forall a. Binary a => Get (Substance a)
get :: Get (Substance a)
$cputList :: forall a. Binary a => [Substance a] -> Put
putList :: [Substance a] -> Put
Binary)
 instance (Num a, Show a) => Show (Substance a) where { show :: Substance a -> String
show = Substance a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Intensity a = Candelas { forall a. Intensity a -> a
candelas :: a }
  deriving (Intensity a -> Intensity a -> Bool
(Intensity a -> Intensity a -> Bool)
-> (Intensity a -> Intensity a -> Bool) -> Eq (Intensity a)
forall a. Eq a => Intensity a -> Intensity a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Intensity a -> Intensity a -> Bool
== :: Intensity a -> Intensity a -> Bool
$c/= :: forall a. Eq a => Intensity a -> Intensity a -> Bool
/= :: Intensity a -> Intensity a -> Bool
Eq,Eq (Intensity a)
Eq (Intensity a) =>
(Intensity a -> Intensity a -> Ordering)
-> (Intensity a -> Intensity a -> Bool)
-> (Intensity a -> Intensity a -> Bool)
-> (Intensity a -> Intensity a -> Bool)
-> (Intensity a -> Intensity a -> Bool)
-> (Intensity a -> Intensity a -> Intensity a)
-> (Intensity a -> Intensity a -> Intensity a)
-> Ord (Intensity a)
Intensity a -> Intensity a -> Bool
Intensity a -> Intensity a -> Ordering
Intensity a -> Intensity a -> Intensity a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Intensity a)
forall a. Ord a => Intensity a -> Intensity a -> Bool
forall a. Ord a => Intensity a -> Intensity a -> Ordering
forall a. Ord a => Intensity a -> Intensity a -> Intensity a
$ccompare :: forall a. Ord a => Intensity a -> Intensity a -> Ordering
compare :: Intensity a -> Intensity a -> Ordering
$c< :: forall a. Ord a => Intensity a -> Intensity a -> Bool
< :: Intensity a -> Intensity a -> Bool
$c<= :: forall a. Ord a => Intensity a -> Intensity a -> Bool
<= :: Intensity a -> Intensity a -> Bool
$c> :: forall a. Ord a => Intensity a -> Intensity a -> Bool
> :: Intensity a -> Intensity a -> Bool
$c>= :: forall a. Ord a => Intensity a -> Intensity a -> Bool
>= :: Intensity a -> Intensity a -> Bool
$cmax :: forall a. Ord a => Intensity a -> Intensity a -> Intensity a
max :: Intensity a -> Intensity a -> Intensity a
$cmin :: forall a. Ord a => Intensity a -> Intensity a -> Intensity a
min :: Intensity a -> Intensity a -> Intensity a
Ord, Typeable, Typeable (Intensity a)
Typeable (Intensity a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Intensity a -> c (Intensity a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Intensity a))
-> (Intensity a -> Constr)
-> (Intensity a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Intensity a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Intensity a)))
-> ((forall b. Data b => b -> b) -> Intensity a -> Intensity a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Intensity a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Intensity a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Intensity a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Intensity a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Intensity a -> m (Intensity a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Intensity a -> m (Intensity a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Intensity a -> m (Intensity a))
-> Data (Intensity a)
Intensity a -> Constr
Intensity a -> DataType
(forall b. Data b => b -> b) -> Intensity a -> Intensity a
forall a. Data a => Typeable (Intensity a)
forall a. Data a => Intensity a -> Constr
forall a. Data a => Intensity a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Intensity a -> Intensity a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Intensity a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Intensity a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Intensity a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Intensity a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Intensity a -> m (Intensity a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Intensity a -> m (Intensity a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Intensity a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Intensity a -> c (Intensity a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Intensity a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Intensity a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Intensity a -> u
forall u. (forall d. Data d => d -> u) -> Intensity a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Intensity a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Intensity a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Intensity a -> m (Intensity a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Intensity a -> m (Intensity a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Intensity a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Intensity a -> c (Intensity a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Intensity a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Intensity a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Intensity a -> c (Intensity a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Intensity a -> c (Intensity a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Intensity a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Intensity a)
$ctoConstr :: forall a. Data a => Intensity a -> Constr
toConstr :: Intensity a -> Constr
$cdataTypeOf :: forall a. Data a => Intensity a -> DataType
dataTypeOf :: Intensity a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Intensity a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Intensity a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Intensity a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Intensity a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Intensity a -> Intensity a
gmapT :: (forall b. Data b => b -> b) -> Intensity a -> Intensity a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Intensity a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Intensity a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Intensity a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Intensity a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Intensity a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Intensity a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Intensity a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Intensity a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Intensity a -> m (Intensity a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Intensity a -> m (Intensity a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Intensity a -> m (Intensity a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Intensity a -> m (Intensity a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Intensity a -> m (Intensity a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Intensity a -> m (Intensity a)
Data, (forall x. Intensity a -> Rep (Intensity a) x)
-> (forall x. Rep (Intensity a) x -> Intensity a)
-> Generic (Intensity a)
forall x. Rep (Intensity a) x -> Intensity a
forall x. Intensity a -> Rep (Intensity a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Intensity a) x -> Intensity a
forall a x. Intensity a -> Rep (Intensity a) x
$cfrom :: forall a x. Intensity a -> Rep (Intensity a) x
from :: forall x. Intensity a -> Rep (Intensity a) x
$cto :: forall a x. Rep (Intensity a) x -> Intensity a
to :: forall x. Rep (Intensity a) x -> Intensity a
Generic)
  deriving newtype (Get (Intensity a)
[Intensity a] -> Put
Intensity a -> Put
(Intensity a -> Put)
-> Get (Intensity a)
-> ([Intensity a] -> Put)
-> Binary (Intensity a)
forall a. Binary a => Get (Intensity a)
forall a. Binary a => [Intensity a] -> Put
forall a. Binary a => Intensity a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Intensity a -> Put
put :: Intensity a -> Put
$cget :: forall a. Binary a => Get (Intensity a)
get :: Get (Intensity a)
$cputList :: forall a. Binary a => [Intensity a] -> Put
putList :: [Intensity a] -> Put
Binary)
 instance (Num a, Show a) => Show (Intensity a) where { show :: Intensity a -> String
show = Intensity a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Frequency a = Hertzes { forall a. Frequency a -> a
hertzes :: a }
  deriving (Frequency a -> Frequency a -> Bool
(Frequency a -> Frequency a -> Bool)
-> (Frequency a -> Frequency a -> Bool) -> Eq (Frequency a)
forall a. Eq a => Frequency a -> Frequency a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Frequency a -> Frequency a -> Bool
== :: Frequency a -> Frequency a -> Bool
$c/= :: forall a. Eq a => Frequency a -> Frequency a -> Bool
/= :: Frequency a -> Frequency a -> Bool
Eq,Eq (Frequency a)
Eq (Frequency a) =>
(Frequency a -> Frequency a -> Ordering)
-> (Frequency a -> Frequency a -> Bool)
-> (Frequency a -> Frequency a -> Bool)
-> (Frequency a -> Frequency a -> Bool)
-> (Frequency a -> Frequency a -> Bool)
-> (Frequency a -> Frequency a -> Frequency a)
-> (Frequency a -> Frequency a -> Frequency a)
-> Ord (Frequency a)
Frequency a -> Frequency a -> Bool
Frequency a -> Frequency a -> Ordering
Frequency a -> Frequency a -> Frequency a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Frequency a)
forall a. Ord a => Frequency a -> Frequency a -> Bool
forall a. Ord a => Frequency a -> Frequency a -> Ordering
forall a. Ord a => Frequency a -> Frequency a -> Frequency a
$ccompare :: forall a. Ord a => Frequency a -> Frequency a -> Ordering
compare :: Frequency a -> Frequency a -> Ordering
$c< :: forall a. Ord a => Frequency a -> Frequency a -> Bool
< :: Frequency a -> Frequency a -> Bool
$c<= :: forall a. Ord a => Frequency a -> Frequency a -> Bool
<= :: Frequency a -> Frequency a -> Bool
$c> :: forall a. Ord a => Frequency a -> Frequency a -> Bool
> :: Frequency a -> Frequency a -> Bool
$c>= :: forall a. Ord a => Frequency a -> Frequency a -> Bool
>= :: Frequency a -> Frequency a -> Bool
$cmax :: forall a. Ord a => Frequency a -> Frequency a -> Frequency a
max :: Frequency a -> Frequency a -> Frequency a
$cmin :: forall a. Ord a => Frequency a -> Frequency a -> Frequency a
min :: Frequency a -> Frequency a -> Frequency a
Ord, Typeable, Typeable (Frequency a)
Typeable (Frequency a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Frequency a -> c (Frequency a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Frequency a))
-> (Frequency a -> Constr)
-> (Frequency a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Frequency a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Frequency a)))
-> ((forall b. Data b => b -> b) -> Frequency a -> Frequency a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Frequency a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Frequency a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Frequency a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Frequency a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Frequency a -> m (Frequency a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Frequency a -> m (Frequency a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Frequency a -> m (Frequency a))
-> Data (Frequency a)
Frequency a -> Constr
Frequency a -> DataType
(forall b. Data b => b -> b) -> Frequency a -> Frequency a
forall a. Data a => Typeable (Frequency a)
forall a. Data a => Frequency a -> Constr
forall a. Data a => Frequency a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Frequency a -> Frequency a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Frequency a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Frequency a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Frequency a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Frequency a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Frequency a -> m (Frequency a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Frequency a -> m (Frequency a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Frequency a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Frequency a -> c (Frequency a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Frequency a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Frequency a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Frequency a -> u
forall u. (forall d. Data d => d -> u) -> Frequency a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Frequency a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Frequency a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Frequency a -> m (Frequency a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Frequency a -> m (Frequency a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Frequency a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Frequency a -> c (Frequency a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Frequency a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Frequency a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Frequency a -> c (Frequency a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Frequency a -> c (Frequency a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Frequency a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Frequency a)
$ctoConstr :: forall a. Data a => Frequency a -> Constr
toConstr :: Frequency a -> Constr
$cdataTypeOf :: forall a. Data a => Frequency a -> DataType
dataTypeOf :: Frequency a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Frequency a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Frequency a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Frequency a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Frequency a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Frequency a -> Frequency a
gmapT :: (forall b. Data b => b -> b) -> Frequency a -> Frequency a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Frequency a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Frequency a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Frequency a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Frequency a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Frequency a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Frequency a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Frequency a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Frequency a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Frequency a -> m (Frequency a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Frequency a -> m (Frequency a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Frequency a -> m (Frequency a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Frequency a -> m (Frequency a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Frequency a -> m (Frequency a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Frequency a -> m (Frequency a)
Data, (forall x. Frequency a -> Rep (Frequency a) x)
-> (forall x. Rep (Frequency a) x -> Frequency a)
-> Generic (Frequency a)
forall x. Rep (Frequency a) x -> Frequency a
forall x. Frequency a -> Rep (Frequency a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Frequency a) x -> Frequency a
forall a x. Frequency a -> Rep (Frequency a) x
$cfrom :: forall a x. Frequency a -> Rep (Frequency a) x
from :: forall x. Frequency a -> Rep (Frequency a) x
$cto :: forall a x. Rep (Frequency a) x -> Frequency a
to :: forall x. Rep (Frequency a) x -> Frequency a
Generic)
  deriving newtype (Get (Frequency a)
[Frequency a] -> Put
Frequency a -> Put
(Frequency a -> Put)
-> Get (Frequency a)
-> ([Frequency a] -> Put)
-> Binary (Frequency a)
forall a. Binary a => Get (Frequency a)
forall a. Binary a => [Frequency a] -> Put
forall a. Binary a => Frequency a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Frequency a -> Put
put :: Frequency a -> Put
$cget :: forall a. Binary a => Get (Frequency a)
get :: Get (Frequency a)
$cputList :: forall a. Binary a => [Frequency a] -> Put
putList :: [Frequency a] -> Put
Binary)
 instance (Num a, Show a) => Show (Frequency a) where { show :: Frequency a -> String
show = Frequency a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Force a = Newtons { forall a. Force a -> a
newtons :: a }
  deriving (Force a -> Force a -> Bool
(Force a -> Force a -> Bool)
-> (Force a -> Force a -> Bool) -> Eq (Force a)
forall a. Eq a => Force a -> Force a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Force a -> Force a -> Bool
== :: Force a -> Force a -> Bool
$c/= :: forall a. Eq a => Force a -> Force a -> Bool
/= :: Force a -> Force a -> Bool
Eq,Eq (Force a)
Eq (Force a) =>
(Force a -> Force a -> Ordering)
-> (Force a -> Force a -> Bool)
-> (Force a -> Force a -> Bool)
-> (Force a -> Force a -> Bool)
-> (Force a -> Force a -> Bool)
-> (Force a -> Force a -> Force a)
-> (Force a -> Force a -> Force a)
-> Ord (Force a)
Force a -> Force a -> Bool
Force a -> Force a -> Ordering
Force a -> Force a -> Force a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Force a)
forall a. Ord a => Force a -> Force a -> Bool
forall a. Ord a => Force a -> Force a -> Ordering
forall a. Ord a => Force a -> Force a -> Force a
$ccompare :: forall a. Ord a => Force a -> Force a -> Ordering
compare :: Force a -> Force a -> Ordering
$c< :: forall a. Ord a => Force a -> Force a -> Bool
< :: Force a -> Force a -> Bool
$c<= :: forall a. Ord a => Force a -> Force a -> Bool
<= :: Force a -> Force a -> Bool
$c> :: forall a. Ord a => Force a -> Force a -> Bool
> :: Force a -> Force a -> Bool
$c>= :: forall a. Ord a => Force a -> Force a -> Bool
>= :: Force a -> Force a -> Bool
$cmax :: forall a. Ord a => Force a -> Force a -> Force a
max :: Force a -> Force a -> Force a
$cmin :: forall a. Ord a => Force a -> Force a -> Force a
min :: Force a -> Force a -> Force a
Ord, Typeable, Typeable (Force a)
Typeable (Force a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Force a -> c (Force a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Force a))
-> (Force a -> Constr)
-> (Force a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Force a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Force a)))
-> ((forall b. Data b => b -> b) -> Force a -> Force a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Force a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Force a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Force a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Force a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Force a -> m (Force a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Force a -> m (Force a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Force a -> m (Force a))
-> Data (Force a)
Force a -> Constr
Force a -> DataType
(forall b. Data b => b -> b) -> Force a -> Force a
forall a. Data a => Typeable (Force a)
forall a. Data a => Force a -> Constr
forall a. Data a => Force a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Force a -> Force a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Force a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Force a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Force a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Force a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Force a -> m (Force a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Force a -> m (Force a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Force a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Force a -> c (Force a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Force a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Force a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Force a -> u
forall u. (forall d. Data d => d -> u) -> Force a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Force a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Force a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Force a -> m (Force a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Force a -> m (Force a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Force a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Force a -> c (Force a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Force a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Force a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Force a -> c (Force a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Force a -> c (Force a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Force a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Force a)
$ctoConstr :: forall a. Data a => Force a -> Constr
toConstr :: Force a -> Constr
$cdataTypeOf :: forall a. Data a => Force a -> DataType
dataTypeOf :: Force a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Force a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Force a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Force a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Force a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Force a -> Force a
gmapT :: (forall b. Data b => b -> b) -> Force a -> Force a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Force a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Force a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Force a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Force a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Force a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Force a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Force a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Force a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Force a -> m (Force a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Force a -> m (Force a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Force a -> m (Force a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Force a -> m (Force a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Force a -> m (Force a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Force a -> m (Force a)
Data, (forall x. Force a -> Rep (Force a) x)
-> (forall x. Rep (Force a) x -> Force a) -> Generic (Force a)
forall x. Rep (Force a) x -> Force a
forall x. Force a -> Rep (Force a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Force a) x -> Force a
forall a x. Force a -> Rep (Force a) x
$cfrom :: forall a x. Force a -> Rep (Force a) x
from :: forall x. Force a -> Rep (Force a) x
$cto :: forall a x. Rep (Force a) x -> Force a
to :: forall x. Rep (Force a) x -> Force a
Generic)
  deriving newtype (Get (Force a)
[Force a] -> Put
Force a -> Put
(Force a -> Put)
-> Get (Force a) -> ([Force a] -> Put) -> Binary (Force a)
forall a. Binary a => Get (Force a)
forall a. Binary a => [Force a] -> Put
forall a. Binary a => Force a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Force a -> Put
put :: Force a -> Put
$cget :: forall a. Binary a => Get (Force a)
get :: Get (Force a)
$cputList :: forall a. Binary a => [Force a] -> Put
putList :: [Force a] -> Put
Binary)
 instance (Num a, Show a) => Show (Force a) where { show :: Force a -> String
show = Force a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Torque a = NewtonMeters { forall a. Torque a -> a
newtonmeters :: a }
   deriving (Torque a -> Torque a -> Bool
(Torque a -> Torque a -> Bool)
-> (Torque a -> Torque a -> Bool) -> Eq (Torque a)
forall a. Eq a => Torque a -> Torque a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Torque a -> Torque a -> Bool
== :: Torque a -> Torque a -> Bool
$c/= :: forall a. Eq a => Torque a -> Torque a -> Bool
/= :: Torque a -> Torque a -> Bool
Eq, Eq (Torque a)
Eq (Torque a) =>
(Torque a -> Torque a -> Ordering)
-> (Torque a -> Torque a -> Bool)
-> (Torque a -> Torque a -> Bool)
-> (Torque a -> Torque a -> Bool)
-> (Torque a -> Torque a -> Bool)
-> (Torque a -> Torque a -> Torque a)
-> (Torque a -> Torque a -> Torque a)
-> Ord (Torque a)
Torque a -> Torque a -> Bool
Torque a -> Torque a -> Ordering
Torque a -> Torque a -> Torque a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Torque a)
forall a. Ord a => Torque a -> Torque a -> Bool
forall a. Ord a => Torque a -> Torque a -> Ordering
forall a. Ord a => Torque a -> Torque a -> Torque a
$ccompare :: forall a. Ord a => Torque a -> Torque a -> Ordering
compare :: Torque a -> Torque a -> Ordering
$c< :: forall a. Ord a => Torque a -> Torque a -> Bool
< :: Torque a -> Torque a -> Bool
$c<= :: forall a. Ord a => Torque a -> Torque a -> Bool
<= :: Torque a -> Torque a -> Bool
$c> :: forall a. Ord a => Torque a -> Torque a -> Bool
> :: Torque a -> Torque a -> Bool
$c>= :: forall a. Ord a => Torque a -> Torque a -> Bool
>= :: Torque a -> Torque a -> Bool
$cmax :: forall a. Ord a => Torque a -> Torque a -> Torque a
max :: Torque a -> Torque a -> Torque a
$cmin :: forall a. Ord a => Torque a -> Torque a -> Torque a
min :: Torque a -> Torque a -> Torque a
Ord, Typeable, Typeable (Torque a)
Typeable (Torque a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Torque a -> c (Torque a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Torque a))
-> (Torque a -> Constr)
-> (Torque a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Torque a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Torque a)))
-> ((forall b. Data b => b -> b) -> Torque a -> Torque a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Torque a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Torque a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Torque a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Torque a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Torque a -> m (Torque a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Torque a -> m (Torque a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Torque a -> m (Torque a))
-> Data (Torque a)
Torque a -> Constr
Torque a -> DataType
(forall b. Data b => b -> b) -> Torque a -> Torque a
forall a. Data a => Typeable (Torque a)
forall a. Data a => Torque a -> Constr
forall a. Data a => Torque a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Torque a -> Torque a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Torque a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Torque a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Torque a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Torque a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Torque a -> m (Torque a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Torque a -> m (Torque a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Torque a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Torque a -> c (Torque a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Torque a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Torque a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Torque a -> u
forall u. (forall d. Data d => d -> u) -> Torque a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Torque a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Torque a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Torque a -> m (Torque a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Torque a -> m (Torque a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Torque a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Torque a -> c (Torque a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Torque a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Torque a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Torque a -> c (Torque a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Torque a -> c (Torque a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Torque a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Torque a)
$ctoConstr :: forall a. Data a => Torque a -> Constr
toConstr :: Torque a -> Constr
$cdataTypeOf :: forall a. Data a => Torque a -> DataType
dataTypeOf :: Torque a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Torque a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Torque a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Torque a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Torque a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Torque a -> Torque a
gmapT :: (forall b. Data b => b -> b) -> Torque a -> Torque a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Torque a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Torque a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Torque a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Torque a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Torque a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Torque a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Torque a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Torque a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Torque a -> m (Torque a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Torque a -> m (Torque a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Torque a -> m (Torque a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Torque a -> m (Torque a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Torque a -> m (Torque a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Torque a -> m (Torque a)
Data, (forall x. Torque a -> Rep (Torque a) x)
-> (forall x. Rep (Torque a) x -> Torque a) -> Generic (Torque a)
forall x. Rep (Torque a) x -> Torque a
forall x. Torque a -> Rep (Torque a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Torque a) x -> Torque a
forall a x. Torque a -> Rep (Torque a) x
$cfrom :: forall a x. Torque a -> Rep (Torque a) x
from :: forall x. Torque a -> Rep (Torque a) x
$cto :: forall a x. Rep (Torque a) x -> Torque a
to :: forall x. Rep (Torque a) x -> Torque a
Generic)
   deriving newtype (Get (Torque a)
[Torque a] -> Put
Torque a -> Put
(Torque a -> Put)
-> Get (Torque a) -> ([Torque a] -> Put) -> Binary (Torque a)
forall a. Binary a => Get (Torque a)
forall a. Binary a => [Torque a] -> Put
forall a. Binary a => Torque a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Torque a -> Put
put :: Torque a -> Put
$cget :: forall a. Binary a => Get (Torque a)
get :: Get (Torque a)
$cputList :: forall a. Binary a => [Torque a] -> Put
putList :: [Torque a] -> Put
Binary)
 instance (Num a, Show a) => Show (Torque a) where { show :: Torque a -> String
show = Torque a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Pressure a = Pascals { forall a. Pressure a -> a
pascals :: a }
  deriving (Pressure a -> Pressure a -> Bool
(Pressure a -> Pressure a -> Bool)
-> (Pressure a -> Pressure a -> Bool) -> Eq (Pressure a)
forall a. Eq a => Pressure a -> Pressure a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Pressure a -> Pressure a -> Bool
== :: Pressure a -> Pressure a -> Bool
$c/= :: forall a. Eq a => Pressure a -> Pressure a -> Bool
/= :: Pressure a -> Pressure a -> Bool
Eq,Eq (Pressure a)
Eq (Pressure a) =>
(Pressure a -> Pressure a -> Ordering)
-> (Pressure a -> Pressure a -> Bool)
-> (Pressure a -> Pressure a -> Bool)
-> (Pressure a -> Pressure a -> Bool)
-> (Pressure a -> Pressure a -> Bool)
-> (Pressure a -> Pressure a -> Pressure a)
-> (Pressure a -> Pressure a -> Pressure a)
-> Ord (Pressure a)
Pressure a -> Pressure a -> Bool
Pressure a -> Pressure a -> Ordering
Pressure a -> Pressure a -> Pressure a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Pressure a)
forall a. Ord a => Pressure a -> Pressure a -> Bool
forall a. Ord a => Pressure a -> Pressure a -> Ordering
forall a. Ord a => Pressure a -> Pressure a -> Pressure a
$ccompare :: forall a. Ord a => Pressure a -> Pressure a -> Ordering
compare :: Pressure a -> Pressure a -> Ordering
$c< :: forall a. Ord a => Pressure a -> Pressure a -> Bool
< :: Pressure a -> Pressure a -> Bool
$c<= :: forall a. Ord a => Pressure a -> Pressure a -> Bool
<= :: Pressure a -> Pressure a -> Bool
$c> :: forall a. Ord a => Pressure a -> Pressure a -> Bool
> :: Pressure a -> Pressure a -> Bool
$c>= :: forall a. Ord a => Pressure a -> Pressure a -> Bool
>= :: Pressure a -> Pressure a -> Bool
$cmax :: forall a. Ord a => Pressure a -> Pressure a -> Pressure a
max :: Pressure a -> Pressure a -> Pressure a
$cmin :: forall a. Ord a => Pressure a -> Pressure a -> Pressure a
min :: Pressure a -> Pressure a -> Pressure a
Ord, Typeable, Typeable (Pressure a)
Typeable (Pressure a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Pressure a -> c (Pressure a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Pressure a))
-> (Pressure a -> Constr)
-> (Pressure a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Pressure a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Pressure a)))
-> ((forall b. Data b => b -> b) -> Pressure a -> Pressure a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Pressure a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Pressure a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Pressure a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Pressure a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pressure a -> m (Pressure a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pressure a -> m (Pressure a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pressure a -> m (Pressure a))
-> Data (Pressure a)
Pressure a -> Constr
Pressure a -> DataType
(forall b. Data b => b -> b) -> Pressure a -> Pressure a
forall a. Data a => Typeable (Pressure a)
forall a. Data a => Pressure a -> Constr
forall a. Data a => Pressure a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Pressure a -> Pressure a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Pressure a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Pressure a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pressure a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pressure a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Pressure a -> m (Pressure a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Pressure a -> m (Pressure a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pressure a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pressure a -> c (Pressure a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Pressure a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Pressure a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Pressure a -> u
forall u. (forall d. Data d => d -> u) -> Pressure a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pressure a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pressure a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pressure a -> m (Pressure a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pressure a -> m (Pressure a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pressure a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pressure a -> c (Pressure a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Pressure a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Pressure a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pressure a -> c (Pressure a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pressure a -> c (Pressure a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pressure a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pressure a)
$ctoConstr :: forall a. Data a => Pressure a -> Constr
toConstr :: Pressure a -> Constr
$cdataTypeOf :: forall a. Data a => Pressure a -> DataType
dataTypeOf :: Pressure a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Pressure a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Pressure a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Pressure a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Pressure a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Pressure a -> Pressure a
gmapT :: (forall b. Data b => b -> b) -> Pressure a -> Pressure a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pressure a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pressure a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pressure a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pressure a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Pressure a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Pressure a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Pressure a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pressure a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Pressure a -> m (Pressure a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pressure a -> m (Pressure a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Pressure a -> m (Pressure a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pressure a -> m (Pressure a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Pressure a -> m (Pressure a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pressure a -> m (Pressure a)
Data, (forall x. Pressure a -> Rep (Pressure a) x)
-> (forall x. Rep (Pressure a) x -> Pressure a)
-> Generic (Pressure a)
forall x. Rep (Pressure a) x -> Pressure a
forall x. Pressure a -> Rep (Pressure a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Pressure a) x -> Pressure a
forall a x. Pressure a -> Rep (Pressure a) x
$cfrom :: forall a x. Pressure a -> Rep (Pressure a) x
from :: forall x. Pressure a -> Rep (Pressure a) x
$cto :: forall a x. Rep (Pressure a) x -> Pressure a
to :: forall x. Rep (Pressure a) x -> Pressure a
Generic)
  deriving newtype (Get (Pressure a)
[Pressure a] -> Put
Pressure a -> Put
(Pressure a -> Put)
-> Get (Pressure a) -> ([Pressure a] -> Put) -> Binary (Pressure a)
forall a. Binary a => Get (Pressure a)
forall a. Binary a => [Pressure a] -> Put
forall a. Binary a => Pressure a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Pressure a -> Put
put :: Pressure a -> Put
$cget :: forall a. Binary a => Get (Pressure a)
get :: Get (Pressure a)
$cputList :: forall a. Binary a => [Pressure a] -> Put
putList :: [Pressure a] -> Put
Binary)
 instance (Num a, Show a) => Show ( Pressure  a) where { show :: Pressure a -> String
show = Pressure a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Energy a = Joules { forall a. Energy a -> a
joules :: a }
  deriving (Energy a -> Energy a -> Bool
(Energy a -> Energy a -> Bool)
-> (Energy a -> Energy a -> Bool) -> Eq (Energy a)
forall a. Eq a => Energy a -> Energy a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Energy a -> Energy a -> Bool
== :: Energy a -> Energy a -> Bool
$c/= :: forall a. Eq a => Energy a -> Energy a -> Bool
/= :: Energy a -> Energy a -> Bool
Eq,Eq (Energy a)
Eq (Energy a) =>
(Energy a -> Energy a -> Ordering)
-> (Energy a -> Energy a -> Bool)
-> (Energy a -> Energy a -> Bool)
-> (Energy a -> Energy a -> Bool)
-> (Energy a -> Energy a -> Bool)
-> (Energy a -> Energy a -> Energy a)
-> (Energy a -> Energy a -> Energy a)
-> Ord (Energy a)
Energy a -> Energy a -> Bool
Energy a -> Energy a -> Ordering
Energy a -> Energy a -> Energy a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Energy a)
forall a. Ord a => Energy a -> Energy a -> Bool
forall a. Ord a => Energy a -> Energy a -> Ordering
forall a. Ord a => Energy a -> Energy a -> Energy a
$ccompare :: forall a. Ord a => Energy a -> Energy a -> Ordering
compare :: Energy a -> Energy a -> Ordering
$c< :: forall a. Ord a => Energy a -> Energy a -> Bool
< :: Energy a -> Energy a -> Bool
$c<= :: forall a. Ord a => Energy a -> Energy a -> Bool
<= :: Energy a -> Energy a -> Bool
$c> :: forall a. Ord a => Energy a -> Energy a -> Bool
> :: Energy a -> Energy a -> Bool
$c>= :: forall a. Ord a => Energy a -> Energy a -> Bool
>= :: Energy a -> Energy a -> Bool
$cmax :: forall a. Ord a => Energy a -> Energy a -> Energy a
max :: Energy a -> Energy a -> Energy a
$cmin :: forall a. Ord a => Energy a -> Energy a -> Energy a
min :: Energy a -> Energy a -> Energy a
Ord, Typeable, Typeable (Energy a)
Typeable (Energy a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Energy a -> c (Energy a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Energy a))
-> (Energy a -> Constr)
-> (Energy a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Energy a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Energy a)))
-> ((forall b. Data b => b -> b) -> Energy a -> Energy a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Energy a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Energy a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Energy a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Energy a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Energy a -> m (Energy a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Energy a -> m (Energy a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Energy a -> m (Energy a))
-> Data (Energy a)
Energy a -> Constr
Energy a -> DataType
(forall b. Data b => b -> b) -> Energy a -> Energy a
forall a. Data a => Typeable (Energy a)
forall a. Data a => Energy a -> Constr
forall a. Data a => Energy a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Energy a -> Energy a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Energy a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Energy a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Energy a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Energy a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Energy a -> m (Energy a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Energy a -> m (Energy a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Energy a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Energy a -> c (Energy a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Energy a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Energy a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Energy a -> u
forall u. (forall d. Data d => d -> u) -> Energy a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Energy a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Energy a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Energy a -> m (Energy a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Energy a -> m (Energy a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Energy a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Energy a -> c (Energy a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Energy a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Energy a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Energy a -> c (Energy a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Energy a -> c (Energy a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Energy a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Energy a)
$ctoConstr :: forall a. Data a => Energy a -> Constr
toConstr :: Energy a -> Constr
$cdataTypeOf :: forall a. Data a => Energy a -> DataType
dataTypeOf :: Energy a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Energy a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Energy a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Energy a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Energy a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Energy a -> Energy a
gmapT :: (forall b. Data b => b -> b) -> Energy a -> Energy a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Energy a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Energy a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Energy a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Energy a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Energy a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Energy a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Energy a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Energy a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Energy a -> m (Energy a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Energy a -> m (Energy a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Energy a -> m (Energy a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Energy a -> m (Energy a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Energy a -> m (Energy a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Energy a -> m (Energy a)
Data, (forall x. Energy a -> Rep (Energy a) x)
-> (forall x. Rep (Energy a) x -> Energy a) -> Generic (Energy a)
forall x. Rep (Energy a) x -> Energy a
forall x. Energy a -> Rep (Energy a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Energy a) x -> Energy a
forall a x. Energy a -> Rep (Energy a) x
$cfrom :: forall a x. Energy a -> Rep (Energy a) x
from :: forall x. Energy a -> Rep (Energy a) x
$cto :: forall a x. Rep (Energy a) x -> Energy a
to :: forall x. Rep (Energy a) x -> Energy a
Generic)
  deriving newtype (Get (Energy a)
[Energy a] -> Put
Energy a -> Put
(Energy a -> Put)
-> Get (Energy a) -> ([Energy a] -> Put) -> Binary (Energy a)
forall a. Binary a => Get (Energy a)
forall a. Binary a => [Energy a] -> Put
forall a. Binary a => Energy a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Energy a -> Put
put :: Energy a -> Put
$cget :: forall a. Binary a => Get (Energy a)
get :: Get (Energy a)
$cputList :: forall a. Binary a => [Energy a] -> Put
putList :: [Energy a] -> Put
Binary)
 instance (Num a, Show a) => Show (Energy a) where { show :: Energy a -> String
show = Energy a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Power a = Watts { forall a. Power a -> a
watts :: a }
  deriving (Power a -> Power a -> Bool
(Power a -> Power a -> Bool)
-> (Power a -> Power a -> Bool) -> Eq (Power a)
forall a. Eq a => Power a -> Power a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Power a -> Power a -> Bool
== :: Power a -> Power a -> Bool
$c/= :: forall a. Eq a => Power a -> Power a -> Bool
/= :: Power a -> Power a -> Bool
Eq,Eq (Power a)
Eq (Power a) =>
(Power a -> Power a -> Ordering)
-> (Power a -> Power a -> Bool)
-> (Power a -> Power a -> Bool)
-> (Power a -> Power a -> Bool)
-> (Power a -> Power a -> Bool)
-> (Power a -> Power a -> Power a)
-> (Power a -> Power a -> Power a)
-> Ord (Power a)
Power a -> Power a -> Bool
Power a -> Power a -> Ordering
Power a -> Power a -> Power a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Power a)
forall a. Ord a => Power a -> Power a -> Bool
forall a. Ord a => Power a -> Power a -> Ordering
forall a. Ord a => Power a -> Power a -> Power a
$ccompare :: forall a. Ord a => Power a -> Power a -> Ordering
compare :: Power a -> Power a -> Ordering
$c< :: forall a. Ord a => Power a -> Power a -> Bool
< :: Power a -> Power a -> Bool
$c<= :: forall a. Ord a => Power a -> Power a -> Bool
<= :: Power a -> Power a -> Bool
$c> :: forall a. Ord a => Power a -> Power a -> Bool
> :: Power a -> Power a -> Bool
$c>= :: forall a. Ord a => Power a -> Power a -> Bool
>= :: Power a -> Power a -> Bool
$cmax :: forall a. Ord a => Power a -> Power a -> Power a
max :: Power a -> Power a -> Power a
$cmin :: forall a. Ord a => Power a -> Power a -> Power a
min :: Power a -> Power a -> Power a
Ord, Typeable, Typeable (Power a)
Typeable (Power a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Power a -> c (Power a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Power a))
-> (Power a -> Constr)
-> (Power a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Power a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Power a)))
-> ((forall b. Data b => b -> b) -> Power a -> Power a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Power a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Power a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Power a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Power a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Power a -> m (Power a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Power a -> m (Power a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Power a -> m (Power a))
-> Data (Power a)
Power a -> Constr
Power a -> DataType
(forall b. Data b => b -> b) -> Power a -> Power a
forall a. Data a => Typeable (Power a)
forall a. Data a => Power a -> Constr
forall a. Data a => Power a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Power a -> Power a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Power a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Power a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Power a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Power a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Power a -> m (Power a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Power a -> m (Power a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Power a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Power a -> c (Power a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Power a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Power a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Power a -> u
forall u. (forall d. Data d => d -> u) -> Power a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Power a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Power a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Power a -> m (Power a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Power a -> m (Power a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Power a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Power a -> c (Power a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Power a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Power a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Power a -> c (Power a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Power a -> c (Power a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Power a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Power a)
$ctoConstr :: forall a. Data a => Power a -> Constr
toConstr :: Power a -> Constr
$cdataTypeOf :: forall a. Data a => Power a -> DataType
dataTypeOf :: Power a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Power a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Power a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Power a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Power a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Power a -> Power a
gmapT :: (forall b. Data b => b -> b) -> Power a -> Power a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Power a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Power a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Power a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Power a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Power a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Power a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Power a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Power a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Power a -> m (Power a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Power a -> m (Power a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Power a -> m (Power a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Power a -> m (Power a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Power a -> m (Power a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Power a -> m (Power a)
Data, (forall x. Power a -> Rep (Power a) x)
-> (forall x. Rep (Power a) x -> Power a) -> Generic (Power a)
forall x. Rep (Power a) x -> Power a
forall x. Power a -> Rep (Power a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Power a) x -> Power a
forall a x. Power a -> Rep (Power a) x
$cfrom :: forall a x. Power a -> Rep (Power a) x
from :: forall x. Power a -> Rep (Power a) x
$cto :: forall a x. Rep (Power a) x -> Power a
to :: forall x. Rep (Power a) x -> Power a
Generic)
  deriving newtype (Get (Power a)
[Power a] -> Put
Power a -> Put
(Power a -> Put)
-> Get (Power a) -> ([Power a] -> Put) -> Binary (Power a)
forall a. Binary a => Get (Power a)
forall a. Binary a => [Power a] -> Put
forall a. Binary a => Power a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Power a -> Put
put :: Power a -> Put
$cget :: forall a. Binary a => Get (Power a)
get :: Get (Power a)
$cputList :: forall a. Binary a => [Power a] -> Put
putList :: [Power a] -> Put
Binary)
 instance (Num a, Show a) => Show (Power a) where { show :: Power a -> String
show = Power a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Charge a = Coulombs { forall a. Charge a -> a
coulombs :: a }
  deriving (Charge a -> Charge a -> Bool
(Charge a -> Charge a -> Bool)
-> (Charge a -> Charge a -> Bool) -> Eq (Charge a)
forall a. Eq a => Charge a -> Charge a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Charge a -> Charge a -> Bool
== :: Charge a -> Charge a -> Bool
$c/= :: forall a. Eq a => Charge a -> Charge a -> Bool
/= :: Charge a -> Charge a -> Bool
Eq,Eq (Charge a)
Eq (Charge a) =>
(Charge a -> Charge a -> Ordering)
-> (Charge a -> Charge a -> Bool)
-> (Charge a -> Charge a -> Bool)
-> (Charge a -> Charge a -> Bool)
-> (Charge a -> Charge a -> Bool)
-> (Charge a -> Charge a -> Charge a)
-> (Charge a -> Charge a -> Charge a)
-> Ord (Charge a)
Charge a -> Charge a -> Bool
Charge a -> Charge a -> Ordering
Charge a -> Charge a -> Charge a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Charge a)
forall a. Ord a => Charge a -> Charge a -> Bool
forall a. Ord a => Charge a -> Charge a -> Ordering
forall a. Ord a => Charge a -> Charge a -> Charge a
$ccompare :: forall a. Ord a => Charge a -> Charge a -> Ordering
compare :: Charge a -> Charge a -> Ordering
$c< :: forall a. Ord a => Charge a -> Charge a -> Bool
< :: Charge a -> Charge a -> Bool
$c<= :: forall a. Ord a => Charge a -> Charge a -> Bool
<= :: Charge a -> Charge a -> Bool
$c> :: forall a. Ord a => Charge a -> Charge a -> Bool
> :: Charge a -> Charge a -> Bool
$c>= :: forall a. Ord a => Charge a -> Charge a -> Bool
>= :: Charge a -> Charge a -> Bool
$cmax :: forall a. Ord a => Charge a -> Charge a -> Charge a
max :: Charge a -> Charge a -> Charge a
$cmin :: forall a. Ord a => Charge a -> Charge a -> Charge a
min :: Charge a -> Charge a -> Charge a
Ord, Typeable, Typeable (Charge a)
Typeable (Charge a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Charge a -> c (Charge a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Charge a))
-> (Charge a -> Constr)
-> (Charge a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Charge a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Charge a)))
-> ((forall b. Data b => b -> b) -> Charge a -> Charge a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Charge a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Charge a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Charge a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Charge a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Charge a -> m (Charge a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Charge a -> m (Charge a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Charge a -> m (Charge a))
-> Data (Charge a)
Charge a -> Constr
Charge a -> DataType
(forall b. Data b => b -> b) -> Charge a -> Charge a
forall a. Data a => Typeable (Charge a)
forall a. Data a => Charge a -> Constr
forall a. Data a => Charge a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Charge a -> Charge a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Charge a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Charge a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Charge a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Charge a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Charge a -> m (Charge a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Charge a -> m (Charge a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Charge a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Charge a -> c (Charge a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Charge a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Charge a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Charge a -> u
forall u. (forall d. Data d => d -> u) -> Charge a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Charge a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Charge a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Charge a -> m (Charge a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Charge a -> m (Charge a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Charge a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Charge a -> c (Charge a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Charge a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Charge a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Charge a -> c (Charge a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Charge a -> c (Charge a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Charge a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Charge a)
$ctoConstr :: forall a. Data a => Charge a -> Constr
toConstr :: Charge a -> Constr
$cdataTypeOf :: forall a. Data a => Charge a -> DataType
dataTypeOf :: Charge a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Charge a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Charge a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Charge a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Charge a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Charge a -> Charge a
gmapT :: (forall b. Data b => b -> b) -> Charge a -> Charge a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Charge a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Charge a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Charge a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Charge a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Charge a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Charge a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Charge a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Charge a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Charge a -> m (Charge a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Charge a -> m (Charge a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Charge a -> m (Charge a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Charge a -> m (Charge a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Charge a -> m (Charge a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Charge a -> m (Charge a)
Data, (forall x. Charge a -> Rep (Charge a) x)
-> (forall x. Rep (Charge a) x -> Charge a) -> Generic (Charge a)
forall x. Rep (Charge a) x -> Charge a
forall x. Charge a -> Rep (Charge a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Charge a) x -> Charge a
forall a x. Charge a -> Rep (Charge a) x
$cfrom :: forall a x. Charge a -> Rep (Charge a) x
from :: forall x. Charge a -> Rep (Charge a) x
$cto :: forall a x. Rep (Charge a) x -> Charge a
to :: forall x. Rep (Charge a) x -> Charge a
Generic)
  deriving newtype (Get (Charge a)
[Charge a] -> Put
Charge a -> Put
(Charge a -> Put)
-> Get (Charge a) -> ([Charge a] -> Put) -> Binary (Charge a)
forall a. Binary a => Get (Charge a)
forall a. Binary a => [Charge a] -> Put
forall a. Binary a => Charge a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Charge a -> Put
put :: Charge a -> Put
$cget :: forall a. Binary a => Get (Charge a)
get :: Get (Charge a)
$cputList :: forall a. Binary a => [Charge a] -> Put
putList :: [Charge a] -> Put
Binary)
 instance (Num a, Show a) => Show (Charge a) where { show :: Charge a -> String
show = Charge a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Voltage a = Volts { forall a. Voltage a -> a
volts :: a }
  deriving (Voltage a -> Voltage a -> Bool
(Voltage a -> Voltage a -> Bool)
-> (Voltage a -> Voltage a -> Bool) -> Eq (Voltage a)
forall a. Eq a => Voltage a -> Voltage a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Voltage a -> Voltage a -> Bool
== :: Voltage a -> Voltage a -> Bool
$c/= :: forall a. Eq a => Voltage a -> Voltage a -> Bool
/= :: Voltage a -> Voltage a -> Bool
Eq,Eq (Voltage a)
Eq (Voltage a) =>
(Voltage a -> Voltage a -> Ordering)
-> (Voltage a -> Voltage a -> Bool)
-> (Voltage a -> Voltage a -> Bool)
-> (Voltage a -> Voltage a -> Bool)
-> (Voltage a -> Voltage a -> Bool)
-> (Voltage a -> Voltage a -> Voltage a)
-> (Voltage a -> Voltage a -> Voltage a)
-> Ord (Voltage a)
Voltage a -> Voltage a -> Bool
Voltage a -> Voltage a -> Ordering
Voltage a -> Voltage a -> Voltage a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Voltage a)
forall a. Ord a => Voltage a -> Voltage a -> Bool
forall a. Ord a => Voltage a -> Voltage a -> Ordering
forall a. Ord a => Voltage a -> Voltage a -> Voltage a
$ccompare :: forall a. Ord a => Voltage a -> Voltage a -> Ordering
compare :: Voltage a -> Voltage a -> Ordering
$c< :: forall a. Ord a => Voltage a -> Voltage a -> Bool
< :: Voltage a -> Voltage a -> Bool
$c<= :: forall a. Ord a => Voltage a -> Voltage a -> Bool
<= :: Voltage a -> Voltage a -> Bool
$c> :: forall a. Ord a => Voltage a -> Voltage a -> Bool
> :: Voltage a -> Voltage a -> Bool
$c>= :: forall a. Ord a => Voltage a -> Voltage a -> Bool
>= :: Voltage a -> Voltage a -> Bool
$cmax :: forall a. Ord a => Voltage a -> Voltage a -> Voltage a
max :: Voltage a -> Voltage a -> Voltage a
$cmin :: forall a. Ord a => Voltage a -> Voltage a -> Voltage a
min :: Voltage a -> Voltage a -> Voltage a
Ord, Typeable, Typeable (Voltage a)
Typeable (Voltage a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Voltage a -> c (Voltage a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Voltage a))
-> (Voltage a -> Constr)
-> (Voltage a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Voltage a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Voltage a)))
-> ((forall b. Data b => b -> b) -> Voltage a -> Voltage a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Voltage a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Voltage a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Voltage a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Voltage a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Voltage a -> m (Voltage a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Voltage a -> m (Voltage a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Voltage a -> m (Voltage a))
-> Data (Voltage a)
Voltage a -> Constr
Voltage a -> DataType
(forall b. Data b => b -> b) -> Voltage a -> Voltage a
forall a. Data a => Typeable (Voltage a)
forall a. Data a => Voltage a -> Constr
forall a. Data a => Voltage a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Voltage a -> Voltage a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Voltage a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Voltage a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Voltage a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Voltage a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Voltage a -> m (Voltage a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Voltage a -> m (Voltage a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Voltage a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Voltage a -> c (Voltage a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Voltage a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Voltage a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Voltage a -> u
forall u. (forall d. Data d => d -> u) -> Voltage a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Voltage a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Voltage a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Voltage a -> m (Voltage a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Voltage a -> m (Voltage a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Voltage a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Voltage a -> c (Voltage a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Voltage a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Voltage a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Voltage a -> c (Voltage a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Voltage a -> c (Voltage a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Voltage a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Voltage a)
$ctoConstr :: forall a. Data a => Voltage a -> Constr
toConstr :: Voltage a -> Constr
$cdataTypeOf :: forall a. Data a => Voltage a -> DataType
dataTypeOf :: Voltage a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Voltage a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Voltage a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Voltage a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Voltage a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Voltage a -> Voltage a
gmapT :: (forall b. Data b => b -> b) -> Voltage a -> Voltage a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Voltage a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Voltage a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Voltage a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Voltage a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Voltage a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Voltage a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Voltage a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Voltage a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Voltage a -> m (Voltage a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Voltage a -> m (Voltage a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Voltage a -> m (Voltage a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Voltage a -> m (Voltage a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Voltage a -> m (Voltage a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Voltage a -> m (Voltage a)
Data, (forall x. Voltage a -> Rep (Voltage a) x)
-> (forall x. Rep (Voltage a) x -> Voltage a)
-> Generic (Voltage a)
forall x. Rep (Voltage a) x -> Voltage a
forall x. Voltage a -> Rep (Voltage a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Voltage a) x -> Voltage a
forall a x. Voltage a -> Rep (Voltage a) x
$cfrom :: forall a x. Voltage a -> Rep (Voltage a) x
from :: forall x. Voltage a -> Rep (Voltage a) x
$cto :: forall a x. Rep (Voltage a) x -> Voltage a
to :: forall x. Rep (Voltage a) x -> Voltage a
Generic)
  deriving newtype (Get (Voltage a)
[Voltage a] -> Put
Voltage a -> Put
(Voltage a -> Put)
-> Get (Voltage a) -> ([Voltage a] -> Put) -> Binary (Voltage a)
forall a. Binary a => Get (Voltage a)
forall a. Binary a => [Voltage a] -> Put
forall a. Binary a => Voltage a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Voltage a -> Put
put :: Voltage a -> Put
$cget :: forall a. Binary a => Get (Voltage a)
get :: Get (Voltage a)
$cputList :: forall a. Binary a => [Voltage a] -> Put
putList :: [Voltage a] -> Put
Binary)
 instance (Num a, Show a) => Show (Voltage a) where { show :: Voltage a -> String
show = Voltage a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Capacitance a = Farads { forall a. Capacitance a -> a
farads :: a }
  deriving (Capacitance a -> Capacitance a -> Bool
(Capacitance a -> Capacitance a -> Bool)
-> (Capacitance a -> Capacitance a -> Bool) -> Eq (Capacitance a)
forall a. Eq a => Capacitance a -> Capacitance a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Capacitance a -> Capacitance a -> Bool
== :: Capacitance a -> Capacitance a -> Bool
$c/= :: forall a. Eq a => Capacitance a -> Capacitance a -> Bool
/= :: Capacitance a -> Capacitance a -> Bool
Eq,Eq (Capacitance a)
Eq (Capacitance a) =>
(Capacitance a -> Capacitance a -> Ordering)
-> (Capacitance a -> Capacitance a -> Bool)
-> (Capacitance a -> Capacitance a -> Bool)
-> (Capacitance a -> Capacitance a -> Bool)
-> (Capacitance a -> Capacitance a -> Bool)
-> (Capacitance a -> Capacitance a -> Capacitance a)
-> (Capacitance a -> Capacitance a -> Capacitance a)
-> Ord (Capacitance a)
Capacitance a -> Capacitance a -> Bool
Capacitance a -> Capacitance a -> Ordering
Capacitance a -> Capacitance a -> Capacitance a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Capacitance a)
forall a. Ord a => Capacitance a -> Capacitance a -> Bool
forall a. Ord a => Capacitance a -> Capacitance a -> Ordering
forall a. Ord a => Capacitance a -> Capacitance a -> Capacitance a
$ccompare :: forall a. Ord a => Capacitance a -> Capacitance a -> Ordering
compare :: Capacitance a -> Capacitance a -> Ordering
$c< :: forall a. Ord a => Capacitance a -> Capacitance a -> Bool
< :: Capacitance a -> Capacitance a -> Bool
$c<= :: forall a. Ord a => Capacitance a -> Capacitance a -> Bool
<= :: Capacitance a -> Capacitance a -> Bool
$c> :: forall a. Ord a => Capacitance a -> Capacitance a -> Bool
> :: Capacitance a -> Capacitance a -> Bool
$c>= :: forall a. Ord a => Capacitance a -> Capacitance a -> Bool
>= :: Capacitance a -> Capacitance a -> Bool
$cmax :: forall a. Ord a => Capacitance a -> Capacitance a -> Capacitance a
max :: Capacitance a -> Capacitance a -> Capacitance a
$cmin :: forall a. Ord a => Capacitance a -> Capacitance a -> Capacitance a
min :: Capacitance a -> Capacitance a -> Capacitance a
Ord, Typeable, Typeable (Capacitance a)
Typeable (Capacitance a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Capacitance a -> c (Capacitance a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Capacitance a))
-> (Capacitance a -> Constr)
-> (Capacitance a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Capacitance a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Capacitance a)))
-> ((forall b. Data b => b -> b) -> Capacitance a -> Capacitance a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Capacitance a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Capacitance a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Capacitance a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Capacitance a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Capacitance a -> m (Capacitance a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Capacitance a -> m (Capacitance a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Capacitance a -> m (Capacitance a))
-> Data (Capacitance a)
Capacitance a -> Constr
Capacitance a -> DataType
(forall b. Data b => b -> b) -> Capacitance a -> Capacitance a
forall a. Data a => Typeable (Capacitance a)
forall a. Data a => Capacitance a -> Constr
forall a. Data a => Capacitance a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Capacitance a -> Capacitance a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Capacitance a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Capacitance a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Capacitance a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Capacitance a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Capacitance a -> m (Capacitance a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Capacitance a -> m (Capacitance a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Capacitance a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Capacitance a -> c (Capacitance a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Capacitance a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Capacitance a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Capacitance a -> u
forall u. (forall d. Data d => d -> u) -> Capacitance a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Capacitance a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Capacitance a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Capacitance a -> m (Capacitance a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Capacitance a -> m (Capacitance a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Capacitance a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Capacitance a -> c (Capacitance a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Capacitance a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Capacitance a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Capacitance a -> c (Capacitance a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Capacitance a -> c (Capacitance a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Capacitance a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Capacitance a)
$ctoConstr :: forall a. Data a => Capacitance a -> Constr
toConstr :: Capacitance a -> Constr
$cdataTypeOf :: forall a. Data a => Capacitance a -> DataType
dataTypeOf :: Capacitance a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Capacitance a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Capacitance a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Capacitance a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Capacitance a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Capacitance a -> Capacitance a
gmapT :: (forall b. Data b => b -> b) -> Capacitance a -> Capacitance a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Capacitance a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Capacitance a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Capacitance a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Capacitance a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Capacitance a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Capacitance a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Capacitance a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Capacitance a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Capacitance a -> m (Capacitance a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Capacitance a -> m (Capacitance a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Capacitance a -> m (Capacitance a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Capacitance a -> m (Capacitance a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Capacitance a -> m (Capacitance a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Capacitance a -> m (Capacitance a)
Data, (forall x. Capacitance a -> Rep (Capacitance a) x)
-> (forall x. Rep (Capacitance a) x -> Capacitance a)
-> Generic (Capacitance a)
forall x. Rep (Capacitance a) x -> Capacitance a
forall x. Capacitance a -> Rep (Capacitance a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Capacitance a) x -> Capacitance a
forall a x. Capacitance a -> Rep (Capacitance a) x
$cfrom :: forall a x. Capacitance a -> Rep (Capacitance a) x
from :: forall x. Capacitance a -> Rep (Capacitance a) x
$cto :: forall a x. Rep (Capacitance a) x -> Capacitance a
to :: forall x. Rep (Capacitance a) x -> Capacitance a
Generic) deriving newtype (Get (Capacitance a)
[Capacitance a] -> Put
Capacitance a -> Put
(Capacitance a -> Put)
-> Get (Capacitance a)
-> ([Capacitance a] -> Put)
-> Binary (Capacitance a)
forall a. Binary a => Get (Capacitance a)
forall a. Binary a => [Capacitance a] -> Put
forall a. Binary a => Capacitance a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Capacitance a -> Put
put :: Capacitance a -> Put
$cget :: forall a. Binary a => Get (Capacitance a)
get :: Get (Capacitance a)
$cputList :: forall a. Binary a => [Capacitance a] -> Put
putList :: [Capacitance a] -> Put
Binary)
 instance (Num a, Show a) => Show (Capacitance a) where { show :: Capacitance a -> String
show = Capacitance a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Resistance a = Ohms { forall a. Resistance a -> a
ohms :: a }
  deriving (Resistance a -> Resistance a -> Bool
(Resistance a -> Resistance a -> Bool)
-> (Resistance a -> Resistance a -> Bool) -> Eq (Resistance a)
forall a. Eq a => Resistance a -> Resistance a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Resistance a -> Resistance a -> Bool
== :: Resistance a -> Resistance a -> Bool
$c/= :: forall a. Eq a => Resistance a -> Resistance a -> Bool
/= :: Resistance a -> Resistance a -> Bool
Eq,Eq (Resistance a)
Eq (Resistance a) =>
(Resistance a -> Resistance a -> Ordering)
-> (Resistance a -> Resistance a -> Bool)
-> (Resistance a -> Resistance a -> Bool)
-> (Resistance a -> Resistance a -> Bool)
-> (Resistance a -> Resistance a -> Bool)
-> (Resistance a -> Resistance a -> Resistance a)
-> (Resistance a -> Resistance a -> Resistance a)
-> Ord (Resistance a)
Resistance a -> Resistance a -> Bool
Resistance a -> Resistance a -> Ordering
Resistance a -> Resistance a -> Resistance a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Resistance a)
forall a. Ord a => Resistance a -> Resistance a -> Bool
forall a. Ord a => Resistance a -> Resistance a -> Ordering
forall a. Ord a => Resistance a -> Resistance a -> Resistance a
$ccompare :: forall a. Ord a => Resistance a -> Resistance a -> Ordering
compare :: Resistance a -> Resistance a -> Ordering
$c< :: forall a. Ord a => Resistance a -> Resistance a -> Bool
< :: Resistance a -> Resistance a -> Bool
$c<= :: forall a. Ord a => Resistance a -> Resistance a -> Bool
<= :: Resistance a -> Resistance a -> Bool
$c> :: forall a. Ord a => Resistance a -> Resistance a -> Bool
> :: Resistance a -> Resistance a -> Bool
$c>= :: forall a. Ord a => Resistance a -> Resistance a -> Bool
>= :: Resistance a -> Resistance a -> Bool
$cmax :: forall a. Ord a => Resistance a -> Resistance a -> Resistance a
max :: Resistance a -> Resistance a -> Resistance a
$cmin :: forall a. Ord a => Resistance a -> Resistance a -> Resistance a
min :: Resistance a -> Resistance a -> Resistance a
Ord, Typeable, Typeable (Resistance a)
Typeable (Resistance a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Resistance a -> c (Resistance a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Resistance a))
-> (Resistance a -> Constr)
-> (Resistance a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Resistance a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Resistance a)))
-> ((forall b. Data b => b -> b) -> Resistance a -> Resistance a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Resistance a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Resistance a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Resistance a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Resistance a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Resistance a -> m (Resistance a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Resistance a -> m (Resistance a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Resistance a -> m (Resistance a))
-> Data (Resistance a)
Resistance a -> Constr
Resistance a -> DataType
(forall b. Data b => b -> b) -> Resistance a -> Resistance a
forall a. Data a => Typeable (Resistance a)
forall a. Data a => Resistance a -> Constr
forall a. Data a => Resistance a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Resistance a -> Resistance a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Resistance a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Resistance a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Resistance a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Resistance a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Resistance a -> m (Resistance a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Resistance a -> m (Resistance a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Resistance a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Resistance a -> c (Resistance a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Resistance a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Resistance a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Resistance a -> u
forall u. (forall d. Data d => d -> u) -> Resistance a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Resistance a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Resistance a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Resistance a -> m (Resistance a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Resistance a -> m (Resistance a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Resistance a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Resistance a -> c (Resistance a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Resistance a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Resistance a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Resistance a -> c (Resistance a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Resistance a -> c (Resistance a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Resistance a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Resistance a)
$ctoConstr :: forall a. Data a => Resistance a -> Constr
toConstr :: Resistance a -> Constr
$cdataTypeOf :: forall a. Data a => Resistance a -> DataType
dataTypeOf :: Resistance a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Resistance a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Resistance a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Resistance a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Resistance a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Resistance a -> Resistance a
gmapT :: (forall b. Data b => b -> b) -> Resistance a -> Resistance a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Resistance a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Resistance a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Resistance a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Resistance a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Resistance a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Resistance a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Resistance a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Resistance a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Resistance a -> m (Resistance a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Resistance a -> m (Resistance a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Resistance a -> m (Resistance a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Resistance a -> m (Resistance a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Resistance a -> m (Resistance a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Resistance a -> m (Resistance a)
Data, (forall x. Resistance a -> Rep (Resistance a) x)
-> (forall x. Rep (Resistance a) x -> Resistance a)
-> Generic (Resistance a)
forall x. Rep (Resistance a) x -> Resistance a
forall x. Resistance a -> Rep (Resistance a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Resistance a) x -> Resistance a
forall a x. Resistance a -> Rep (Resistance a) x
$cfrom :: forall a x. Resistance a -> Rep (Resistance a) x
from :: forall x. Resistance a -> Rep (Resistance a) x
$cto :: forall a x. Rep (Resistance a) x -> Resistance a
to :: forall x. Rep (Resistance a) x -> Resistance a
Generic)
  deriving newtype (Get (Resistance a)
[Resistance a] -> Put
Resistance a -> Put
(Resistance a -> Put)
-> Get (Resistance a)
-> ([Resistance a] -> Put)
-> Binary (Resistance a)
forall a. Binary a => Get (Resistance a)
forall a. Binary a => [Resistance a] -> Put
forall a. Binary a => Resistance a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Resistance a -> Put
put :: Resistance a -> Put
$cget :: forall a. Binary a => Get (Resistance a)
get :: Get (Resistance a)
$cputList :: forall a. Binary a => [Resistance a] -> Put
putList :: [Resistance a] -> Put
Binary)
 instance (Num a, Show a) => Show (Resistance a) where { show :: Resistance a -> String
show = Resistance a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Conductance a = Siemenses { forall a. Conductance a -> a
siemenses :: a }
  deriving (Conductance a -> Conductance a -> Bool
(Conductance a -> Conductance a -> Bool)
-> (Conductance a -> Conductance a -> Bool) -> Eq (Conductance a)
forall a. Eq a => Conductance a -> Conductance a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Conductance a -> Conductance a -> Bool
== :: Conductance a -> Conductance a -> Bool
$c/= :: forall a. Eq a => Conductance a -> Conductance a -> Bool
/= :: Conductance a -> Conductance a -> Bool
Eq,Eq (Conductance a)
Eq (Conductance a) =>
(Conductance a -> Conductance a -> Ordering)
-> (Conductance a -> Conductance a -> Bool)
-> (Conductance a -> Conductance a -> Bool)
-> (Conductance a -> Conductance a -> Bool)
-> (Conductance a -> Conductance a -> Bool)
-> (Conductance a -> Conductance a -> Conductance a)
-> (Conductance a -> Conductance a -> Conductance a)
-> Ord (Conductance a)
Conductance a -> Conductance a -> Bool
Conductance a -> Conductance a -> Ordering
Conductance a -> Conductance a -> Conductance a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Conductance a)
forall a. Ord a => Conductance a -> Conductance a -> Bool
forall a. Ord a => Conductance a -> Conductance a -> Ordering
forall a. Ord a => Conductance a -> Conductance a -> Conductance a
$ccompare :: forall a. Ord a => Conductance a -> Conductance a -> Ordering
compare :: Conductance a -> Conductance a -> Ordering
$c< :: forall a. Ord a => Conductance a -> Conductance a -> Bool
< :: Conductance a -> Conductance a -> Bool
$c<= :: forall a. Ord a => Conductance a -> Conductance a -> Bool
<= :: Conductance a -> Conductance a -> Bool
$c> :: forall a. Ord a => Conductance a -> Conductance a -> Bool
> :: Conductance a -> Conductance a -> Bool
$c>= :: forall a. Ord a => Conductance a -> Conductance a -> Bool
>= :: Conductance a -> Conductance a -> Bool
$cmax :: forall a. Ord a => Conductance a -> Conductance a -> Conductance a
max :: Conductance a -> Conductance a -> Conductance a
$cmin :: forall a. Ord a => Conductance a -> Conductance a -> Conductance a
min :: Conductance a -> Conductance a -> Conductance a
Ord, Typeable, Typeable (Conductance a)
Typeable (Conductance a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Conductance a -> c (Conductance a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Conductance a))
-> (Conductance a -> Constr)
-> (Conductance a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Conductance a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Conductance a)))
-> ((forall b. Data b => b -> b) -> Conductance a -> Conductance a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Conductance a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Conductance a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Conductance a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Conductance a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Conductance a -> m (Conductance a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Conductance a -> m (Conductance a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Conductance a -> m (Conductance a))
-> Data (Conductance a)
Conductance a -> Constr
Conductance a -> DataType
(forall b. Data b => b -> b) -> Conductance a -> Conductance a
forall a. Data a => Typeable (Conductance a)
forall a. Data a => Conductance a -> Constr
forall a. Data a => Conductance a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Conductance a -> Conductance a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Conductance a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Conductance a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Conductance a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Conductance a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Conductance a -> m (Conductance a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Conductance a -> m (Conductance a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Conductance a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Conductance a -> c (Conductance a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Conductance a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Conductance a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Conductance a -> u
forall u. (forall d. Data d => d -> u) -> Conductance a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Conductance a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Conductance a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Conductance a -> m (Conductance a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Conductance a -> m (Conductance a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Conductance a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Conductance a -> c (Conductance a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Conductance a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Conductance a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Conductance a -> c (Conductance a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Conductance a -> c (Conductance a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Conductance a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Conductance a)
$ctoConstr :: forall a. Data a => Conductance a -> Constr
toConstr :: Conductance a -> Constr
$cdataTypeOf :: forall a. Data a => Conductance a -> DataType
dataTypeOf :: Conductance a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Conductance a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Conductance a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Conductance a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Conductance a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Conductance a -> Conductance a
gmapT :: (forall b. Data b => b -> b) -> Conductance a -> Conductance a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Conductance a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Conductance a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Conductance a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Conductance a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Conductance a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Conductance a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Conductance a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Conductance a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Conductance a -> m (Conductance a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Conductance a -> m (Conductance a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Conductance a -> m (Conductance a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Conductance a -> m (Conductance a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Conductance a -> m (Conductance a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Conductance a -> m (Conductance a)
Data, (forall x. Conductance a -> Rep (Conductance a) x)
-> (forall x. Rep (Conductance a) x -> Conductance a)
-> Generic (Conductance a)
forall x. Rep (Conductance a) x -> Conductance a
forall x. Conductance a -> Rep (Conductance a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Conductance a) x -> Conductance a
forall a x. Conductance a -> Rep (Conductance a) x
$cfrom :: forall a x. Conductance a -> Rep (Conductance a) x
from :: forall x. Conductance a -> Rep (Conductance a) x
$cto :: forall a x. Rep (Conductance a) x -> Conductance a
to :: forall x. Rep (Conductance a) x -> Conductance a
Generic) deriving newtype (Get (Conductance a)
[Conductance a] -> Put
Conductance a -> Put
(Conductance a -> Put)
-> Get (Conductance a)
-> ([Conductance a] -> Put)
-> Binary (Conductance a)
forall a. Binary a => Get (Conductance a)
forall a. Binary a => [Conductance a] -> Put
forall a. Binary a => Conductance a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Conductance a -> Put
put :: Conductance a -> Put
$cget :: forall a. Binary a => Get (Conductance a)
get :: Get (Conductance a)
$cputList :: forall a. Binary a => [Conductance a] -> Put
putList :: [Conductance a] -> Put
Binary)
 instance (Num a, Show a) => Show ( Conductance  a) where { show :: Conductance a -> String
show = Conductance a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Flux a = Webers { forall a. Flux a -> a
webers :: a }
  deriving (Flux a -> Flux a -> Bool
(Flux a -> Flux a -> Bool)
-> (Flux a -> Flux a -> Bool) -> Eq (Flux a)
forall a. Eq a => Flux a -> Flux a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Flux a -> Flux a -> Bool
== :: Flux a -> Flux a -> Bool
$c/= :: forall a. Eq a => Flux a -> Flux a -> Bool
/= :: Flux a -> Flux a -> Bool
Eq,Eq (Flux a)
Eq (Flux a) =>
(Flux a -> Flux a -> Ordering)
-> (Flux a -> Flux a -> Bool)
-> (Flux a -> Flux a -> Bool)
-> (Flux a -> Flux a -> Bool)
-> (Flux a -> Flux a -> Bool)
-> (Flux a -> Flux a -> Flux a)
-> (Flux a -> Flux a -> Flux a)
-> Ord (Flux a)
Flux a -> Flux a -> Bool
Flux a -> Flux a -> Ordering
Flux a -> Flux a -> Flux a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Flux a)
forall a. Ord a => Flux a -> Flux a -> Bool
forall a. Ord a => Flux a -> Flux a -> Ordering
forall a. Ord a => Flux a -> Flux a -> Flux a
$ccompare :: forall a. Ord a => Flux a -> Flux a -> Ordering
compare :: Flux a -> Flux a -> Ordering
$c< :: forall a. Ord a => Flux a -> Flux a -> Bool
< :: Flux a -> Flux a -> Bool
$c<= :: forall a. Ord a => Flux a -> Flux a -> Bool
<= :: Flux a -> Flux a -> Bool
$c> :: forall a. Ord a => Flux a -> Flux a -> Bool
> :: Flux a -> Flux a -> Bool
$c>= :: forall a. Ord a => Flux a -> Flux a -> Bool
>= :: Flux a -> Flux a -> Bool
$cmax :: forall a. Ord a => Flux a -> Flux a -> Flux a
max :: Flux a -> Flux a -> Flux a
$cmin :: forall a. Ord a => Flux a -> Flux a -> Flux a
min :: Flux a -> Flux a -> Flux a
Ord, Typeable, Typeable (Flux a)
Typeable (Flux a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Flux a -> c (Flux a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Flux a))
-> (Flux a -> Constr)
-> (Flux a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Flux a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Flux a)))
-> ((forall b. Data b => b -> b) -> Flux a -> Flux a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Flux a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Flux a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Flux a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Flux a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Flux a -> m (Flux a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Flux a -> m (Flux a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Flux a -> m (Flux a))
-> Data (Flux a)
Flux a -> Constr
Flux a -> DataType
(forall b. Data b => b -> b) -> Flux a -> Flux a
forall a. Data a => Typeable (Flux a)
forall a. Data a => Flux a -> Constr
forall a. Data a => Flux a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Flux a -> Flux a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Flux a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> Flux a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flux a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flux a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Flux a -> m (Flux a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Flux a -> m (Flux a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Flux a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flux a -> c (Flux a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Flux a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Flux a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Flux a -> u
forall u. (forall d. Data d => d -> u) -> Flux a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flux a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flux a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Flux a -> m (Flux a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Flux a -> m (Flux a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Flux a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flux a -> c (Flux a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Flux a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Flux a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flux a -> c (Flux a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flux a -> c (Flux a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Flux a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Flux a)
$ctoConstr :: forall a. Data a => Flux a -> Constr
toConstr :: Flux a -> Constr
$cdataTypeOf :: forall a. Data a => Flux a -> DataType
dataTypeOf :: Flux a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Flux a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Flux a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Flux a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Flux a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Flux a -> Flux a
gmapT :: (forall b. Data b => b -> b) -> Flux a -> Flux a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flux a -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flux a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flux a -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flux a -> r
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Flux a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Flux a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Flux a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Flux a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Flux a -> m (Flux a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Flux a -> m (Flux a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Flux a -> m (Flux a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Flux a -> m (Flux a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Flux a -> m (Flux a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Flux a -> m (Flux a)
Data, (forall x. Flux a -> Rep (Flux a) x)
-> (forall x. Rep (Flux a) x -> Flux a) -> Generic (Flux a)
forall x. Rep (Flux a) x -> Flux a
forall x. Flux a -> Rep (Flux a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Flux a) x -> Flux a
forall a x. Flux a -> Rep (Flux a) x
$cfrom :: forall a x. Flux a -> Rep (Flux a) x
from :: forall x. Flux a -> Rep (Flux a) x
$cto :: forall a x. Rep (Flux a) x -> Flux a
to :: forall x. Rep (Flux a) x -> Flux a
Generic) deriving newtype (Get (Flux a)
[Flux a] -> Put
Flux a -> Put
(Flux a -> Put)
-> Get (Flux a) -> ([Flux a] -> Put) -> Binary (Flux a)
forall a. Binary a => Get (Flux a)
forall a. Binary a => [Flux a] -> Put
forall a. Binary a => Flux a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Flux a -> Put
put :: Flux a -> Put
$cget :: forall a. Binary a => Get (Flux a)
get :: Get (Flux a)
$cputList :: forall a. Binary a => [Flux a] -> Put
putList :: [Flux a] -> Put
Binary)
 instance (Num a, Show a) => Show (Flux a) where { show :: Flux a -> String
show = Flux a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype FluxDensity a = Teslas { forall a. FluxDensity a -> a
teslas :: a }
  deriving (FluxDensity a -> FluxDensity a -> Bool
(FluxDensity a -> FluxDensity a -> Bool)
-> (FluxDensity a -> FluxDensity a -> Bool) -> Eq (FluxDensity a)
forall a. Eq a => FluxDensity a -> FluxDensity a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => FluxDensity a -> FluxDensity a -> Bool
== :: FluxDensity a -> FluxDensity a -> Bool
$c/= :: forall a. Eq a => FluxDensity a -> FluxDensity a -> Bool
/= :: FluxDensity a -> FluxDensity a -> Bool
Eq,Eq (FluxDensity a)
Eq (FluxDensity a) =>
(FluxDensity a -> FluxDensity a -> Ordering)
-> (FluxDensity a -> FluxDensity a -> Bool)
-> (FluxDensity a -> FluxDensity a -> Bool)
-> (FluxDensity a -> FluxDensity a -> Bool)
-> (FluxDensity a -> FluxDensity a -> Bool)
-> (FluxDensity a -> FluxDensity a -> FluxDensity a)
-> (FluxDensity a -> FluxDensity a -> FluxDensity a)
-> Ord (FluxDensity a)
FluxDensity a -> FluxDensity a -> Bool
FluxDensity a -> FluxDensity a -> Ordering
FluxDensity a -> FluxDensity a -> FluxDensity a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (FluxDensity a)
forall a. Ord a => FluxDensity a -> FluxDensity a -> Bool
forall a. Ord a => FluxDensity a -> FluxDensity a -> Ordering
forall a. Ord a => FluxDensity a -> FluxDensity a -> FluxDensity a
$ccompare :: forall a. Ord a => FluxDensity a -> FluxDensity a -> Ordering
compare :: FluxDensity a -> FluxDensity a -> Ordering
$c< :: forall a. Ord a => FluxDensity a -> FluxDensity a -> Bool
< :: FluxDensity a -> FluxDensity a -> Bool
$c<= :: forall a. Ord a => FluxDensity a -> FluxDensity a -> Bool
<= :: FluxDensity a -> FluxDensity a -> Bool
$c> :: forall a. Ord a => FluxDensity a -> FluxDensity a -> Bool
> :: FluxDensity a -> FluxDensity a -> Bool
$c>= :: forall a. Ord a => FluxDensity a -> FluxDensity a -> Bool
>= :: FluxDensity a -> FluxDensity a -> Bool
$cmax :: forall a. Ord a => FluxDensity a -> FluxDensity a -> FluxDensity a
max :: FluxDensity a -> FluxDensity a -> FluxDensity a
$cmin :: forall a. Ord a => FluxDensity a -> FluxDensity a -> FluxDensity a
min :: FluxDensity a -> FluxDensity a -> FluxDensity a
Ord, Typeable, Typeable (FluxDensity a)
Typeable (FluxDensity a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FluxDensity a -> c (FluxDensity a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FluxDensity a))
-> (FluxDensity a -> Constr)
-> (FluxDensity a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FluxDensity a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FluxDensity a)))
-> ((forall b. Data b => b -> b) -> FluxDensity a -> FluxDensity a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FluxDensity a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FluxDensity a -> r)
-> (forall u. (forall d. Data d => d -> u) -> FluxDensity a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FluxDensity a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FluxDensity a -> m (FluxDensity a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FluxDensity a -> m (FluxDensity a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FluxDensity a -> m (FluxDensity a))
-> Data (FluxDensity a)
FluxDensity a -> Constr
FluxDensity a -> DataType
(forall b. Data b => b -> b) -> FluxDensity a -> FluxDensity a
forall a. Data a => Typeable (FluxDensity a)
forall a. Data a => FluxDensity a -> Constr
forall a. Data a => FluxDensity a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> FluxDensity a -> FluxDensity a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> FluxDensity a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> FluxDensity a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FluxDensity a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FluxDensity a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> FluxDensity a -> m (FluxDensity a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> FluxDensity a -> m (FluxDensity a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FluxDensity a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FluxDensity a -> c (FluxDensity a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FluxDensity a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FluxDensity a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FluxDensity a -> u
forall u. (forall d. Data d => d -> u) -> FluxDensity a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FluxDensity a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FluxDensity a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FluxDensity a -> m (FluxDensity a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FluxDensity a -> m (FluxDensity a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FluxDensity a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FluxDensity a -> c (FluxDensity a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FluxDensity a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FluxDensity a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FluxDensity a -> c (FluxDensity a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FluxDensity a -> c (FluxDensity a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FluxDensity a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FluxDensity a)
$ctoConstr :: forall a. Data a => FluxDensity a -> Constr
toConstr :: FluxDensity a -> Constr
$cdataTypeOf :: forall a. Data a => FluxDensity a -> DataType
dataTypeOf :: FluxDensity a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FluxDensity a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FluxDensity a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FluxDensity a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FluxDensity a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> FluxDensity a -> FluxDensity a
gmapT :: (forall b. Data b => b -> b) -> FluxDensity a -> FluxDensity a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FluxDensity a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FluxDensity a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FluxDensity a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FluxDensity a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> FluxDensity a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FluxDensity a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> FluxDensity a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FluxDensity a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> FluxDensity a -> m (FluxDensity a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FluxDensity a -> m (FluxDensity a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> FluxDensity a -> m (FluxDensity a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FluxDensity a -> m (FluxDensity a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> FluxDensity a -> m (FluxDensity a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FluxDensity a -> m (FluxDensity a)
Data, (forall x. FluxDensity a -> Rep (FluxDensity a) x)
-> (forall x. Rep (FluxDensity a) x -> FluxDensity a)
-> Generic (FluxDensity a)
forall x. Rep (FluxDensity a) x -> FluxDensity a
forall x. FluxDensity a -> Rep (FluxDensity a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (FluxDensity a) x -> FluxDensity a
forall a x. FluxDensity a -> Rep (FluxDensity a) x
$cfrom :: forall a x. FluxDensity a -> Rep (FluxDensity a) x
from :: forall x. FluxDensity a -> Rep (FluxDensity a) x
$cto :: forall a x. Rep (FluxDensity a) x -> FluxDensity a
to :: forall x. Rep (FluxDensity a) x -> FluxDensity a
Generic) deriving newtype (Get (FluxDensity a)
[FluxDensity a] -> Put
FluxDensity a -> Put
(FluxDensity a -> Put)
-> Get (FluxDensity a)
-> ([FluxDensity a] -> Put)
-> Binary (FluxDensity a)
forall a. Binary a => Get (FluxDensity a)
forall a. Binary a => [FluxDensity a] -> Put
forall a. Binary a => FluxDensity a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => FluxDensity a -> Put
put :: FluxDensity a -> Put
$cget :: forall a. Binary a => Get (FluxDensity a)
get :: Get (FluxDensity a)
$cputList :: forall a. Binary a => [FluxDensity a] -> Put
putList :: [FluxDensity a] -> Put
Binary)
 instance (Num a, Show a) => Show (FluxDensity a) where { show :: FluxDensity a -> String
show = FluxDensity a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Inductance a = Henrys { forall a. Inductance a -> a
henrys :: a }
  deriving (Inductance a -> Inductance a -> Bool
(Inductance a -> Inductance a -> Bool)
-> (Inductance a -> Inductance a -> Bool) -> Eq (Inductance a)
forall a. Eq a => Inductance a -> Inductance a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Inductance a -> Inductance a -> Bool
== :: Inductance a -> Inductance a -> Bool
$c/= :: forall a. Eq a => Inductance a -> Inductance a -> Bool
/= :: Inductance a -> Inductance a -> Bool
Eq,Eq (Inductance a)
Eq (Inductance a) =>
(Inductance a -> Inductance a -> Ordering)
-> (Inductance a -> Inductance a -> Bool)
-> (Inductance a -> Inductance a -> Bool)
-> (Inductance a -> Inductance a -> Bool)
-> (Inductance a -> Inductance a -> Bool)
-> (Inductance a -> Inductance a -> Inductance a)
-> (Inductance a -> Inductance a -> Inductance a)
-> Ord (Inductance a)
Inductance a -> Inductance a -> Bool
Inductance a -> Inductance a -> Ordering
Inductance a -> Inductance a -> Inductance a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Inductance a)
forall a. Ord a => Inductance a -> Inductance a -> Bool
forall a. Ord a => Inductance a -> Inductance a -> Ordering
forall a. Ord a => Inductance a -> Inductance a -> Inductance a
$ccompare :: forall a. Ord a => Inductance a -> Inductance a -> Ordering
compare :: Inductance a -> Inductance a -> Ordering
$c< :: forall a. Ord a => Inductance a -> Inductance a -> Bool
< :: Inductance a -> Inductance a -> Bool
$c<= :: forall a. Ord a => Inductance a -> Inductance a -> Bool
<= :: Inductance a -> Inductance a -> Bool
$c> :: forall a. Ord a => Inductance a -> Inductance a -> Bool
> :: Inductance a -> Inductance a -> Bool
$c>= :: forall a. Ord a => Inductance a -> Inductance a -> Bool
>= :: Inductance a -> Inductance a -> Bool
$cmax :: forall a. Ord a => Inductance a -> Inductance a -> Inductance a
max :: Inductance a -> Inductance a -> Inductance a
$cmin :: forall a. Ord a => Inductance a -> Inductance a -> Inductance a
min :: Inductance a -> Inductance a -> Inductance a
Ord, Typeable, Typeable (Inductance a)
Typeable (Inductance a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Inductance a -> c (Inductance a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Inductance a))
-> (Inductance a -> Constr)
-> (Inductance a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Inductance a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Inductance a)))
-> ((forall b. Data b => b -> b) -> Inductance a -> Inductance a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Inductance a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Inductance a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Inductance a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Inductance a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Inductance a -> m (Inductance a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inductance a -> m (Inductance a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inductance a -> m (Inductance a))
-> Data (Inductance a)
Inductance a -> Constr
Inductance a -> DataType
(forall b. Data b => b -> b) -> Inductance a -> Inductance a
forall a. Data a => Typeable (Inductance a)
forall a. Data a => Inductance a -> Constr
forall a. Data a => Inductance a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Inductance a -> Inductance a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Inductance a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Inductance a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Inductance a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Inductance a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Inductance a -> m (Inductance a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Inductance a -> m (Inductance a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Inductance a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inductance a -> c (Inductance a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Inductance a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Inductance a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Inductance a -> u
forall u. (forall d. Data d => d -> u) -> Inductance a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Inductance a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Inductance a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Inductance a -> m (Inductance a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Inductance a -> m (Inductance a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Inductance a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inductance a -> c (Inductance a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Inductance a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Inductance a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inductance a -> c (Inductance a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inductance a -> c (Inductance a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Inductance a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Inductance a)
$ctoConstr :: forall a. Data a => Inductance a -> Constr
toConstr :: Inductance a -> Constr
$cdataTypeOf :: forall a. Data a => Inductance a -> DataType
dataTypeOf :: Inductance a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Inductance a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Inductance a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Inductance a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Inductance a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Inductance a -> Inductance a
gmapT :: (forall b. Data b => b -> b) -> Inductance a -> Inductance a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Inductance a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Inductance a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Inductance a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Inductance a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Inductance a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Inductance a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Inductance a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Inductance a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Inductance a -> m (Inductance a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Inductance a -> m (Inductance a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Inductance a -> m (Inductance a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Inductance a -> m (Inductance a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Inductance a -> m (Inductance a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Inductance a -> m (Inductance a)
Data, (forall x. Inductance a -> Rep (Inductance a) x)
-> (forall x. Rep (Inductance a) x -> Inductance a)
-> Generic (Inductance a)
forall x. Rep (Inductance a) x -> Inductance a
forall x. Inductance a -> Rep (Inductance a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Inductance a) x -> Inductance a
forall a x. Inductance a -> Rep (Inductance a) x
$cfrom :: forall a x. Inductance a -> Rep (Inductance a) x
from :: forall x. Inductance a -> Rep (Inductance a) x
$cto :: forall a x. Rep (Inductance a) x -> Inductance a
to :: forall x. Rep (Inductance a) x -> Inductance a
Generic)
  deriving newtype (Get (Inductance a)
[Inductance a] -> Put
Inductance a -> Put
(Inductance a -> Put)
-> Get (Inductance a)
-> ([Inductance a] -> Put)
-> Binary (Inductance a)
forall a. Binary a => Get (Inductance a)
forall a. Binary a => [Inductance a] -> Put
forall a. Binary a => Inductance a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Inductance a -> Put
put :: Inductance a -> Put
$cget :: forall a. Binary a => Get (Inductance a)
get :: Get (Inductance a)
$cputList :: forall a. Binary a => [Inductance a] -> Put
putList :: [Inductance a] -> Put
Binary)
 instance (Num a, Show a) => Show (Inductance a) where { show :: Inductance a -> String
show = Inductance a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype LuminousFlux a = Lumens { forall a. LuminousFlux a -> a
lumens :: a }
  deriving (LuminousFlux a -> LuminousFlux a -> Bool
(LuminousFlux a -> LuminousFlux a -> Bool)
-> (LuminousFlux a -> LuminousFlux a -> Bool)
-> Eq (LuminousFlux a)
forall a. Eq a => LuminousFlux a -> LuminousFlux a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => LuminousFlux a -> LuminousFlux a -> Bool
== :: LuminousFlux a -> LuminousFlux a -> Bool
$c/= :: forall a. Eq a => LuminousFlux a -> LuminousFlux a -> Bool
/= :: LuminousFlux a -> LuminousFlux a -> Bool
Eq,Eq (LuminousFlux a)
Eq (LuminousFlux a) =>
(LuminousFlux a -> LuminousFlux a -> Ordering)
-> (LuminousFlux a -> LuminousFlux a -> Bool)
-> (LuminousFlux a -> LuminousFlux a -> Bool)
-> (LuminousFlux a -> LuminousFlux a -> Bool)
-> (LuminousFlux a -> LuminousFlux a -> Bool)
-> (LuminousFlux a -> LuminousFlux a -> LuminousFlux a)
-> (LuminousFlux a -> LuminousFlux a -> LuminousFlux a)
-> Ord (LuminousFlux a)
LuminousFlux a -> LuminousFlux a -> Bool
LuminousFlux a -> LuminousFlux a -> Ordering
LuminousFlux a -> LuminousFlux a -> LuminousFlux a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (LuminousFlux a)
forall a. Ord a => LuminousFlux a -> LuminousFlux a -> Bool
forall a. Ord a => LuminousFlux a -> LuminousFlux a -> Ordering
forall a.
Ord a =>
LuminousFlux a -> LuminousFlux a -> LuminousFlux a
$ccompare :: forall a. Ord a => LuminousFlux a -> LuminousFlux a -> Ordering
compare :: LuminousFlux a -> LuminousFlux a -> Ordering
$c< :: forall a. Ord a => LuminousFlux a -> LuminousFlux a -> Bool
< :: LuminousFlux a -> LuminousFlux a -> Bool
$c<= :: forall a. Ord a => LuminousFlux a -> LuminousFlux a -> Bool
<= :: LuminousFlux a -> LuminousFlux a -> Bool
$c> :: forall a. Ord a => LuminousFlux a -> LuminousFlux a -> Bool
> :: LuminousFlux a -> LuminousFlux a -> Bool
$c>= :: forall a. Ord a => LuminousFlux a -> LuminousFlux a -> Bool
>= :: LuminousFlux a -> LuminousFlux a -> Bool
$cmax :: forall a.
Ord a =>
LuminousFlux a -> LuminousFlux a -> LuminousFlux a
max :: LuminousFlux a -> LuminousFlux a -> LuminousFlux a
$cmin :: forall a.
Ord a =>
LuminousFlux a -> LuminousFlux a -> LuminousFlux a
min :: LuminousFlux a -> LuminousFlux a -> LuminousFlux a
Ord, Typeable, Typeable (LuminousFlux a)
Typeable (LuminousFlux a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> LuminousFlux a -> c (LuminousFlux a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (LuminousFlux a))
-> (LuminousFlux a -> Constr)
-> (LuminousFlux a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (LuminousFlux a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (LuminousFlux a)))
-> ((forall b. Data b => b -> b)
    -> LuminousFlux a -> LuminousFlux a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LuminousFlux a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LuminousFlux a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> LuminousFlux a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> LuminousFlux a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> LuminousFlux a -> m (LuminousFlux a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> LuminousFlux a -> m (LuminousFlux a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> LuminousFlux a -> m (LuminousFlux a))
-> Data (LuminousFlux a)
LuminousFlux a -> Constr
LuminousFlux a -> DataType
(forall b. Data b => b -> b) -> LuminousFlux a -> LuminousFlux a
forall a. Data a => Typeable (LuminousFlux a)
forall a. Data a => LuminousFlux a -> Constr
forall a. Data a => LuminousFlux a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> LuminousFlux a -> LuminousFlux a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> LuminousFlux a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> LuminousFlux a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LuminousFlux a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LuminousFlux a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> LuminousFlux a -> m (LuminousFlux a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> LuminousFlux a -> m (LuminousFlux a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LuminousFlux a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LuminousFlux a -> c (LuminousFlux a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (LuminousFlux a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (LuminousFlux a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> LuminousFlux a -> u
forall u. (forall d. Data d => d -> u) -> LuminousFlux a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LuminousFlux a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LuminousFlux a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> LuminousFlux a -> m (LuminousFlux a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LuminousFlux a -> m (LuminousFlux a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LuminousFlux a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LuminousFlux a -> c (LuminousFlux a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (LuminousFlux a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (LuminousFlux a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LuminousFlux a -> c (LuminousFlux a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LuminousFlux a -> c (LuminousFlux a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LuminousFlux a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LuminousFlux a)
$ctoConstr :: forall a. Data a => LuminousFlux a -> Constr
toConstr :: LuminousFlux a -> Constr
$cdataTypeOf :: forall a. Data a => LuminousFlux a -> DataType
dataTypeOf :: LuminousFlux a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (LuminousFlux a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (LuminousFlux a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (LuminousFlux a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (LuminousFlux a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> LuminousFlux a -> LuminousFlux a
gmapT :: (forall b. Data b => b -> b) -> LuminousFlux a -> LuminousFlux a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LuminousFlux a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LuminousFlux a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LuminousFlux a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LuminousFlux a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> LuminousFlux a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> LuminousFlux a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> LuminousFlux a -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> LuminousFlux a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> LuminousFlux a -> m (LuminousFlux a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> LuminousFlux a -> m (LuminousFlux a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> LuminousFlux a -> m (LuminousFlux a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LuminousFlux a -> m (LuminousFlux a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> LuminousFlux a -> m (LuminousFlux a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LuminousFlux a -> m (LuminousFlux a)
Data, (forall x. LuminousFlux a -> Rep (LuminousFlux a) x)
-> (forall x. Rep (LuminousFlux a) x -> LuminousFlux a)
-> Generic (LuminousFlux a)
forall x. Rep (LuminousFlux a) x -> LuminousFlux a
forall x. LuminousFlux a -> Rep (LuminousFlux a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (LuminousFlux a) x -> LuminousFlux a
forall a x. LuminousFlux a -> Rep (LuminousFlux a) x
$cfrom :: forall a x. LuminousFlux a -> Rep (LuminousFlux a) x
from :: forall x. LuminousFlux a -> Rep (LuminousFlux a) x
$cto :: forall a x. Rep (LuminousFlux a) x -> LuminousFlux a
to :: forall x. Rep (LuminousFlux a) x -> LuminousFlux a
Generic) deriving newtype (Get (LuminousFlux a)
[LuminousFlux a] -> Put
LuminousFlux a -> Put
(LuminousFlux a -> Put)
-> Get (LuminousFlux a)
-> ([LuminousFlux a] -> Put)
-> Binary (LuminousFlux a)
forall a. Binary a => Get (LuminousFlux a)
forall a. Binary a => [LuminousFlux a] -> Put
forall a. Binary a => LuminousFlux a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => LuminousFlux a -> Put
put :: LuminousFlux a -> Put
$cget :: forall a. Binary a => Get (LuminousFlux a)
get :: Get (LuminousFlux a)
$cputList :: forall a. Binary a => [LuminousFlux a] -> Put
putList :: [LuminousFlux a] -> Put
Binary)
 instance (Num a, Show a) => Show ( LuminousFlux  a) where { show :: LuminousFlux a -> String
show = LuminousFlux a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Illuminance a = Luxes { forall a. Illuminance a -> a
luxes :: a }
  deriving (Illuminance a -> Illuminance a -> Bool
(Illuminance a -> Illuminance a -> Bool)
-> (Illuminance a -> Illuminance a -> Bool) -> Eq (Illuminance a)
forall a. Eq a => Illuminance a -> Illuminance a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Illuminance a -> Illuminance a -> Bool
== :: Illuminance a -> Illuminance a -> Bool
$c/= :: forall a. Eq a => Illuminance a -> Illuminance a -> Bool
/= :: Illuminance a -> Illuminance a -> Bool
Eq,Eq (Illuminance a)
Eq (Illuminance a) =>
(Illuminance a -> Illuminance a -> Ordering)
-> (Illuminance a -> Illuminance a -> Bool)
-> (Illuminance a -> Illuminance a -> Bool)
-> (Illuminance a -> Illuminance a -> Bool)
-> (Illuminance a -> Illuminance a -> Bool)
-> (Illuminance a -> Illuminance a -> Illuminance a)
-> (Illuminance a -> Illuminance a -> Illuminance a)
-> Ord (Illuminance a)
Illuminance a -> Illuminance a -> Bool
Illuminance a -> Illuminance a -> Ordering
Illuminance a -> Illuminance a -> Illuminance a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Illuminance a)
forall a. Ord a => Illuminance a -> Illuminance a -> Bool
forall a. Ord a => Illuminance a -> Illuminance a -> Ordering
forall a. Ord a => Illuminance a -> Illuminance a -> Illuminance a
$ccompare :: forall a. Ord a => Illuminance a -> Illuminance a -> Ordering
compare :: Illuminance a -> Illuminance a -> Ordering
$c< :: forall a. Ord a => Illuminance a -> Illuminance a -> Bool
< :: Illuminance a -> Illuminance a -> Bool
$c<= :: forall a. Ord a => Illuminance a -> Illuminance a -> Bool
<= :: Illuminance a -> Illuminance a -> Bool
$c> :: forall a. Ord a => Illuminance a -> Illuminance a -> Bool
> :: Illuminance a -> Illuminance a -> Bool
$c>= :: forall a. Ord a => Illuminance a -> Illuminance a -> Bool
>= :: Illuminance a -> Illuminance a -> Bool
$cmax :: forall a. Ord a => Illuminance a -> Illuminance a -> Illuminance a
max :: Illuminance a -> Illuminance a -> Illuminance a
$cmin :: forall a. Ord a => Illuminance a -> Illuminance a -> Illuminance a
min :: Illuminance a -> Illuminance a -> Illuminance a
Ord, Typeable, Typeable (Illuminance a)
Typeable (Illuminance a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Illuminance a -> c (Illuminance a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Illuminance a))
-> (Illuminance a -> Constr)
-> (Illuminance a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Illuminance a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Illuminance a)))
-> ((forall b. Data b => b -> b) -> Illuminance a -> Illuminance a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Illuminance a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Illuminance a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Illuminance a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Illuminance a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Illuminance a -> m (Illuminance a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Illuminance a -> m (Illuminance a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Illuminance a -> m (Illuminance a))
-> Data (Illuminance a)
Illuminance a -> Constr
Illuminance a -> DataType
(forall b. Data b => b -> b) -> Illuminance a -> Illuminance a
forall a. Data a => Typeable (Illuminance a)
forall a. Data a => Illuminance a -> Constr
forall a. Data a => Illuminance a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Illuminance a -> Illuminance a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Illuminance a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Illuminance a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Illuminance a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Illuminance a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Illuminance a -> m (Illuminance a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Illuminance a -> m (Illuminance a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Illuminance a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Illuminance a -> c (Illuminance a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Illuminance a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Illuminance a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Illuminance a -> u
forall u. (forall d. Data d => d -> u) -> Illuminance a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Illuminance a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Illuminance a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Illuminance a -> m (Illuminance a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Illuminance a -> m (Illuminance a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Illuminance a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Illuminance a -> c (Illuminance a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Illuminance a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Illuminance a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Illuminance a -> c (Illuminance a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Illuminance a -> c (Illuminance a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Illuminance a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Illuminance a)
$ctoConstr :: forall a. Data a => Illuminance a -> Constr
toConstr :: Illuminance a -> Constr
$cdataTypeOf :: forall a. Data a => Illuminance a -> DataType
dataTypeOf :: Illuminance a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Illuminance a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Illuminance a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Illuminance a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Illuminance a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Illuminance a -> Illuminance a
gmapT :: (forall b. Data b => b -> b) -> Illuminance a -> Illuminance a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Illuminance a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Illuminance a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Illuminance a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Illuminance a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Illuminance a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Illuminance a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Illuminance a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Illuminance a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Illuminance a -> m (Illuminance a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Illuminance a -> m (Illuminance a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Illuminance a -> m (Illuminance a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Illuminance a -> m (Illuminance a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Illuminance a -> m (Illuminance a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Illuminance a -> m (Illuminance a)
Data, (forall x. Illuminance a -> Rep (Illuminance a) x)
-> (forall x. Rep (Illuminance a) x -> Illuminance a)
-> Generic (Illuminance a)
forall x. Rep (Illuminance a) x -> Illuminance a
forall x. Illuminance a -> Rep (Illuminance a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Illuminance a) x -> Illuminance a
forall a x. Illuminance a -> Rep (Illuminance a) x
$cfrom :: forall a x. Illuminance a -> Rep (Illuminance a) x
from :: forall x. Illuminance a -> Rep (Illuminance a) x
$cto :: forall a x. Rep (Illuminance a) x -> Illuminance a
to :: forall x. Rep (Illuminance a) x -> Illuminance a
Generic)
  deriving newtype (Get (Illuminance a)
[Illuminance a] -> Put
Illuminance a -> Put
(Illuminance a -> Put)
-> Get (Illuminance a)
-> ([Illuminance a] -> Put)
-> Binary (Illuminance a)
forall a. Binary a => Get (Illuminance a)
forall a. Binary a => [Illuminance a] -> Put
forall a. Binary a => Illuminance a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Illuminance a -> Put
put :: Illuminance a -> Put
$cget :: forall a. Binary a => Get (Illuminance a)
get :: Get (Illuminance a)
$cputList :: forall a. Binary a => [Illuminance a] -> Put
putList :: [Illuminance a] -> Put
Binary)
 instance (Num a, Show a) => Show (Illuminance a) where { show :: Illuminance a -> String
show = Illuminance a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype Radioactivity a = Becquerels { forall a. Radioactivity a -> a
becquerels :: a }
  deriving (Radioactivity a -> Radioactivity a -> Bool
(Radioactivity a -> Radioactivity a -> Bool)
-> (Radioactivity a -> Radioactivity a -> Bool)
-> Eq (Radioactivity a)
forall a. Eq a => Radioactivity a -> Radioactivity a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Radioactivity a -> Radioactivity a -> Bool
== :: Radioactivity a -> Radioactivity a -> Bool
$c/= :: forall a. Eq a => Radioactivity a -> Radioactivity a -> Bool
/= :: Radioactivity a -> Radioactivity a -> Bool
Eq,Eq (Radioactivity a)
Eq (Radioactivity a) =>
(Radioactivity a -> Radioactivity a -> Ordering)
-> (Radioactivity a -> Radioactivity a -> Bool)
-> (Radioactivity a -> Radioactivity a -> Bool)
-> (Radioactivity a -> Radioactivity a -> Bool)
-> (Radioactivity a -> Radioactivity a -> Bool)
-> (Radioactivity a -> Radioactivity a -> Radioactivity a)
-> (Radioactivity a -> Radioactivity a -> Radioactivity a)
-> Ord (Radioactivity a)
Radioactivity a -> Radioactivity a -> Bool
Radioactivity a -> Radioactivity a -> Ordering
Radioactivity a -> Radioactivity a -> Radioactivity a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Radioactivity a)
forall a. Ord a => Radioactivity a -> Radioactivity a -> Bool
forall a. Ord a => Radioactivity a -> Radioactivity a -> Ordering
forall a.
Ord a =>
Radioactivity a -> Radioactivity a -> Radioactivity a
$ccompare :: forall a. Ord a => Radioactivity a -> Radioactivity a -> Ordering
compare :: Radioactivity a -> Radioactivity a -> Ordering
$c< :: forall a. Ord a => Radioactivity a -> Radioactivity a -> Bool
< :: Radioactivity a -> Radioactivity a -> Bool
$c<= :: forall a. Ord a => Radioactivity a -> Radioactivity a -> Bool
<= :: Radioactivity a -> Radioactivity a -> Bool
$c> :: forall a. Ord a => Radioactivity a -> Radioactivity a -> Bool
> :: Radioactivity a -> Radioactivity a -> Bool
$c>= :: forall a. Ord a => Radioactivity a -> Radioactivity a -> Bool
>= :: Radioactivity a -> Radioactivity a -> Bool
$cmax :: forall a.
Ord a =>
Radioactivity a -> Radioactivity a -> Radioactivity a
max :: Radioactivity a -> Radioactivity a -> Radioactivity a
$cmin :: forall a.
Ord a =>
Radioactivity a -> Radioactivity a -> Radioactivity a
min :: Radioactivity a -> Radioactivity a -> Radioactivity a
Ord, Typeable, Typeable (Radioactivity a)
Typeable (Radioactivity a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Radioactivity a -> c (Radioactivity a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Radioactivity a))
-> (Radioactivity a -> Constr)
-> (Radioactivity a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Radioactivity a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Radioactivity a)))
-> ((forall b. Data b => b -> b)
    -> Radioactivity a -> Radioactivity a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Radioactivity a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Radioactivity a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Radioactivity a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Radioactivity a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Radioactivity a -> m (Radioactivity a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Radioactivity a -> m (Radioactivity a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Radioactivity a -> m (Radioactivity a))
-> Data (Radioactivity a)
Radioactivity a -> Constr
Radioactivity a -> DataType
(forall b. Data b => b -> b) -> Radioactivity a -> Radioactivity a
forall a. Data a => Typeable (Radioactivity a)
forall a. Data a => Radioactivity a -> Constr
forall a. Data a => Radioactivity a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Radioactivity a -> Radioactivity a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Radioactivity a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Radioactivity a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Radioactivity a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Radioactivity a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Radioactivity a -> m (Radioactivity a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Radioactivity a -> m (Radioactivity a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Radioactivity a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Radioactivity a -> c (Radioactivity a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Radioactivity a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Radioactivity a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> Radioactivity a -> u
forall u. (forall d. Data d => d -> u) -> Radioactivity a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Radioactivity a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Radioactivity a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Radioactivity a -> m (Radioactivity a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Radioactivity a -> m (Radioactivity a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Radioactivity a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Radioactivity a -> c (Radioactivity a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Radioactivity a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Radioactivity a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Radioactivity a -> c (Radioactivity a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Radioactivity a -> c (Radioactivity a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Radioactivity a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Radioactivity a)
$ctoConstr :: forall a. Data a => Radioactivity a -> Constr
toConstr :: Radioactivity a -> Constr
$cdataTypeOf :: forall a. Data a => Radioactivity a -> DataType
dataTypeOf :: Radioactivity a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Radioactivity a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Radioactivity a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Radioactivity a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Radioactivity a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Radioactivity a -> Radioactivity a
gmapT :: (forall b. Data b => b -> b) -> Radioactivity a -> Radioactivity a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Radioactivity a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Radioactivity a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Radioactivity a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Radioactivity a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Radioactivity a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Radioactivity a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Radioactivity a -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> Radioactivity a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Radioactivity a -> m (Radioactivity a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Radioactivity a -> m (Radioactivity a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Radioactivity a -> m (Radioactivity a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Radioactivity a -> m (Radioactivity a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Radioactivity a -> m (Radioactivity a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Radioactivity a -> m (Radioactivity a)
Data, (forall x. Radioactivity a -> Rep (Radioactivity a) x)
-> (forall x. Rep (Radioactivity a) x -> Radioactivity a)
-> Generic (Radioactivity a)
forall x. Rep (Radioactivity a) x -> Radioactivity a
forall x. Radioactivity a -> Rep (Radioactivity a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Radioactivity a) x -> Radioactivity a
forall a x. Radioactivity a -> Rep (Radioactivity a) x
$cfrom :: forall a x. Radioactivity a -> Rep (Radioactivity a) x
from :: forall x. Radioactivity a -> Rep (Radioactivity a) x
$cto :: forall a x. Rep (Radioactivity a) x -> Radioactivity a
to :: forall x. Rep (Radioactivity a) x -> Radioactivity a
Generic)
  deriving newtype (Get (Radioactivity a)
[Radioactivity a] -> Put
Radioactivity a -> Put
(Radioactivity a -> Put)
-> Get (Radioactivity a)
-> ([Radioactivity a] -> Put)
-> Binary (Radioactivity a)
forall a. Binary a => Get (Radioactivity a)
forall a. Binary a => [Radioactivity a] -> Put
forall a. Binary a => Radioactivity a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => Radioactivity a -> Put
put :: Radioactivity a -> Put
$cget :: forall a. Binary a => Get (Radioactivity a)
get :: Get (Radioactivity a)
$cputList :: forall a. Binary a => [Radioactivity a] -> Put
putList :: [Radioactivity a] -> Put
Binary)
 instance (Num a, Show a) => Show (Radioactivity a) where { show :: Radioactivity a -> String
show = Radioactivity a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype AbsorbedDose a = Grays { forall a. AbsorbedDose a -> a
grays :: a }
  deriving (AbsorbedDose a -> AbsorbedDose a -> Bool
(AbsorbedDose a -> AbsorbedDose a -> Bool)
-> (AbsorbedDose a -> AbsorbedDose a -> Bool)
-> Eq (AbsorbedDose a)
forall a. Eq a => AbsorbedDose a -> AbsorbedDose a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => AbsorbedDose a -> AbsorbedDose a -> Bool
== :: AbsorbedDose a -> AbsorbedDose a -> Bool
$c/= :: forall a. Eq a => AbsorbedDose a -> AbsorbedDose a -> Bool
/= :: AbsorbedDose a -> AbsorbedDose a -> Bool
Eq,Eq (AbsorbedDose a)
Eq (AbsorbedDose a) =>
(AbsorbedDose a -> AbsorbedDose a -> Ordering)
-> (AbsorbedDose a -> AbsorbedDose a -> Bool)
-> (AbsorbedDose a -> AbsorbedDose a -> Bool)
-> (AbsorbedDose a -> AbsorbedDose a -> Bool)
-> (AbsorbedDose a -> AbsorbedDose a -> Bool)
-> (AbsorbedDose a -> AbsorbedDose a -> AbsorbedDose a)
-> (AbsorbedDose a -> AbsorbedDose a -> AbsorbedDose a)
-> Ord (AbsorbedDose a)
AbsorbedDose a -> AbsorbedDose a -> Bool
AbsorbedDose a -> AbsorbedDose a -> Ordering
AbsorbedDose a -> AbsorbedDose a -> AbsorbedDose a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (AbsorbedDose a)
forall a. Ord a => AbsorbedDose a -> AbsorbedDose a -> Bool
forall a. Ord a => AbsorbedDose a -> AbsorbedDose a -> Ordering
forall a.
Ord a =>
AbsorbedDose a -> AbsorbedDose a -> AbsorbedDose a
$ccompare :: forall a. Ord a => AbsorbedDose a -> AbsorbedDose a -> Ordering
compare :: AbsorbedDose a -> AbsorbedDose a -> Ordering
$c< :: forall a. Ord a => AbsorbedDose a -> AbsorbedDose a -> Bool
< :: AbsorbedDose a -> AbsorbedDose a -> Bool
$c<= :: forall a. Ord a => AbsorbedDose a -> AbsorbedDose a -> Bool
<= :: AbsorbedDose a -> AbsorbedDose a -> Bool
$c> :: forall a. Ord a => AbsorbedDose a -> AbsorbedDose a -> Bool
> :: AbsorbedDose a -> AbsorbedDose a -> Bool
$c>= :: forall a. Ord a => AbsorbedDose a -> AbsorbedDose a -> Bool
>= :: AbsorbedDose a -> AbsorbedDose a -> Bool
$cmax :: forall a.
Ord a =>
AbsorbedDose a -> AbsorbedDose a -> AbsorbedDose a
max :: AbsorbedDose a -> AbsorbedDose a -> AbsorbedDose a
$cmin :: forall a.
Ord a =>
AbsorbedDose a -> AbsorbedDose a -> AbsorbedDose a
min :: AbsorbedDose a -> AbsorbedDose a -> AbsorbedDose a
Ord, Typeable, Typeable (AbsorbedDose a)
Typeable (AbsorbedDose a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> AbsorbedDose a -> c (AbsorbedDose a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (AbsorbedDose a))
-> (AbsorbedDose a -> Constr)
-> (AbsorbedDose a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (AbsorbedDose a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (AbsorbedDose a)))
-> ((forall b. Data b => b -> b)
    -> AbsorbedDose a -> AbsorbedDose a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AbsorbedDose a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AbsorbedDose a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> AbsorbedDose a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> AbsorbedDose a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AbsorbedDose a -> m (AbsorbedDose a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AbsorbedDose a -> m (AbsorbedDose a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AbsorbedDose a -> m (AbsorbedDose a))
-> Data (AbsorbedDose a)
AbsorbedDose a -> Constr
AbsorbedDose a -> DataType
(forall b. Data b => b -> b) -> AbsorbedDose a -> AbsorbedDose a
forall a. Data a => Typeable (AbsorbedDose a)
forall a. Data a => AbsorbedDose a -> Constr
forall a. Data a => AbsorbedDose a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> AbsorbedDose a -> AbsorbedDose a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> AbsorbedDose a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> AbsorbedDose a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AbsorbedDose a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AbsorbedDose a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> AbsorbedDose a -> m (AbsorbedDose a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> AbsorbedDose a -> m (AbsorbedDose a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AbsorbedDose a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AbsorbedDose a -> c (AbsorbedDose a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (AbsorbedDose a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AbsorbedDose a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> AbsorbedDose a -> u
forall u. (forall d. Data d => d -> u) -> AbsorbedDose a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AbsorbedDose a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AbsorbedDose a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AbsorbedDose a -> m (AbsorbedDose a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AbsorbedDose a -> m (AbsorbedDose a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AbsorbedDose a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AbsorbedDose a -> c (AbsorbedDose a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (AbsorbedDose a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AbsorbedDose a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AbsorbedDose a -> c (AbsorbedDose a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AbsorbedDose a -> c (AbsorbedDose a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AbsorbedDose a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AbsorbedDose a)
$ctoConstr :: forall a. Data a => AbsorbedDose a -> Constr
toConstr :: AbsorbedDose a -> Constr
$cdataTypeOf :: forall a. Data a => AbsorbedDose a -> DataType
dataTypeOf :: AbsorbedDose a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (AbsorbedDose a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (AbsorbedDose a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AbsorbedDose a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AbsorbedDose a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> AbsorbedDose a -> AbsorbedDose a
gmapT :: (forall b. Data b => b -> b) -> AbsorbedDose a -> AbsorbedDose a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AbsorbedDose a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AbsorbedDose a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AbsorbedDose a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AbsorbedDose a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> AbsorbedDose a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AbsorbedDose a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> AbsorbedDose a -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> AbsorbedDose a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> AbsorbedDose a -> m (AbsorbedDose a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AbsorbedDose a -> m (AbsorbedDose a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> AbsorbedDose a -> m (AbsorbedDose a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AbsorbedDose a -> m (AbsorbedDose a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> AbsorbedDose a -> m (AbsorbedDose a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AbsorbedDose a -> m (AbsorbedDose a)
Data, (forall x. AbsorbedDose a -> Rep (AbsorbedDose a) x)
-> (forall x. Rep (AbsorbedDose a) x -> AbsorbedDose a)
-> Generic (AbsorbedDose a)
forall x. Rep (AbsorbedDose a) x -> AbsorbedDose a
forall x. AbsorbedDose a -> Rep (AbsorbedDose a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (AbsorbedDose a) x -> AbsorbedDose a
forall a x. AbsorbedDose a -> Rep (AbsorbedDose a) x
$cfrom :: forall a x. AbsorbedDose a -> Rep (AbsorbedDose a) x
from :: forall x. AbsorbedDose a -> Rep (AbsorbedDose a) x
$cto :: forall a x. Rep (AbsorbedDose a) x -> AbsorbedDose a
to :: forall x. Rep (AbsorbedDose a) x -> AbsorbedDose a
Generic)
  deriving newtype (Get (AbsorbedDose a)
[AbsorbedDose a] -> Put
AbsorbedDose a -> Put
(AbsorbedDose a -> Put)
-> Get (AbsorbedDose a)
-> ([AbsorbedDose a] -> Put)
-> Binary (AbsorbedDose a)
forall a. Binary a => Get (AbsorbedDose a)
forall a. Binary a => [AbsorbedDose a] -> Put
forall a. Binary a => AbsorbedDose a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => AbsorbedDose a -> Put
put :: AbsorbedDose a -> Put
$cget :: forall a. Binary a => Get (AbsorbedDose a)
get :: Get (AbsorbedDose a)
$cputList :: forall a. Binary a => [AbsorbedDose a] -> Put
putList :: [AbsorbedDose a] -> Put
Binary)
 instance (Num a, Show a) => Show (AbsorbedDose a) where { show :: AbsorbedDose a -> String
show = AbsorbedDose a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 newtype EquivalentDose a = Sieverts { forall a. EquivalentDose a -> a
sieverts :: a }
  deriving (EquivalentDose a -> EquivalentDose a -> Bool
(EquivalentDose a -> EquivalentDose a -> Bool)
-> (EquivalentDose a -> EquivalentDose a -> Bool)
-> Eq (EquivalentDose a)
forall a. Eq a => EquivalentDose a -> EquivalentDose a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => EquivalentDose a -> EquivalentDose a -> Bool
== :: EquivalentDose a -> EquivalentDose a -> Bool
$c/= :: forall a. Eq a => EquivalentDose a -> EquivalentDose a -> Bool
/= :: EquivalentDose a -> EquivalentDose a -> Bool
Eq,Eq (EquivalentDose a)
Eq (EquivalentDose a) =>
(EquivalentDose a -> EquivalentDose a -> Ordering)
-> (EquivalentDose a -> EquivalentDose a -> Bool)
-> (EquivalentDose a -> EquivalentDose a -> Bool)
-> (EquivalentDose a -> EquivalentDose a -> Bool)
-> (EquivalentDose a -> EquivalentDose a -> Bool)
-> (EquivalentDose a -> EquivalentDose a -> EquivalentDose a)
-> (EquivalentDose a -> EquivalentDose a -> EquivalentDose a)
-> Ord (EquivalentDose a)
EquivalentDose a -> EquivalentDose a -> Bool
EquivalentDose a -> EquivalentDose a -> Ordering
EquivalentDose a -> EquivalentDose a -> EquivalentDose a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (EquivalentDose a)
forall a. Ord a => EquivalentDose a -> EquivalentDose a -> Bool
forall a. Ord a => EquivalentDose a -> EquivalentDose a -> Ordering
forall a.
Ord a =>
EquivalentDose a -> EquivalentDose a -> EquivalentDose a
$ccompare :: forall a. Ord a => EquivalentDose a -> EquivalentDose a -> Ordering
compare :: EquivalentDose a -> EquivalentDose a -> Ordering
$c< :: forall a. Ord a => EquivalentDose a -> EquivalentDose a -> Bool
< :: EquivalentDose a -> EquivalentDose a -> Bool
$c<= :: forall a. Ord a => EquivalentDose a -> EquivalentDose a -> Bool
<= :: EquivalentDose a -> EquivalentDose a -> Bool
$c> :: forall a. Ord a => EquivalentDose a -> EquivalentDose a -> Bool
> :: EquivalentDose a -> EquivalentDose a -> Bool
$c>= :: forall a. Ord a => EquivalentDose a -> EquivalentDose a -> Bool
>= :: EquivalentDose a -> EquivalentDose a -> Bool
$cmax :: forall a.
Ord a =>
EquivalentDose a -> EquivalentDose a -> EquivalentDose a
max :: EquivalentDose a -> EquivalentDose a -> EquivalentDose a
$cmin :: forall a.
Ord a =>
EquivalentDose a -> EquivalentDose a -> EquivalentDose a
min :: EquivalentDose a -> EquivalentDose a -> EquivalentDose a
Ord, Typeable, Typeable (EquivalentDose a)
Typeable (EquivalentDose a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> EquivalentDose a
 -> c (EquivalentDose a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EquivalentDose a))
-> (EquivalentDose a -> Constr)
-> (EquivalentDose a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (EquivalentDose a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EquivalentDose a)))
-> ((forall b. Data b => b -> b)
    -> EquivalentDose a -> EquivalentDose a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EquivalentDose a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EquivalentDose a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> EquivalentDose a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> EquivalentDose a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> EquivalentDose a -> m (EquivalentDose a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EquivalentDose a -> m (EquivalentDose a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EquivalentDose a -> m (EquivalentDose a))
-> Data (EquivalentDose a)
EquivalentDose a -> Constr
EquivalentDose a -> DataType
(forall b. Data b => b -> b)
-> EquivalentDose a -> EquivalentDose a
forall a. Data a => Typeable (EquivalentDose a)
forall a. Data a => EquivalentDose a -> Constr
forall a. Data a => EquivalentDose a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b)
-> EquivalentDose a -> EquivalentDose a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> EquivalentDose a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> EquivalentDose a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EquivalentDose a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EquivalentDose a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> EquivalentDose a -> m (EquivalentDose a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> EquivalentDose a -> m (EquivalentDose a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EquivalentDose a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EquivalentDose a -> c (EquivalentDose a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (EquivalentDose a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EquivalentDose a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> EquivalentDose a -> u
forall u. (forall d. Data d => d -> u) -> EquivalentDose a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EquivalentDose a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EquivalentDose a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EquivalentDose a -> m (EquivalentDose a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EquivalentDose a -> m (EquivalentDose a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EquivalentDose a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EquivalentDose a -> c (EquivalentDose a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (EquivalentDose a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EquivalentDose a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EquivalentDose a -> c (EquivalentDose a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EquivalentDose a -> c (EquivalentDose a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EquivalentDose a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EquivalentDose a)
$ctoConstr :: forall a. Data a => EquivalentDose a -> Constr
toConstr :: EquivalentDose a -> Constr
$cdataTypeOf :: forall a. Data a => EquivalentDose a -> DataType
dataTypeOf :: EquivalentDose a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (EquivalentDose a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (EquivalentDose a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EquivalentDose a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EquivalentDose a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b)
-> EquivalentDose a -> EquivalentDose a
gmapT :: (forall b. Data b => b -> b)
-> EquivalentDose a -> EquivalentDose a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EquivalentDose a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EquivalentDose a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EquivalentDose a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EquivalentDose a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> EquivalentDose a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> EquivalentDose a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> EquivalentDose a -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> EquivalentDose a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> EquivalentDose a -> m (EquivalentDose a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EquivalentDose a -> m (EquivalentDose a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> EquivalentDose a -> m (EquivalentDose a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EquivalentDose a -> m (EquivalentDose a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> EquivalentDose a -> m (EquivalentDose a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EquivalentDose a -> m (EquivalentDose a)
Data, (forall x. EquivalentDose a -> Rep (EquivalentDose a) x)
-> (forall x. Rep (EquivalentDose a) x -> EquivalentDose a)
-> Generic (EquivalentDose a)
forall x. Rep (EquivalentDose a) x -> EquivalentDose a
forall x. EquivalentDose a -> Rep (EquivalentDose a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (EquivalentDose a) x -> EquivalentDose a
forall a x. EquivalentDose a -> Rep (EquivalentDose a) x
$cfrom :: forall a x. EquivalentDose a -> Rep (EquivalentDose a) x
from :: forall x. EquivalentDose a -> Rep (EquivalentDose a) x
$cto :: forall a x. Rep (EquivalentDose a) x -> EquivalentDose a
to :: forall x. Rep (EquivalentDose a) x -> EquivalentDose a
Generic)
  deriving newtype (Get (EquivalentDose a)
[EquivalentDose a] -> Put
EquivalentDose a -> Put
(EquivalentDose a -> Put)
-> Get (EquivalentDose a)
-> ([EquivalentDose a] -> Put)
-> Binary (EquivalentDose a)
forall a. Binary a => Get (EquivalentDose a)
forall a. Binary a => [EquivalentDose a] -> Put
forall a. Binary a => EquivalentDose a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => EquivalentDose a -> Put
put :: EquivalentDose a -> Put
$cget :: forall a. Binary a => Get (EquivalentDose a)
get :: Get (EquivalentDose a)
$cputList :: forall a. Binary a => [EquivalentDose a] -> Put
putList :: [EquivalentDose a] -> Put
Binary)

 instance (Num a, Show a) => Show (EquivalentDose a) where { show :: EquivalentDose a -> String
show = EquivalentDose a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }


 newtype CatalyticActivity a = Katals { forall a. CatalyticActivity a -> a
katals :: a }
  deriving (CatalyticActivity a -> CatalyticActivity a -> Bool
(CatalyticActivity a -> CatalyticActivity a -> Bool)
-> (CatalyticActivity a -> CatalyticActivity a -> Bool)
-> Eq (CatalyticActivity a)
forall a.
Eq a =>
CatalyticActivity a -> CatalyticActivity a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a.
Eq a =>
CatalyticActivity a -> CatalyticActivity a -> Bool
== :: CatalyticActivity a -> CatalyticActivity a -> Bool
$c/= :: forall a.
Eq a =>
CatalyticActivity a -> CatalyticActivity a -> Bool
/= :: CatalyticActivity a -> CatalyticActivity a -> Bool
Eq,Eq (CatalyticActivity a)
Eq (CatalyticActivity a) =>
(CatalyticActivity a -> CatalyticActivity a -> Ordering)
-> (CatalyticActivity a -> CatalyticActivity a -> Bool)
-> (CatalyticActivity a -> CatalyticActivity a -> Bool)
-> (CatalyticActivity a -> CatalyticActivity a -> Bool)
-> (CatalyticActivity a -> CatalyticActivity a -> Bool)
-> (CatalyticActivity a
    -> CatalyticActivity a -> CatalyticActivity a)
-> (CatalyticActivity a
    -> CatalyticActivity a -> CatalyticActivity a)
-> Ord (CatalyticActivity a)
CatalyticActivity a -> CatalyticActivity a -> Bool
CatalyticActivity a -> CatalyticActivity a -> Ordering
CatalyticActivity a -> CatalyticActivity a -> CatalyticActivity a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (CatalyticActivity a)
forall a.
Ord a =>
CatalyticActivity a -> CatalyticActivity a -> Bool
forall a.
Ord a =>
CatalyticActivity a -> CatalyticActivity a -> Ordering
forall a.
Ord a =>
CatalyticActivity a -> CatalyticActivity a -> CatalyticActivity a
$ccompare :: forall a.
Ord a =>
CatalyticActivity a -> CatalyticActivity a -> Ordering
compare :: CatalyticActivity a -> CatalyticActivity a -> Ordering
$c< :: forall a.
Ord a =>
CatalyticActivity a -> CatalyticActivity a -> Bool
< :: CatalyticActivity a -> CatalyticActivity a -> Bool
$c<= :: forall a.
Ord a =>
CatalyticActivity a -> CatalyticActivity a -> Bool
<= :: CatalyticActivity a -> CatalyticActivity a -> Bool
$c> :: forall a.
Ord a =>
CatalyticActivity a -> CatalyticActivity a -> Bool
> :: CatalyticActivity a -> CatalyticActivity a -> Bool
$c>= :: forall a.
Ord a =>
CatalyticActivity a -> CatalyticActivity a -> Bool
>= :: CatalyticActivity a -> CatalyticActivity a -> Bool
$cmax :: forall a.
Ord a =>
CatalyticActivity a -> CatalyticActivity a -> CatalyticActivity a
max :: CatalyticActivity a -> CatalyticActivity a -> CatalyticActivity a
$cmin :: forall a.
Ord a =>
CatalyticActivity a -> CatalyticActivity a -> CatalyticActivity a
min :: CatalyticActivity a -> CatalyticActivity a -> CatalyticActivity a
Ord, Typeable, Typeable (CatalyticActivity a)
Typeable (CatalyticActivity a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> CatalyticActivity a
 -> c (CatalyticActivity a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CatalyticActivity a))
-> (CatalyticActivity a -> Constr)
-> (CatalyticActivity a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (CatalyticActivity a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CatalyticActivity a)))
-> ((forall b. Data b => b -> b)
    -> CatalyticActivity a -> CatalyticActivity a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CatalyticActivity a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CatalyticActivity a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> CatalyticActivity a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CatalyticActivity a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CatalyticActivity a -> m (CatalyticActivity a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CatalyticActivity a -> m (CatalyticActivity a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CatalyticActivity a -> m (CatalyticActivity a))
-> Data (CatalyticActivity a)
CatalyticActivity a -> Constr
CatalyticActivity a -> DataType
(forall b. Data b => b -> b)
-> CatalyticActivity a -> CatalyticActivity a
forall a. Data a => Typeable (CatalyticActivity a)
forall a. Data a => CatalyticActivity a -> Constr
forall a. Data a => CatalyticActivity a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b)
-> CatalyticActivity a -> CatalyticActivity a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CatalyticActivity a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> CatalyticActivity a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CatalyticActivity a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CatalyticActivity a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> CatalyticActivity a -> m (CatalyticActivity a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CatalyticActivity a -> m (CatalyticActivity a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CatalyticActivity a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CatalyticActivity a
-> c (CatalyticActivity a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CatalyticActivity a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CatalyticActivity a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> CatalyticActivity a -> u
forall u.
(forall d. Data d => d -> u) -> CatalyticActivity a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CatalyticActivity a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CatalyticActivity a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CatalyticActivity a -> m (CatalyticActivity a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CatalyticActivity a -> m (CatalyticActivity a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CatalyticActivity a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CatalyticActivity a
-> c (CatalyticActivity a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CatalyticActivity a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CatalyticActivity a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CatalyticActivity a
-> c (CatalyticActivity a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CatalyticActivity a
-> c (CatalyticActivity a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CatalyticActivity a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CatalyticActivity a)
$ctoConstr :: forall a. Data a => CatalyticActivity a -> Constr
toConstr :: CatalyticActivity a -> Constr
$cdataTypeOf :: forall a. Data a => CatalyticActivity a -> DataType
dataTypeOf :: CatalyticActivity a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CatalyticActivity a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CatalyticActivity a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CatalyticActivity a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CatalyticActivity a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b)
-> CatalyticActivity a -> CatalyticActivity a
gmapT :: (forall b. Data b => b -> b)
-> CatalyticActivity a -> CatalyticActivity a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CatalyticActivity a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CatalyticActivity a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CatalyticActivity a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CatalyticActivity a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> CatalyticActivity a -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> CatalyticActivity a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CatalyticActivity a -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CatalyticActivity a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> CatalyticActivity a -> m (CatalyticActivity a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CatalyticActivity a -> m (CatalyticActivity a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CatalyticActivity a -> m (CatalyticActivity a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CatalyticActivity a -> m (CatalyticActivity a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CatalyticActivity a -> m (CatalyticActivity a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CatalyticActivity a -> m (CatalyticActivity a)
Data, (forall x. CatalyticActivity a -> Rep (CatalyticActivity a) x)
-> (forall x. Rep (CatalyticActivity a) x -> CatalyticActivity a)
-> Generic (CatalyticActivity a)
forall x. Rep (CatalyticActivity a) x -> CatalyticActivity a
forall x. CatalyticActivity a -> Rep (CatalyticActivity a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (CatalyticActivity a) x -> CatalyticActivity a
forall a x. CatalyticActivity a -> Rep (CatalyticActivity a) x
$cfrom :: forall a x. CatalyticActivity a -> Rep (CatalyticActivity a) x
from :: forall x. CatalyticActivity a -> Rep (CatalyticActivity a) x
$cto :: forall a x. Rep (CatalyticActivity a) x -> CatalyticActivity a
to :: forall x. Rep (CatalyticActivity a) x -> CatalyticActivity a
Generic)
  deriving newtype (Get (CatalyticActivity a)
[CatalyticActivity a] -> Put
CatalyticActivity a -> Put
(CatalyticActivity a -> Put)
-> Get (CatalyticActivity a)
-> ([CatalyticActivity a] -> Put)
-> Binary (CatalyticActivity a)
forall a. Binary a => Get (CatalyticActivity a)
forall a. Binary a => [CatalyticActivity a] -> Put
forall a. Binary a => CatalyticActivity a -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall a. Binary a => CatalyticActivity a -> Put
put :: CatalyticActivity a -> Put
$cget :: forall a. Binary a => Get (CatalyticActivity a)
get :: Get (CatalyticActivity a)
$cputList :: forall a. Binary a => [CatalyticActivity a] -> Put
putList :: [CatalyticActivity a] -> Put
Binary)
 instance (Num a, Show a) => Show (CatalyticActivity a) where { show :: CatalyticActivity a -> String
show = CatalyticActivity a -> String
forall u. (Unit u, Show (Scalar u)) => u -> String
showUnit }

 instance (Num a, Show a) => Unit (CatalyticActivity a) where
    amount :: CatalyticActivity a -> Scalar (CatalyticActivity a)
amount = CatalyticActivity a -> a
CatalyticActivity a -> Scalar (CatalyticActivity a)
forall a. CatalyticActivity a -> a
katals
    dimension :: CatalyticActivity a -> Dimension
dimension CatalyticActivity a
_ = Dimension
katalDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (CatalyticActivity a)) -> m (CatalyticActivity a)
fromQuantity = Dimension
-> (a -> CatalyticActivity a)
-> Quantity a
-> m (CatalyticActivity a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
katalDimension a -> CatalyticActivity a
forall a. a -> CatalyticActivity a
Katals
    unitOf :: CatalyticActivity a -> String
unitOf CatalyticActivity a
_ = String
"kat"
 instance (Show a, Num a) => LiteralUnit (CatalyticActivity a) where { fromAmount :: Scalar (CatalyticActivity a) -> CatalyticActivity a
fromAmount = a -> CatalyticActivity a
Scalar (CatalyticActivity a) -> CatalyticActivity a
forall a. a -> CatalyticActivity a
Katals }
 instance (Num a, Show a) => Unit (EquivalentDose a) where
    amount :: EquivalentDose a -> Scalar (EquivalentDose a)
amount = EquivalentDose a -> a
EquivalentDose a -> Scalar (EquivalentDose a)
forall a. EquivalentDose a -> a
sieverts
    dimension :: EquivalentDose a -> Dimension
dimension EquivalentDose a
_ = Dimension
sievertDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (EquivalentDose a)) -> m (EquivalentDose a)
fromQuantity = Dimension
-> (a -> EquivalentDose a) -> Quantity a -> m (EquivalentDose a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
sievertDimension a -> EquivalentDose a
forall a. a -> EquivalentDose a
Sieverts
    unitOf :: EquivalentDose a -> String
unitOf EquivalentDose a
_ = String
"Sv"
 instance (Show a, Num a) => LiteralUnit (EquivalentDose a) where { fromAmount :: Scalar (EquivalentDose a) -> EquivalentDose a
fromAmount = a -> EquivalentDose a
Scalar (EquivalentDose a) -> EquivalentDose a
forall a. a -> EquivalentDose a
Sieverts }
    
                                      
 instance (Num a, Show a) => Unit (AbsorbedDose a) where
    amount :: AbsorbedDose a -> Scalar (AbsorbedDose a)
amount = AbsorbedDose a -> a
AbsorbedDose a -> Scalar (AbsorbedDose a)
forall a. AbsorbedDose a -> a
grays
    dimension :: AbsorbedDose a -> Dimension
dimension AbsorbedDose a
_ = Dimension
grayDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (AbsorbedDose a)) -> m (AbsorbedDose a)
fromQuantity = Dimension
-> (a -> AbsorbedDose a) -> Quantity a -> m (AbsorbedDose a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
grayDimension a -> AbsorbedDose a
forall a. a -> AbsorbedDose a
Grays
    unitOf :: AbsorbedDose a -> String
unitOf AbsorbedDose a
_ = String
"Gy"
 instance (Show a, Num a) => LiteralUnit (AbsorbedDose a) where { fromAmount :: Scalar (AbsorbedDose a) -> AbsorbedDose a
fromAmount = a -> AbsorbedDose a
Scalar (AbsorbedDose a) -> AbsorbedDose a
forall a. a -> AbsorbedDose a
Grays }   
 instance (Num a, Show a) => Unit (Radioactivity a) where
    amount :: Radioactivity a -> Scalar (Radioactivity a)
amount = Radioactivity a -> a
Radioactivity a -> Scalar (Radioactivity a)
forall a. Radioactivity a -> a
becquerels
    dimension :: Radioactivity a -> Dimension
dimension Radioactivity a
_ = Dimension
becquerelDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Radioactivity a)) -> m (Radioactivity a)
fromQuantity = Dimension
-> (a -> Radioactivity a) -> Quantity a -> m (Radioactivity a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
becquerelDimension a -> Radioactivity a
forall a. a -> Radioactivity a
Becquerels
    unitOf :: Radioactivity a -> String
unitOf Radioactivity a
_ = String
"Bq"
 instance (Show a, Num a) => LiteralUnit (Radioactivity a) where { fromAmount :: Scalar (Radioactivity a) -> Radioactivity a
fromAmount = a -> Radioactivity a
Scalar (Radioactivity a) -> Radioactivity a
forall a. a -> Radioactivity a
Becquerels }
 instance (Num a, Show a) => Unit (Illuminance a) where
    amount :: Illuminance a -> Scalar (Illuminance a)
amount = Illuminance a -> a
Illuminance a -> Scalar (Illuminance a)
forall a. Illuminance a -> a
luxes
    dimension :: Illuminance a -> Dimension
dimension Illuminance a
_ = Dimension
luxDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Illuminance a)) -> m (Illuminance a)
fromQuantity = Dimension
-> (a -> Illuminance a) -> Quantity a -> m (Illuminance a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
luxDimension a -> Illuminance a
forall a. a -> Illuminance a
Luxes
    unitOf :: Illuminance a -> String
unitOf Illuminance a
_ = String
"lx"
 instance (Show a, Num a) => LiteralUnit (Illuminance a) where { fromAmount :: Scalar (Illuminance a) -> Illuminance a
fromAmount = a -> Illuminance a
Scalar (Illuminance a) -> Illuminance a
forall a. a -> Illuminance a
Luxes }
 instance (Num a, Show a) => Unit (LuminousFlux a) where
    amount :: LuminousFlux a -> Scalar (LuminousFlux a)
amount = LuminousFlux a -> a
LuminousFlux a -> Scalar (LuminousFlux a)
forall a. LuminousFlux a -> a
lumens
    dimension :: LuminousFlux a -> Dimension
dimension LuminousFlux a
_ = Dimension
lumenDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (LuminousFlux a)) -> m (LuminousFlux a)
fromQuantity = Dimension
-> (a -> LuminousFlux a) -> Quantity a -> m (LuminousFlux a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
lumenDimension a -> LuminousFlux a
forall a. a -> LuminousFlux a
Lumens
    unitOf :: LuminousFlux a -> String
unitOf LuminousFlux a
_ = String
"lm"
 instance (Show a, Num a) => LiteralUnit (LuminousFlux a) where { fromAmount :: Scalar (LuminousFlux a) -> LuminousFlux a
fromAmount = a -> LuminousFlux a
Scalar (LuminousFlux a) -> LuminousFlux a
forall a. a -> LuminousFlux a
Lumens }
 instance (Num a, Show a) => Unit (Inductance a) where
    amount :: Inductance a -> Scalar (Inductance a)
amount = Inductance a -> a
Inductance a -> Scalar (Inductance a)
forall a. Inductance a -> a
henrys
    dimension :: Inductance a -> Dimension
dimension Inductance a
_ = Dimension
henryDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Inductance a)) -> m (Inductance a)
fromQuantity = Dimension -> (a -> Inductance a) -> Quantity a -> m (Inductance a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
henryDimension a -> Inductance a
forall a. a -> Inductance a
Henrys
    unitOf :: Inductance a -> String
unitOf Inductance a
_ = String
"H"
 instance (Show a, Num a) => LiteralUnit (Inductance a) where { fromAmount :: Scalar (Inductance a) -> Inductance a
fromAmount = a -> Inductance a
Scalar (Inductance a) -> Inductance a
forall a. a -> Inductance a
Henrys }
 instance (Num a, Show a) => Unit (FluxDensity a) where
    amount :: FluxDensity a -> Scalar (FluxDensity a)
amount = FluxDensity a -> a
FluxDensity a -> Scalar (FluxDensity a)
forall a. FluxDensity a -> a
teslas
    dimension :: FluxDensity a -> Dimension
dimension FluxDensity a
_ = Dimension
teslaDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (FluxDensity a)) -> m (FluxDensity a)
fromQuantity = Dimension
-> (a -> FluxDensity a) -> Quantity a -> m (FluxDensity a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
teslaDimension a -> FluxDensity a
forall a. a -> FluxDensity a
Teslas
    unitOf :: FluxDensity a -> String
unitOf FluxDensity a
_ = String
"T"
 instance (Show a, Num a) => LiteralUnit (FluxDensity a) where { fromAmount :: Scalar (FluxDensity a) -> FluxDensity a
fromAmount = a -> FluxDensity a
Scalar (FluxDensity a) -> FluxDensity a
forall a. a -> FluxDensity a
Teslas }
 instance (Num a, Show a) => Unit (Flux a) where
    amount :: Flux a -> Scalar (Flux a)
amount = Flux a -> a
Flux a -> Scalar (Flux a)
forall a. Flux a -> a
webers
    dimension :: Flux a -> Dimension
dimension Flux a
_ = Dimension
weberDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Flux a)) -> m (Flux a)
fromQuantity = Dimension -> (a -> Flux a) -> Quantity a -> m (Flux a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
weberDimension a -> Flux a
forall a. a -> Flux a
Webers
    unitOf :: Flux a -> String
unitOf Flux a
_ = String
"W"
 instance (Show a, Num a) => LiteralUnit (Flux a) where { fromAmount :: Scalar (Flux a) -> Flux a
fromAmount = a -> Flux a
Scalar (Flux a) -> Flux a
forall a. a -> Flux a
Webers }
 instance (Num a, Show a) => Unit (Conductance a) where
    amount :: Conductance a -> Scalar (Conductance a)
amount = Conductance a -> a
Conductance a -> Scalar (Conductance a)
forall a. Conductance a -> a
siemenses
    dimension :: Conductance a -> Dimension
dimension Conductance a
_ = Dimension
siemensDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Conductance a)) -> m (Conductance a)
fromQuantity = Dimension
-> (a -> Conductance a) -> Quantity a -> m (Conductance a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
siemensDimension a -> Conductance a
forall a. a -> Conductance a
Siemenses
    unitOf :: Conductance a -> String
unitOf Conductance a
_ = String
"S"
 instance (Show a, Num a) => LiteralUnit (Conductance a) where { fromAmount :: Scalar (Conductance a) -> Conductance a
fromAmount = a -> Conductance a
Scalar (Conductance a) -> Conductance a
forall a. a -> Conductance a
Siemenses }
 instance (Num a, Show a) => Unit (Resistance a) where
    amount :: Resistance a -> Scalar (Resistance a)
amount = Resistance a -> a
Resistance a -> Scalar (Resistance a)
forall a. Resistance a -> a
ohms
    dimension :: Resistance a -> Dimension
dimension Resistance a
_ = Dimension
ohmDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Resistance a)) -> m (Resistance a)
fromQuantity = Dimension -> (a -> Resistance a) -> Quantity a -> m (Resistance a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
ohmDimension a -> Resistance a
forall a. a -> Resistance a
Ohms
    unitOf :: Resistance a -> String
unitOf Resistance a
_ = String
"Ω"
 instance (Show a, Num a) => LiteralUnit (Resistance a) where { fromAmount :: Scalar (Resistance a) -> Resistance a
fromAmount = a -> Resistance a
Scalar (Resistance a) -> Resistance a
forall a. a -> Resistance a
Ohms }
 instance (Num a, Show a) => Unit (Capacitance a) where
    amount :: Capacitance a -> Scalar (Capacitance a)
amount = Capacitance a -> a
Capacitance a -> Scalar (Capacitance a)
forall a. Capacitance a -> a
farads
    dimension :: Capacitance a -> Dimension
dimension Capacitance a
_ = Dimension
faradDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Capacitance a)) -> m (Capacitance a)
fromQuantity = Dimension
-> (a -> Capacitance a) -> Quantity a -> m (Capacitance a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
faradDimension a -> Capacitance a
forall a. a -> Capacitance a
Farads
    unitOf :: Capacitance a -> String
unitOf Capacitance a
_ = String
"F"
 instance (Show a, Num a) => LiteralUnit (Capacitance a) where { fromAmount :: Scalar (Capacitance a) -> Capacitance a
fromAmount = a -> Capacitance a
Scalar (Capacitance a) -> Capacitance a
forall a. a -> Capacitance a
Farads }
 instance (Num a, Show a) => Unit (Voltage a) where
    amount :: Voltage a -> Scalar (Voltage a)
amount = Voltage a -> a
Voltage a -> Scalar (Voltage a)
forall a. Voltage a -> a
volts
    dimension :: Voltage a -> Dimension
dimension Voltage a
_ = Dimension
voltDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Voltage a)) -> m (Voltage a)
fromQuantity = Dimension -> (a -> Voltage a) -> Quantity a -> m (Voltage a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
voltDimension a -> Voltage a
forall a. a -> Voltage a
Volts
    unitOf :: Voltage a -> String
unitOf Voltage a
_ = String
"V"
 instance (Show a, Num a) => LiteralUnit (Voltage a) where { fromAmount :: Scalar (Voltage a) -> Voltage a
fromAmount = a -> Voltage a
Scalar (Voltage a) -> Voltage a
forall a. a -> Voltage a
Volts }
 instance (Num a, Show a) => Unit (Charge a) where
    amount :: Charge a -> Scalar (Charge a)
amount = Charge a -> a
Charge a -> Scalar (Charge a)
forall a. Charge a -> a
coulombs
    dimension :: Charge a -> Dimension
dimension Charge a
_ = Dimension
coulombDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Charge a)) -> m (Charge a)
fromQuantity = Dimension -> (a -> Charge a) -> Quantity a -> m (Charge a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
coulombDimension a -> Charge a
forall a. a -> Charge a
Coulombs
    unitOf :: Charge a -> String
unitOf Charge a
_ = String
"C"
 instance (Show a, Num a) => LiteralUnit (Charge a) where { fromAmount :: Scalar (Charge a) -> Charge a
fromAmount = a -> Charge a
Scalar (Charge a) -> Charge a
forall a. a -> Charge a
Coulombs }
 instance (Num a, Show a) => Unit ( Power  a) where
    amount :: Power a -> Scalar (Power a)
amount = Power a -> a
Power a -> Scalar (Power a)
forall a. Power a -> a
watts
    dimension :: Power a -> Dimension
dimension Power a
_ = Dimension
wattDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Power a)) -> m (Power a)
fromQuantity = Dimension -> (a -> Power a) -> Quantity a -> m (Power a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
wattDimension a -> Power a
forall a. a -> Power a
Watts
    unitOf :: Power a -> String
unitOf Power a
_ = String
"W"
 instance (Show a, Num a) => LiteralUnit ( Power  a) where { fromAmount :: Scalar (Power a) -> Power a
fromAmount = a -> Power a
Scalar (Power a) -> Power a
forall a. a -> Power a
Watts }
 instance (Num a, Show a) => Unit ( Energy  a) where
    amount :: Energy a -> Scalar (Energy a)
amount = Energy a -> a
Energy a -> Scalar (Energy a)
forall a. Energy a -> a
joules
    dimension :: Energy a -> Dimension
dimension Energy a
_ = Dimension
jouleDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Energy a)) -> m (Energy a)
fromQuantity = Dimension -> (a -> Energy a) -> Quantity a -> m (Energy a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
jouleDimension a -> Energy a
forall a. a -> Energy a
Joules
    unitOf :: Energy a -> String
unitOf Energy a
_ = String
"J"
 instance (Show a, Num a) => LiteralUnit ( Energy  a) where { fromAmount :: Scalar (Energy a) -> Energy a
fromAmount = a -> Energy a
Scalar (Energy a) -> Energy a
forall a. a -> Energy a
Joules }
 instance (Num a, Show a) => Unit ( Pressure  a) where
    amount :: Pressure a -> Scalar (Pressure a)
amount = Pressure a -> a
Pressure a -> Scalar (Pressure a)
forall a. Pressure a -> a
pascals
    dimension :: Pressure a -> Dimension
dimension Pressure a
_ = Dimension
pascalDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Pressure a)) -> m (Pressure a)
fromQuantity = Dimension -> (a -> Pressure a) -> Quantity a -> m (Pressure a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
pascalDimension a -> Pressure a
forall a. a -> Pressure a
Pascals
    unitOf :: Pressure a -> String
unitOf Pressure a
_ = String
"Pa"
 instance (Show a, Num a) => LiteralUnit ( Pressure  a) where { fromAmount :: Scalar (Pressure a) -> Pressure a
fromAmount = a -> Pressure a
Scalar (Pressure a) -> Pressure a
forall a. a -> Pressure a
Pascals }
 instance (Num a, Show a) => Unit ( Force  a) where
    amount :: Force a -> Scalar (Force a)
amount = Force a -> a
Force a -> Scalar (Force a)
forall a. Force a -> a
newtons
    dimension :: Force a -> Dimension
dimension Force a
_ = Dimension
newtonDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Force a)) -> m (Force a)
fromQuantity = Dimension -> (a -> Force a) -> Quantity a -> m (Force a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
newtonDimension a -> Force a
forall a. a -> Force a
Newtons
    unitOf :: Force a -> String
unitOf Force a
_ = String
"N"
 instance (Show a, Num a) => LiteralUnit ( Force  a) where { fromAmount :: Scalar (Force a) -> Force a
fromAmount = a -> Force a
Scalar (Force a) -> Force a
forall a. a -> Force a
Newtons }
 instance (Num a, Show a) => Unit ( Torque  a) where
    amount :: Torque a -> Scalar (Torque a)
amount = Torque a -> a
Torque a -> Scalar (Torque a)
forall a. Torque a -> a
newtonmeters
    dimension :: Torque a -> Dimension
dimension Torque a
_ = Dimension
jouleDimension Dimension -> Dimension -> Dimension
forall v. VectorSpace v => v -> v -> v
%- Dimension
radianDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Torque a)) -> m (Torque a)
fromQuantity = Dimension -> (a -> Torque a) -> Quantity a -> m (Torque a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef (Dimension
jouleDimension Dimension -> Dimension -> Dimension
forall v. VectorSpace v => v -> v -> v
%- Dimension
radianDimension) a -> Torque a
forall a. a -> Torque a
NewtonMeters
    unitOf :: Torque a -> String
unitOf Torque a
_ = String
"N m" -- notice not displayed similarly than joule.
 instance (Show a, Num a) => LiteralUnit ( Torque  a) where { fromAmount :: Scalar (Torque a) -> Torque a
fromAmount = a -> Torque a
Scalar (Torque a) -> Torque a
forall a. a -> Torque a
NewtonMeters }

 instance (Num a, Show a) => Unit ( Frequency  a) where
    amount :: Frequency a -> Scalar (Frequency a)
amount = Frequency a -> a
Frequency a -> Scalar (Frequency a)
forall a. Frequency a -> a
hertzes
    dimension :: Frequency a -> Dimension
dimension Frequency a
_ = Dimension
hertzDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Frequency a)) -> m (Frequency a)
fromQuantity = Dimension -> (a -> Frequency a) -> Quantity a -> m (Frequency a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
hertzDimension a -> Frequency a
forall a. a -> Frequency a
Hertzes
    unitOf :: Frequency a -> String
unitOf Frequency a
_ = String
"Hz"
 instance (Show a, Num a) => LiteralUnit ( Frequency  a) where { fromAmount :: Scalar (Frequency a) -> Frequency a
fromAmount = a -> Frequency a
Scalar (Frequency a) -> Frequency a
forall a. a -> Frequency a
Hertzes }
 instance (Num a, Show a) => Unit ( Length  a) where
    amount :: Length a -> Scalar (Length a)
amount = Length a -> a
Length a -> Scalar (Length a)
forall a. Length a -> a
meters
    dimension :: Length a -> Dimension
dimension Length a
_ = Dimension
meterDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Length a)) -> m (Length a)
fromQuantity = Dimension -> (a -> Length a) -> Quantity a -> m (Length a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
meterDimension a -> Length a
forall a. a -> Length a
Meters
    unitOf :: Length a -> String
unitOf Length a
_ = String
"m"
 instance (Show a, Num a) => LiteralUnit ( Length  a) where { fromAmount :: Scalar (Length a) -> Length a
fromAmount = a -> Length a
Scalar (Length a) -> Length a
forall a. a -> Length a
Meters }
 instance (Num a, Show a) => Unit ( Mass  a) where
    amount :: Mass a -> Scalar (Mass a)
amount = Mass a -> a
Mass a -> Scalar (Mass a)
forall a. Mass a -> a
kilograms
    dimension :: Mass a -> Dimension
dimension Mass a
_ = Dimension
kilogramDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Mass a)) -> m (Mass a)
fromQuantity = Dimension -> (a -> Mass a) -> Quantity a -> m (Mass a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
kilogramDimension a -> Mass a
forall a. a -> Mass a
Kilograms
    unitOf :: Mass a -> String
unitOf Mass a
_ = String
"kg"
 instance (Show a, Num a) => LiteralUnit ( Mass  a) where { fromAmount :: Scalar (Mass a) -> Mass a
fromAmount = a -> Mass a
Scalar (Mass a) -> Mass a
forall a. a -> Mass a
Kilograms }
 instance (Num a, Show a) => Unit ( Time  a) where
    amount :: Time a -> Scalar (Time a)
amount = Time a -> a
Time a -> Scalar (Time a)
forall a. Time a -> a
seconds
    dimension :: Time a -> Dimension
dimension Time a
_ = Dimension
secondDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Time a)) -> m (Time a)
fromQuantity = Dimension -> (a -> Time a) -> Quantity a -> m (Time a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
secondDimension a -> Time a
forall a. a -> Time a
Seconds
    unitOf :: Time a -> String
unitOf Time a
_ = String
"s"
 instance (Show a, Num a) => LiteralUnit ( Time  a) where { fromAmount :: Scalar (Time a) -> Time a
fromAmount = a -> Time a
Scalar (Time a) -> Time a
forall a. a -> Time a
Seconds }
 instance (Num a, Show a) => Unit ( Current  a) where
    amount :: Current a -> Scalar (Current a)
amount = Current a -> a
Current a -> Scalar (Current a)
forall a. Current a -> a
amperes
    dimension :: Current a -> Dimension
dimension Current a
_ = Dimension
ampereDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Current a)) -> m (Current a)
fromQuantity = Dimension -> (a -> Current a) -> Quantity a -> m (Current a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
ampereDimension a -> Current a
forall a. a -> Current a
Amperes
    unitOf :: Current a -> String
unitOf Current a
_ = String
"A"
 instance (Show a, Num a) => LiteralUnit ( Current  a) where { fromAmount :: Scalar (Current a) -> Current a
fromAmount = a -> Current a
Scalar (Current a) -> Current a
forall a. a -> Current a
Amperes }
 instance (Num a, Show a) => Unit ( Temperature  a) where
    amount :: Temperature a -> Scalar (Temperature a)
amount = Temperature a -> a
Temperature a -> Scalar (Temperature a)
forall a. Temperature a -> a
kelvins
    dimension :: Temperature a -> Dimension
dimension Temperature a
_ = Dimension
kelvinDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Temperature a)) -> m (Temperature a)
fromQuantity = Dimension
-> (a -> Temperature a) -> Quantity a -> m (Temperature a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
kelvinDimension a -> Temperature a
forall a. a -> Temperature a
DegreesKelvin
    unitOf :: Temperature a -> String
unitOf Temperature a
_ = String
"K"
 instance (Show a, Num a) => LiteralUnit ( Temperature  a) where { fromAmount :: Scalar (Temperature a) -> Temperature a
fromAmount = a -> Temperature a
Scalar (Temperature a) -> Temperature a
forall a. a -> Temperature a
DegreesKelvin }
  
 instance (Num a, Show a) => Unit ( Substance  a) where
    amount :: Substance a -> Scalar (Substance a)
amount = Substance a -> a
Substance a -> Scalar (Substance a)
forall a. Substance a -> a
moles
    dimension :: Substance a -> Dimension
dimension Substance a
_ = Dimension
molDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Substance a)) -> m (Substance a)
fromQuantity = Dimension -> (a -> Substance a) -> Quantity a -> m (Substance a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
molDimension a -> Substance a
forall a. a -> Substance a
Moles
    unitOf :: Substance a -> String
unitOf Substance a
_ = String
"mol"
 instance (Show a, Num a) => LiteralUnit ( Substance  a) where { fromAmount :: Scalar (Substance a) -> Substance a
fromAmount = a -> Substance a
Scalar (Substance a) -> Substance a
forall a. a -> Substance a
Moles }
 instance (Num a, Show a) => Unit ( Intensity  a) where
    amount :: Intensity a -> Scalar (Intensity a)
amount = Intensity a -> a
Intensity a -> Scalar (Intensity a)
forall a. Intensity a -> a
candelas
    dimension :: Intensity a -> Dimension
dimension Intensity a
_ = Dimension
candelaDimension
    fromQuantity :: forall (m :: * -> *).
(Alternative m, MonadFail m) =>
Quantity (Scalar (Intensity a)) -> m (Intensity a)
fromQuantity = Dimension -> (a -> Intensity a) -> Quantity a -> m (Intensity a)
forall (m :: * -> *) a b.
(MonadFail m, Alternative m, Show a) =>
Dimension -> (a -> b) -> Quantity a -> m b
fromQuantityDef Dimension
candelaDimension a -> Intensity a
forall a. a -> Intensity a
Candelas
    unitOf :: Intensity a -> String
unitOf Intensity a
_ = String
"cd"
 instance (Show a, Num a) => LiteralUnit ( Intensity  a) where { fromAmount :: Scalar (Intensity a) -> Intensity a
fromAmount = a -> Intensity a
Scalar (Intensity a) -> Intensity a
forall a. a -> Intensity a
Candelas }
 instance (Floating a, Read a, Show a) => Read (Angle a) where { readPrec :: ReadPrec (Angle a)
readPrec = UnitName (Angle a) -> ReadPrec (Angle a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Angle a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Read a, Num a) => Read (Resistance a) where { readPrec :: ReadPrec (Resistance a)
readPrec = UnitName (Resistance a) -> ReadPrec (Resistance a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Resistance a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Floating a, Read a, Show a) => Read (DegreesAngle a) where { readPrec :: ReadPrec (DegreesAngle a)
readPrec = UnitName (DegreesAngle a) -> ReadPrec (DegreesAngle a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (DegreesAngle a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Information  a) where { readPrec :: ReadPrec (Information a)
readPrec = UnitName (Information a) -> ReadPrec (Information a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Information a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Inductance  a) where { readPrec :: ReadPrec (Inductance a)
readPrec = UnitName (Inductance a) -> ReadPrec (Inductance a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Inductance a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( EquivalentDose  a) where { readPrec :: ReadPrec (EquivalentDose a)
readPrec = UnitName (EquivalentDose a) -> ReadPrec (EquivalentDose a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (EquivalentDose a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Conductance  a) where { readPrec :: ReadPrec (Conductance a)
readPrec = UnitName (Conductance a) -> ReadPrec (Conductance a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Conductance a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( CatalyticActivity  a) where { readPrec :: ReadPrec (CatalyticActivity a)
readPrec = UnitName (CatalyticActivity a) -> ReadPrec (CatalyticActivity a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (CatalyticActivity a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Radioactivity  a) where { readPrec :: ReadPrec (Radioactivity a)
readPrec = UnitName (Radioactivity a) -> ReadPrec (Radioactivity a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Radioactivity a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Illuminance  a) where { readPrec :: ReadPrec (Illuminance a)
readPrec = UnitName (Illuminance a) -> ReadPrec (Illuminance a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Illuminance a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( AbsorbedDose  a) where { readPrec :: ReadPrec (AbsorbedDose a)
readPrec = UnitName (AbsorbedDose a) -> ReadPrec (AbsorbedDose a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (AbsorbedDose a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( FluxDensity  a) where { readPrec :: ReadPrec (FluxDensity a)
readPrec = UnitName (FluxDensity a) -> ReadPrec (FluxDensity a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (FluxDensity a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Flux  a) where { readPrec :: ReadPrec (Flux a)
readPrec = UnitName (Flux a) -> ReadPrec (Flux a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Flux a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( LuminousFlux  a) where { readPrec :: ReadPrec (LuminousFlux a)
readPrec = UnitName (LuminousFlux a) -> ReadPrec (LuminousFlux a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (LuminousFlux a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Capacitance  a) where { readPrec :: ReadPrec (Capacitance a)
readPrec = UnitName (Capacitance a) -> ReadPrec (Capacitance a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Capacitance a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Charge  a) where { readPrec :: ReadPrec (Charge a)
readPrec = UnitName (Charge a) -> ReadPrec (Charge a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Charge a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Power  a) where { readPrec :: ReadPrec (Power a)
readPrec = UnitName (Power a) -> ReadPrec (Power a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Power a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Voltage  a) where { readPrec :: ReadPrec (Voltage a)
readPrec = UnitName (Voltage a) -> ReadPrec (Voltage a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Voltage a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Energy  a) where { readPrec :: ReadPrec (Energy a)
readPrec = UnitName (Energy a) -> ReadPrec (Energy a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Energy a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Pressure  a) where { readPrec :: ReadPrec (Pressure a)
readPrec = UnitName (Pressure a) -> ReadPrec (Pressure a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Pressure a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Force  a) where { readPrec :: ReadPrec (Force a)
readPrec = UnitName (Force a) -> ReadPrec (Force a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Force a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Intensity  a) where { readPrec :: ReadPrec (Intensity a)
readPrec = UnitName (Intensity a) -> ReadPrec (Intensity a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Intensity a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Substance  a) where { readPrec :: ReadPrec (Substance a)
readPrec = UnitName (Substance a) -> ReadPrec (Substance a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Substance a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Temperature  a) where { readPrec :: ReadPrec (Temperature a)
readPrec = UnitName (Temperature a) -> ReadPrec (Temperature a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Temperature a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Frequency  a) where { readPrec :: ReadPrec (Frequency a)
readPrec = UnitName (Frequency a) -> ReadPrec (Frequency a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Frequency a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( SolidAngle  a) where { readPrec :: ReadPrec (SolidAngle a)
readPrec = UnitName (SolidAngle a) -> ReadPrec (SolidAngle a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (SolidAngle a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Fractional a, Read a) => Read ( DegreesTemperature  a) where { readPrec :: ReadPrec (DegreesTemperature a)
readPrec = UnitName (DegreesTemperature a) -> ReadPrec (DegreesTemperature a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (DegreesTemperature a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Current  a) where { readPrec :: ReadPrec (Current a)
readPrec = UnitName (Current a) -> ReadPrec (Current a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Current a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Fractional a, Read a) => Read ( DegreesFahrenheit  a) where { readPrec :: ReadPrec (DegreesFahrenheit a)
readPrec = UnitName (DegreesFahrenheit a) -> ReadPrec (DegreesFahrenheit a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (DegreesFahrenheit a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Fractional a, Read a) => Read ( DegreesRankine  a) where { readPrec :: ReadPrec (DegreesRankine a)
readPrec = UnitName (DegreesRankine a) -> ReadPrec (DegreesRankine a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (DegreesRankine a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Fractional a, Read a) => Read ( Percentage  a) where { readPrec :: ReadPrec (Percentage a)
readPrec = UnitName (Percentage a) -> ReadPrec (Percentage a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Percentage a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Time  a) where { readPrec :: ReadPrec (Time a)
readPrec = UnitName (Time a) -> ReadPrec (Time a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Time a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Length  a) where { readPrec :: ReadPrec (Length a)
readPrec = UnitName (Length a) -> ReadPrec (Length a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Length a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Mass  a) where { readPrec :: ReadPrec (Mass a)
readPrec = UnitName (Mass a) -> ReadPrec (Mass a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Mass a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( SquareLength  a) where { readPrec :: ReadPrec (SquareLength a)
readPrec = UnitName (SquareLength a) -> ReadPrec (SquareLength a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (SquareLength a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( CubicLength  a) where { readPrec :: ReadPrec (CubicLength a)
readPrec = UnitName (CubicLength a) -> ReadPrec (CubicLength a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (CubicLength a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Acceleration  a) where { readPrec :: ReadPrec (Acceleration a)
readPrec = UnitName (Acceleration a) -> ReadPrec (Acceleration a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Acceleration a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Velocity  a) where { readPrec :: ReadPrec (Velocity a)
readPrec = UnitName (Velocity a) -> ReadPrec (Velocity a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Velocity a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Num a, Read a) => Read ( Torque  a) where { readPrec :: ReadPrec (Torque a)
readPrec = UnitName (Torque a) -> ReadPrec (Torque a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (Torque a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (Show a, Floating a, Read a) => Read ( SoundLevel  a) where { readPrec :: ReadPrec (SoundLevel a)
readPrec = UnitName (SoundLevel a) -> ReadPrec (SoundLevel a)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit UnitName (SoundLevel a)
forall u. LiteralUnit u => Scalar u -> u
fromAmount }
 instance (LiteralUnit a, LiteralUnit b, Read (Scalar a), Show (Scalar a), Scalar a ~ Scalar b) => Read (a :* b) where { readPrec :: ReadPrec (a :* b)
readPrec = UnitName (a :* b) -> ReadPrec (a :* b)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit (Scalar a -> a
forall u. LiteralUnit u => Scalar u -> u
fromAmount (Scalar a -> a) -> UnitName b -> UnitName (a :* b)
forall u u'.
(Scalar u ~ Scalar u') =>
UnitName u -> UnitName u' -> UnitName (u :* u')
*%% UnitName b
forall u. LiteralUnit u => Scalar u -> u
fromAmount) }
 instance (LiteralUnit a, LiteralUnit b, Read (Scalar a), Show (Scalar a), Scalar a ~ Scalar b) => Read (a :/ b) where { readPrec :: ReadPrec (a :/ b)
readPrec = UnitName (a :/ b) -> ReadPrec (a :/ b)
forall u. (Unit u, Read (Scalar u)) => UnitName u -> ReadPrec u
readUnit (Scalar a -> a
forall u. LiteralUnit u => Scalar u -> u
fromAmount (Scalar a -> a) -> UnitName b -> UnitName (a :/ b)
forall u u'.
(Scalar u ~ Scalar u') =>
UnitName u -> UnitName u' -> UnitName (u :/ u')
/%% UnitName b
forall u. LiteralUnit u => Scalar u -> u
fromAmount) }

 instance (Num a) => VectorSpace (Angle a) where
   type Scalar (Angle a) = a
   vzero :: Angle a
vzero = a -> Angle a
forall a. a -> Angle a
Radians a
0
   vnegate :: Angle a -> Angle a
vnegate (Radians a
a) = a -> Angle a
forall a. a -> Angle a
Radians (a -> a
forall a. Num a => a -> a
negate a
a)
   (Radians a
a) %+ :: Angle a -> Angle a -> Angle a
%+ (Radians a
b) = a -> Angle a
forall a. a -> Angle a
Radians (a
a a -> a -> a
forall a. Num a => a -> a -> a
+ a
b)
   Scalar (Angle a)
k %* :: Scalar (Angle a) -> Angle a -> Angle a
%* (Radians a
a) = a -> Angle a
forall a. a -> Angle a
Radians (a -> Angle a) -> a -> Angle a
forall a b. (a -> b) -> a -> b
$ a
Scalar (Angle a)
k a -> a -> a
forall a. Num a => a -> a -> a
* a
a

 instance (Num a) => VectorSpace (DegreesAngle a) where
   type Scalar (DegreesAngle a) = a
   vzero :: DegreesAngle a
vzero = a -> DegreesAngle a
forall a. a -> DegreesAngle a
Degrees a
0
   vnegate :: DegreesAngle a -> DegreesAngle a
vnegate (Degrees a
a) = a -> DegreesAngle a
forall a. a -> DegreesAngle a
Degrees (a -> a
forall a. Num a => a -> a
negate a
a)
   (Degrees a
a) %+ :: DegreesAngle a -> DegreesAngle a -> DegreesAngle a
%+ (Degrees a
b) = a -> DegreesAngle a
forall a. a -> DegreesAngle a
Degrees (a
a a -> a -> a
forall a. Num a => a -> a -> a
+ a
b)
   Scalar (DegreesAngle a)
k %* :: Scalar (DegreesAngle a) -> DegreesAngle a -> DegreesAngle a
%* (Degrees a
a) = a -> DegreesAngle a
forall a. a -> DegreesAngle a
Degrees (a -> DegreesAngle a) -> a -> DegreesAngle a
forall a b. (a -> b) -> a -> b
$ a
Scalar (DegreesAngle a)
k a -> a -> a
forall a. Num a => a -> a -> a
* a
a

#if __GLASGOW_HASKELL__ >= 806

 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Resistance a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Information a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Inductance a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (EquivalentDose a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Conductance a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (CatalyticActivity a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Radioactivity a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Illuminance a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (AbsorbedDose a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (FluxDensity a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Flux a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (LuminousFlux a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Capacitance a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Charge a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Power a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Voltage a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Energy a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Pressure a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Force a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Intensity a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Substance a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Temperature a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Frequency a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (SolidAngle a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (DegreesTemperature a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Current a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (DegreesFahrenheit a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (DegreesRankine a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Percentage a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Time a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Length a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Mass a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (SquareLength a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (CubicLength a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Acceleration a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Velocity a)
 deriving via (Dimensionless a) instance (MetricSpace a) => MetricSpace (Torque a)


  -- ----


 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Resistance a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Information a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Inductance a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (EquivalentDose a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Conductance a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (CatalyticActivity a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Radioactivity a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Illuminance a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (AbsorbedDose a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (FluxDensity a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Flux a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (LuminousFlux a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Capacitance a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Charge a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Power a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Voltage a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Energy a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Pressure a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Force a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Intensity a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Substance a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Temperature a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Frequency a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (SolidAngle a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (DegreesTemperature a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Current a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (DegreesFahrenheit a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (DegreesRankine a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Percentage a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Time a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Length a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Mass a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (SquareLength a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (CubicLength a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Acceleration a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Velocity a)
 deriving via (Dimensionless a) instance (Num a) => VectorSpace (Torque a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Angle a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Resistance a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (DegreesAngle a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Information a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Inductance a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (EquivalentDose a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Conductance a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (CatalyticActivity a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Radioactivity a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Illuminance a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (AbsorbedDose a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (FluxDensity a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Flux a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (LuminousFlux a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Capacitance a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Charge a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Power a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Voltage a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Energy a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Pressure a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Force a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Intensity a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Substance a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Temperature a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Frequency a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (SolidAngle a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (DegreesTemperature a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Current a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (DegreesFahrenheit a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (DegreesRankine a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Percentage a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Time a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Length a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Mass a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (SquareLength a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Acceleration a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Velocity a)
 deriving via (Dimensionless a) instance (Num a) => NormedSpace (Torque a)

#else

 instance (Num a) => VectorSpace ( Velocity  a) where
    type Scalar (Velocity a) = a
    vzero = MetersPerSecond 0
    vnegate (MetersPerSecond x) = MetersPerSecond (negate x)
    (MetersPerSecond x) %+ (MetersPerSecond y) = MetersPerSecond $ x + y
    k %* (MetersPerSecond x) = MetersPerSecond (k * x)
 instance NormedSpace Velocity where { norm = amount }
 instance (Num a) => VectorSpace ( Acceleration  a) where
    type Scalar (Acceleration a) = a
    vzero = MetersPerSquareSecond 0
    vnegate (MetersPerSquareSecond x) = MetersPerSquareSecond (negate x)
    (MetersPerSquareSecond x) %+ (MetersPerSquareSecond y) = MetersPerSquareSecond (x + y)
    k %* (MetersPerSquareSecond x) = MetersPerSquareSecond (k %* x)
 instance NormedSpace Acceleration where { norm = amount }
 instance (Num a) => VectorSpace ( CubicLength  a) where
    type Scalar (CubicLength a) = a
    vzero = CubicMeters 0
    vnegate (CubicMeters x) = CubicMeters $ negate x
    (CubicMeters x) %+ (CubicMeters y) = CubicMeters $ x + y
    k %* (CubicMeters x) = CubicMeters $ k * x
 instance (Num a) => VectorSpace ( SquareLength  a) where
    type Scalar (SquareLength a) = a
    vzero = SquareMeters 0
    vnegate (SquareMeters x) = SquareMeters $ negate x
    (SquareMeters x) %+ (SquareMeters y) = SquareMeters $ x + y
    k %* (SquareMeters x) = SquareMeters $ k * x
 instance NormedSpace SquareLength where { norm = amount }

 instance (Num a) => VectorSpace ( Mass  a) where
    type Scalar (Mass a) = a
    vzero = Kilograms 0
    vnegate (Kilograms x) = Kilograms $ negate x
    (Kilograms x) %+ (Kilograms y) = Kilograms $ x + y
    k %* (Kilograms x) = Kilograms $ k * x
 instance NormedSpace Mass where { norm = amount }
 instance (Num a) => VectorSpace ( Length  a) where
    type Scalar (Length a) = a
    vzero = Meters 0
    vnegate (Meters x) = Meters $ negate x
    (Meters x) %+ (Meters y) = Meters $ x + y
    k %* (Meters x) = Meters $ k * x
 instance NormedSpace Length where { norm = amount }
 instance (Num a) => VectorSpace ( Time  a) where
    type Scalar (Time a) = a
    vzero = Seconds 0
    vnegate (Seconds x) = Seconds $ negate x
    (Seconds x) %+ (Seconds y) = Seconds $ x + y
    k %* (Seconds x) = Seconds $ k * x
 instance NormedSpace Time where { norm = amount }
 instance (Num a) => VectorSpace ( Percentage  a) where
    type Scalar (Percentage a) = a
    vzero = Percentages 0
    vnegate (Percentages i) = Percentages $ negate i
    (Percentages x) %+ (Percentages y) = Percentages $ x + y
    k %* (Percentages x) = Percentages (k * x)
 instance NormedSpace Percentage where { norm = amount }
 instance (Num a) => VectorSpace ( DegreesFahrenheit  a) where
    type Scalar (DegreesFahrenheit a) = a
    vzero = DegreesFahrenheit 0
    vnegate (DegreesFahrenheit x) = DegreesFahrenheit $ negate x
    (DegreesFahrenheit x) %+ (DegreesFahrenheit y) = DegreesFahrenheit $ x + y
    k %* (DegreesFahrenheit x) = DegreesFahrenheit $ k * x
 instance NormedSpace DegreesFahrenheit where { norm = amount }
 instance (Num a) => VectorSpace ( DegreesRankine  a) where
    type Scalar (DegreesRankine a) = a
    vzero = DegreesRankine 0
    vnegate (DegreesRankine x) = DegreesRankine $ negate x
    (DegreesRankine x) %+ (DegreesRankine y) = DegreesRankine $ x + y
    k %* (DegreesRankine x) = DegreesRankine $ k * x
 instance NormedSpace DegreesRankine where { norm = amount }
 instance (Num a) => VectorSpace ( Current  a) where
    type Scalar (Current a) = a
    vzero = Amperes 0
    vnegate (Amperes x) = Amperes $ negate x
    (Amperes x) %+ (Amperes y) = Amperes $ x + y
    k %* (Amperes x) = Amperes $ k * x
 instance NormedSpace Current where { norm = amount }
 instance (Num a) => VectorSpace ( DegreesTemperature  a) where
    type Scalar (DegreesTemperature a) = a
    vzero = DegreesCelcius 0
    vnegate (DegreesCelcius x) = DegreesCelcius $ negate x
    (DegreesCelcius x) %+ (DegreesCelcius y) = DegreesCelcius $ x + y
    k %* (DegreesCelcius x) = DegreesCelcius $ k * x
 instance NormedSpace DegreesTemperature where { norm = amount }
 instance (Num a) => VectorSpace ( SolidAngle  a) where
    type Scalar (SolidAngle a) = a
    vzero = Steradians 0
    vnegate (Steradians x) = Steradians (negate x)
    (Steradians x) %+ (Steradians y) = Steradians $ x + y
    k %* (Steradians x) = Steradians $ k * x
 instance NormedSpace SolidAngle where { norm = amount }
 instance (Num a) => VectorSpace ( Frequency  a) where
    type Scalar (Frequency a) = a
    vzero = Hertzes 0
    vnegate (Hertzes x) = Hertzes $ negate x
    (Hertzes x) %+ (Hertzes y) = Hertzes $ x + y
    k %* (Hertzes x) = Hertzes $ k * x
 instance NormedSpace Frequency where { norm = amount }
 instance (Num a) => VectorSpace ( Temperature  a) where
    type Scalar (Temperature a) = a
    vzero = DegreesKelvin 0
    vnegate (DegreesKelvin x) = DegreesKelvin $ negate x
    (DegreesKelvin x) %+ (DegreesKelvin y) = DegreesKelvin $ x + y
    k %* (DegreesKelvin x) = DegreesKelvin $ k * x
 instance NormedSpace Temperature where { norm = amount }
 instance (Num a) => VectorSpace ( Substance  a) where
    type Scalar (Substance a) = a
    vzero = Moles 0
    vnegate (Moles x) = Moles $ negate x
    (Moles x) %+ (Moles y) = Moles $ x + y
    k %* (Moles x) = Moles $ k * x
 instance NormedSpace Substance where { norm = amount }
 instance (Num a) => VectorSpace ( Intensity  a) where
    type Scalar (Intensity a) = a
    vzero = Candelas 0
    vnegate (Candelas x) = Candelas $ negate x
    (Candelas x) %+ (Candelas y) = Candelas $ x + y
    k %* (Candelas x) = Candelas $ k * x
 instance NormedSpace Intensity where { norm = amount }
 instance (Num a) => VectorSpace ( Force  a) where
    type Scalar (Force a) = a
    vzero = Newtons 0
    vnegate (Newtons x) = Newtons $ negate x
    (Newtons x) %+ (Newtons y) = Newtons $ x + y
    k %* (Newtons x) = Newtons $ k * x
 instance NormedSpace Force where { norm = amount }
 instance (Num a) => VectorSpace ( Pressure  a) where
    type Scalar (Pressure a) = a
    vzero = Pascals 0
    vnegate (Pascals x) = Pascals $ negate x
    (Pascals x) %+ (Pascals y) = Pascals $ x + y
    k %* (Pascals x) = Pascals $ k * x
 instance NormedSpace Pressure where { norm = amount }
 instance (Num a) => VectorSpace ( Energy  a) where
    type Scalar (Energy a) = a
    vzero = Joules 0
    vnegate (Joules x) = Joules $ negate x
    (Joules x) %+ (Joules y) = Joules $ x + y
    k %* (Joules x) = Joules $ k * x
 instance NormedSpace Energy where { norm = amount }
 instance (Num a) => VectorSpace ( Voltage  a) where
    type Scalar (Voltage a) = a
    vzero = Volts 0
    vnegate (Volts x) = Volts $ negate x
    (Volts x) %+ (Volts y) = Volts $ x + y
    k %* (Volts x) = Volts $ k * x
 instance NormedSpace Voltage where { norm = amount }
 instance (Num a) => VectorSpace ( Power  a) where
    type Scalar (Power a) = a
    vzero = Watts 0
    vnegate (Watts x) = Watts $ negate x
    (Watts x) %+ (Watts y) = Watts $ x + y
    k %* (Watts x) = Watts $ k * x
 instance NormedSpace Power where { norm = amount }
 instance (Num a) => VectorSpace ( Charge  a) where
    type Scalar (Charge a) = a
    vzero = Coulombs 0
    vnegate (Coulombs x) = Coulombs $ negate x
    (Coulombs x) %+ (Coulombs y) = Coulombs $ x + y
    k %* (Coulombs x) = Coulombs $ k * x
 instance NormedSpace Charge where { norm = amount }
 instance (Num a) => VectorSpace ( Capacitance  a) where
    type Scalar (Capacitance a) = a
    vzero = Farads 0
    vnegate (Farads x) = Farads $ negate x
    (Farads x) %+ (Farads y) = Farads $ x + y
    k %* (Farads x) = Farads $ k * x
 instance NormedSpace Capacitance where { norm = amount }
 instance (Num a) => VectorSpace ( LuminousFlux  a) where
    type Scalar (LuminousFlux a) = a
    vzero = Lumens 0
    vnegate (Lumens x) = Lumens $ negate x
    (Lumens x) %+ (Lumens y) = Lumens $ x + y
    k %* (Lumens x) = Lumens $ k * x
 instance NormedSpace LuminousFlux where { norm = amount }
 instance (Num a) => VectorSpace ( Flux  a) where
    type Scalar (Flux a) = a
    vzero = Webers 0
    vnegate (Webers x) = Webers $ negate x
    (Webers x) %+ (Webers y) = Webers $ x + y
    k %* (Webers x) = Webers $ k * x
 instance NormedSpace Flux where { norm = amount }

 instance (Num a) => VectorSpace ( FluxDensity  a) where
    type Scalar (FluxDensity a) = a
    vzero = Teslas 0
    vnegate (Teslas x) = Teslas $ negate x
    (Teslas x) %+ (Teslas y) = Teslas $ x + y
    k %* (Teslas x) = Teslas $ k * x
 instance NormedSpace FluxDensity where { norm = amount }
 instance (Num a) => VectorSpace ( AbsorbedDose  a) where
    type Scalar (AbsorbedDose a) = a
    vzero = Grays 0
    vnegate (Grays x) = Grays $ negate x
    (Grays x) %+ (Grays y) = Grays $ x + y
    k %* (Grays x) = Grays $ k * x
 instance NormedSpace AbsorbedDose where { norm = amount }
 instance (Num a) => VectorSpace ( Illuminance  a) where
    type Scalar (Illuminance a) = a
    vzero = Luxes 0
    vnegate (Luxes x) = Luxes $ negate x
    (Luxes x) %+ (Luxes y) = Luxes $ x + y
    k %* (Luxes x) = Luxes $ k * x
 instance NormedSpace Illuminance where { norm = amount }
 instance (Num a) => VectorSpace ( Radioactivity  a) where
    type Scalar (Radioactivity a) = a
    vzero = Becquerels 0
    vnegate (Becquerels x) = Becquerels $ negate x
    (Becquerels x) %+ (Becquerels y) = Becquerels $ x + y
    k %* (Becquerels x) = Becquerels $ k * x
 instance NormedSpace Radioactivity where { norm = amount }
 instance (Num a) => VectorSpace ( CatalyticActivity  a) where
    type Scalar (CatalyticActivity a) = a
    vzero = Katals 0
    vnegate (Katals x) = Katals $ negate x
    (Katals x) %+ (Katals y) = Katals $ x + y
    k %* (Katals x) = Katals $ k * x
 instance NormedSpace CatalyticActivity where { norm = amount }
 instance (Num a) => VectorSpace ( Conductance  a) where
    type Scalar (Conductance a) = a
    vzero = Siemenses 0
    vnegate (Siemenses x) = Siemenses $ negate x
    (Siemenses x) %+ (Siemenses y) = Siemenses $ x + y
    k %* (Siemenses x) = Siemenses $ k * x
 instance NormedSpace Conductance where { norm = amount }

 instance (Num a) => VectorSpace ( EquivalentDose  a) where
    type Scalar (EquivalentDose a) = a
    vzero = Sieverts 0
    vnegate (Sieverts x) = Sieverts $ negate x
    (Sieverts x) %+ (Sieverts y) = Sieverts $ x + y
    k %* (Sieverts x) = Sieverts $ k * x
 instance NormedSpace EquivalentDose where { norm = amount }

 instance (Num a) => VectorSpace ( Angle  a) where
    type Scalar (Angle a) = a
    vzero = Radians 0
    vnegate (Radians x) = Radians (negate x)
    (Radians x) %+ (Radians y) = Radians $ x + y
    k %* (Radians x) = Radians $ k * x

 instance NormedSpace Angle where { norm = amount }

 instance (Num a) => VectorSpace ( Resistance  a) where
    type Scalar (Resistance a) = a
    vzero = Ohms 0
    vnegate (Ohms x) = Ohms $ negate x
    (Ohms x) %+ (Ohms y) = Ohms $ x + y
    k %* (Ohms x) = Ohms $ k * x
 instance NormedSpace Resistance where { norm = amount }

 instance (Num a) => VectorSpace ( DegreesAngle  a) where
    type Scalar (DegreesAngle a) = a
    vzero = Degrees 0
    vnegate (Degrees x) = Degrees $ negate x
    (Degrees x) %+ (Degrees y) = Degrees $ x + y
    k %* (Degrees x) = Degrees $ k * x
 instance NormedSpace DegreesAngle where { norm = amount }

 instance (Num a) => VectorSpace ( Information  a) where
    type Scalar (Information a) = a
    vzero = Bits 0
    vnegate (Bits x) = Bits (negate x)
    (Bits x) %+ (Bits y) = Bits $ x + y
    k %* (Bits x) = Bits (k * x)
 instance NormedSpace Information where { norm = amount }

 instance (Num a) => VectorSpace ( Inductance  a) where
    type Scalar (Inductance a) = a
    vzero = Henrys 0
    vnegate (Henrys x) = Henrys $ negate x
    (Henrys x) %+ (Henrys y) = Henrys $ x + y
    k %* (Henrys x) = Henrys $ k * x
 instance NormedSpace Inductance where { norm = amount }

 instance (Num a) => VectorSpace ( Torque  a) where
    type Scalar (Torque a) = a
    vzero = NewtonMeters 0
    vnegate (NewtonMeters x) = NewtonMeters $ negate x
    (NewtonMeters x) %+ (NewtonMeters y) = NewtonMeters $ x + y
    k %* (NewtonMeters x) = NewtonMeters $ k * x
 instance NormedSpace Torque where { norm = amount }

#endif