在 OCaml 中扩展不可变类型（或：不可变类型的快速缓存）

Question

我在 ocaml 中有一个递归的不可变数据结构，可以简化为这样的：

type expr =
{
    eexpr : expr_expr;
    some_other_complex_field : a_complex_type;
}

and expr_expr =
    | TInt of int
    | TSum of (expr * expr)
    | TMul of (expr * expr)

这是一个 AST，有时它会变得非常复杂（非常深）。

有一个计算表达式的递归函数。例如，假设，

let rec result expr =
    match expr.eexpr with
        | TInt i -> i
        | TSum (e1, e2) -> result e1 + result e2
        | TMul (e1, e2) -> result e1 * result e2

现在假设我正在将一个表达式映射到另一个表达式，并且我需要不断检查 expr 的结果，有时对同一个 expr 进行多次检查，有时对最近使用该模式映射的表达式进行检查

{ someExpr with eexpr = TSum(someExpr, otherExpr) }

现在，结果函数非常轻量级，但多次运行深度 AST 并不会得到很好的优化。我知道我可以使用 Hashtbl 缓存值，但 AFAIK Hashtbl 只会做结构相等，所以无论如何它都需要遍历我的长 AST。 我知道最好的选择是在 expr 类型中包含一个可能不可变的“结果”字段。但我做不到。

那么在 Ocaml 中是否有任何方法可以将值缓存到不可变类型，这样我就不必每次需要时都急切地计算它？

谢谢！

Answer 1

Hash-cons expr_expr 的值。通过在您的程序中执行此结构相等的值将共享完全相同的内存表示，您可以用物理相等 (==) 替换结构相等 (=)。

这个paper 应该让你快速开始在 OCaml 中使用哈希函数。

Answer 2

您可以使用函数接口来控制哈希表使用的相等类型。我相信 (==) 的语义对于您的目的是合法的；即，如果 A == B，则对于任何纯函数 f，f A = f B。所以你可以缓存f A的结果。然后如果你找到一个物理上等于A的B，那么缓存的值对于B是正确的。

使用 (==) 进行散列的缺点是散列函数会将所有结构上相等的对象发送到同一个散列桶，在那里它们将被视为不同的对象。如果表中有很多结构上相同的对象，则散列不会给您带来任何好处。行为退化为线性搜索。

您不能定义散列函数来处理物理地址，因为垃圾收集器可以随时更改物理地址。

但是，如果您知道您的表将只包含相对较少的大值，则使用物理相等可能对您有用。

Answer 3

我认为您可以合并上述两个想法：使用类似哈希的技术来获取数据的“纯表达式”部分的哈希，并将此哈希用作eval 的记忆表中的键功能。

当然，这仅在您的 eval 函数确实仅取决于函数的“纯表达式”部分时才有效，如您给出的示例所示。我相信这是一个相对普遍的情况，至少如果您限制自己存储 成功 评估（例如，不会返回包含某些位置信息的错误）。

编辑：一个小的概念证明：

type 'a _expr =
  | Int of int
  | Add of 'a * 'a

(* a constructor to avoid needing -rectypes *)
type pure_expr = Pure of pure_expr _expr

type loc = int
type loc_expr = {
  loc : loc;
  expr : loc_expr _expr;
  pure : pure_expr (* or any hash_consing of it for efficiency *)
}

(* this is where you could hash-cons *)
let pure x = Pure x

let int loc n =
  { loc; expr = Int n; pure = pure (Int n) }
let add loc a b =
  { loc; expr = Add (a, b); pure = pure (Add(a.pure, b.pure)) }

let eval =
  let cache = Hashtbl.create 251 in
  let rec eval term =
    (* for debug and checking memoization *)
    Printf.printf "log: %d\n" term.loc;
    try Hashtbl.find cache term.pure with Not_found ->
      let result =
        match term.expr with
          | Int n -> n
          | Add(a, b) -> eval a + eval b in
      Hashtbl.add cache term.pure result;
      result
  in eval



let test = add 3 (int 1 1) (int 2 2)
# eval test;;
log: 3
log: 2
log: 1
- : int = 3
# eval test;;
log: 3
- : int = 3