Version française
Home     About     Download     Resources     Contact us    
Browse thread
Misunderstandings about the AST
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Nicolas Pouillard <nicolas.pouillard@g...>
Subject: Re: [Caml-list] Misunderstandings about the AST
On 3/27/07, Loup Vaillant <loup.vaillant@gmail.com> wrote:
> Good afternoon,
>
> Pursuing my goal of making a lisp syntax for Ocaml, I began to take a
> close look at the AST (Ocaml-3.09.3/parsing/parsetree.mli). I don't
> understand some of the constructors in the type expression_desc:
>
>
> | Pexp_function of label * expression option * (pattern * expression) list
> What is the "expression option" for?

The default value for labeled arguments  << fun ?(label=default_value) -> ... >>

> | Pexp_construct of Longident.t * expression option * bool
>
> What is the boolean for?

Ha, ha...

Is one is more tricky this it seems not produced by the parser (my
main source of inspiration for this mail). In fact it's use by camlp4,
and it means that you know that the arity is good.

When you write:

A(x, y) how to know if it's 2 args for A or 1 arg but a pair.

If you directly produce AST nodes and that you know want you do you
can set this flag to true.

> | Pexp_variant of label * expression option
>
> What is a "variant"? (Does not seem to be related to variant types, as
> "Pexp_construct" is used for them)

It's for polymorphic variants, checkout the documentation...

> | Pexp_record of (Longident.t * expression) list * expression option
> What is the "expression option" for?

{ (expression) with field1 = expr1; ... ; fieldN = exprN }

> | Pexp_constraint of expression * core_type option * core_type option
> Why two "core_type option", instead of just a "core_type"?

Since there is 3 type of constraints.

(e : t)

(e :> t)

(e : t1 :> t2)

> | Pexp_when of expression * expression
> Why not "pattern * expression"?

The `when' form is:

pattern when expr1 -> expr2

expr1 and expr2 are paired with Pexp_when

> | Pexp_send of expression * string
> What does "Pexp_send" stand for?

Method call.

object_value#method_name

> | Pexp_new of Longident.t
> What does "Pexp_new" stand for?

new class_name

> | Pexp_setinstvar of string * expression
> What does "Pexp_setinstvar" stand for?

object_value.instance_variable <- expr

> | Pexp_override of (string * expression) list
> What does "Pexp_override" stand for?

{< instvar1 = expr1 ; ... ; instvarN = exprN >}

Same as { expr with ... } but for objects and automatically on self.

> | Pexp_lazy of expression
> Why does this constructor even exist? Are some specific optimizations made?

Since the evaluation of the expression is delayed it's not a plain function.

> | Pexp_poly of expression * core_type option
> What does "Pexp_poly" stand for?

It's for methods with polymorphic types, some syntax nodes are
inserted to keep track of this polymorphism.

Regards,

-- 
Nicolas Pouillard