F# 为函数分配(自定义)类型

Question

尽管我在 F# 中取得了所有进展，但我仍然迷失在各种构造函数和解构函数语法中。

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

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

我认为我做对了，从教程中，对于单个区分联合的情况，具有类型名称和相同的构造函数名称(令人困惑......(。但是现在我不知道如何将这种类型应用于实际函数：

let Condition1 lastRet nextRet i fl =
    true

如何使条件 1 的类型为停止条件？我敢打赌这是微不足道的。但是我尝试将 StoppingCondition 作为 let 之后的第一个、第二个或最后一个术语，带或不带括号和冒号。一切都是错误。

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

编辑：

我将尝试综合我从四个答案(截至此刻(中得出的结论，一切都很好：

尝试模仿此模式：

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# 类型声明可能阿拉哈斯克尔？

(而且，是的，"分配类型"也不是正确的说法。

Answer 1

你不会"让它成为类型"StoppingCondition。声明一个类型为 StoppingCondition 的值，并将 Condition1 作为 DU case 构造函数的参数传递：

let stop = StoppingCondition Condition1

然而，这意味着，每次你想访问单个DU案例中包含的函数时，你必须以某种方式对它进行模式匹配;这可能会变得烦人。

你

说你不希望任何满足签名的函数作为停止条件有效;但是，它似乎足够具体，以避免"意外"传入"不合适"的函数 - 有了这个，你可以做一些更简单的事情 - 定义StoppingCondition作为特定函数类型的类型别名：

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

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

Answer 2

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

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

没有奇怪的缩进或额外括号的一种很好的方法是向后管道：

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

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

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 3

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

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 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)