F# type definition with expression

Question

Is it possible to express something like this:

type id = int > 0

I know its not possible to do statically, since this would mean F# has dependent types. In C# I'm used to do this sort of thing with code contracts and get a runtime enforcement. I'm looking for something similiar here.

Thanks

EDIT: Thank you for all the answers which have various pros and cons. At the monent I'm only using a small subset of F#, a subset of the ocaml core that lends itself easily to program proofs. So no classes.

Answer 1

Contrary to what others said, I would suggest not using classes here, if I understood your problem correctly.
Since the value is immutable, we need applying constraint only once. Any wrapper classes would be an overhead and load GC. Instead, a simple function will do the job:

let inline constrained predicate errormessage value =
    if not (predicate value)
    then invalidArg "value" errormessage
    else value

let positive =
    constrained (fun x -> x > 0) "Value must be positive"

let int1 = positive 5      // OK
let int2 = positive -3     // ArgumentException

You can do the same for other types:

let mustBeLong =
    constrained (fun (x:string) -> x.Length > 3) "String must be long"

let str1 = mustBeLong "foobar"  // OK
let str2 = mustBeLong "baz"     // ArgumentException

Using the same within a struct:

type Point2D =
   struct 
      val X: int
      val Y: int
      new(x: int, y: int) = { X = positive x; Y = positive y }
   end

let point1 = Point2D(5, 3)  // OK
let point2 = Point2D(5, -2) // ArgumentException

Answer 2

Define it as a union type:

type Id = Id of int

and shadow the constructor with another function:

let Id n =
  assert(n > 0)
  Id n

Answer 3

In F#, you have to resort to classes and check arguments inside constructors. Other types such as discriminated unions, records and structs have implicit constructors which you can't easily alter.

type Id(i: int) =
    do if i <= 0 then 
         invalidArg "i" "the argument has to be a positive integer"
    member x.Value = i

Pattern matching doesn't play nicely with classes. You can remedy the problem using active patterns:

let (|Id|) (id: Id) = id.Value

let id = Id(1)

match id with
| Id 1 -> printfn "matched"
| _ -> printfn "unmatched"