Re: [Caml-list] Camlp4 type constructor transformation

[Hendrik Tews <tews@os.inf.tu-dresden.de>]

eagriffis@gmail.com writes:

   I am having trouble getting Camlp4 to detect and transform type constructors
   that take parameters. I believe the problem is with my grammar. Here is a base
   case (call it base.ml):

If you want to transform the syntax tree after parsing you should
not modify the grammar. Instead you should install a filter
function. Transforming the syntax tree is the very purpose of
filter functions.

If you look at the sources of the camlp4 parser, you see

    expr: LEVEL "apply" (* LEFTA *)
      [ [ e1 = SELF; e2 = SELF ->
            match (is_expr_constr_call e1, e2) with
            [ (True, <:expr< ( $tup:e$ ) >>) ->
                List.fold_left (fun e1 e2 -> <:expr< $e1$ $e2$ >>) e1
                                (Ast.list_of_expr e [])
            | _ -> <:expr< $e1$ $e2$ >> ]
      ] ];

i.e, your expression "Foo(1,1)" is first parsed as Foo applied to
a pair and only if is_expr_constr_call detects a constructor it
is transformed into Foo applied to 1 applied to 1.

Your rule

     expr: LEVEL "apply"
       [ LEFTA
   	[ e1 = SELF; e2 = SELF -> apply _loc e1 e2 ] ];

does not curry constructor calls. I don't understand the code in
Camlp4/Struct/Camlp4Ast2OCamlAst.ml, but I would expect that you
get strange errors if you connect this parser to the ocaml
compiler.

   It seems that my constructor of arity 2 can be located as an uppercase
   identifier nested twice deep in ExApps. So either I do not understand how to
   modify the grammar rule to catch this, or the problem is not in the rule?

This is true, but only after the transformation in the original
parser. Filter functions run after the parsing completed, so a
filter function sees precisely what you expect.


Bye,

Hendrik