What are the strategies to support/integrate units of measurements in languages?

Question

I wonder from purely language-design point of view which "features" (semantically and syntactically) an "implementation" of SI units would require.

Which "functionality" is generally expected if someone claims that a language has great support for units of measurements?

• Just something like special literals or syntactic sugar?
• Special conventions which make units typesafe (but without costly runtime wrapping)?
• A special math mode for computations with fractions?
• Automatic conversions and coercion between units?

For instance F# has integrated support for units of measurements in the language. How does it improve over e. g. a library for Java?

Which features should be built into the languages to improve usability of units? Which features are not necessarily related to units of measurement but make an implementation nicer?

Answer 1

F#'s advantage over a Java UOM library is simple - type safety. You will get compile-time errors if you attempt to add 3.<s> and 4.<m / s>.

In F#, UOM are erased after the type-checking, because it is the only .NET language with such feature.

In reply to comment, here is a simple fraction type and its usage:

type Fraction<[<Measure>] 'a>(a : int, b : int) =
    member __.Divisor = a
    member __.Dividend = b
    member __.AsFloat = float a / float b
    static member (*) (a : Fraction<'a>, b : Fraction<'b>) : Fraction<'a * 'b> =
        Fraction(a.Divisor * b.Divisor, a.Dividend * b.Dividend)

type [<Measure>] m
type [<Measure>] kg
type [<Measure>] s

let a = Fraction<m / s>(4, 3)
let b = Fraction<kg>(2, 5)
let ``a times b`` = a * b

And the value returned is of type Fraction<kg m/s> and its AsFloat value is 0.5333333333.

Answer 2

From a language-design point of view, it's enough to be able to :

1. tag data types with arbitrary labels (not just string or other primitive labels, but arbitrarily structured labels)
2. perform arbitrary compile-time calculations on labels
3. given operand labels and an operator (function), calculate the label of the result of the function applied to labelled operands

This all can be done and was done more than 10 years ago with C++ template metaprogramming.

There's also an implementation for Haskell that uses Haskell's (limited) ability to perform compile-time calculations over typeclass instances. It's not as complete though (AFAIK no fractional powers and no non-SI units).