Question

我正在OCaml中实现一个packrat解析器，根据Master Thesis by B. Ford.我的解析器应该接收一个表示语言语法的数据结构，并解析给定的符号序列。

我被记忆部分困住了。原始论文使用Haskell的惰性评估来实现线性时间复杂度。我想在OCaml中这样做（通过懒惰进行记忆），但不知道该怎么做。

那么，如何通过OCaml中的延迟评估来记忆函数？

编辑：我知道懒惰评估是什么以及如何在OCaml中利用它。问题是如何使用它来记忆功能。

编辑：我写的代表语法的数据结构是：

type ('a, 'b, 'c) expr =
| Empty of 'c
| Term of 'a * ('a -> 'c)
| NTerm of 'b
| Juxta of ('a, 'b, 'c) expr * ('a, 'b, 'c) expr * ('c -> 'c -> 'c)
| Alter of ('a, 'b, 'c) expr * ('a, 'b, 'c) expr
| Pred of ('a, 'b, 'c) expr * 'c
| NPred of ('a, 'b, 'c) expr * 'c
type ('a, 'b, 'c) grammar = ('a * ('a, 'b, 'c) expr) list

解析符号列表的（not-memoized）函数是：

let rec parse g v xs = parse' g (List.assoc v g) xs
and parse' g e xs =
  match e with
  | Empty y -> Parsed (y, xs)
  | Term (x, f) ->
     begin
       match xs with
       | x' :: xs when x = x' -> Parsed (f x, xs)
       | _ -> NoParse
     end
  | NTerm v' -> parse g v' xs
  | Juxta (e1, e2, f) ->
     begin
       match parse' g e1 xs with
       | Parsed (y, xs) ->
          begin
            match parse' g e2 xs with
            | Parsed (y', xs) -> Parsed (f y y', xs)
            | p -> p
          end
       | p -> p
     end
( and so on )

其中parse返回值的类型由

定义

type ('a, 'c) result = Parsed of 'c * ('a list) | NoParse

例如，基本算术表达式的语法可以指定为g，在：

type nt = Add | Mult | Prim | Dec | Expr
let zero _  = 0
let g =
  [(Expr, Juxta (NTerm Add, Term ('$', zero), fun x _ -> x));
   (Add, Alter (Juxta (NTerm Mult, Juxta (Term ('+', zero), NTerm Add, fun _ x -> x), (+)), NTerm Mult));
   (Mult, Alter (Juxta (NTerm Prim, Juxta (Term ('*', zero), NTerm Mult, fun _ x -> x), ( * )), NTerm Prim));
   (Prim, Alter (Juxta (Term ('<', zero), Juxta (NTerm Dec, Term ('>', zero), fun x _ -> x), fun _ x -> x), NTerm Dec));
   (Dec, List.fold_left (fun acc d -> Alter (Term (d, (fun c -> int_of_char c - 48)), acc)) (Term ('0', zero)) ['1';'2';'3';])]

Answer 1

使用延迟进行memoization的想法不是使用函数，而是使用数据结构进行memoization。懒惰意味着当你写let x = foo in some_expr时，foo不会立即评估，但只有some_expr需要它，但x some_expr的不同出现将共享同一个主干：只要其中一个强制计算，结果就可以全部使用。

这对于函数不起作用：如果你在let f x = foo in some_expr中写f并多次调用some_expr，那么每个调用都会被独立评估，没有共享的thunk存储结果。

因此，您可以通过使用数据结构而不是函数来获取memoization。通常，这是使用关联数据结构完成的：您不是计算a -> b函数，而是计算Table a b，其中Table是从结果的参数映射的映射。一个例子是这个关于斐波那契的Haskell演示：

fib n = fibTable !! n
fibTable = [0,1] ++ map (\n -> fib (n - 1) + fib (n - 2)) [2..]

（你也可以用tail和zip来写，但这并不能说明问题。）

看到你没有记住一个函数，而是一个列表：它是执行memoization的列表fibTable。您也可以在OCaml中编写它，例如使用Batteries库的LazyList模块：

open Batteries
module LL = LazyList

let from_2 = LL.seq 2 ((+) 1) (fun _ -> true)

let rec fib n = LL.at fib_table (n - 1) + LL.at fib_table (n - 2)
and fib_table = lazy (LL.Cons (0, LL.cons 1 <| LL.map fib from_2))

然而，没有兴趣这样做：正如你在上面的例子中看到的那样，OCaml并不特别支持按需求评估 - 使用它是合理的，但不是非常方便，因为它被迫在哈斯克尔。通过直接变异直接写缓存结构实际上同样简单：

open Batteries

let fib =
  let fib_table = DynArray.of_list [0; 1] in
  let get_fib n = DynArray.get fib_table n in
  fun n ->
    for i = DynArray.length fib_table to n do
      DynArray.add fib_table (get_fib (i - 1) + get_fib (i - 2))
    done;
    get_fib n

此示例可能选择不当，因为您需要一个动态结构来存储缓存。在packrat解析器的情况下，您将对已知输入文本进行分析，因此您可以使用普通数组（由语法规则索引）：对于每个规则，您将拥有('a, 'c) result option数组，其大小为输入长度并初始化为None。例如。 juxta.(n)表示从输入位置Juxta尝试规则n的结果，如果尚未尝试，则None。{/ p>

懒惰是提供这种记忆的一种很好的方式，但并不总是足够表达：如果你需要部分释放结果缓存的某些部分以降低内存使用量，那么如果你从一个懒惰的演讲。有关此问题的评论，请参阅this blog post。

Answer 2

为什么要记忆功能？您想要记住的是，我相信，给定（解析）表达式和输入流中给定位置的解析结果。例如，您可以使用Ocaml的Hashtables。

Answer 3

lazy关键字。

Here你可以找到一些很好的例子。

如果它适合您的使用案例，您也可以使用OCaml流而不是手动生成thunk。

在OCaml中解析Packrat（通过懒惰进行记忆）

3 个答案: