MeasurementDecorator

public struct MeasurementDecorator<UnitType> where UnitType : Unit

Extending standard structures like Measurement with properties like var meters is convenient:

it avoids extracting value without explicit conversion to a certain unit
it simplifies getting value from an optional Measurement But it is also risky because these extensions might conflict with extensions from other libraries or Apple. This decorator mitigates the risk of conflicts while providing a short, readable code. Typical use cases are:
extracting value from a value representing a unit of measure: let optionalDistanceInMeters = distance?.tt.meters
performing computations on values representing units of measure: cumulativeDistance += anotherDistance.tt
comparing values representing units of measure: if delay < .tt.seconds(5) {}
combining value extraction and typecast: let intValue = distance.tt.intValue(in: .meters)

Lifecycle

init(measurement:)
Create a MeasurementDecorator given a specified measurement.
Declaration
Swift

public init(measurement: Measurement<UnitType>)

Public

measurement
Measurement with some UnitType.
Declaration
Swift

public let measurement: Measurement<UnitType>

Available where `UnitType`: `Dimension`

intValue(in:)
A convenience method to perform both conversion to Int and conversion to the specified unit.
- let intValue = distance?.tt.intValue(in: .meters)
Declaration
Swift

public func intValue(in unit: UnitType) -> Int
floatValue(in:)
Convenient method to always convert before getting value and allow optional chaining.
- let optionalFloatValueInMeters = distance?.tt.floatValue(in: .meters)
Declaration
Swift

public func floatValue(in unit: UnitType) -> Float
doubleValue(in:)
Convenient method to always convert before getting value and allow optional chaining.
- let optionalDoubleValueInMeters = distance?.tt.doubleValue(in: .meters)
Declaration
Swift

public func doubleValue(in unit: UnitType) -> Double

Available where `UnitType` == `TTUnitElectricEfficiency`


                    
                    
                    kilowattHoursPer100Kilometers(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func kilowattHoursPer100Kilometers(_ value: Double) -> Measurement<UnitType>


                    
                    
                    kilowattHoursPerKilometer(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func kilowattHoursPerKilometer(_ value: Double) -> Measurement<UnitType>


                    
                    
                    kilometersPerKilowattHour(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func kilometersPerKilowattHour(_ value: Double) -> Measurement<UnitType>


                    
                    
                    milesPerKilowattHour(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func milesPerKilowattHour(_ value: Double) -> Measurement<UnitType>

kilowattHoursPer100Kilometers
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var kilowattHoursPer100Kilometers: Double { get }
kilowattHoursPerKilometer
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var kilowattHoursPerKilometer: Double { get }
kilometersPerKilowattHour
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var kilometersPerKilowattHour: Double { get }
milesPerKilowattHour
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var milesPerKilowattHour: Double { get }

Available where `UnitType` == `TTUnitEnergyDensity`


                    
                    
                    megaJoulePerLiter(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func megaJoulePerLiter(_ value: Double) -> Measurement<UnitType>


                    
                    
                    kiloJoulePerLiter(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func kiloJoulePerLiter(_ value: Double) -> Measurement<UnitType>


                    
                    
                    joulePerLiter(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func joulePerLiter(_ value: Double) -> Measurement<UnitType>


                    
                    
                    kiloCaloriesPerLiter(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func kiloCaloriesPerLiter(_ value: Double) -> Measurement<UnitType>


                    
                    
                    caloriesPerLiter(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func caloriesPerLiter(_ value: Double) -> Measurement<UnitType>

megaJoulePerLiter
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var megaJoulePerLiter: Double { get }
kiloJoulePerLiter
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var kiloJoulePerLiter: Double { get }
joulePerLiter
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var joulePerLiter: Double { get }
kilocaloriesPerLiter
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var kilocaloriesPerLiter: Double { get }
caloriesPerLiter
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var caloriesPerLiter: Double { get }

Available where `UnitType` == `TTUnitFuelPerTime`


                    
                    
                    litersPerHour(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func litersPerHour(_ value: Double) -> Measurement<UnitType>


                    
                    
                    gallonsPerHour(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func gallonsPerHour(_ value: Double) -> Measurement<UnitType>


                    
                    
                    imperialGallonsPerHour(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func imperialGallonsPerHour(_ value: Double) -> Measurement<UnitType>

litersPerHour
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var litersPerHour: Double { get }
gallonsPerHour
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var gallonsPerHour: Double { get }
imperialGallonsPerHour
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var imperialGallonsPerHour: Double { get }

Available where `UnitType` == `UnitAngle`


                    
                    
                    degrees(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func degrees(_ value: Double) -> Measurement<UnitType>


                    
                    
                    arcMinutes(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func arcMinutes(_ value: Double) -> Measurement<UnitType>


                    
                    
                    arcSeconds(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func arcSeconds(_ value: Double) -> Measurement<UnitType>


                    
                    
                    radians(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func radians(_ value: Double) -> Measurement<UnitType>


                    
                    
                    gradians(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func gradians(_ value: Double) -> Measurement<UnitType>


                    
                    
                    revolutions(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func revolutions(_ value: Double) -> Measurement<UnitType>

degrees
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var degrees: Double { get }
arcMinutes
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var arcMinutes: Double { get }
arcSeconds
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var arcSeconds: Double { get }
radians
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var radians: Double { get }
gradians
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var gradians: Double { get }
revolutions
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var revolutions: Double { get }

Available where `UnitType` == `UnitDuration`


                    
                    
                    hours(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func hours(_ value: Double) -> Measurement<UnitType>


                    
                    
                    minutes(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func minutes(_ value: Double) -> Measurement<UnitType>


                    
                    
                    seconds(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func seconds(_ value: Double) -> Measurement<UnitType>


                    
                    
                    milliseconds(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func milliseconds(_ value: Double) -> Measurement<UnitType>


                    
                    
                    microseconds(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func microseconds(_ value: Double) -> Measurement<UnitType>


                    
                    
                    nanoseconds(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func nanoseconds(_ value: Double) -> Measurement<UnitType>


                    
                    
                    picoseconds(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func picoseconds(_ value: Double) -> Measurement<UnitType>


                    
                    
                    date(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func date(_ value: Date) -> Measurement<UnitType>

hours
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var hours: Double { get }
minutes
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var minutes: Double { get }
seconds
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var seconds: Double { get }
milliseconds
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var milliseconds: Double { get }
microseconds
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var microseconds: Double { get }
nanoseconds
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var nanoseconds: Double { get }
picoseconds
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var picoseconds: Double { get }
date
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var date: Date { get }

Available where `UnitType` == `UnitElectricCurrent`


                    
                    
                    megaamperes(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func megaamperes(_ value: Double) -> Measurement<UnitType>


                    
                    
                    kiloamperes(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func kiloamperes(_ value: Double) -> Measurement<UnitType>


                    
                    
                    amperes(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func amperes(_ value: Double) -> Measurement<UnitType>


                    
                    
                    milliamperes(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func milliamperes(_ value: Double) -> Measurement<UnitType>


                    
                    
                    microamperes(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func microamperes(_ value: Double) -> Measurement<UnitType>

megaamperes
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var megaamperes: Double { get }
kiloamperes
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var kiloamperes: Double { get }
amperes
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var amperes: Double { get }
milliamperes
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var milliamperes: Double { get }
microamperes
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var microamperes: Double { get }

Available where `UnitType` == `UnitElectricPotentialDifference`


                    
                    
                    megavolts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func megavolts(_ value: Double) -> Measurement<UnitType>


                    
                    
                    kilovolts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func kilovolts(_ value: Double) -> Measurement<UnitType>


                    
                    
                    volts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func volts(_ value: Double) -> Measurement<UnitType>


                    
                    
                    millivolts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func millivolts(_ value: Double) -> Measurement<UnitType>


                    
                    
                    microvolts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func microvolts(_ value: Double) -> Measurement<UnitType>

megavolts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var megavolts: Double { get }
kilovolts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var kilovolts: Double { get }
volts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var volts: Double { get }
millivolts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var millivolts: Double { get }
microvolts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var microvolts: Double { get }

Available where `UnitType` == `UnitEnergy`


                    
                    
                    kilojoules(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func kilojoules(_ value: Double) -> Measurement<UnitType>


                    
                    
                    joules(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func joules(_ value: Double) -> Measurement<UnitType>


                    
                    
                    kilocalories(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func kilocalories(_ value: Double) -> Measurement<UnitType>


                    
                    
                    calories(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func calories(_ value: Double) -> Measurement<UnitType>


                    
                    
                    kilowattHours(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func kilowattHours(_ value: Double) -> Measurement<UnitType>

kilojoules
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var kilojoules: Double { get }
joules
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var joules: Double { get }
kilocalories
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var kilocalories: Double { get }
calories
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var calories: Double { get }
kilowattHours
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var kilowattHours: Double { get }

Available where `UnitType` == `UnitFuelEfficiency`


                    
                    
                    litersPer100Kilometers(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func litersPer100Kilometers(_ value: Double) -> Measurement<UnitType>


                    
                    
                    milesPerImperialGallon(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func milesPerImperialGallon(_ value: Double) -> Measurement<UnitType>


                    
                    
                    milesPerGallon(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func milesPerGallon(_ value: Double) -> Measurement<UnitType>

litersPer100Kilometers
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var litersPer100Kilometers: Double { get }
milesPerImperialGallon
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var milesPerImperialGallon: Double { get }
milesPerGallon
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var milesPerGallon: Double { get }

Available where `UnitType` == `UnitLength`


                    
                    
                    megameters(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func megameters(_ value: Double) -> Measurement<UnitType>


                    
                    
                    kilometers(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func kilometers(_ value: Double) -> Measurement<UnitType>


                    
                    
                    hectometers(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func hectometers(_ value: Double) -> Measurement<UnitType>


                    
                    
                    decameters(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func decameters(_ value: Double) -> Measurement<UnitType>


                    
                    
                    meters(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func meters(_ value: Double) -> Measurement<UnitType>


                    
                    
                    decimeters(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func decimeters(_ value: Double) -> Measurement<UnitType>


                    
                    
                    centimeters(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func centimeters(_ value: Double) -> Measurement<UnitType>


                    
                    
                    millimeters(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func millimeters(_ value: Double) -> Measurement<UnitType>


                    
                    
                    micrometers(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func micrometers(_ value: Double) -> Measurement<UnitType>


                    
                    
                    nanometers(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func nanometers(_ value: Double) -> Measurement<UnitType>


                    
                    
                    picometers(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func picometers(_ value: Double) -> Measurement<UnitType>


                    
                    
                    inches(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func inches(_ value: Double) -> Measurement<UnitType>


                    
                    
                    feet(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func feet(_ value: Double) -> Measurement<UnitType>


                    
                    
                    yards(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func yards(_ value: Double) -> Measurement<UnitType>


                    
                    
                    miles(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func miles(_ value: Double) -> Measurement<UnitType>


                    
                    
                    scandinavianMiles(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func scandinavianMiles(_ value: Double) -> Measurement<UnitType>


                    
                    
                    lightyears(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func lightyears(_ value: Double) -> Measurement<UnitType>


                    
                    
                    nauticalMiles(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func nauticalMiles(_ value: Double) -> Measurement<UnitType>


                    
                    
                    fathoms(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func fathoms(_ value: Double) -> Measurement<UnitType>


                    
                    
                    furlongs(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func furlongs(_ value: Double) -> Measurement<UnitType>


                    
                    
                    astronomicalUnits(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func astronomicalUnits(_ value: Double) -> Measurement<UnitType>


                    
                    
                    parsecs(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func parsecs(_ value: Double) -> Measurement<UnitType>

megameters
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var megameters: Double { get }
kilometers
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var kilometers: Double { get }
hectometers
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var hectometers: Double { get }
decameters
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var decameters: Double { get }
meters
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var meters: Double { get }
decimeters
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var decimeters: Double { get }
centimeters
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var centimeters: Double { get }
millimeters
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var millimeters: Double { get }
micrometers
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var micrometers: Double { get }
nanometers
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var nanometers: Double { get }
picometers
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var picometers: Double { get }
inches
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var inches: Double { get }
feet
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var feet: Double { get }
yards
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var yards: Double { get }
miles
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var miles: Double { get }
scandinavianMiles
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var scandinavianMiles: Double { get }
lightyears
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var lightyears: Double { get }
nauticalMiles
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var nauticalMiles: Double { get }
fathoms
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var fathoms: Double { get }
furlongs
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var furlongs: Double { get }
astronomicalUnits
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var astronomicalUnits: Double { get }
parsecs
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var parsecs: Double { get }

Available where `UnitType` == `UnitMass`


                    
                    
                    kilograms(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func kilograms(_ value: Double) -> Measurement<UnitType>


                    
                    
                    grams(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func grams(_ value: Double) -> Measurement<UnitType>


                    
                    
                    decigrams(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func decigrams(_ value: Double) -> Measurement<UnitType>


                    
                    
                    centigrams(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func centigrams(_ value: Double) -> Measurement<UnitType>


                    
                    
                    milligrams(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func milligrams(_ value: Double) -> Measurement<UnitType>


                    
                    
                    micrograms(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func micrograms(_ value: Double) -> Measurement<UnitType>


                    
                    
                    nanograms(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func nanograms(_ value: Double) -> Measurement<UnitType>


                    
                    
                    picograms(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func picograms(_ value: Double) -> Measurement<UnitType>


                    
                    
                    ounces(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func ounces(_ value: Double) -> Measurement<UnitType>


                    
                    
                    pounds(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func pounds(_ value: Double) -> Measurement<UnitType>


                    
                    
                    stones(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func stones(_ value: Double) -> Measurement<UnitType>


                    
                    
                    metricTons(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func metricTons(_ value: Double) -> Measurement<UnitType>


                    
                    
                    shortTons(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func shortTons(_ value: Double) -> Measurement<UnitType>


                    
                    
                    carats(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func carats(_ value: Double) -> Measurement<UnitType>


                    
                    
                    ouncesTroy(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func ouncesTroy(_ value: Double) -> Measurement<UnitType>


                    
                    
                    slugs(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func slugs(_ value: Double) -> Measurement<UnitType>

kilograms
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var kilograms: Double { get }
grams
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var grams: Double { get }
decigrams
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var decigrams: Double { get }
centigrams
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var centigrams: Double { get }
milligrams
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var milligrams: Double { get }
micrograms
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var micrograms: Double { get }
nanograms
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var nanograms: Double { get }
picograms
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var picograms: Double { get }
ounces
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var ounces: Double { get }
pounds
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var pounds: Double { get }
stones
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var stones: Double { get }
metricTons
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var metricTons: Double { get }
shortTons
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var shortTons: Double { get }
carats
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var carats: Double { get }
ouncesTroy
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var ouncesTroy: Double { get }
slugs
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var slugs: Double { get }

Available where `UnitType` == `UnitPower`


                    
                    
                    terawatts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func terawatts(_ value: Double) -> Measurement<UnitType>


                    
                    
                    gigawatts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func gigawatts(_ value: Double) -> Measurement<UnitType>


                    
                    
                    megawatts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func megawatts(_ value: Double) -> Measurement<UnitType>


                    
                    
                    kilowatts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func kilowatts(_ value: Double) -> Measurement<UnitType>


                    
                    
                    watts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func watts(_ value: Double) -> Measurement<UnitType>


                    
                    
                    milliwatts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func milliwatts(_ value: Double) -> Measurement<UnitType>


                    
                    
                    microwatts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func microwatts(_ value: Double) -> Measurement<UnitType>


                    
                    
                    nanowatts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func nanowatts(_ value: Double) -> Measurement<UnitType>


                    
                    
                    picowatts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func picowatts(_ value: Double) -> Measurement<UnitType>


                    
                    
                    femtowatts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func femtowatts(_ value: Double) -> Measurement<UnitType>


                    
                    
                    horsepower(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func horsepower(_ value: Double) -> Measurement<UnitType>

terawatts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var terawatts: Double { get }
gigawatts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var gigawatts: Double { get }
megawatts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var megawatts: Double { get }
kilowatts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var kilowatts: Double { get }
watts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var watts: Double { get }
milliwatts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var milliwatts: Double { get }
microwatts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var microwatts: Double { get }
nanowatts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var nanowatts: Double { get }
picowatts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var picowatts: Double { get }
femtowatts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var femtowatts: Double { get }
horsepower
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var horsepower: Double { get }

Available where `UnitType` == `UnitSpeed`


                    
                    
                    metersPerSecond(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func metersPerSecond(_ value: Double) -> Measurement<UnitType>


                    
                    
                    kilometersPerHour(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func kilometersPerHour(_ value: Double) -> Measurement<UnitType>


                    
                    
                    milesPerHour(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func milesPerHour(_ value: Double) -> Measurement<UnitType>


                    
                    
                    knots(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func knots(_ value: Double) -> Measurement<UnitType>

metersPerSecond
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var metersPerSecond: Double { get }
kilometersPerHour
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var kilometersPerHour: Double { get }
milesPerHour
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var milesPerHour: Double { get }
knots
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var knots: Double { get }

Available where `UnitType` == `UnitInformationStorage`


                    
                    
                    kilobytes(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func kilobytes(_ value: Double) -> Measurement<UnitType>


                    
                    
                    megabytes(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func megabytes(_ value: Double) -> Measurement<UnitType>


                    
                    
                    gigabytes(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func gigabytes(_ value: Double) -> Measurement<UnitType>

kilobytes
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var kilobytes: Double { get }
megabytes
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var megabytes: Double { get }
gigabytes
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var gigabytes: Double { get }

Available where `UnitType` == `UnitVolume`


                    
                    
                    megaliters(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func megaliters(_ value: Double) -> Measurement<UnitType>


                    
                    
                    kiloliters(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func kiloliters(_ value: Double) -> Measurement<UnitType>


                    
                    
                    liters(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func liters(_ value: Double) -> Measurement<UnitType>


                    
                    
                    deciliters(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func deciliters(_ value: Double) -> Measurement<UnitType>


                    
                    
                    centiliters(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func centiliters(_ value: Double) -> Measurement<UnitType>


                    
                    
                    milliliters(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func milliliters(_ value: Double) -> Measurement<UnitType>


                    
                    
                    cubicKilometers(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func cubicKilometers(_ value: Double) -> Measurement<UnitType>


                    
                    
                    cubicMeters(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func cubicMeters(_ value: Double) -> Measurement<UnitType>


                    
                    
                    cubicDecimeters(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func cubicDecimeters(_ value: Double) -> Measurement<UnitType>


                    
                    
                    cubicCentimeters(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func cubicCentimeters(_ value: Double) -> Measurement<UnitType>


                    
                    
                    cubicMillimeters(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func cubicMillimeters(_ value: Double) -> Measurement<UnitType>


                    
                    
                    cubicInches(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func cubicInches(_ value: Double) -> Measurement<UnitType>


                    
                    
                    cubicFeet(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func cubicFeet(_ value: Double) -> Measurement<UnitType>


                    
                    
                    cubicYards(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func cubicYards(_ value: Double) -> Measurement<UnitType>


                    
                    
                    cubicMiles(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func cubicMiles(_ value: Double) -> Measurement<UnitType>


                    
                    
                    acreFeet(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func acreFeet(_ value: Double) -> Measurement<UnitType>


                    
                    
                    bushels(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func bushels(_ value: Double) -> Measurement<UnitType>


                    
                    
                    teaspoons(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func teaspoons(_ value: Double) -> Measurement<UnitType>


                    
                    
                    tablespoons(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func tablespoons(_ value: Double) -> Measurement<UnitType>


                    
                    
                    fluidOunces(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func fluidOunces(_ value: Double) -> Measurement<UnitType>


                    
                    
                    cups(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func cups(_ value: Double) -> Measurement<UnitType>


                    
                    
                    pints(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func pints(_ value: Double) -> Measurement<UnitType>


                    
                    
                    quarts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func quarts(_ value: Double) -> Measurement<UnitType>


                    
                    
                    gallons(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func gallons(_ value: Double) -> Measurement<UnitType>


                    
                    
                    imperialTeaspoons(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func imperialTeaspoons(_ value: Double) -> Measurement<UnitType>


                    
                    
                    imperialTablespoons(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func imperialTablespoons(_ value: Double) -> Measurement<UnitType>


                    
                    
                    imperialFluidOunces(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func imperialFluidOunces(_ value: Double) -> Measurement<UnitType>


                    
                    
                    imperialPints(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func imperialPints(_ value: Double) -> Measurement<UnitType>


                    
                    
                    imperialQuarts(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func imperialQuarts(_ value: Double) -> Measurement<UnitType>


                    
                    
                    imperialGallons(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func imperialGallons(_ value: Double) -> Measurement<UnitType>


                    
                    
                    metricCups(_:)

A shortcut to shorten measurement creation.

Declaration

Swift

public static func metricCups(_ value: Double) -> Measurement<UnitType>

megaliters
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var megaliters: Double { get }
kiloliters
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var kiloliters: Double { get }
liters
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var liters: Double { get }
deciliters
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var deciliters: Double { get }
centiliters
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var centiliters: Double { get }
milliliters
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var milliliters: Double { get }
cubicKilometers
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var cubicKilometers: Double { get }
cubicMeters
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var cubicMeters: Double { get }
cubicDecimeters
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var cubicDecimeters: Double { get }
cubicCentimeters
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var cubicCentimeters: Double { get }
cubicMillimeters
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var cubicMillimeters: Double { get }
cubicInches
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var cubicInches: Double { get }
cubicFeet
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var cubicFeet: Double { get }
cubicYards
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var cubicYards: Double { get }
cubicMiles
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var cubicMiles: Double { get }
acreFeet
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var acreFeet: Double { get }
bushels
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var bushels: Double { get }
teaspoons
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var teaspoons: Double { get }
tablespoons
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var tablespoons: Double { get }
fluidOunces
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var fluidOunces: Double { get }
cups
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var cups: Double { get }
pints
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var pints: Double { get }
quarts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var quarts: Double { get }
gallons
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var gallons: Double { get }
imperialTeaspoons
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var imperialTeaspoons: Double { get }
imperialTablespoons
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var imperialTablespoons: Double { get }
imperialFluidOunces
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var imperialFluidOunces: Double { get }
imperialPints
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var imperialPints: Double { get }
imperialQuarts
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var imperialQuarts: Double { get }
imperialGallons
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var imperialGallons: Double { get }
metricCups
A convenient way to always convert before extracting the value.

Getting a value from Measurement without conversion to the expected unit is error-prone. It requires verifying the context during the PR. To simplify the code, keep the data in Measurement and convert using this method whenever need a value.
Declaration
Swift

public var metricCups: Double { get }

MeasurementDecorator

Lifecycle

Declaration

Public

Declaration

Available where UnitType: Dimension

Declaration

Declaration

Declaration

Available where UnitType == TTUnitElectricEfficiency

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Available where UnitType == TTUnitEnergyDensity

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Available where UnitType == TTUnitFuelPerTime

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Available where UnitType == UnitAngle

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Available where UnitType == UnitDuration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Available where UnitType == UnitElectricCurrent

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Declaration

Available where UnitType == UnitElectricPotentialDifference

Declaration

Declaration

Available where `UnitType`: `Dimension`

Available where `UnitType` == `TTUnitElectricEfficiency`

Available where `UnitType` == `TTUnitEnergyDensity`

Available where `UnitType` == `TTUnitFuelPerTime`

Available where `UnitType` == `UnitAngle`

Available where `UnitType` == `UnitDuration`

Available where `UnitType` == `UnitElectricCurrent`

Available where `UnitType` == `UnitElectricPotentialDifference`

Available where `UnitType` == `UnitEnergy`

Available where `UnitType` == `UnitFuelEfficiency`

Available where `UnitType` == `UnitLength`