Performance of single-constructor disjoint union in fsharp - performance

Question

I try to wrap up a primitive type in a single-constructor disjoint union with members:
type T = | T of int
with
member inline this.add k =
let (T i) = this
T (i+k)
member inline this.ret =
let (T i) = this
i
I do this to get type safety (not all primitive values are meaningful to me), and because in some settings it is nice to get to pretend the value is an object (e.g., you get to override ToString()).
I was expecting the compiler to remove the overhead of the unnecessary tag T, but it doesn't seem to be doing that. I try the following two functions, one using the members, one deconstructing and working on the int value 'by hand'. When I disassmble (using fasmi), I get the assembly on the right:
let byMembers (c : Card) =
let d = c.add 0xcafebabe L0000: push rbx
let e = d.add 0xcafebab0 L0001: mov ebx, [rdi+8]
e.ret L0004: mov rdi, 0x1147adb08
L000e: call 0x00000001047b6c10
L0013: add ebx, 0xcafebabe
L0019: mov [rax+8], ebx
L001c: mov ebx, [rax+8]
L001f: mov rdi, 0x1147adb08
L0029: call 0x00000001047b6c10
L002e: lea edi, [rbx-0x35014550]
L0034: mov [rax+8], edi
L0037: mov eax, [rax+8]
L003a: pop rbx
L003b: ret
let byHand (Card i) =
let d = i + 0xcafebabe L0000: mov eax, [rdi+8]
let e = d + 0xcafebab0 L0003: add eax, 0x95fd756e
e L0008: ret
When I benchmark these, I get unsurprisingly that byHand runs at roughly .66 the time of byMembers, which is undesirable for my actual application.
Am I doing it wrong with the type T? Is there a way to type-safely abstract a primitive type in f# such that the compiled output would have no overhead compare to the 'raw' implementation?

Answer 1

Add [<Struct>]:
[<Struct>] // <--- here
type T = | T of int
with
member inline this.add k =
let (T i) = this
T (i+k)
member inline this.ret =
let (T i) = this
i
Disassembling, we find byMembers has been optimized down to essentials:
let byMembers (c : T) =
let d = c.add 0xcafebabe L0000: add edi, 0xcafebabe
let e = d.add 0xcafebab0 L0006: lea eax, [rdi-0x35014550]
e.ret L000c: ret
NB! The [<Struct>] attribute causes T to be stack-allocated and get pass-by-value semantics; presumably this is why the optimizer can remove the unnecessary tag.
The [<Struct>] attribute also applies to records and classes, with the same meaning, and yield the desired performance characteristics also in that setting. In this case, there is neater syntax available via the struct keyword.
Documentation here.