有没有办法获得A a a feference＆＃x27;到可变的结构场

Question

因此，我有一个具有可变字段的记录类型：

type mpoint = { mutable x:int ; mutable y: int };;
let apoint = { x=3 ; y=4};;

而且我的功能期望“ ref”并对其内容做点事。 例如：

let increment x = x := !x+1;;
val increment : int ref -> unit = <fun>

是否有一种方法可以从可变的字段中获取“参考”，以便我可以将其传递给函数。即我想做类似的事情：

increment apoint.x;; (* increment value of the x field 'in place' *)
Error: This expression has type int but an expression was expected of type
         int ref

但是上面的事情不起作用，因为apoint.x返回字段的值，而不是其“ ref”。如果这是Golang或C ++，也许我们可以使用＆amp;操作员指示我们需要地址而不是字段的值：＆amp; apoint.x。

（我们如何）在OCAML中执行此操作？

PS：是的，我知道以这种方式避免使用副作用可能更常见。但是我保证，我这样做是有充分理由的，在这种情况下，这比这个简化/人为的例子更有意义。

Answer 1

无法准确地做您要求的事情。参考的类型非常具体：

# let x = ref 3
val x : int ref = {contents = 3}

参考是一个可突出字段的记录，名为contents。您不能真正从其他一些记录的任意可变领域来构建它。即使您愿意对类型系统撒谎，记录的字段也与记录完全没有表示。

您可以将您的字段声明为实际引用：

type mpoint = { x: int ref; y: int ref; }

然后没有问题，apoint.x确实是参考。但是，这种表示并不那么高效，即，它需要更多的内存，并且有更多的删除来访问值。

如果以命令式设计API，则很难在OCAML中使用。无论如何，这就是我的看法。另一种说法是INT很小。接口也许应该接受int并返回新的int，而不是接受对int的引用并将其修改为适当的。

Answer 2

杰弗里·斯科菲尔德（Jeffrey Scofield）解释了为什么从类型系统的角度开始在OCAML中做到这一点。

但是您也可以从GC（垃圾收集器）的角度看它。在OCAML中，所有内容都是琐碎的类型（int，bool，char，...），其存储为31/63位值，或者是指向内存块的指针。每个内存块都有一个描述GC内容的标头，并且具有GC使用的一些额外位。

当您在内部查看参考时，它是一个指向内存块的指针，其中包含Mutable内容的记录。通过该尖端，GC可以访问标头，并且知道存储器的块仍然可以到达。

但是，让我们假设您可以将apoint.y传递给参考的函数。然后，指针将指向apoint的中间，并且GC试图访问该块的标题时，GC将失败，因为它不知道标题所在的指针的偏移。

现在如何解决这个问题？

已经提到的一种方法是使用参考而不是可变的。另一种方法是使用getter和setter：

# type 'a mut = (unit -> 'a) * ('a -> unit);;
type 'a mut = (unit -> 'a) * ('a -> unit)

# type mpoint = { mutable x:int ; mutable y: int };;
type mpoint = { mutable x : int; mutable y : int; }

# let mut_x p = (fun () -> p.x), (fun x -> p.x <- x);;
val mut_x : mpoint -> (unit -> int) * (int -> unit) = <fun>

# let mut_y p = (fun () -> p.y), (fun y -> p.y <- y);;
val mut_y : mpoint -> (unit -> int) * (int -> unit) = <fun>

如果您只想engry可以传递增量器函数而不是getter/setter的变量。或任何其他辅助功能集合。 Getter/Setter Pait只是最通用的接口。

Answer 3

您始终可以暂时复制字段内容，在此函数再次调用该功能：

let increment_point_x apoint =
  let x = ref apoint.x in
  increment x;
  apoint.x <- !x

肯定不是尽可能高效（也不优雅），但可以正常工作。

Answer 4

不可能确切地做问题的问题（@JeffReyScofield解释了原因，所以我不会重复这一点）。建议一些解决方法。

如果您可以更改增量函数的实现，则可以使用这是另一个可行的解决方法。这非常接近所要求的。

我们可以定义自己的参考类型，而不是让它进行“内置”参考。您可以设定并获得“参考”的精神。因此，我们可以将其描述/表示为get和set函数的组合。

type 'a ref = {
  set: 'a -> unit;
  get: unit -> 'a;
};;
type 'a ref = { set : 'a -> unit; get : unit -> 'a; }

我们可以在此类型上定义通常的！和：=运算符：

let (!) cell = cell.get ();;
val ( ! ) : 'a ref -> 'a = <fun>

let (:=) cell = cell.set;;
val ( := ) : 'a ref -> 'a -> unit = <fun>

增量函数的代码甚至相同的'外观'相同（但是它是微妙的'不同的'因为现在使用我们自己的ref而不是内置参考）。

let increment cell = cell := !cell + 1;;
val increment : int ref -> unit = <fun>

当我们想要对一个字段的引用时，我们现在可以做一个。例如，一个可以引用X的函数：

let xref pt = {
  set = (fun v -> pt.x <- v);
  get = (fun () -> pt.x); 
};;
val xref : mpoint -> int ref = <fun>

现在我们可以在x字段上调用增量：

increment (xref apoint);;
- : unit = ()