多参数构造函数是否比单个元组参数构造函数有用?
Is a multiple argument constructor ever useful over a single tuple argument constructor?
例如,是否存在像 type x = A of int * int
这样的类型比 type y = B of (int * int)
更好的情况?这种区别究竟意味着什么?
我看到 x
更糟糕的地方是试图将构造函数的“参数”(看起来像是两个参数,但它打印为一个元组)作为一个元组进行匹配:
type x = A of int * int
type y = B of (int * int)
let v = (1, 1)
(* let a = A v (* Doesn't work *) *)
let b = B v (* Works *)
(* let f = function
| A v -> v (* Doesn't work *) *)
let g = function
| B v -> v (* Works *)
所以看起来它只限制有多个参数,即使它们具有相同的表示?
它们的表示方式不同。元组表示占用更多内存,需要两个 objects 而不是一个
构造值由一个 header 词表示,每个值后跟一个词。
所以A (x, y)
由3个词表示:header、x
、y
.
而B ((x, y))
由2个词表示:header,元组。
那么元组由3个词表示:header、x
、y
A
共 3 个字。 B
的总计为 5 个字。另外 B
有两个 objects 来管理 GC 等等。访问 A
的 x 组件需要一个间接,而对于 B
它需要两个间接。
如果您的意思是 A (x, y)
和 B (x, y)
在语法上看起来相同,那是对的。这肯定有点奇怪。但是有必要让它们在内部有所不同(正如我试图展示的那样)。
例如,是否存在像 type x = A of int * int
这样的类型比 type y = B of (int * int)
更好的情况?这种区别究竟意味着什么?
我看到 x
更糟糕的地方是试图将构造函数的“参数”(看起来像是两个参数,但它打印为一个元组)作为一个元组进行匹配:
type x = A of int * int
type y = B of (int * int)
let v = (1, 1)
(* let a = A v (* Doesn't work *) *)
let b = B v (* Works *)
(* let f = function
| A v -> v (* Doesn't work *) *)
let g = function
| B v -> v (* Works *)
所以看起来它只限制有多个参数,即使它们具有相同的表示?
它们的表示方式不同。元组表示占用更多内存,需要两个 objects 而不是一个
构造值由一个 header 词表示,每个值后跟一个词。
所以A (x, y)
由3个词表示:header、x
、y
.
而B ((x, y))
由2个词表示:header,元组。
那么元组由3个词表示:header、x
、y
A
共 3 个字。 B
的总计为 5 个字。另外 B
有两个 objects 来管理 GC 等等。访问 A
的 x 组件需要一个间接,而对于 B
它需要两个间接。
如果您的意思是 A (x, y)
和 B (x, y)
在语法上看起来相同,那是对的。这肯定有点奇怪。但是有必要让它们在内部有所不同(正如我试图展示的那样)。