dimensional 1.6.1 → 1.6.2

raw patch · 2 files changed

+12/−5 lines, 2 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Numeric.Units.Dimensional: data Dimensional v :: Dimension -> Type -> Type

- Numeric.Units.Dimensional.Coercion: data Dimensional v :: Dimension -> Type -> Type

- Numeric.Units.Dimensional.FixedPoint: data Dimensional v :: Dimension -> Type -> Type

- Numeric.Units.Dimensional.UnitNames: type UnitNameTransformer = (forall m. UnitName m -> UnitName 'NonMetric)

- Numeric.Units.Dimensional.UnitNames: type UnitNameTransformer2 = (forall m1 m2. UnitName m1 -> UnitName m2 -> UnitName 'NonMetric)

+ Numeric.Units.Dimensional: data family Dimensional (v :: Variant) :: Dimension -> Type -> Type

+ Numeric.Units.Dimensional.Coercion: data family Dimensional (v :: Variant) :: Dimension -> Type -> Type

+ Numeric.Units.Dimensional.Dimensions: ($dmdynamicDimension) :: (HasDynamicDimension a, HasDimension a) => a -> DynamicDimension

+ Numeric.Units.Dimensional.Dimensions.TermLevel: ($dmdynamicDimension) :: (HasDynamicDimension a, HasDimension a) => a -> DynamicDimension

+ Numeric.Units.Dimensional.Dynamic: ($dmdynamicDimension) :: (HasDynamicDimension a, HasDimension a) => a -> DynamicDimension

+ Numeric.Units.Dimensional.FixedPoint: data family Dimensional (v :: Variant) :: Dimension -> Type -> Type

+ Numeric.Units.Dimensional.Prelude: data family Dimensional (v :: Variant) :: Dimension -> Type -> Type

+ Numeric.Units.Dimensional.UnitNames: type UnitNameTransformer2 = forall (m1 :: Metricality) (m2 :: Metricality). () => UnitName m1 -> UnitName m2 -> UnitName 'NonMetric

- Numeric.Units.Dimensional: (*) :: (KnownVariant v1, KnownVariant v2, KnownVariant (v1 * v2), Num a) => Dimensional v1 d1 a -> Dimensional v2 d2 a -> Dimensional (v1 * v2) (d1 * d2) a

+ Numeric.Units.Dimensional: (*) :: forall (v1 :: Variant) (v2 :: Variant) a (d1 :: Dimension) (d2 :: Dimension). (KnownVariant v1, KnownVariant v2, KnownVariant (v1 * v2), Num a) => Dimensional v1 d1 a -> Dimensional v2 d2 a -> Dimensional (v1 * v2) (d1 * d2) a

- Numeric.Units.Dimensional: (*~) :: Num a => a -> Unit m d a -> Quantity d a

+ Numeric.Units.Dimensional: (*~) :: forall a (m :: Metricality) (d :: Dimension). Num a => a -> Unit m d a -> Quantity d a

- Numeric.Units.Dimensional: (*~~) :: (Functor f, Num a) => f a -> Unit m d a -> f (Quantity d a)

+ Numeric.Units.Dimensional: (*~~) :: forall f a (m :: Metricality) (d :: Dimension). (Functor f, Num a) => f a -> Unit m d a -> f (Quantity d a)

- Numeric.Units.Dimensional: (+) :: Num a => Quantity d a -> Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional: (+) :: forall a (d :: Dimension). Num a => Quantity d a -> Quantity d a -> Quantity d a

- Numeric.Units.Dimensional: (-) :: Num a => Quantity d a -> Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional: (-) :: forall a (d :: Dimension). Num a => Quantity d a -> Quantity d a -> Quantity d a

- Numeric.Units.Dimensional: (/) :: (KnownVariant v1, KnownVariant v2, KnownVariant (v1 / v2), Fractional a) => Dimensional v1 d1 a -> Dimensional v2 d2 a -> Dimensional (v1 / v2) (d1 / d2) a

+ Numeric.Units.Dimensional: (/) :: forall (v1 :: Variant) (v2 :: Variant) a (d1 :: Dimension) (d2 :: Dimension). (KnownVariant v1, KnownVariant v2, KnownVariant (v1 / v2), Fractional a) => Dimensional v1 d1 a -> Dimensional v2 d2 a -> Dimensional (v1 / v2) (d1 / d2) a

- Numeric.Units.Dimensional: (/~) :: Fractional a => Quantity d a -> Unit m d a -> a

+ Numeric.Units.Dimensional: (/~) :: forall a (d :: Dimension) (m :: Metricality). Fractional a => Quantity d a -> Unit m d a -> a

- Numeric.Units.Dimensional: (/~~) :: forall f m d a. (Functor f, Fractional a) => f (Quantity d a) -> Unit m d a -> f a

+ Numeric.Units.Dimensional: (/~~) :: forall f (m :: Metricality) (d :: Dimension) a. (Functor f, Fractional a) => f (Quantity d a) -> Unit m d a -> f a

- Numeric.Units.Dimensional: (^) :: (Fractional a, KnownTypeInt i, KnownVariant v, KnownVariant (Weaken v)) => Dimensional v d1 a -> Proxy i -> Dimensional (Weaken v) (d1 ^ i) a

+ Numeric.Units.Dimensional: (^) :: forall a (i :: TypeInt) (v :: Variant) (d1 :: Dimension). (Fractional a, KnownTypeInt i, KnownVariant v, KnownVariant (Weaken v)) => Dimensional v d1 a -> Proxy i -> Dimensional (Weaken v) (d1 ^ i) a

- Numeric.Units.Dimensional: (^/) :: (KnownTypeInt n, Floating a) => Quantity d a -> Proxy n -> Quantity (NRoot d n) a

+ Numeric.Units.Dimensional: (^/) :: forall (n :: TypeInt) a (d :: Dimension). (KnownTypeInt n, Floating a) => Quantity d a -> Proxy n -> Quantity (NRoot d n) a

- Numeric.Units.Dimensional: _0 :: Num a => Quantity d a

+ Numeric.Units.Dimensional: _0 :: forall a (d :: Dimension). Num a => Quantity d a

- Numeric.Units.Dimensional: abs :: Num a => Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional: abs :: forall a (d :: Dimension). Num a => Quantity d a -> Quantity d a

- Numeric.Units.Dimensional: asLens :: Fractional a => Unit m d a -> forall f. Functor f => (a -> f a) -> Quantity d a -> f (Quantity d a)

+ Numeric.Units.Dimensional: asLens :: forall a (m :: Metricality) (d :: Dimension). Fractional a => Unit m d a -> forall (f :: Type -> Type). Functor f => (a -> f a) -> Quantity d a -> f (Quantity d a)

- Numeric.Units.Dimensional: atan2 :: RealFloat a => Quantity d a -> Quantity d a -> Dimensionless a

+ Numeric.Units.Dimensional: atan2 :: forall a (d :: Dimension). RealFloat a => Quantity d a -> Quantity d a -> Dimensionless a

- Numeric.Units.Dimensional: cbrt :: Floating a => Quantity d a -> Quantity (Cbrt d) a

+ Numeric.Units.Dimensional: cbrt :: forall a (d :: Dimension). Floating a => Quantity d a -> Quantity (Cbrt d) a

- Numeric.Units.Dimensional: changeRep :: (KnownVariant v, Real a, Fractional b) => Dimensional v d a -> Dimensional v d b

+ Numeric.Units.Dimensional: changeRep :: forall (v :: Variant) a b (d :: Dimension). (KnownVariant v, Real a, Fractional b) => Dimensional v d a -> Dimensional v d b

- Numeric.Units.Dimensional: changeRepApproximate :: (KnownVariant v, Floating b) => Dimensional v d ExactPi -> Dimensional v d b

+ Numeric.Units.Dimensional: changeRepApproximate :: forall (v :: Variant) b (d :: Dimension). (KnownVariant v, Floating b) => Dimensional v d ExactPi -> Dimensional v d b

- Numeric.Units.Dimensional: dmap :: KnownVariant v => (a1 -> a2) -> Dimensional v d a1 -> Dimensional v d a2

+ Numeric.Units.Dimensional: dmap :: forall a1 a2 (d :: Dimension). KnownVariant v => (a1 -> a2) -> Dimensional v d a1 -> Dimensional v d a2

- Numeric.Units.Dimensional: exactValue :: Unit m d a -> ExactPi

+ Numeric.Units.Dimensional: exactValue :: forall (m :: Metricality) (d :: Dimension) a. Unit m d a -> ExactPi

- Numeric.Units.Dimensional: exactify :: Unit m d a -> Unit m d ExactPi

+ Numeric.Units.Dimensional: exactify :: forall (m :: Metricality) (d :: Dimension) a. Unit m d a -> Unit m d ExactPi

- Numeric.Units.Dimensional: mean :: (Fractional a, Foldable f) => f (Quantity d a) -> Quantity d a

+ Numeric.Units.Dimensional: mean :: forall a f (d :: Dimension). (Fractional a, Foldable f) => f (Quantity d a) -> Quantity d a

- Numeric.Units.Dimensional: mkUnitQ :: Fractional a => UnitName m -> Rational -> Unit m1 d a -> Unit m d a

+ Numeric.Units.Dimensional: mkUnitQ :: forall a (m :: Metricality) (m1 :: Metricality) (d :: Dimension). Fractional a => UnitName m -> Rational -> Unit m1 d a -> Unit m d a

- Numeric.Units.Dimensional: mkUnitR :: Floating a => UnitName m -> ExactPi -> Unit m1 d a -> Unit m d a

+ Numeric.Units.Dimensional: mkUnitR :: forall a (m :: Metricality) (m1 :: Metricality) (d :: Dimension). Floating a => UnitName m -> ExactPi -> Unit m1 d a -> Unit m d a

- Numeric.Units.Dimensional: mkUnitZ :: Num a => UnitName m -> Integer -> Unit m1 d a -> Unit m d a

+ Numeric.Units.Dimensional: mkUnitZ :: forall a (m :: Metricality) (m1 :: Metricality) (d :: Dimension). Num a => UnitName m -> Integer -> Unit m1 d a -> Unit m d a

- Numeric.Units.Dimensional: nFromTo :: (Fractional a, Integral b) => Quantity d a -> Quantity d a -> b -> [Quantity d a]

+ Numeric.Units.Dimensional: nFromTo :: forall a b (d :: Dimension). (Fractional a, Integral b) => Quantity d a -> Quantity d a -> b -> [Quantity d a]

- Numeric.Units.Dimensional: name :: Unit m d a -> UnitName m

+ Numeric.Units.Dimensional: name :: forall (m :: Metricality) (d :: Dimension) a. Unit m d a -> UnitName m

- Numeric.Units.Dimensional: negate :: Num a => Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional: negate :: forall a (d :: Dimension). Num a => Quantity d a -> Quantity d a

- Numeric.Units.Dimensional: nroot :: (KnownTypeInt n, Floating a) => Proxy n -> Quantity d a -> Quantity (NRoot d n) a

+ Numeric.Units.Dimensional: nroot :: forall (n :: TypeInt) a (d :: Dimension). (KnownTypeInt n, Floating a) => Proxy n -> Quantity d a -> Quantity (NRoot d n) a

- Numeric.Units.Dimensional: recip :: Fractional a => Quantity d a -> Quantity (Recip d) a

+ Numeric.Units.Dimensional: recip :: forall a (d :: Dimension). Fractional a => Quantity d a -> Quantity (Recip d) a

- Numeric.Units.Dimensional: showIn :: (Show a, Fractional a) => Unit m d a -> Quantity d a -> String

+ Numeric.Units.Dimensional: showIn :: forall a (m :: Metricality) (d :: Dimension). (Show a, Fractional a) => Unit m d a -> Quantity d a -> String

- Numeric.Units.Dimensional: siUnit :: forall d a. (KnownDimension d, Num a) => Unit 'NonMetric d a

+ Numeric.Units.Dimensional: siUnit :: forall (d :: Dimension) a. (KnownDimension d, Num a) => Unit 'NonMetric d a

- Numeric.Units.Dimensional: signum :: Num a => Quantity d a -> Dimensionless a

+ Numeric.Units.Dimensional: signum :: forall a (d :: Dimension). Num a => Quantity d a -> Dimensionless a

- Numeric.Units.Dimensional: sqrt :: Floating a => Quantity d a -> Quantity (Sqrt d) a

+ Numeric.Units.Dimensional: sqrt :: forall a (d :: Dimension). Floating a => Quantity d a -> Quantity (Sqrt d) a

- Numeric.Units.Dimensional: strengthen :: Unit m d a -> Maybe (Unit 'Metric d a)

+ Numeric.Units.Dimensional: strengthen :: forall (m :: Metricality) (d :: Dimension) a. Unit m d a -> Maybe (Unit 'Metric d a)

- Numeric.Units.Dimensional: sum :: (Num a, Foldable f) => f (Quantity d a) -> Quantity d a

+ Numeric.Units.Dimensional: sum :: forall a f (d :: Dimension). (Num a, Foldable f) => f (Quantity d a) -> Quantity d a

- Numeric.Units.Dimensional: type Cbrt d = NRoot d 'Pos3

+ Numeric.Units.Dimensional: type Cbrt (d :: Dimension) = NRoot d 'Pos3

- Numeric.Units.Dimensional: type KnownDimension (d :: Dimension) = HasDimension (Proxy d)

+ Numeric.Units.Dimensional: type KnownDimension (d :: Dimension) = HasDimension Proxy d

- Numeric.Units.Dimensional: type Sqrt d = NRoot d 'Pos2

+ Numeric.Units.Dimensional: type Sqrt (d :: Dimension) = NRoot d 'Pos2

- Numeric.Units.Dimensional: type Unit (m :: Metricality) = Dimensional ('DUnit m)

+ Numeric.Units.Dimensional: type Unit (m :: Metricality) = Dimensional 'DUnit m

- Numeric.Units.Dimensional: type family NRoot (d :: Dimension) (x :: TypeInt)

+ Numeric.Units.Dimensional: type family NRoot (d :: Dimension) (x :: TypeInt) :: Dimension

- Numeric.Units.Dimensional: weaken :: Unit m d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional: weaken :: forall (m :: Metricality) (d :: Dimension) a. Unit m d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.Coercion: coerce :: forall {k :: RuntimeRep} (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b

+ Numeric.Units.Dimensional.Coercion: coerce :: Coercible a b => a -> b

- Numeric.Units.Dimensional.Coercion: unQuantity :: SQuantity s d a -> a

+ Numeric.Units.Dimensional.Coercion: unQuantity :: forall (s :: ExactPi') (d :: Dimension) a. SQuantity s d a -> a

- Numeric.Units.Dimensional.Dimensions: dynamicDimension :: (HasDynamicDimension a, HasDimension a) => a -> DynamicDimension

+ Numeric.Units.Dimensional.Dimensions: dynamicDimension :: HasDynamicDimension a => a -> DynamicDimension

- Numeric.Units.Dimensional.Dimensions.TermLevel: dynamicDimension :: (HasDynamicDimension a, HasDimension a) => a -> DynamicDimension

+ Numeric.Units.Dimensional.Dimensions.TermLevel: dynamicDimension :: HasDynamicDimension a => a -> DynamicDimension

- Numeric.Units.Dimensional.Dimensions.TypeLevel: type Cbrt d = NRoot d 'Pos3

+ Numeric.Units.Dimensional.Dimensions.TypeLevel: type Cbrt (d :: Dimension) = NRoot d 'Pos3

- Numeric.Units.Dimensional.Dimensions.TypeLevel: type KnownDimension (d :: Dimension) = HasDimension (Proxy d)

+ Numeric.Units.Dimensional.Dimensions.TypeLevel: type KnownDimension (d :: Dimension) = HasDimension Proxy d

- Numeric.Units.Dimensional.Dimensions.TypeLevel: type Sqrt d = NRoot d 'Pos2

+ Numeric.Units.Dimensional.Dimensions.TypeLevel: type Sqrt (d :: Dimension) = NRoot d 'Pos2

- Numeric.Units.Dimensional.Dimensions.TypeLevel: type family NRoot (d :: Dimension) (x :: TypeInt)

+ Numeric.Units.Dimensional.Dimensions.TypeLevel: type family NRoot (d :: Dimension) (x :: TypeInt) :: Dimension

- Numeric.Units.Dimensional.Dynamic: demoteUnit :: forall m d a. KnownDimension d => Unit m d a -> AnyUnit

+ Numeric.Units.Dimensional.Dynamic: demoteUnit :: forall (m :: Metricality) (d :: Dimension) a. KnownDimension d => Unit m d a -> AnyUnit

- Numeric.Units.Dimensional.Dynamic: demoteUnit' :: KnownDimension d => Unit m d ExactPi -> AnyUnit

+ Numeric.Units.Dimensional.Dynamic: demoteUnit' :: forall (d :: Dimension) (m :: Metricality). KnownDimension d => Unit m d ExactPi -> AnyUnit

- Numeric.Units.Dimensional.Dynamic: dynamicDimension :: (HasDynamicDimension a, HasDimension a) => a -> DynamicDimension

+ Numeric.Units.Dimensional.Dynamic: dynamicDimension :: HasDynamicDimension a => a -> DynamicDimension

- Numeric.Units.Dimensional.Dynamic: promoteQuantity :: forall a d q. (Promotable q, KnownDimension d) => q a -> Maybe (Quantity d a)

+ Numeric.Units.Dimensional.Dynamic: promoteQuantity :: forall a (d :: Dimension) q. (Promotable q, KnownDimension d) => q a -> Maybe (Quantity d a)

- Numeric.Units.Dimensional.Dynamic: promoteUnit :: forall d. KnownDimension d => AnyUnit -> Maybe (Unit 'NonMetric d ExactPi)

+ Numeric.Units.Dimensional.Dynamic: promoteUnit :: forall (d :: Dimension). KnownDimension d => AnyUnit -> Maybe (Unit 'NonMetric d ExactPi)

- Numeric.Units.Dimensional.FixedPoint: (*) :: (KnownVariant v1, KnownVariant v2, KnownVariant (v1 * v2), Num a) => Dimensional v1 d1 a -> Dimensional v2 d2 a -> Dimensional (v1 * v2) (d1 * d2) a

+ Numeric.Units.Dimensional.FixedPoint: (*) :: forall (v1 :: Variant) (v2 :: Variant) a (d1 :: Dimension) (d2 :: Dimension). (KnownVariant v1, KnownVariant v2, KnownVariant (v1 * v2), Num a) => Dimensional v1 d1 a -> Dimensional v2 d2 a -> Dimensional (v1 * v2) (d1 * d2) a

- Numeric.Units.Dimensional.FixedPoint: (*~) :: forall s m d a b. (RealFrac a, Integral b, MinCtxt s a) => a -> Unit m d a -> SQuantity s d b

+ Numeric.Units.Dimensional.FixedPoint: (*~) :: forall (s :: ExactPi') (m :: Metricality) (d :: Dimension) a b. (RealFrac a, Integral b, MinCtxt s a) => a -> Unit m d a -> SQuantity s d b

- Numeric.Units.Dimensional.FixedPoint: (*~~) :: (Functor f, RealFrac a, Integral b, MinCtxt s a) => f a -> Unit m d a -> f (SQuantity s d b)

+ Numeric.Units.Dimensional.FixedPoint: (*~~) :: forall f a b (s :: ExactPi') (m :: Metricality) (d :: Dimension). (Functor f, RealFrac a, Integral b, MinCtxt s a) => f a -> Unit m d a -> f (SQuantity s d b)

- Numeric.Units.Dimensional.FixedPoint: (+) :: Num a => SQuantity s d a -> SQuantity s d a -> SQuantity s d a

+ Numeric.Units.Dimensional.FixedPoint: (+) :: forall a (s :: ExactPi') (d :: Dimension). Num a => SQuantity s d a -> SQuantity s d a -> SQuantity s d a

- Numeric.Units.Dimensional.FixedPoint: (-) :: Num a => SQuantity s d a -> SQuantity s d a -> SQuantity s d a

+ Numeric.Units.Dimensional.FixedPoint: (-) :: forall a (s :: ExactPi') (d :: Dimension). Num a => SQuantity s d a -> SQuantity s d a -> SQuantity s d a

- Numeric.Units.Dimensional.FixedPoint: (/) :: (KnownVariant v1, KnownVariant v2, KnownVariant (v1 / v2), Fractional a) => Dimensional v1 d1 a -> Dimensional v2 d2 a -> Dimensional (v1 / v2) (d1 / d2) a

+ Numeric.Units.Dimensional.FixedPoint: (/) :: forall (v1 :: Variant) (v2 :: Variant) a (d1 :: Dimension) (d2 :: Dimension). (KnownVariant v1, KnownVariant v2, KnownVariant (v1 / v2), Fractional a) => Dimensional v1 d1 a -> Dimensional v2 d2 a -> Dimensional (v1 / v2) (d1 / d2) a

- Numeric.Units.Dimensional.FixedPoint: (/~) :: forall s m d a b. (Real a, Fractional b, MinCtxt s b) => SQuantity s d a -> Unit m d b -> b

+ Numeric.Units.Dimensional.FixedPoint: (/~) :: forall (s :: ExactPi') (m :: Metricality) (d :: Dimension) a b. (Real a, Fractional b, MinCtxt s b) => SQuantity s d a -> Unit m d b -> b

- Numeric.Units.Dimensional.FixedPoint: (/~~) :: (Functor f, Real a, Fractional b, MinCtxt s b) => f (SQuantity s d a) -> Unit m d b -> f b

+ Numeric.Units.Dimensional.FixedPoint: (/~~) :: forall f a b (s :: ExactPi') (d :: Dimension) (m :: Metricality). (Functor f, Real a, Fractional b, MinCtxt s b) => f (SQuantity s d a) -> Unit m d b -> f b

- Numeric.Units.Dimensional.FixedPoint: _0 :: Num a => SQuantity s d a

+ Numeric.Units.Dimensional.FixedPoint: _0 :: forall a (s :: ExactPi') (d :: Dimension). Num a => SQuantity s d a

- Numeric.Units.Dimensional.FixedPoint: _1 :: (Integral a, KnownExactPi s) => SQuantity s DOne a

+ Numeric.Units.Dimensional.FixedPoint: _1 :: forall a (s :: ExactPi'). (Integral a, KnownExactPi s) => SQuantity s DOne a

- Numeric.Units.Dimensional.FixedPoint: _2 :: (Integral a, KnownExactPi s) => SQuantity s DOne a

+ Numeric.Units.Dimensional.FixedPoint: _2 :: forall a (s :: ExactPi'). (Integral a, KnownExactPi s) => SQuantity s DOne a

- Numeric.Units.Dimensional.FixedPoint: _3 :: (Integral a, KnownExactPi s) => SQuantity s DOne a

+ Numeric.Units.Dimensional.FixedPoint: _3 :: forall a (s :: ExactPi'). (Integral a, KnownExactPi s) => SQuantity s DOne a

- Numeric.Units.Dimensional.FixedPoint: _4 :: (Integral a, KnownExactPi s) => SQuantity s DOne a

+ Numeric.Units.Dimensional.FixedPoint: _4 :: forall a (s :: ExactPi'). (Integral a, KnownExactPi s) => SQuantity s DOne a

- Numeric.Units.Dimensional.FixedPoint: _5 :: (Integral a, KnownExactPi s) => SQuantity s DOne a

+ Numeric.Units.Dimensional.FixedPoint: _5 :: forall a (s :: ExactPi'). (Integral a, KnownExactPi s) => SQuantity s DOne a

- Numeric.Units.Dimensional.FixedPoint: _6 :: (Integral a, KnownExactPi s) => SQuantity s DOne a

+ Numeric.Units.Dimensional.FixedPoint: _6 :: forall a (s :: ExactPi'). (Integral a, KnownExactPi s) => SQuantity s DOne a

- Numeric.Units.Dimensional.FixedPoint: _7 :: (Integral a, KnownExactPi s) => SQuantity s DOne a

+ Numeric.Units.Dimensional.FixedPoint: _7 :: forall a (s :: ExactPi'). (Integral a, KnownExactPi s) => SQuantity s DOne a

- Numeric.Units.Dimensional.FixedPoint: _8 :: (Integral a, KnownExactPi s) => SQuantity s DOne a

+ Numeric.Units.Dimensional.FixedPoint: _8 :: forall a (s :: ExactPi'). (Integral a, KnownExactPi s) => SQuantity s DOne a

- Numeric.Units.Dimensional.FixedPoint: _9 :: (Integral a, KnownExactPi s) => SQuantity s DOne a

+ Numeric.Units.Dimensional.FixedPoint: _9 :: forall a (s :: ExactPi'). (Integral a, KnownExactPi s) => SQuantity s DOne a

- Numeric.Units.Dimensional.FixedPoint: abs :: Num a => SQuantity s d a -> SQuantity s d a

+ Numeric.Units.Dimensional.FixedPoint: abs :: forall a (s :: ExactPi') (d :: Dimension). Num a => SQuantity s d a -> SQuantity s d a

- Numeric.Units.Dimensional.FixedPoint: acosD :: (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

+ Numeric.Units.Dimensional.FixedPoint: acosD :: forall a b (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

- Numeric.Units.Dimensional.FixedPoint: acosVia :: (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

+ Numeric.Units.Dimensional.FixedPoint: acosVia :: forall a b c (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

- Numeric.Units.Dimensional.FixedPoint: acoshD :: (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

+ Numeric.Units.Dimensional.FixedPoint: acoshD :: forall a b (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

- Numeric.Units.Dimensional.FixedPoint: acoshVia :: (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

+ Numeric.Units.Dimensional.FixedPoint: acoshVia :: forall a b c (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

- Numeric.Units.Dimensional.FixedPoint: asinD :: (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

+ Numeric.Units.Dimensional.FixedPoint: asinD :: forall a b (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

- Numeric.Units.Dimensional.FixedPoint: asinVia :: (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

+ Numeric.Units.Dimensional.FixedPoint: asinVia :: forall a b c (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

- Numeric.Units.Dimensional.FixedPoint: asinhD :: (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

+ Numeric.Units.Dimensional.FixedPoint: asinhD :: forall a b (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

- Numeric.Units.Dimensional.FixedPoint: asinhVia :: (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

+ Numeric.Units.Dimensional.FixedPoint: asinhVia :: forall a b c (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

- Numeric.Units.Dimensional.FixedPoint: atan2D :: (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double, MinCtxt s3 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne a -> SQuantity s3 DOne b

+ Numeric.Units.Dimensional.FixedPoint: atan2D :: forall a b (s1 :: ExactPi') (s2 :: ExactPi') (s3 :: ExactPi'). (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double, MinCtxt s3 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne a -> SQuantity s3 DOne b

- Numeric.Units.Dimensional.FixedPoint: atan2Via :: forall s1 s2 s3 a b c d. (Integral a, RealFloat b, Integral c, MinCtxt s1 b, MinCtxt s2 b, MinCtxt s3 b, KnownDimension d) => Proxy b -> SQuantity s1 d a -> SQuantity s2 d a -> SQuantity s3 DOne c

+ Numeric.Units.Dimensional.FixedPoint: atan2Via :: forall (s1 :: ExactPi') (s2 :: ExactPi') (s3 :: ExactPi') a b c (d :: Dimension). (Integral a, RealFloat b, Integral c, MinCtxt s1 b, MinCtxt s2 b, MinCtxt s3 b, KnownDimension d) => Proxy b -> SQuantity s1 d a -> SQuantity s2 d a -> SQuantity s3 DOne c

- Numeric.Units.Dimensional.FixedPoint: atanD :: (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

+ Numeric.Units.Dimensional.FixedPoint: atanD :: forall a b (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

- Numeric.Units.Dimensional.FixedPoint: atanVia :: (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

+ Numeric.Units.Dimensional.FixedPoint: atanVia :: forall a b c (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

- Numeric.Units.Dimensional.FixedPoint: atanhD :: (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

+ Numeric.Units.Dimensional.FixedPoint: atanhD :: forall a b (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

- Numeric.Units.Dimensional.FixedPoint: atanhVia :: (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

+ Numeric.Units.Dimensional.FixedPoint: atanhVia :: forall a b c (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

- Numeric.Units.Dimensional.FixedPoint: changeRep :: forall v1 v2 d a b. (KnownVariant v1, KnownVariant v2, CompatibleVariants v1 v2, MinCtxt (ScaleFactor v1 / ScaleFactor v2) b, Real a, Fractional b) => Dimensional v1 d a -> Dimensional v2 d b

+ Numeric.Units.Dimensional.FixedPoint: changeRep :: forall (v1 :: Variant) (v2 :: Variant) (d :: Dimension) a b. (KnownVariant v1, KnownVariant v2, CompatibleVariants v1 v2, MinCtxt (ScaleFactor v1 / ScaleFactor v2) b, Real a, Fractional b) => Dimensional v1 d a -> Dimensional v2 d b

- Numeric.Units.Dimensional.FixedPoint: changeRepApproximate :: (KnownVariant v, Floating b) => Dimensional v d ExactPi -> Dimensional v d b

+ Numeric.Units.Dimensional.FixedPoint: changeRepApproximate :: forall (v :: Variant) b (d :: Dimension). (KnownVariant v, Floating b) => Dimensional v d ExactPi -> Dimensional v d b

- Numeric.Units.Dimensional.FixedPoint: changeRepRound :: forall v1 v2 d a b. (KnownVariant v1, KnownVariant v2, CompatibleVariants v1 v2, MinCtxt (ScaleFactor v1 / ScaleFactor v2) a, RealFrac a, Integral b) => Dimensional v1 d a -> Dimensional v2 d b

+ Numeric.Units.Dimensional.FixedPoint: changeRepRound :: forall (v1 :: Variant) (v2 :: Variant) (d :: Dimension) a b. (KnownVariant v1, KnownVariant v2, CompatibleVariants v1 v2, MinCtxt (ScaleFactor v1 / ScaleFactor v2) a, RealFrac a, Integral b) => Dimensional v1 d a -> Dimensional v2 d b

- Numeric.Units.Dimensional.FixedPoint: cosD :: (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

+ Numeric.Units.Dimensional.FixedPoint: cosD :: forall a b (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

- Numeric.Units.Dimensional.FixedPoint: cosVia :: (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

+ Numeric.Units.Dimensional.FixedPoint: cosVia :: forall a b c (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

- Numeric.Units.Dimensional.FixedPoint: coshD :: (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

+ Numeric.Units.Dimensional.FixedPoint: coshD :: forall a b (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

- Numeric.Units.Dimensional.FixedPoint: coshVia :: (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

+ Numeric.Units.Dimensional.FixedPoint: coshVia :: forall a b c (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

- Numeric.Units.Dimensional.FixedPoint: dmap :: KnownVariant v => (a1 -> a2) -> Dimensional v d a1 -> Dimensional v d a2

+ Numeric.Units.Dimensional.FixedPoint: dmap :: forall a1 a2 (d :: Dimension). KnownVariant v => (a1 -> a2) -> Dimensional v d a1 -> Dimensional v d a2

- Numeric.Units.Dimensional.FixedPoint: epsilon :: Integral a => SQuantity s d a

+ Numeric.Units.Dimensional.FixedPoint: epsilon :: forall a (s :: ExactPi') (d :: Dimension). Integral a => SQuantity s d a

- Numeric.Units.Dimensional.FixedPoint: exactValue :: Unit m d a -> ExactPi

+ Numeric.Units.Dimensional.FixedPoint: exactValue :: forall (m :: Metricality) (d :: Dimension) a. Unit m d a -> ExactPi

- Numeric.Units.Dimensional.FixedPoint: exactify :: Unit m d a -> Unit m d ExactPi

+ Numeric.Units.Dimensional.FixedPoint: exactify :: forall (m :: Metricality) (d :: Dimension) a. Unit m d a -> Unit m d ExactPi

- Numeric.Units.Dimensional.FixedPoint: expD :: (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

+ Numeric.Units.Dimensional.FixedPoint: expD :: forall a b (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

- Numeric.Units.Dimensional.FixedPoint: expVia :: (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

+ Numeric.Units.Dimensional.FixedPoint: expVia :: forall a b c (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

- Numeric.Units.Dimensional.FixedPoint: logD :: (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

+ Numeric.Units.Dimensional.FixedPoint: logD :: forall a b (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

- Numeric.Units.Dimensional.FixedPoint: logVia :: (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

+ Numeric.Units.Dimensional.FixedPoint: logVia :: forall a b c (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

- Numeric.Units.Dimensional.FixedPoint: mean :: (Fractional a, Foldable f) => f (SQuantity s d a) -> SQuantity s d a

+ Numeric.Units.Dimensional.FixedPoint: mean :: forall a f (s :: ExactPi') (d :: Dimension). (Fractional a, Foldable f) => f (SQuantity s d a) -> SQuantity s d a

- Numeric.Units.Dimensional.FixedPoint: mkUnitQ :: Fractional a => UnitName m -> Rational -> Unit m1 d a -> Unit m d a

+ Numeric.Units.Dimensional.FixedPoint: mkUnitQ :: forall a (m :: Metricality) (m1 :: Metricality) (d :: Dimension). Fractional a => UnitName m -> Rational -> Unit m1 d a -> Unit m d a

- Numeric.Units.Dimensional.FixedPoint: mkUnitR :: Floating a => UnitName m -> ExactPi -> Unit m1 d a -> Unit m d a

+ Numeric.Units.Dimensional.FixedPoint: mkUnitR :: forall a (m :: Metricality) (m1 :: Metricality) (d :: Dimension). Floating a => UnitName m -> ExactPi -> Unit m1 d a -> Unit m d a

- Numeric.Units.Dimensional.FixedPoint: mkUnitZ :: Num a => UnitName m -> Integer -> Unit m1 d a -> Unit m d a

+ Numeric.Units.Dimensional.FixedPoint: mkUnitZ :: forall a (m :: Metricality) (m1 :: Metricality) (d :: Dimension). Num a => UnitName m -> Integer -> Unit m1 d a -> Unit m d a

- Numeric.Units.Dimensional.FixedPoint: name :: Unit m d a -> UnitName m

+ Numeric.Units.Dimensional.FixedPoint: name :: forall (m :: Metricality) (d :: Dimension) a. Unit m d a -> UnitName m

- Numeric.Units.Dimensional.FixedPoint: negate :: Num a => SQuantity s d a -> SQuantity s d a

+ Numeric.Units.Dimensional.FixedPoint: negate :: forall a (s :: ExactPi') (d :: Dimension). Num a => SQuantity s d a -> SQuantity s d a

- Numeric.Units.Dimensional.FixedPoint: pi :: (Integral a, KnownExactPi s) => SQuantity s DOne a

+ Numeric.Units.Dimensional.FixedPoint: pi :: forall a (s :: ExactPi'). (Integral a, KnownExactPi s) => SQuantity s DOne a

- Numeric.Units.Dimensional.FixedPoint: rescale :: forall a b d s1 s2. (Integral a, Integral b, KnownExactPi s1, KnownExactPi s2) => SQuantity s1 d a -> SQuantity s2 d b

+ Numeric.Units.Dimensional.FixedPoint: rescale :: forall a b (d :: Dimension) (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, Integral b, KnownExactPi s1, KnownExactPi s2) => SQuantity s1 d a -> SQuantity s2 d b

- Numeric.Units.Dimensional.FixedPoint: rescaleD :: (Integral a, Integral b, KnownExactPi s1, KnownExactPi s2) => SQuantity s1 d a -> SQuantity s2 d b

+ Numeric.Units.Dimensional.FixedPoint: rescaleD :: forall a b (s1 :: ExactPi') (s2 :: ExactPi') (d :: Dimension). (Integral a, Integral b, KnownExactPi s1, KnownExactPi s2) => SQuantity s1 d a -> SQuantity s2 d b

- Numeric.Units.Dimensional.FixedPoint: rescaleFinite :: (Integral a, FiniteBits a, Integral b, FiniteBits b, KnownExactPi s1, KnownExactPi s2) => SQuantity s1 d a -> SQuantity s2 d b

+ Numeric.Units.Dimensional.FixedPoint: rescaleFinite :: forall a b (s1 :: ExactPi') (s2 :: ExactPi') (d :: Dimension). (Integral a, FiniteBits a, Integral b, FiniteBits b, KnownExactPi s1, KnownExactPi s2) => SQuantity s1 d a -> SQuantity s2 d b

- Numeric.Units.Dimensional.FixedPoint: rescaleVia :: forall a b c d s1 s2. (Integral a, RealFrac b, Floating b, Integral c, KnownExactPi s1, KnownExactPi s2) => Proxy b -> SQuantity s1 d a -> SQuantity s2 d c

+ Numeric.Units.Dimensional.FixedPoint: rescaleVia :: forall a b c (d :: Dimension) (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, RealFrac b, Floating b, Integral c, KnownExactPi s1, KnownExactPi s2) => Proxy b -> SQuantity s1 d a -> SQuantity s2 d c

- Numeric.Units.Dimensional.FixedPoint: siUnit :: forall d a. (KnownDimension d, Num a) => Unit 'NonMetric d a

+ Numeric.Units.Dimensional.FixedPoint: siUnit :: forall (d :: Dimension) a. (KnownDimension d, Num a) => Unit 'NonMetric d a

- Numeric.Units.Dimensional.FixedPoint: sinD :: (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

+ Numeric.Units.Dimensional.FixedPoint: sinD :: forall a b (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

- Numeric.Units.Dimensional.FixedPoint: sinVia :: (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

+ Numeric.Units.Dimensional.FixedPoint: sinVia :: forall a b c (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

- Numeric.Units.Dimensional.FixedPoint: sinhD :: (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

+ Numeric.Units.Dimensional.FixedPoint: sinhD :: forall a b (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

- Numeric.Units.Dimensional.FixedPoint: sinhVia :: (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

+ Numeric.Units.Dimensional.FixedPoint: sinhVia :: forall a b c (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

- Numeric.Units.Dimensional.FixedPoint: strengthen :: Unit m d a -> Maybe (Unit 'Metric d a)

+ Numeric.Units.Dimensional.FixedPoint: strengthen :: forall (m :: Metricality) (d :: Dimension) a. Unit m d a -> Maybe (Unit 'Metric d a)

- Numeric.Units.Dimensional.FixedPoint: sum :: (Num a, Foldable f) => f (SQuantity s d a) -> SQuantity s d a

+ Numeric.Units.Dimensional.FixedPoint: sum :: forall a f (s :: ExactPi') (d :: Dimension). (Num a, Foldable f) => f (SQuantity s d a) -> SQuantity s d a

- Numeric.Units.Dimensional.FixedPoint: tanD :: (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

+ Numeric.Units.Dimensional.FixedPoint: tanD :: forall a b (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

- Numeric.Units.Dimensional.FixedPoint: tanVia :: (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

+ Numeric.Units.Dimensional.FixedPoint: tanVia :: forall a b c (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

- Numeric.Units.Dimensional.FixedPoint: tanhD :: (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

+ Numeric.Units.Dimensional.FixedPoint: tanhD :: forall a b (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, Integral b, MinCtxt s1 Double, MinCtxt s2 Double) => SQuantity s1 DOne a -> SQuantity s2 DOne b

- Numeric.Units.Dimensional.FixedPoint: tanhVia :: (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

+ Numeric.Units.Dimensional.FixedPoint: tanhVia :: forall a b c (s1 :: ExactPi') (s2 :: ExactPi'). (Integral a, RealFrac b, Floating b, Integral c, MinCtxt s1 b, MinCtxt s2 b) => Proxy b -> SQuantity s1 DOne a -> SQuantity s2 DOne c

- Numeric.Units.Dimensional.FixedPoint: tau :: (Integral a, KnownExactPi s) => SQuantity s DOne a

+ Numeric.Units.Dimensional.FixedPoint: tau :: forall a (s :: ExactPi'). (Integral a, KnownExactPi s) => SQuantity s DOne a

- Numeric.Units.Dimensional.FixedPoint: type Angle16 = SQuantity (Pi * (QScale 15)) DPlaneAngle Int16

+ Numeric.Units.Dimensional.FixedPoint: type Angle16 = SQuantity Pi * QScale 15 DPlaneAngle Int16

- Numeric.Units.Dimensional.FixedPoint: type Angle32 = SQuantity (Pi * (QScale 31)) DPlaneAngle Int32

+ Numeric.Units.Dimensional.FixedPoint: type Angle32 = SQuantity Pi * QScale 31 DPlaneAngle Int32

- Numeric.Units.Dimensional.FixedPoint: type Angle8 = SQuantity (Pi * (QScale 7)) DPlaneAngle Int8

+ Numeric.Units.Dimensional.FixedPoint: type Angle8 = SQuantity Pi * QScale 7 DPlaneAngle Int8

- Numeric.Units.Dimensional.FixedPoint: type KnownDimension (d :: Dimension) = HasDimension (Proxy d)

+ Numeric.Units.Dimensional.FixedPoint: type KnownDimension (d :: Dimension) = HasDimension Proxy d

- Numeric.Units.Dimensional.FixedPoint: type Q n a = SQuantity (QScale n) DOne a

+ Numeric.Units.Dimensional.FixedPoint: type Q (n :: Natural) a = SQuantity QScale n DOne a

- Numeric.Units.Dimensional.FixedPoint: type QScale n = (One / (ExactNatural (2 ^ n)))

+ Numeric.Units.Dimensional.FixedPoint: type QScale (n :: Natural) = One / ExactNatural 2 ^ n

- Numeric.Units.Dimensional.FixedPoint: type SQuantity s = Dimensional ('DQuantity s)

+ Numeric.Units.Dimensional.FixedPoint: type SQuantity (s :: ExactPi') = Dimensional 'DQuantity s

- Numeric.Units.Dimensional.FixedPoint: type Unit (m :: Metricality) = Dimensional ('DUnit m)

+ Numeric.Units.Dimensional.FixedPoint: type Unit (m :: Metricality) = Dimensional 'DUnit m

- Numeric.Units.Dimensional.FixedPoint: type family NRoot (d :: Dimension) (x :: TypeInt)

+ Numeric.Units.Dimensional.FixedPoint: type family NRoot (d :: Dimension) (x :: TypeInt) :: Dimension

- Numeric.Units.Dimensional.FixedPoint: weaken :: Unit m d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.FixedPoint: weaken :: forall (m :: Metricality) (d :: Dimension) a. Unit m d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.Float: bisectIEEE :: IEEE a => Quantity d a -> Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional.Float: bisectIEEE :: forall a (d :: Dimension). IEEE a => Quantity d a -> Quantity d a -> Quantity d a

- Numeric.Units.Dimensional.Float: copySign :: IEEE a => Quantity d a -> Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional.Float: copySign :: forall a (d :: Dimension). IEEE a => Quantity d a -> Quantity d a -> Quantity d a

- Numeric.Units.Dimensional.Float: identicalIEEE :: IEEE a => Quantity d a -> Quantity d a -> Bool

+ Numeric.Units.Dimensional.Float: identicalIEEE :: forall a (d :: Dimension). IEEE a => Quantity d a -> Quantity d a -> Bool

- Numeric.Units.Dimensional.Float: infinity :: IEEE a => Quantity d a

+ Numeric.Units.Dimensional.Float: infinity :: forall a (d :: Dimension). IEEE a => Quantity d a

- Numeric.Units.Dimensional.Float: isDenormalized :: RealFloat a => Quantity d a -> Bool

+ Numeric.Units.Dimensional.Float: isDenormalized :: forall a (d :: Dimension). RealFloat a => Quantity d a -> Bool

- Numeric.Units.Dimensional.Float: isFiniteNumber :: RealFloat a => Quantity d a -> Bool

+ Numeric.Units.Dimensional.Float: isFiniteNumber :: forall a (d :: Dimension). RealFloat a => Quantity d a -> Bool

- Numeric.Units.Dimensional.Float: isInfinite :: RealFloat a => Quantity d a -> Bool

+ Numeric.Units.Dimensional.Float: isInfinite :: forall a (d :: Dimension). RealFloat a => Quantity d a -> Bool

- Numeric.Units.Dimensional.Float: isNaN :: RealFloat a => Quantity d a -> Bool

+ Numeric.Units.Dimensional.Float: isNaN :: forall a (d :: Dimension). RealFloat a => Quantity d a -> Bool

- Numeric.Units.Dimensional.Float: isNegativeZero :: RealFloat a => Quantity d a -> Bool

+ Numeric.Units.Dimensional.Float: isNegativeZero :: forall a (d :: Dimension). RealFloat a => Quantity d a -> Bool

- Numeric.Units.Dimensional.Float: maxFinite :: IEEE a => Quantity d a

+ Numeric.Units.Dimensional.Float: maxFinite :: forall a (d :: Dimension). IEEE a => Quantity d a

- Numeric.Units.Dimensional.Float: maxNaN :: RealFloat a => Quantity d a -> Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional.Float: maxNaN :: forall a (d :: Dimension). RealFloat a => Quantity d a -> Quantity d a -> Quantity d a

- Numeric.Units.Dimensional.Float: maxNum :: RealFloat a => Quantity d a -> Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional.Float: maxNum :: forall a (d :: Dimension). RealFloat a => Quantity d a -> Quantity d a -> Quantity d a

- Numeric.Units.Dimensional.Float: minNaN :: RealFloat a => Quantity d a -> Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional.Float: minNaN :: forall a (d :: Dimension). RealFloat a => Quantity d a -> Quantity d a -> Quantity d a

- Numeric.Units.Dimensional.Float: minNormal :: IEEE a => Quantity d a

+ Numeric.Units.Dimensional.Float: minNormal :: forall a (d :: Dimension). IEEE a => Quantity d a

- Numeric.Units.Dimensional.Float: minNum :: RealFloat a => Quantity d a -> Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional.Float: minNum :: forall a (d :: Dimension). RealFloat a => Quantity d a -> Quantity d a -> Quantity d a

- Numeric.Units.Dimensional.Float: nan :: IEEE a => Quantity d a

+ Numeric.Units.Dimensional.Float: nan :: forall a (d :: Dimension). IEEE a => Quantity d a

- Numeric.Units.Dimensional.Float: nanPayload :: IEEE a => Quantity d a -> Word64

+ Numeric.Units.Dimensional.Float: nanPayload :: forall a (d :: Dimension). IEEE a => Quantity d a -> Word64

- Numeric.Units.Dimensional.Float: nanWithPayload :: IEEE a => Word64 -> Quantity d a

+ Numeric.Units.Dimensional.Float: nanWithPayload :: forall a (d :: Dimension). IEEE a => Word64 -> Quantity d a

- Numeric.Units.Dimensional.Float: predIEEE :: IEEE a => Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional.Float: predIEEE :: forall a (d :: Dimension). IEEE a => Quantity d a -> Quantity d a

- Numeric.Units.Dimensional.Float: scaleFloat :: RealFloat a => Int -> Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional.Float: scaleFloat :: forall a (d :: Dimension). RealFloat a => Int -> Quantity d a -> Quantity d a

- Numeric.Units.Dimensional.Float: succIEEE :: IEEE a => Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional.Float: succIEEE :: forall a (d :: Dimension). IEEE a => Quantity d a -> Quantity d a

- Numeric.Units.Dimensional.Prelude: ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b

+ Numeric.Units.Dimensional.Prelude: ($!) :: (a -> b) -> a -> b

- Numeric.Units.Dimensional.Prelude: ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b

+ Numeric.Units.Dimensional.Prelude: ($) :: (a -> b) -> a -> b

- Numeric.Units.Dimensional.Prelude: (*) :: (KnownVariant v1, KnownVariant v2, KnownVariant (v1 * v2), Num a) => Dimensional v1 d1 a -> Dimensional v2 d2 a -> Dimensional (v1 * v2) (d1 * d2) a

+ Numeric.Units.Dimensional.Prelude: (*) :: forall (v1 :: Variant) (v2 :: Variant) a (d1 :: Dimension) (d2 :: Dimension). (KnownVariant v1, KnownVariant v2, KnownVariant (v1 * v2), Num a) => Dimensional v1 d1 a -> Dimensional v2 d2 a -> Dimensional (v1 * v2) (d1 * d2) a

- Numeric.Units.Dimensional.Prelude: (*~) :: Num a => a -> Unit m d a -> Quantity d a

+ Numeric.Units.Dimensional.Prelude: (*~) :: forall a (m :: Metricality) (d :: Dimension). Num a => a -> Unit m d a -> Quantity d a

- Numeric.Units.Dimensional.Prelude: (*~~) :: (Functor f, Num a) => f a -> Unit m d a -> f (Quantity d a)

+ Numeric.Units.Dimensional.Prelude: (*~~) :: forall f a (m :: Metricality) (d :: Dimension). (Functor f, Num a) => f a -> Unit m d a -> f (Quantity d a)

- Numeric.Units.Dimensional.Prelude: (+) :: Num a => Quantity d a -> Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional.Prelude: (+) :: forall a (d :: Dimension). Num a => Quantity d a -> Quantity d a -> Quantity d a

- Numeric.Units.Dimensional.Prelude: (-) :: Num a => Quantity d a -> Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional.Prelude: (-) :: forall a (d :: Dimension). Num a => Quantity d a -> Quantity d a -> Quantity d a

- Numeric.Units.Dimensional.Prelude: (/) :: (KnownVariant v1, KnownVariant v2, KnownVariant (v1 / v2), Fractional a) => Dimensional v1 d1 a -> Dimensional v2 d2 a -> Dimensional (v1 / v2) (d1 / d2) a

+ Numeric.Units.Dimensional.Prelude: (/) :: forall (v1 :: Variant) (v2 :: Variant) a (d1 :: Dimension) (d2 :: Dimension). (KnownVariant v1, KnownVariant v2, KnownVariant (v1 / v2), Fractional a) => Dimensional v1 d1 a -> Dimensional v2 d2 a -> Dimensional (v1 / v2) (d1 / d2) a

- Numeric.Units.Dimensional.Prelude: (/~) :: Fractional a => Quantity d a -> Unit m d a -> a

+ Numeric.Units.Dimensional.Prelude: (/~) :: forall a (d :: Dimension) (m :: Metricality). Fractional a => Quantity d a -> Unit m d a -> a

- Numeric.Units.Dimensional.Prelude: (/~~) :: forall f m d a. (Functor f, Fractional a) => f (Quantity d a) -> Unit m d a -> f a

+ Numeric.Units.Dimensional.Prelude: (/~~) :: forall f (m :: Metricality) (d :: Dimension) a. (Functor f, Fractional a) => f (Quantity d a) -> Unit m d a -> f a

- Numeric.Units.Dimensional.Prelude: (^) :: (Fractional a, KnownTypeInt i, KnownVariant v, KnownVariant (Weaken v)) => Dimensional v d1 a -> Proxy i -> Dimensional (Weaken v) (d1 ^ i) a

+ Numeric.Units.Dimensional.Prelude: (^) :: forall a (i :: TypeInt) (v :: Variant) (d1 :: Dimension). (Fractional a, KnownTypeInt i, KnownVariant v, KnownVariant (Weaken v)) => Dimensional v d1 a -> Proxy i -> Dimensional (Weaken v) (d1 ^ i) a

- Numeric.Units.Dimensional.Prelude: (^/) :: (KnownTypeInt n, Floating a) => Quantity d a -> Proxy n -> Quantity (NRoot d n) a

+ Numeric.Units.Dimensional.Prelude: (^/) :: forall (n :: TypeInt) a (d :: Dimension). (KnownTypeInt n, Floating a) => Quantity d a -> Proxy n -> Quantity (NRoot d n) a

- Numeric.Units.Dimensional.Prelude: _0 :: Num a => Quantity d a

+ Numeric.Units.Dimensional.Prelude: _0 :: forall a (d :: Dimension). Num a => Quantity d a

- Numeric.Units.Dimensional.Prelude: abs :: Num a => Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional.Prelude: abs :: forall a (d :: Dimension). Num a => Quantity d a -> Quantity d a

- Numeric.Units.Dimensional.Prelude: asLens :: Fractional a => Unit m d a -> forall f. Functor f => (a -> f a) -> Quantity d a -> f (Quantity d a)

+ Numeric.Units.Dimensional.Prelude: asLens :: forall a (m :: Metricality) (d :: Dimension). Fractional a => Unit m d a -> forall (f :: Type -> Type). Functor f => (a -> f a) -> Quantity d a -> f (Quantity d a)

- Numeric.Units.Dimensional.Prelude: atan2 :: RealFloat a => Quantity d a -> Quantity d a -> Dimensionless a

+ Numeric.Units.Dimensional.Prelude: atan2 :: forall a (d :: Dimension). RealFloat a => Quantity d a -> Quantity d a -> Dimensionless a

- Numeric.Units.Dimensional.Prelude: cbrt :: Floating a => Quantity d a -> Quantity (Cbrt d) a

+ Numeric.Units.Dimensional.Prelude: cbrt :: forall a (d :: Dimension). Floating a => Quantity d a -> Quantity (Cbrt d) a

- Numeric.Units.Dimensional.Prelude: changeRep :: (KnownVariant v, Real a, Fractional b) => Dimensional v d a -> Dimensional v d b

+ Numeric.Units.Dimensional.Prelude: changeRep :: forall (v :: Variant) a b (d :: Dimension). (KnownVariant v, Real a, Fractional b) => Dimensional v d a -> Dimensional v d b

- Numeric.Units.Dimensional.Prelude: changeRepApproximate :: (KnownVariant v, Floating b) => Dimensional v d ExactPi -> Dimensional v d b

+ Numeric.Units.Dimensional.Prelude: changeRepApproximate :: forall (v :: Variant) b (d :: Dimension). (KnownVariant v, Floating b) => Dimensional v d ExactPi -> Dimensional v d b

- Numeric.Units.Dimensional.Prelude: class () => Bounded a

+ Numeric.Units.Dimensional.Prelude: class Bounded a

- Numeric.Units.Dimensional.Prelude: class () => Category (cat :: k -> k -> Type)

+ Numeric.Units.Dimensional.Prelude: class Category (cat :: k -> k -> Type)

- Numeric.Units.Dimensional.Prelude: class () => Enum a

+ Numeric.Units.Dimensional.Prelude: class Enum a

- Numeric.Units.Dimensional.Prelude: class () => Eq a

+ Numeric.Units.Dimensional.Prelude: class Eq a

- Numeric.Units.Dimensional.Prelude: class () => Foldable (t :: Type -> Type)

+ Numeric.Units.Dimensional.Prelude: class Foldable (t :: Type -> Type)

- Numeric.Units.Dimensional.Prelude: class () => Functor (f :: Type -> Type)

+ Numeric.Units.Dimensional.Prelude: class Functor (f :: Type -> Type)

- Numeric.Units.Dimensional.Prelude: class () => Num a

+ Numeric.Units.Dimensional.Prelude: class Num a

- Numeric.Units.Dimensional.Prelude: class () => Read a

+ Numeric.Units.Dimensional.Prelude: class Read a

- Numeric.Units.Dimensional.Prelude: class () => Semigroup a

+ Numeric.Units.Dimensional.Prelude: class Semigroup a

- Numeric.Units.Dimensional.Prelude: class () => Show a

+ Numeric.Units.Dimensional.Prelude: class Show a

- Numeric.Units.Dimensional.Prelude: data () => Bool

+ Numeric.Units.Dimensional.Prelude: data Bool

- Numeric.Units.Dimensional.Prelude: data () => Char

+ Numeric.Units.Dimensional.Prelude: data Char

- Numeric.Units.Dimensional.Prelude: data Dimensional v :: Dimension -> Type -> Type;

+ Numeric.Units.Dimensional.Prelude: data Dimensional (v :: Variant) :: Dimension -> Type -> Type;

- Numeric.Units.Dimensional.Prelude: data () => Double

+ Numeric.Units.Dimensional.Prelude: data Double

- Numeric.Units.Dimensional.Prelude: data () => Either a b

+ Numeric.Units.Dimensional.Prelude: data Either a b

- Numeric.Units.Dimensional.Prelude: data () => Float

+ Numeric.Units.Dimensional.Prelude: data Float

- Numeric.Units.Dimensional.Prelude: data () => IO a

+ Numeric.Units.Dimensional.Prelude: data IO a

- Numeric.Units.Dimensional.Prelude: data () => Int

+ Numeric.Units.Dimensional.Prelude: data Int

- Numeric.Units.Dimensional.Prelude: data () => Integer

+ Numeric.Units.Dimensional.Prelude: data Integer

- Numeric.Units.Dimensional.Prelude: data () => Maybe a

+ Numeric.Units.Dimensional.Prelude: data Maybe a

- Numeric.Units.Dimensional.Prelude: data () => Ordering

+ Numeric.Units.Dimensional.Prelude: data Ordering

- Numeric.Units.Dimensional.Prelude: data () => Word

+ Numeric.Units.Dimensional.Prelude: data Word

- Numeric.Units.Dimensional.Prelude: error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a

+ Numeric.Units.Dimensional.Prelude: error :: HasCallStack => [Char] -> a

- Numeric.Units.Dimensional.Prelude: errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a

+ Numeric.Units.Dimensional.Prelude: errorWithoutStackTrace :: [Char] -> a

- Numeric.Units.Dimensional.Prelude: exactValue :: Unit m d a -> ExactPi

+ Numeric.Units.Dimensional.Prelude: exactValue :: forall (m :: Metricality) (d :: Dimension) a. Unit m d a -> ExactPi

- Numeric.Units.Dimensional.Prelude: exactify :: Unit m d a -> Unit m d ExactPi

+ Numeric.Units.Dimensional.Prelude: exactify :: forall (m :: Metricality) (d :: Dimension) a. Unit m d a -> Unit m d ExactPi

- Numeric.Units.Dimensional.Prelude: infixl 4 <$>

+ Numeric.Units.Dimensional.Prelude: infixl 4 <*

- Numeric.Units.Dimensional.Prelude: mean :: (Fractional a, Foldable f) => f (Quantity d a) -> Quantity d a

+ Numeric.Units.Dimensional.Prelude: mean :: forall a f (d :: Dimension). (Fractional a, Foldable f) => f (Quantity d a) -> Quantity d a

- Numeric.Units.Dimensional.Prelude: mkUnitQ :: Fractional a => UnitName m -> Rational -> Unit m1 d a -> Unit m d a

+ Numeric.Units.Dimensional.Prelude: mkUnitQ :: forall a (m :: Metricality) (m1 :: Metricality) (d :: Dimension). Fractional a => UnitName m -> Rational -> Unit m1 d a -> Unit m d a

- Numeric.Units.Dimensional.Prelude: mkUnitR :: Floating a => UnitName m -> ExactPi -> Unit m1 d a -> Unit m d a

+ Numeric.Units.Dimensional.Prelude: mkUnitR :: forall a (m :: Metricality) (m1 :: Metricality) (d :: Dimension). Floating a => UnitName m -> ExactPi -> Unit m1 d a -> Unit m d a

- Numeric.Units.Dimensional.Prelude: mkUnitZ :: Num a => UnitName m -> Integer -> Unit m1 d a -> Unit m d a

+ Numeric.Units.Dimensional.Prelude: mkUnitZ :: forall a (m :: Metricality) (m1 :: Metricality) (d :: Dimension). Num a => UnitName m -> Integer -> Unit m1 d a -> Unit m d a

- Numeric.Units.Dimensional.Prelude: nFromTo :: (Fractional a, Integral b) => Quantity d a -> Quantity d a -> b -> [Quantity d a]

+ Numeric.Units.Dimensional.Prelude: nFromTo :: forall a b (d :: Dimension). (Fractional a, Integral b) => Quantity d a -> Quantity d a -> b -> [Quantity d a]

- Numeric.Units.Dimensional.Prelude: name :: Unit m d a -> UnitName m

+ Numeric.Units.Dimensional.Prelude: name :: forall (m :: Metricality) (d :: Dimension) a. Unit m d a -> UnitName m

- Numeric.Units.Dimensional.Prelude: negate :: Num a => Quantity d a -> Quantity d a

+ Numeric.Units.Dimensional.Prelude: negate :: forall a (d :: Dimension). Num a => Quantity d a -> Quantity d a

- Numeric.Units.Dimensional.Prelude: nroot :: (KnownTypeInt n, Floating a) => Proxy n -> Quantity d a -> Quantity (NRoot d n) a

+ Numeric.Units.Dimensional.Prelude: nroot :: forall (n :: TypeInt) a (d :: Dimension). (KnownTypeInt n, Floating a) => Proxy n -> Quantity d a -> Quantity (NRoot d n) a

- Numeric.Units.Dimensional.Prelude: recip :: Fractional a => Quantity d a -> Quantity (Recip d) a

+ Numeric.Units.Dimensional.Prelude: recip :: forall a (d :: Dimension). Fractional a => Quantity d a -> Quantity (Recip d) a

- Numeric.Units.Dimensional.Prelude: seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b

+ Numeric.Units.Dimensional.Prelude: seq :: a -> b -> b

- Numeric.Units.Dimensional.Prelude: showIn :: (Show a, Fractional a) => Unit m d a -> Quantity d a -> String

+ Numeric.Units.Dimensional.Prelude: showIn :: forall a (m :: Metricality) (d :: Dimension). (Show a, Fractional a) => Unit m d a -> Quantity d a -> String

- Numeric.Units.Dimensional.Prelude: siUnit :: forall d a. (KnownDimension d, Num a) => Unit 'NonMetric d a

+ Numeric.Units.Dimensional.Prelude: siUnit :: forall (d :: Dimension) a. (KnownDimension d, Num a) => Unit 'NonMetric d a

- Numeric.Units.Dimensional.Prelude: signum :: Num a => Quantity d a -> Dimensionless a

+ Numeric.Units.Dimensional.Prelude: signum :: forall a (d :: Dimension). Num a => Quantity d a -> Dimensionless a

- Numeric.Units.Dimensional.Prelude: sqrt :: Floating a => Quantity d a -> Quantity (Sqrt d) a

+ Numeric.Units.Dimensional.Prelude: sqrt :: forall a (d :: Dimension). Floating a => Quantity d a -> Quantity (Sqrt d) a

- Numeric.Units.Dimensional.Prelude: strengthen :: Unit m d a -> Maybe (Unit 'Metric d a)

+ Numeric.Units.Dimensional.Prelude: strengthen :: forall (m :: Metricality) (d :: Dimension) a. Unit m d a -> Maybe (Unit 'Metric d a)

- Numeric.Units.Dimensional.Prelude: sum :: (Num a, Foldable f) => f (Quantity d a) -> Quantity d a

+ Numeric.Units.Dimensional.Prelude: sum :: forall a f (d :: Dimension). (Num a, Foldable f) => f (Quantity d a) -> Quantity d a

- Numeric.Units.Dimensional.Prelude: type Cbrt d = NRoot d 'Pos3

+ Numeric.Units.Dimensional.Prelude: type Cbrt (d :: Dimension) = NRoot d 'Pos3

- Numeric.Units.Dimensional.Prelude: type KnownDimension (d :: Dimension) = HasDimension (Proxy d)

+ Numeric.Units.Dimensional.Prelude: type KnownDimension (d :: Dimension) = HasDimension Proxy d

- Numeric.Units.Dimensional.Prelude: type Sqrt d = NRoot d 'Pos2

+ Numeric.Units.Dimensional.Prelude: type Sqrt (d :: Dimension) = NRoot d 'Pos2

- Numeric.Units.Dimensional.Prelude: type Unit (m :: Metricality) = Dimensional ('DUnit m)

+ Numeric.Units.Dimensional.Prelude: type Unit (m :: Metricality) = Dimensional 'DUnit m

- Numeric.Units.Dimensional.Prelude: type family NRoot (d :: Dimension) (x :: TypeInt)

+ Numeric.Units.Dimensional.Prelude: type family NRoot (d :: Dimension) (x :: TypeInt) :: Dimension

- Numeric.Units.Dimensional.Prelude: undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a

+ Numeric.Units.Dimensional.Prelude: undefined :: HasCallStack => a

- Numeric.Units.Dimensional.Prelude: weaken :: Unit m d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.Prelude: weaken :: forall (m :: Metricality) (d :: Dimension) a. Unit m d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.Quantities: cubic :: (Fractional a, Typeable m) => Unit m DLength a -> Unit 'NonMetric DVolume a

+ Numeric.Units.Dimensional.Quantities: cubic :: forall a (m :: Metricality). (Fractional a, Typeable m) => Unit m DLength a -> Unit 'NonMetric DVolume a

- Numeric.Units.Dimensional.Quantities: square :: (Fractional a, Typeable m) => Unit m DLength a -> Unit 'NonMetric DArea a

+ Numeric.Units.Dimensional.Quantities: square :: forall a (m :: Metricality). (Fractional a, Typeable m) => Unit m DLength a -> Unit 'NonMetric DArea a

- Numeric.Units.Dimensional.SIUnits: applyPrefix :: Fractional a => Prefix -> Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: applyPrefix :: forall a (d :: Dimension). Fractional a => Prefix -> Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: atto :: Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: atto :: forall a (d :: Dimension). Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: centi :: Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: centi :: forall a (d :: Dimension). Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: deca :: Num a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: deca :: forall a (d :: Dimension). Num a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: deci :: Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: deci :: forall a (d :: Dimension). Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: deka :: Num a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: deka :: forall a (d :: Dimension). Num a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: exa :: Num a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: exa :: forall a (d :: Dimension). Num a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: femto :: Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: femto :: forall a (d :: Dimension). Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: giga :: Num a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: giga :: forall a (d :: Dimension). Num a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: hecto :: Num a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: hecto :: forall a (d :: Dimension). Num a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: kilo :: Num a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: kilo :: forall a (d :: Dimension). Num a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: mega :: Num a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: mega :: forall a (d :: Dimension). Num a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: micro :: Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: micro :: forall a (d :: Dimension). Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: milli :: Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: milli :: forall a (d :: Dimension). Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: nano :: Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: nano :: forall a (d :: Dimension). Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: peta :: Num a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: peta :: forall a (d :: Dimension). Num a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: pico :: Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: pico :: forall a (d :: Dimension). Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: quecto :: Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: quecto :: forall a (d :: Dimension). Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: quetta :: Num a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: quetta :: forall a (d :: Dimension). Num a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: ronna :: Num a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: ronna :: forall a (d :: Dimension). Num a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: ronto :: Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: ronto :: forall a (d :: Dimension). Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: tera :: Num a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: tera :: forall a (d :: Dimension). Num a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: yocto :: Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: yocto :: forall a (d :: Dimension). Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: yotta :: Num a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: yotta :: forall a (d :: Dimension). Num a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: zepto :: Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: zepto :: forall a (d :: Dimension). Fractional a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.SIUnits: zetta :: Num a => Unit 'Metric d a -> Unit 'NonMetric d a

+ Numeric.Units.Dimensional.SIUnits: zetta :: forall a (d :: Dimension). Num a => Unit 'Metric d a -> Unit 'NonMetric d a

- Numeric.Units.Dimensional.UnitNames: (*) :: UnitName m1 -> UnitName m2 -> UnitName 'NonMetric

+ Numeric.Units.Dimensional.UnitNames: (*) :: forall (m1 :: Metricality) (m2 :: Metricality). UnitName m1 -> UnitName m2 -> UnitName 'NonMetric

- Numeric.Units.Dimensional.UnitNames: (/) :: UnitName m1 -> UnitName m2 -> UnitName 'NonMetric

+ Numeric.Units.Dimensional.UnitNames: (/) :: forall (m1 :: Metricality) (m2 :: Metricality). UnitName m1 -> UnitName m2 -> UnitName 'NonMetric

- Numeric.Units.Dimensional.UnitNames: (^) :: UnitName m -> Int -> UnitName 'NonMetric

+ Numeric.Units.Dimensional.UnitNames: (^) :: forall (m :: Metricality). UnitName m -> Int -> UnitName 'NonMetric

- Numeric.Units.Dimensional.UnitNames: asAtomic :: UnitName m -> Maybe (NameAtom ('UnitAtom m))

+ Numeric.Units.Dimensional.UnitNames: asAtomic :: forall (m :: Metricality). UnitName m -> Maybe (NameAtom ('UnitAtom m))

- Numeric.Units.Dimensional.UnitNames: grouped :: UnitName m -> UnitName 'NonMetric

+ Numeric.Units.Dimensional.UnitNames: grouped :: forall (m :: Metricality). UnitName m -> UnitName 'NonMetric

- Numeric.Units.Dimensional.UnitNames: reduce :: UnitName m -> UnitName m

+ Numeric.Units.Dimensional.UnitNames: reduce :: forall (m :: Metricality). UnitName m -> UnitName m

- Numeric.Units.Dimensional.UnitNames: relax :: forall m1 m2. (Typeable m1, Typeable m2) => UnitName m1 -> Maybe (UnitName m2)

+ Numeric.Units.Dimensional.UnitNames: relax :: forall (m1 :: Metricality) (m2 :: Metricality). (Typeable m1, Typeable m2) => UnitName m1 -> Maybe (UnitName m2)

- Numeric.Units.Dimensional.UnitNames: strengthen :: UnitName m -> Maybe (UnitName 'Metric)

+ Numeric.Units.Dimensional.UnitNames: strengthen :: forall (m :: Metricality). UnitName m -> Maybe (UnitName 'Metric)

- Numeric.Units.Dimensional.UnitNames: weaken :: UnitName m -> UnitName 'NonMetric

+ Numeric.Units.Dimensional.UnitNames: weaken :: forall (m :: Metricality). UnitName m -> UnitName 'NonMetric

- Numeric.Units.Dimensional.Variants: type CompatibleVariants v1 v2 = ('True ~ AreCompatible v1 v2)

+ Numeric.Units.Dimensional.Variants: type CompatibleVariants (v1 :: Variant) (v2 :: Variant) = 'True ~ AreCompatible v1 v2

Files

CHANGELOG.md +6/−1
dimensional.cabal +6/−4

CHANGELOG.md view

@@ -1,5 +1,10 @@+1.6.2 (2026-01)+---------------++* Support for GHC 9.14;+ 1.6.1 (2024-10)--------------+---------------  * Fixed an issue where `Control.DeepSeq.Unit`, exported as of version 1.5.1.0, conflicts with `Numeric.Units.Dimensional.Unit` (#228). * Fixed broken links to the Tau and Pi manifestos (#229).

dimensional.cabal view

@@ -1,5 +1,5 @@ name:                dimensional-version:             1.6.1+version:             1.6.2 license:             BSD3 license-file:        LICENSE copyright:           Bjorn Buckwalter 2006-2024@@ -15,9 +15,11 @@                      GHC == 9.0.2,                      GHC == 9.2.8,                      GHC == 9.4.8,-                     GHC == 9.6.6,-                     GHC == 9.8.2,-                     GHC == 9.10.1+                     GHC == 9.6.7,+                     GHC == 9.8.4,+                     GHC == 9.10.3,+                     GHC == 9.12.2,+                     GHC == 9.14.1 build-type:          Simple  description: