Question

是否可以表达这样的内容：

type id = int > 0

我知道静态不可能，因为这意味着F＃具有依赖类型。在C＃中，我习惯于使用代码契约来执行此类操作并获得运行时实施。我正在寻找类似的东西。

由于

编辑：感谢所有有各种利弊的答案。在那里，我只使用F＃的一小部分，这是ocaml核心的一个子集，可以很容易地编程证明。所以没有课程。

Answer 1

与其他人所说的相反，如果我理解你的问题，我会建议不要在这里使用课程。
由于值是 immutable ，我们只需要应用约束一次。任何包装类都是开销和加载GC。相反，一个简单的功能将完成这项工作：

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

您可以对其他类型执行相同的操作：

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

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

在结构中使用相同的内容：

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

将其定义为联合类型：

type Id = Id of int

并用另一个函数遮蔽构造函数：

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

Answer 3

在F＃中，你必须求助于类并检查构造函数内部的参数。其他类型，例如有区别的联合，记录和结构都有隐式构造函数，你不能轻易改变它们。

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

模式匹配与类不兼容。您可以使用活动模式解决问题：

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

let id = Id(1)

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

Answer 4

您可以像这样创建一个通用类：

type verify<'t>(t:'t,cond) =
    let mutable tval = t
    let _verify v = if not (cond v) then failwith "bad argument"
    do _verify tval
    member x.get() = tval
    member x.set v =
        _verify v 
        tval <- v

然后您可以将其与

一起使用

verify(1,fun t -> t>0)

使用.set将重新检查条件。

带表达式的F＃类型定义

4 个答案: