Question

对于我在F＃中取得的所有进展，我仍然迷失在各种构造函数和解构函数语法中。

我正在运行递归模拟。其中一个参数是停止条件的函数。我有各种可能的停止条件可供选择。我让它们都有相同的签名。因此，我认为将这些函数锁定为自定义类型会很好，也很有教育意义 - 因此，不仅可以发送符合签名的任何函数：

type StoppingCondition = | StoppingCondition of (ReturnType -> ReturnType -> int -> float -> bool)

我认为我正在这样做，从教程，具有类型名称和相同的构造函数名称（令人困惑的......），对于单个案例区分联合。但现在我无法弄清楚如何将这种类型应用于实际函数：

let Condition1 lastRet nextRet i fl =
    true

如何使Condition1成为StoppingCondition类型？我打赌这是微不足道的。但是我尝试将StoppingCondition作为let之后的第一个，第二个或最后一个术语，无论有没有parens和冒号。一切都是错误的。

感谢您在这里找到的耐心。

编辑：

我会尝试综合我从四个答案中得到的东西（截至当下），一切都很好：

试图模仿这种模式：

s : string = "abc"

我试着写：

type StoppingCondition = | StoppingCondition of (ReturnType -> ReturnType -> int -> float -> bool)

let condition1 lastRet nextRet i fl : StoppingCondition =  // BAD 
    //wrong for a type alias, totally wrong for a union constructor
    true
    //or
let condition1 : StoppingCondition lastRet nextRet i fl = // BAD again
    true

或: Stopping Condition的其他插入（尝试以构造函数的方式为其添加前缀，在该行中）。

现在，我知道要获得我所得到的东西，我必须这样做：

type StoppingCondition = | StoppingCondition of (ReturnType -> ReturnType -> int -> float -> bool)
let conditionFunc1 lastRet nextRet i fl =   //...
    true
let stoppingCondition1 = StoppingCondition conditionFunc1 
    //or
let stoppingCondition2 = StoppingCondition <| (func lastRet nextRet i fl -> false) 
    //and there's another variation or 2 below

而我并不认为这种方法的一个重大缺点是联合类型与类型别名的不同之处。类型别名of string在声明时允许字符串函数 - 它实际上是一个字符串并且“字符串事物。单个案例区分联合of string - 不再是字符串。要拥有它你需要解开它的“字符串”。（或者将这些函数的版本写入你的类型（可能是字符串函数的包装）。）同样，我的函数的类型别名接受这些参数。我的函数的DU是只是一个包装器，不带参数。所以这不适用于有区别的联合：

let x = stoppingCondition1 ret1 ret2 2 3.0 // BAD
    //"stoppingCondition1 is not a function and cannot be applied"

在我的案例中，没有足够的价值来解决包装器问题。但类型别名有效：

type StoppingAlias = ReturnType -> ReturnType -> int -> float -> bool
let stoppingCondition:StoppingAlias = fun prevRet nextRet i x -> true
let b = stoppingCondition ret1 ret2 10 1.0  // b = true

在我刚才所说的内容中，我可能没有一切，但我认为我更接近了。

编辑2：

旁注。我的问题是关于定义函数的类型。它使用类型别名和联合类型进行比较。当我努力做到这些时，我也学会了使用类型别名：

这有效（来自：https://fsharpforfunandprofit.com/posts/defining-functions/）：

type Adder = decimal -> decimal -> decimal
let f1 : Adder = (fun x y -> x + y)
    //or
let f2 : decimal -> decimal -> decimal = fun x y -> x + y

但这些都是错误的：

let (f2 : Adder) x y = x + y    // bad 
let (f3 x y) : (decimal -> decimal -> decimal) = x + y   // bad 
let (f3 : (decimal -> decimal -> decimal)) x y  = x + y  // bad

关于整个问题的一些讨论：F# Type declaration possible ala Haskell?

（而且，是的，“分配类型”也不是正确的说法。）

Answer 1

你不能使它成为＆＃34; StoppingCondition。声明类型StoppingCondition的值并传递Condition1作为DU case构造函数的参数：

let stop = StoppingCondition Condition1

但是，这意味着，每次要访问单个DU案例中包含的函数时，都必须以某种方式对其进行模式匹配;这会变得很烦人。

您说您不希望任何履行签名的功能作为停止条件有效;然而，它似乎足够具体，以避免＆＃34;意外＆＃34;传入一个不合适的＆＃34;函数 - 用它，你可以做一些更简单的事情 - 将StoppingCondition定义为特定函数类型的类型别名：

type StoppingCondition = ReturnType -> ReturnType -> int -> float -> bool

现在，您可以在需要的任何地方使用StoppingCondition来指定类型，并且您传递/返回的实际值可以是符合签名ReturnType -> ReturnType -> int -> float -> bool的任何函数。

Answer 2

指定函数的返回类型如下：

let Condition1 lastRet nextRet i fl :StoppingCondition=
    true

当然，这不会编译，因为true不是正确的类型。

我怀疑你想要的实际定义更接近

let Condition1  :StoppingCondition=
    true

但是，因为它看起来像包含函数参数。

对此进行扩展，您可以定义如下函数：

let Condition1=fun a b c d -> StoppingCondition(fun a b c d -> whatever)

但这整件事非常难看。

实际上，我认为最好将所有函数放在一个数组中，这将强制类型匹配

Answer 3

如前所述，您必须从适当的函数构造StoppingCondition的实例，例如：

let Condition1 = StoppingCondition (fun _ _ _ _ -> true)`

在没有奇怪的缩进或额外括号的情况下执行此操作的一个好方法是反向管道：

let Condition1 = StoppingCondition <| fun lastRet nextRet i fl ->
    // Add function code here

签名可能足够长，足以证明记录类型而不是四个curried参数。这是一个风格问题以及它将如何被使用;结果可能如下所示：

type MyInput =
    { LastReturn : ReturnType
      NextReturn : ReturnType
      MyInt      : int
      MyFloat    : float }

type StopCondition = StopCondition of (MyInput -> bool)

let impossibleCondition = StopCondition (fun _ -> false)

let moreComplicatedCondition = StopCondition <| fun inp ->
    inp.MyInt < int (round inp.MyFloat)

要在StopCondition内调用该函数，请使用模式打开它：

let testStopCondition (StopCondition c) input = c input

Answer 4

所以，在我看来，你可能希望用StoppingCondition来创建一些预定义类型的停止条件。

以下是一些可能的停止条件的一些例子：

let stopWhenNextGreaterThanLast = StoppingCondition (fun last next _ _ -> next > last)

let stopWhenLastGreaterThanLast = StoppingCondition (fun last next _ _ -> last> next)

（我已经强调了我在停止条件定义中没有使用的参数）

希望您可以看到StoppingCondition类型的这两个值。

然后你可能想要一个函数来确定是否在给定一些参数的情况下满足停止条件：

let shouldStop stoppingCond last next i value = 
    match stoppingCond with
    |StoppingCondition f -> f last next i value

此函数采用停止条件和递归的各种状态，并返回true或false，具体取决于它是否应该停止。

这应该是在实践中使用这种方法所需的全部。

你可以通过这样做来扩展这种方法，以涵盖多种潜在的停止条件：

type StoppingCondition =
    | StoppingCondition of (ReturnType -> ReturnType -> int -> float -> bool)
    | Or of StoppingCondition * StoppingCondition

修改shouldStop功能

let rec shouldStop stoppingCond last next i value = 
    match stoppingCond with
    |StoppingCondition f -> f last next i value
    |Or (stp1, stp2) -> (shouldStop stp1 last next i value) || (shouldStop stp2 last next i value)

现在，如果我们有一个条件，我们会在满足时停止，或者如果我们有多个条件，我们可以检查是否满足其中任何条件。

然后你可以Or从基本条件中let stopWhenIIsEven = StoppingCondition (fun _ _ i _ -> i % 2 = 0) let stopWhenValueIsZero = StoppingCondition (fun _ _ _ value -> value = 0.0) let stopWhenIEvenOrValueZero = Or (stopWhenIIsEven, stopWhenValueIsZero)新的停止条件：

if(isChrome){
     // alert("Chrome is detected");
     $("#exitbutton").trigger('click'); //
}

F＃将（自定义）类型赋值给函数

4 个答案: