网站界面设计规划wordpress 标签分类

在文章map和filter里，谈到SML系统实现的map和filter方法使用的Currying这个特性。

那Currying柯里化特性是什么，到底有什么好处，让系统函数这样写？

在计算机科学中，柯里化（英语：Currying），是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术。

比如fun f (x, y, z) = x+y+z, 函数f，接受三个参数x, y, z，返回x + y + z表达式的值， 类型是int * int * int -> int。调用方式：val result = f (1, 3, 5), result结果为9.

 函数柯里化后变成这样

fun f x = fn y =>  fn z => x + y + z,   f函数接受参数x, 返回一个函数，这个函数接受参数y，返回一个函数，这个函数接受z， 返回x + y + z表达式的值。类型是 int -> int -> int -> int （等同于int -> (int -> (int -> int))。 柯里化函数可以部分参数调用。

val result = f 1, result结果为函数，类型是 int -> int -> int。

val result1 = result 3, result1 结果为函数，类型是int -> int

val result2 = result1 5,  result2结果为9， 是一个int值。

下面是另一个例子：

(* 接受三个参数或者说接受一个tuple的函数Sorted3_tuple *)
fun Sorted3_tuple (x, y, z) = z >= y andalso y >= x(* 将Sorted3_tuple函数柯里化 *）
val Sorted3 = fn x => fn y => fn z => z >= y andalso y >= xval t2 = ((Sorted3 7) 9) 11(* f v1 v2 v3等同于 ((f v1) v2) v3 *)
val t3 = Sorted3 7 9 11(* Sorted3_nicer是Sorted3的语法糖，更简洁的写出柯里化函数 *）
fun Sorted3_nicer x y z = z >= y andalso y>= xval t4 = Sorted3_nicer 7 9 11

柯里化更简洁，支持部分参数调用。

SML库中, List.map, List.filter, List.fold1函数都是柯里化函数。

例如val non_negate = List.filter(fn x => x <> 0), non_negate是一个函数，接受一个int list, 过滤掉这个list中的0值，返回一个int list.

一个柯里化函数和非柯里化函数进行转换：

fun f (x, y, z) = .... 这个函数已经定义好了，如何柯里化调用这个函数

fun curry f x y z = f (x, y, z) ， 

f x y z = ... 这个柯里化函数已经定义好了，如何非柯里化调用这个函数

fun uncurry f (x, y, z) = f x y z

如何调换柯里化函数顺序

fun other_curry f x y = f y x

柯里化非常灵活，那它的性能如何呢？

是直接多个参数调用更快还是柯里化调用更快？这个取决于语言的实现。 在SML中，对性能至关重要的部分，直接调用多个参数比柯里化调用更快，但他们都是常量级别的。

柯里化的缺陷：

如果使用柯里化函数部分调用参数来创建多态函数，则由于值的限制，它可能不起作用。

编译的时候（REPL）会出现警报：

Warning about "type vars not generalized"(类型变量未通用)。

因此，一旦开始使用这些带有部分参数调用的多态柯里化函数，您可能会遇到称为The Value Restriction值限制的东西。如果没有它，类型系统就会崩溃，为什么会崩溃，需要看下语言type checking的机制。

这个问题只出现返回函数是多态函数的时候。

这个特性会让你很奇怪：你没有做错，但是必须改变你的代码。

比如我们运用List.map柯里化函数的调用获得一个函数

List.map的类型是( 'a -> 'b) -> 'a list -> 'b list

运用柯里化思想，如下代码，pariWithOne应该是一个函数，我们有理由推测类型是 'a list -> ('a * int)  list

val pairWithOne = List.map (fn x => (x, 1))

但实际上，这个函数在编译的时候会报warning

partial_application.sml:12.5-12.44 Warning: type vars not generalized because of
   value restriction are instantiated to dummy types (X1,X2,...)

在REPL中显示的真实类型是：

val pairWithOne = fn : ?.X1 list -> (?.X1 * int) list

调用此函数，系统也会报错， 因为这个函数不能被调用。

- pairWithOne [1, 2, 3];
stdIn:3.1-3.22 Error: operator and operand do not agree [overload - bad instantiation]
  operator domain: ?.X1 list
  operand:         'Z[INT] list
  in expression:
    pairWithOne (1 :: 2 :: 3 :: nil)

上面这个问题是SML语言的一个不完美的地方。

那如何解决这个问题呢？

这里提供两种方法

fun pairWithOne xs = List.map (fn x => (x,1)) xs

函数显示声明类型

val pairWith1 : string list -> (string * int) list = List.map(fn x => (x, 1))

可能有人想像下面这样写，直接type checking错误， 显示声明的类型变量

val pairWith2 : 'a list -> ('a * int) list = List.map(fn x => (x, 1))