The number 0, polymorphic in its dimension. Use of this will often require a type annotation.

Add two compatible quantities

Subtract two compatible quantities

Take the sum of a list of quantities

Negate a quantity

Multiply two quantities

Divide two quantities

Multiply a quantity by a scalar from the left

Multiply a quantity by a scalar from the right

Divide a scalar by a quantity

Divide a quantity by a scalar

Raise a quantity to a integer power, knowing at compile time that the integer is non-negative.

Raise a quantity to a integer power known at compile time

Take the n'th root of a quantity, where n is known at compile time

Square a quantity

Cube a quantity

Take the square root of a quantity

Take the cubic root of a quantity

Compare two quantities

Check if one quantity is less than a compatible one

Check if one quantity is greater than a compatible one

Check if one quantity is less than or equal to a compatible one

Check if one quantity is greater than or equal to a compatible one

Check if two quantities are equal (uses the equality of the underlying numerical type)

Check if two quantities are not equal

Compare two compatible quantities for approximate equality. If the difference between the left hand side and the right hand side arguments are less than or equal to the epsilon, they are considered equal.

Compare two compatible quantities for approixmate inequality. qNapprox e a b = not $ qApprox e a b

Extracts a numerical value from a dimensioned quantity, expressed in the given unit. For example:

inMeters :: Length -> Double
inMeters x = numIn x Meter

or

inMeters x = x # Meter

Infix synonym for numIn

Creates a dimensioned quantity in the given unit. For example:

height :: Length
height = quOf 2.0 Meter

or

height = 2.0 % Meter

Infix synonym for quOf

Show a dimensioned quantity in a given unit. (The default Show instance always uses units as specified in the LCSU.)

The number 1, expressed as a unitless dimensioned quantity.

Cast between equivalent dimension within the same CSU. for example [kg m s] and [s m kg]. See the README for more info.

Dimension-keeping cast between different CSUs.

Use this to choose a default LCSU for a dimensioned quantity. The default LCSU uses the DefaultUnitOfDim representation for each dimension.

Compute the argument in the DefaultLCSU, and present the result as lcsu-polymorphic dimension-polymorphic value. Named constant because one of its dominant usecase is to inject constant quantities into dimension-polymorphic expressions.

Multiply two units to get another unit. For example: type MetersSquared = Meter :* Meter

Divide two units to get another unit

Raise a unit to a power, known at compile time

Multiply a conversion ratio by some constant. Used for defining prefixes.

A class for user-defined prefixes

Multiply two quantity types to produce a new one. For example:

type Velocity = Length %/ Time

Divide two quantity types to produce a new one

Exponentiate a quantity type to an integer

Qu adds a dimensional annotation to its numerical value type n. This is the representation for all quantities.

Make a quantity type capable of storing a value of a given unit. This uses a Double for storage of the value. For example:

data LengthDim = LengthDim
instance Dimension LengthDim
data Meter = Meter
instance Unit Meter where
  type BaseUnit Meter = Canonical
  type DimOfUnit Meter = LengthDim
type instance DefaultUnitOfDim LengthDim = Meter
type Length = MkQu_D LengthDim

Note that the dimension must have an instance for the type family DefaultUnitOfDim for this to work.

Make a quantity type with a custom numerical type and LCSU.

Make a quantity type with a given unit. It will be stored as a Double. Note that the corresponding dimension must have an appropriate instance for DefaultUnitOfDim for this to work.

Make a quantity type with a unit and LCSU with custom numerical type. The quantity will have the dimension corresponding to the unit.

This class is used to mark abstract dimensions, such as Length, or Mass.

Dummy type use just to label canonical units. It does not have a Unit instance.

The dimension for the dimensionless quantities. It is also called "quantities of dimension one", but One is confusing with the type-level integer One.

The unit for unitless dimensioned quantities

The type of unitless dimensioned quantities. This is an instance of Num, though Haddock doesn't show it. This is parameterized by an LCSU and a number representation.

Convert a raw number into a unitless dimensioned quantity

Make a local consistent set of units. The argument is a type-level list of tuple types, to be interpreted as an association list from dimensions to units. For example:

type MyLCSU = MkLCSU '[(Length, Foot), (Mass, Gram), (Time, Year)]

Assign a default unit for a dimension. Necessary only when using default LCSUs.

Check if an LCSU has consistent entries for the given unit. i.e. can the lcsu describe the unit?

Check if an LCSU can express the given dimension

Like ConvertibleLCSUs, but takes a dimension, not a dimension factors.

Check if the DefaultLCSU can convert into the given one, at the given dimension.

Check if the DefaultLCSU can convert into the given one, at the given unit.

Extract a dimension specifier from a list of factors

Extract a unit specifier from a list of factors

Extract a unit from a dimension factor list and an LCSU

The datatype for type-level integers.

Add one to an integer

Subtract one from an integer

Add two integers

Subtract two integers

Multiply two integers

Divide two integers

Negate an integer

This is the singleton value representing Zero at the term level and at the type level, simultaneously. Used for raising units to powers.

Add one to a singleton Z.

Subtract one from a singleton Z.

Negate a singleton Z.