Comment author: @xavierleroy

This representation optimization has been considered before. Unclear to me
that a special case is warranted. Similar efficiency can be achieved
by "type color = int", possibly with a signature constraint to make "color"
abstract.

Comment author: Christophe

type color = Color of int
let dark = function Color i -> Color (i+1)

but...

module Color : sig
type color
val of_int : int -> color
val to_int : color -> int
end = struct
type color = int
let of_int x = x
let to_int x = x end

let dark c = Color.of_int (Color.to_int c + 1)

this is a more complex code just for efficiency ! This makes difficult to use primitive types without merging them (just say type color = int).
This is specially true when I want several different ints or strings or something primitive... The use of a constructor as a flag is very useful in those cases.

Comment author: n8gray

I think Christophe makes the case for this pretty well, but I just wanted to add my support. I keep wanting to use this sort of construct for units:

type cm = Cm of float
type inch = Inch of float
let in_of_cm (Cm f) = Inch (0.393700787 *. f)
let cm_of_in (Inch f) = Cm (2.54 *. f)
...

I would argue that guaranteeing an efficient representation for this would lead to more reliable software, since programmers wouldn't have to worry about killing performance with needless boxing ops, even in low-level math code.

Update: Fixed my math! (blush)

Comment author: @mshinwell

Fixed by #606