2

我正在查看我的教授给出的关于语言 SML 的一些注释,其中一个函数如下所示:

fun max gt = 
    let fun lp curr [] = curr
           | lp curr (a::l) = if gt(a,curr)
                             then lp a l
                             else lp curr l
in
    lp
end

有人可以帮助解释这是在做什么吗?我最困惑的是这条线:

    let fun lp curr [] = curr

这到底是什么意思?据我所知,有一个函数被调用lp,但这是什么curr []意思?这些是论据吗?如果是这样,您不是只允许sml中的一个参数吗?

4

2 回答 2

8

这意味着这lp是一个带有 2 个参数的函数,第一个是curr,第二个是一个列表,从逻辑上讲,它可能是空的 ( []) 或包含至少一个元素((a::l)是列表的模式,a其中头,列表的其余部分是l)

如果要将那段 FP 代码翻译成某种著名的命令式语言,它看起来像:

function lp(curr, lst) {
  if (lst.length == 0) {  
    return curr;
  } else {
    var a = lst[0];                   // first element
    var l = lst.slice(1, lst.length); // the rest
    if (gt(a, curr)) {
      return lp(a, l);
    } else {
      return lp(curr, l)
    }
  }
}

相当拗口,但它是一个忠实的翻译。

函数式语言基于Lambda 演算,其中函数只取一个值并返回一个结果。虽然 SML 和其他 FP 语言基于此理论,但在实践中相当不方便,因此其中许多语言允许您通过所谓的Currying将多个参数传递给函数。

所以是的,在 ML 函数中实际上只取一个值,但是柯里化可以让你模拟多个参数。

让我们创建一个名为 的函数add,它添加 2 个数字:

fun add a b = a + b

应该这样做,但我们定义了 2 个参数。是什么类型的add?如果你看一下 REPL,它是val add = fn : int -> int -> int. 其中写道,“add 是一个函数,它接受一个 int 并返回另一个函数(它接受一个 int 并返回一个 int)”

所以我们也可以这样定义add

fun add a = 
  fn b => a + b

你会发现它们是相似的。事实上,可以肯定地说,前者在某种程度上是后者的语法糖。因此,您在 ML 中定义的所有函数,即使是具有多个参数的函数,实际上也是具有一个参数的函数,它们返回接受第二个参数的函数,依此类推。一开始有点难以适应,但很快就会成为第二天性。

fun add a b = a + b  (* add is of type  int -> int -> int *)

add 1 2 (* returns 3 as you expect *)

(* calling add with only one parameter *)

val add1 = add 1

是什么add1?这是一个将添加到您传递给它的单个参数的函数!1

add1 2 (* returns 3 *)

这是一个部分应用的例子,你正在调用一个函数,一次一个参数,每次返回,另一个函数接受其余的参数。

此外,还有另一种方法可以显示多个参数:元组:

(1, 2);     (* evaluates to a tuple of (int,int) *)

fun add (a,b) = a + b;

add (1, 2)  (* passing a SINGLE argument to a function that
               expects only a single argument, a tuple of 2 numbers *)

在您的问题中,lp 也可以实现为lp (curr, someList)

fun max gt curr lst = 
    let fun lp (curr, []) = curr
          | lp (curr, (a::l)) = if gt(a,curr) then lp (a, l)
                                else lp (curr, l)
in
    lp (curr, lst)
end

请注意,在这种情况下,我们必须声明maxmax gt curr lst

在您发布的代码中,lp显然是用柯里化实现的。而 max它本身的类型是fn: ('a * 'a -> bool) -> 'a -> 'a list -> 'a. 把它分开:

('a * 'a -> bool) ->  (* passed to 'max' as 'gt' *)   
    'a ->             (* passed to 'lp' as 'curr' *)
       'a list ->     (* passed to 'lp' as 'someList' *)
          'a          (* what 'lp' returns (same as what 'max' itself returns) *)

注意 的类型gt第一个参数maxfn : (('a * 'a) -> bool)- 它是一个参数的函数,('a * 'a)一个 2 的元组,'a它返回一个'a. 所以这里没有咖喱。

使用哪个是品味、惯例和实际考虑的问题。

希望这可以帮助。

于 2013-01-21T07:39:28.960 回答
4

只是从 Faiz 的出色回答中澄清一下柯里化。

如前所述,SML 仅允许函数采用 1 个参数。这样做的原因是因为函数fun foo x = x实际上是 (语法糖) 的派生形式val rec foo = fn x => x。好吧,实际上这并不完全正确,但让我们保持简单一秒钟

现在以这个幂函数为例。这里我们声明函数“接受两个参数”

fun pow n 0 = 1 
  | pow n k = n * pow n (k-1)

如上所述,fun ...是一个派生形式,因此幂函数的等价形式是

val rec pow = fn n => fn k => ...

正如您可能在这里看到的,我们在表达原始函数声明的两种不同模式匹配时遇到了问题,因此我们不能再保持它“简单”了,fun声明的真正等价形式是

val rec pow = fn n => fn k =>
    case (n, k) of 
      (n, 0) => 1
    | (n, k) => n * pow n (k-1)

为了完整起见,cases其实也是一种派生形式,以匿名函数为等价形式

val rec pow = fn n => fn k => 
    (fn (n,0) => 1
      | (n,k) => n * pow n (k-1)) (n,k)

请注意,(n,k)它直接应用于最内部的匿名函数。

于 2013-01-21T12:41:37.377 回答