soc - 5 months ago 26

Java 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

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`

.