Dear all (especially Francois),

I am currently porting a DSL to OCaml and wanted to use the most modern ppx
approach for the typical boilerplate. One of the first things is the
implementation of the free variables with the help of ppx_visitors.
Naturally, the set of free variables forms a monoid, so I can comfortably
use the reduce variety. But that allocates quite a lot of temporary sets,
so I had a look into the fold variety.

If I understand the documentation correctly, this class requires to define
a build method for each variant of the datatype. I wonder if there is a way
to have a "default" function, namely the identity of the result value?

Consider, for example the simple lambda calculus:


type expr = Abs of (string[@opaque]) * expr | App of expr * expr | Var of
(string[@opaque]) [@@deriving visitors { variety = "fold" }]

In that case, you'd want to define

method build_Abs () x = StrSet.remove x
method build_Var () = StrSet.singleton

but also have to

method build_App () = StrSet.union

According to the manual, the visitor should be something like this:

method visit_App () l r fvs0 =
  let fvs1 = self#visit_expr () l fvs0 in
  let fvs2 = self#visit_expr () l fvs1 in
  self#build_App () fvs1 fvs2                (* Why is this /always/
necessary ? *)

I suppose this final step of building the results allows some flexibility,
but in my case I could as well just yield fvs2. I wonder if it would be
possible to have a default implementation like this:

method build_App () _ r = r

For now, I am perfectly fine with the reduce variety, but I suppose that
there are some use cases where you would actually need to fold, but only
some variants actually do something. Is this a reasonable idea or is there
some caveat in the design of ppx_visitors that makes it impossible?

thanks,

Christoph