Question

Is it possible to somehow create a pow function for measure types?
The pow function in f# only takes int as parameter, and then pow function in the Math class takes a float – but dosent allow float<cm>.

I first thought that:

let rec myPow(x:float<cm>,y:int) =
    if y = 0 then x
    else myPow(x*x, y - 1)

might work out, but its obvious that each time it come across the else line it will change the return type.

Any suggestions?

Answer 1

Ankur is correct – you cannot do this (without resorting to hacks that would break units).

Maybe a clearer description of the problem is that the type of pow function would depend on the value of the argument and F# doesn’t allow you to do this. You could imagine this would work if were using just literals as the second argument, but it would become tricky if you used expressions:

pow a 3 // Assuming a = 1.0<cm>, the return type is float<cm ^ 3>
pow a n // Assuming a = 1.0<cm>, the return type is float<cm ^ n>

In the second case the value n would have to appear in the type!

You can use some nasty tricks (inspired by this Haskell article), but it becomes a bit crazy. Instead of using numeric literals, you’d use something like S(S(S(N))) to represent the number 3. This way, you can bring the number into the type. You probably don’t want to do this, but here is an example:

[<Measure>] type cm

// Represents a number with units of measure powered to the
// number's value (e.g "(S (S O))" has type Num<cm, cm^3>)
type Num<[<Measure>] 'M, [<Measure>] 'N> = 
  | O_ of int * float<'N>
  | S_ of int * Num<'M, 'N / 'M>

// Constructors that hide that simplify the creation  
let O : Num<'M, 'M> = O_ (1, 0.0<_>)
let S n = match n with O_(i, _) | S_(i, _) -> S_(i + 1, n)

// Type-safe power function with units of measure
let pow (x:float<'M>) ((O_(i, _) | S_(i, _)):Num<'M, 'M 'N>) : float<'M 'N> =
  // Unsafe hacky implementation, which is hidden
  // from the user (for simplicity)
  unbox ((float x) ** float i)

let res = pow 2.0<cm> (S (S O))

EDIT: I posted the source code to F# snippets, so that you can see the inferred types: http://fssnip.net/4H