Bit Shifting with units of measure in F# - f#

Question

I have three types of position - called Position, WalkPosition and TilePosition. I've converted them to units of measure, and it is much cleaner, but some things just don't quite work for me.
Unfortunately, I'm not using purely F# (there's a C++ interface exposed via CLI - fun times!). Firstly, for converting in and out, I've used * 1<tile> and * 1<1/tile> because I noticed a performance hit on my use of int. That's all well and good until I start trying to do interesting things with generics. I'm currently stumped by the getApproxDistance function, with an operator I'm calling |~|. This version assumes no unit of measure attached to my Position:
[<Measure>] type pixel
[<Measure>] type walk
[<Measure>] type tile
module Position =
type Position<[<Measure>] 'u> = Pos of int<'u> * int<'u> with
static member inline (+) (Pos (x1, y1), Pos (x2, y2)) = Pos (x1 + x2, y1 + y2)
static member inline (-) (Pos (x1, y1), Pos (x2, y2)) = Pos (x1 - x2, y1 - y2)
static member inline (*) (Pos (x, y), f) = Pos (x * f, y * f)
static member inline (/) (Pos (x, y), d) = Pos (x / d, y / d)
// getApproxDistance as per Starcraft: Broodwar
static member (|~|) (Pos (x1, y1), Pos (x2, y2)) =
let xDist = abs (x1 - x2)
let yDist = abs (y1 - y2)
let largeDist, smallDist = max xDist yDist, min xDist yDist
if smallDist < (largeDist >>> 2) then largeDist
else
let smallCalc = (3*smallDist) >>> 3
((smallCalc >>> 5) + smallCalc + largeDist - (largeDist >>> 4) - (largeDist >>> 6))
// Precise length calc - may be slow
static member inline (|-|) (Pos (x1, y1), Pos (x2, y2)) =
pown (x1 - x2) 2 + pown (y1 - y2) 2 |> float |> sqrt
let inline posx (Pos (_x, _)) = _x
let inline posy (Pos (_, _y)) = _y
let PixelPerWalk : int<pixel/walk> = 8<pixel/walk>
let PixelPerTile : int<pixel/tile> = 32<pixel/tile>
let WalkPerTile : int<walk/tile> = 4<walk/tile>
let inline walkToPixel (pos:Position<_>) = pos * PixelPerWalk
let inline tileToPixel (pos:Position<_>) = pos * PixelPerTile
let inline pixelToWalk (pos:Position<_>) = pos / PixelPerWalk
let inline tileToWalk (pos:Position<_>) = pos * WalkPerTile
let inline pixelToTile (pos:Position<_>) = pos / PixelPerTile
let inline walkToTile (pos:Position<_>) = pos / WalkPerTile
let example = Pos (1<walk>, 2<walk>) |~| Pos (2<walk>, 1<walk>)
I'd be content to rip the unit of measure off (|> int doesn't seem to slow it down in this scenario) and add it back on the returned distance, but it seems I can't do that. I can't even overload an inline call, because you can't overload purely on units of measure. Ideas?

Answer 1

The error that you are seeing is because the units of measure in your |~| function are being constrained to 1. This means that an int<walk> is not a valid input to this function.
You are correct that the int function will strip units of measure from something of type int<'u>. What you may not be aware of is that you can use LanguagePrimitives.Int32WithMeasure<'u> to add a particular unit of measure.
You can therefore write |~|:
static member (|~|) (Pos (x1 : int<'u>, y1 : int<'u>), Pos (x2 : int<'u>, y2 : int<'u>)) =
let xDist = abs (int x1 - int x2)
let yDist = abs (int y1 - int y2)
let largeDist, smallDist = max xDist yDist, min xDist yDist
if smallDist < (largeDist >>> 2) then
largeDist
|> LanguagePrimitives.Int32WithMeasure<'u>
else
let smallCalc = (3*smallDist) >>> 3
((smallCalc >>> 5) + smallCalc + largeDist - (largeDist >>> 4) - (largeDist >>> 6))
|> LanguagePrimitives.Int32WithMeasure<'u>
Your example:
let example = Pos (1<walk>, 2<walk>) |~| Pos (2<walk>, 1<walk>)
This then has the correct type: int<walk>.
You shouldn't need to worry about the performance impact of stripping away/adding units of measure, they are just a compile time construct - unit of measure information is not retained at runtime.
By the way, you also don't really need all of those inline keywords everywhere, you aren't doing anything with statically resolved type parameters, see https://msdn.microsoft.com/en-us/library/dd548047.aspx for more detail about use of inline.