open Typedtree

class virtual omap =

object ((self : 'self))

method virtual ref :

'a1. ('self -> 'a1 -> ('self * 'a1)) -> 'a1 ref -> ('self * ('a1 ref))

method virtual option :

'a1.

('self -> 'a1 -> ('self * 'a1)) ->

'a1 option -> ('self * ('a1 option))

method virtual list :

'a1.

('self -> 'a1 -> ('self * 'a1)) -> 'a1 list -> ('self * ('a1 list))

method pattern : pattern -> ('self * pattern) =

fun __value ->

let (self, pat_desc) = self#pattern_desc __value.pat_desc in

let pat_loc = __value.pat_loc in

let (self, pat_extra) =

self#list

(fun self (((__x1, __x2) as __value)) ->

let (self, __y1) = self#pat_extra __x1 in

let __y2 = __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else (__y1, __y2))))

__value.pat_extra in

let pat_type = __value.pat_type in

let pat_env = __value.pat_env

in

(self,

(if

(__value.pat_loc == pat_loc) &&

((__value.pat_extra == pat_extra) &&

((__value.pat_type == pat_type) &&

((__value.pat_env == pat_env) &&

(__value.pat_desc == pat_desc))))

then __value

else

{

pat_desc = pat_desc;

pat_loc = pat_loc;

pat_extra = pat_extra;

pat_type = pat_type;

pat_env = pat_env;

}))

method pat_extra : pat_extra -> ('self * pat_extra) =

fun __value ->

match __value with

| Tpat_constraint __x1 ->

let (self, __y1) = self#core_type __x1

in

(self,

(if __x1 == __y1 then __value else Tpat_constraint __y1))

| Tpat_type (__x1, __x2) -> (self, __value)

| Tpat_unpack -> (self, __value)

method pattern_desc : pattern_desc -> ('self * pattern_desc) =

fun __value ->

match __value with

| Tpat_any -> (self, __value)

| Tpat_var (__x1, __x2) -> (self, __value)

| Tpat_alias (__x1, __x2, __x3) ->

let (self, __y1) = self#pattern __x1 in

let __y2 = __x2 in

let __y3 = __x3

in

(self,

(if (__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else Tpat_alias (__y1, __y2, __y3)))

| Tpat_constant __x1 -> (self, __value)

| Tpat_tuple __x1 ->

let (self, __y1) = self#list (fun self -> self#pattern) __x1

in (self, (if __x1 == __y1 then __value else Tpat_tuple __y1))

| Tpat_construct (__x2, __x3, __x4, __x5) ->

let __y2 = __x2 in

let __y3 = __x3 in

let (self, __y4) = self#list (fun self -> self#pattern) __x4 in

let __y5 = __x5

in

(self,

(if

(__x2 == __y2) &&

((__x3 == __y3) &&

((__x4 == __y4) && ((__x5 == __y5))))

then __value

else Tpat_construct (__y2, __y3, __y4, __y5)))

| Tpat_variant (__x1, __x2, __x3) ->

let __y1 = __x1 in

let (self, __y2) = self#option (fun self -> self#pattern) __x2 in

let (self, __y3) = self#ref (fun self v -> (self, v)) __x3

in

(self,

(if (__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else Tpat_variant (__y1, __y2, __y3)))

| Tpat_record (__x1, __x2) ->

let (self, __y1) =

self#list

(fun self (((__x2, __x3, __x4) as __value)) ->

let __y2 = __x2 in

let __y3 = __x3 in

let (self, __y4) = self#pattern __x4

in

(self,

(if

(__x2 == __y2) &&

((__x3 == __y3) &&

((__x4 == __y4)))

then __value

else (__y2, __y3, __y4))))

__x1 in

let __y2 = __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else Tpat_record (__y1, __y2)))

| Tpat_array __x1 ->

let (self, __y1) = self#list (fun self -> self#pattern) __x1

in (self, (if __x1 == __y1 then __value else Tpat_array __y1))

| Tpat_or (__x1, __x2, __x3) ->

let (self, __y1) = self#pattern __x1 in

let (self, __y2) = self#pattern __x2 in

let (self, __y3) = self#option (fun self v -> (self, v)) __x3

in

(self,

(if (__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else Tpat_or (__y1, __y2, __y3)))

| Tpat_lazy __x1 ->

let (self, __y1) = self#pattern __x1

in (self, (if __x1 == __y1 then __value else Tpat_lazy __y1))

method expression : expression -> ('self * expression) =

fun __value ->

let (self, exp_desc) = self#expression_desc __value.exp_desc in

let exp_loc = __value.exp_loc in

let (self, exp_extra) =

self#list

(fun self (((__x1, __x2) as __value)) ->

let (self, __y1) = self#exp_extra __x1 in

let __y2 = __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else (__y1, __y2))))

__value.exp_extra in

let exp_type = __value.exp_type in

let exp_env = __value.exp_env

in

(self,

(if

(__value.exp_loc == exp_loc) &&

((__value.exp_extra == exp_extra) &&

((__value.exp_type == exp_type) &&

((__value.exp_env == exp_env) &&

(__value.exp_desc == exp_desc))))

then __value

else

{

exp_desc = exp_desc;

exp_loc = exp_loc;

exp_extra = exp_extra;

exp_type = exp_type;

exp_env = exp_env;

}))

method exp_extra : exp_extra -> ('self * exp_extra) =

fun __value ->

match __value with

| Texp_constraint (__x1, __x2) ->

let (self, __y1) =

self#option (fun self -> self#core_type) __x1 in

let (self, __y2) = self#option (fun self -> self#core_type) __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else Texp_constraint (__y1, __y2)))

| Texp_open (__x0, __x1, __x2, __x3) -> (self, __value)

| Texp_poly __x1 ->

let (self, __y1) = self#option (fun self -> self#core_type) __x1

in (self, (if __x1 == __y1 then __value else Texp_poly __y1))

| Texp_newtype __x1 -> (self, __value)

method expression_desc : expression_desc -> ('self * expression_desc) =

fun __value ->

match __value with

| Texp_ident (__x1, __x2, __x3) -> (self, __value)

| Texp_constant __x1 -> (self, __value)

| Texp_let (__x1, __x2, __x3) ->

let __y1 = __x1 in

let (self, __y2) =

self#list

(fun self (((__x1, __x2) as __value)) ->

let (self, __y1) = self#pattern __x1 in

let (self, __y2) = self#expression __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else (__y1, __y2))))

__x2 in

let (self, __y3) = self#expression __x3

in

(self,

(if (__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else Texp_let (__y1, __y2, __y3)))

| Texp_function (__x1, __x2, __x3) ->

let __y1 = __x1 in

let (self, __y2) =

self#list

(fun self (((__x1, __x2) as __value)) ->

let (self, __y1) = self#pattern __x1 in

let (self, __y2) = self#expression __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else (__y1, __y2))))

__x2 in

let __y3 = __x3

in

(self,

(if (__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else Texp_function (__y1, __y2, __y3)))

| Texp_apply (__x1, __x2) ->

let (self, __y1) = self#expression __x1 in

let (self, __y2) =

self#list

(fun self (((__x1, __x2, __x3) as __value)) ->

let __y1 = __x1 in

let (self, __y2) =

self#option (fun self -> self#expression) __x2 in

let __y3 = __x3

in

(self,

(if

(__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else (__y1, __y2, __y3))))

__x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else Texp_apply (__y1, __y2)))

| Texp_match (__x1, __x2, __x3) ->

let (self, __y1) = self#expression __x1 in

let (self, __y2) =

self#list

(fun self (((__x1, __x2) as __value)) ->

let (self, __y1) = self#pattern __x1 in

let (self, __y2) = self#expression __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else (__y1, __y2))))

__x2 in

let __y3 = __x3

in

(self,

(if (__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else Texp_match (__y1, __y2, __y3)))

| Texp_try (__x1, __x2) ->

let (self, __y1) = self#expression __x1 in

let (self, __y2) =

self#list

(fun self (((__x1, __x2) as __value)) ->

let (self, __y1) = self#pattern __x1 in

let (self, __y2) = self#expression __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else (__y1, __y2))))

__x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else Texp_try (__y1, __y2)))

| Texp_tuple __x1 ->

let (self, __y1) = self#list (fun self -> self#expression) __x1

in (self, (if __x1 == __y1 then __value else Texp_tuple __y1))

| Texp_construct (__x2, __x3, __x4, __x5) ->

let __y2 = __x2 in

let __y3 = __x3 in

let (self, __y4) =

self#list (fun self -> self#expression) __x4 in

let __y5 = __x5

in

(self,

(if

(__x2 == __y2) &&

((__x3 == __y3) &&

((__x4 == __y4) && ((__x5 == __y5))))

then __value

else Texp_construct (__y2, __y3, __y4, __y5)))

| Texp_variant (__x1, __x2) ->

let __y1 = __x1 in

let (self, __y2) = self#option (fun self -> self#expression) __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else Texp_variant (__y1, __y2)))

| Texp_record (__x1, __x2) ->

let (self, __y1) =

self#list

(fun self (((__x2, __x3, __x4) as __value)) ->

let __y1 = __x1 in

let __y2 = __x2 in

let __y3 = __x3 in

let (self, __y4) = self#expression __x4

in

(self,

(if

(__x2 == __y2) &&

((__x3 == __y3) &&

((__x4 == __y4)))

then __value

else (__y2, __y3, __y4))))

__x1 in

let (self, __y2) = self#option (fun self -> self#expression) __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else Texp_record (__y1, __y2)))

| Texp_field (__x1, __x3, __x4) ->

let (self, __y1) = self#expression __x1 in

let __y3 = __x3 in

let __y4 = __x4

in

(self,

(if

((__x3 == __y3) && ((__x4 == __y4) && (__x1 == __y1)))

then __value

else Texp_field (__y1, __y3, __y4)))

| Texp_setfield (__x1, __x3, __x4, __x5) ->

let (self, __y1) = self#expression __x1 in

let __y3 = __x3 in

let __y4 = __x4 in

let (self, __y5) = self#expression __x5

in

(self,

(if

((__x3 == __y3) &&

((__x4 == __y4) && ((__x5 == __y5) && (__x1 == __y1))))

then __value

else Texp_setfield (__y1, __y3, __y4, __y5)))

| Texp_array __x1 ->

let (self, __y1) = self#list (fun self -> self#expression) __x1

in (self, (if __x1 == __y1 then __value else Texp_array __y1))

| Texp_ifthenelse (__x1, __x2, __x3) ->

let (self, __y1) = self#expression __x1 in

let (self, __y2) = self#expression __x2 in

let (self, __y3) = self#option (fun self -> self#expression) __x3

in

(self,

(if (__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else Texp_ifthenelse (__y1, __y2, __y3)))

| Texp_sequence (__x1, __x2) ->

let (self, __y1) = self#expression __x1 in

let (self, __y2) = self#expression __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else Texp_sequence (__y1, __y2)))

| Texp_while (__x1, __x2) ->

let (self, __y1) = self#expression __x1 in

let (self, __y2) = self#expression __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else Texp_while (__y1, __y2)))

| Texp_for (__x1, __x2, __x3, __x4, __x5, __x6) ->

let __y1 = __x1 in

let __y2 = __x2 in

let (self, __y3) = self#expression __x3 in

let (self, __y4) = self#expression __x4 in

let __y5 = __x5 in

let (self, __y6) = self#expression __x6

in

(self,

(if

(__x2 == __y2) &&

((__x3 == __y3) &&

((__x4 == __y4) &&

((__x5 == __y5) &&

((__x6 == __y6) && (__x1 == __y1)))))

then __value

else Texp_for (__y1, __y2, __y3, __y4, __y5, __y6)))

| Texp_when (__x1, __x2) ->

let (self, __y1) = self#expression __x1 in

let (self, __y2) = self#expression __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else Texp_when (__y1, __y2)))

| Texp_send (__x1, __x2, __x3) ->

let (self, __y1) = self#expression __x1 in

let (self, __y2) = self#meth __x2 in

let (self, __y3) = self#option (fun self -> self#expression) __x3

in

(self,

(if (__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else Texp_send (__y1, __y2, __y3)))

| Texp_new (__x1, __x2, __x3) -> (self, __value)

| Texp_instvar (__x1, __x2, __x3) -> (self, __value)

| Texp_setinstvar (__x1, __x2, __x3, __x4) ->

let __y1 = __x1 in

let __y2 = __x2 in

let __y3 = __x3 in

let (self, __y4) = self#expression __x4

in

(self,

(if

(__x2 == __y2) &&

((__x3 == __y3) && ((__x4 == __y4) && (__x1 == __y1)))

then __value

else Texp_setinstvar (__y1, __y2, __y3, __y4)))

| Texp_override (__x1, __x2) ->

let __y1 = __x1 in

let (self, __y2) =

self#list

(fun self (((__x1, __x2, __x3) as __value)) ->

let __y1 = __x1 in

let __y2 = __x2 in

let (self, __y3) = self#expression __x3

in

(self,

(if

(__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else (__y1, __y2, __y3))))

__x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else Texp_override (__y1, __y2)))

| Texp_letmodule (__x1, __x2, __x3, __x4) ->

let __y1 = __x1 in

let __y2 = __x2 in

let (self, __y3) = self#module_expr __x3 in

let (self, __y4) = self#expression __x4

in

(self,

(if

(__x2 == __y2) &&

((__x3 == __y3) && ((__x4 == __y4) && (__x1 == __y1)))

then __value

else Texp_letmodule (__y1, __y2, __y3, __y4)))

| Texp_assert __x1 ->

let (self, __y1) = self#expression __x1

in (self, (if __x1 == __y1 then __value else Texp_assert __y1))

| Texp_assertfalse -> (self, __value)

| Texp_lazy __x1 ->

let (self, __y1) = self#expression __x1

in (self, (if __x1 == __y1 then __value else Texp_lazy __y1))

| Texp_object (__x1, __x2) ->

let (self, __y1) = self#class_structure __x1 in

let (self, __y2) = self#list (fun self v -> (self, v)) __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else Texp_object (__y1, __y2)))

| Texp_pack __x1 ->

let (self, __y1) = self#module_expr __x1

in (self, (if __x1 == __y1 then __value else Texp_pack __y1))

method meth : meth -> ('self * meth) = fun __value -> (self, __value)

method class_expr : class_expr -> ('self * class_expr) =

fun __value ->

let (self, cl_desc) = self#class_expr_desc __value.cl_desc in

let cl_loc = __value.cl_loc in

let cl_type = __value.cl_type in

let cl_env = __value.cl_env

in

(self,

(if

(__value.cl_loc == cl_loc) &&

((__value.cl_type == cl_type) &&

((__value.cl_env == cl_env) &&

(__value.cl_desc == cl_desc)))

then __value

else

{

cl_desc = cl_desc;

cl_loc = cl_loc;

cl_type = cl_type;

cl_env = cl_env;

}))

method class_expr_desc : class_expr_desc -> ('self * class_expr_desc) =

fun __value ->

match __value with

| Tcl_ident (__x1, __x2, __x3) ->

let __y1 = __x1 in

let __y2 = __x2 in

let (self, __y3) = self#list (fun self -> self#core_type) __x3

in

(self,

(if (__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else Tcl_ident (__y1, __y2, __y3)))

| Tcl_structure __x1 ->

let (self, __y1) = self#class_structure __x1

in (self, (if __x1 == __y1 then __value else Tcl_structure __y1))

| Tcl_fun (__x1, __x2, __x3, __x4, __x5) ->

let __y1 = __x1 in

let (self, __y2) = self#pattern __x2 in

let (self, __y3) =

self#list

(fun self (((__x1, __x2, __x3) as __value)) ->

let __y1 = __x1 in

let __y2 = __x2 in

let (self, __y3) = self#expression __x3

in

(self,

(if

(__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else (__y1, __y2, __y3))))

__x3 in

let (self, __y4) = self#class_expr __x4 in

let __y5 = __x5

in

(self,

(if

(__x2 == __y2) &&

((__x3 == __y3) &&

((__x4 == __y4) && ((__x5 == __y5) && (__x1 == __y1))))

then __value

else Tcl_fun (__y1, __y2, __y3, __y4, __y5)))

| Tcl_apply (__x1, __x2) ->

let (self, __y1) = self#class_expr __x1 in

let (self, __y2) =

self#list

(fun self (((__x1, __x2, __x3) as __value)) ->

let __y1 = __x1 in

let (self, __y2) =

self#option (fun self -> self#expression) __x2 in

let __y3 = __x3

in

(self,

(if

(__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else (__y1, __y2, __y3))))

__x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else Tcl_apply (__y1, __y2)))

| Tcl_let (__x1, __x2, __x3, __x4) ->

let __y1 = __x1 in

let (self, __y2) =

self#list

(fun self (((__x1, __x2) as __value)) ->

let (self, __y1) = self#pattern __x1 in

let (self, __y2) = self#expression __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else (__y1, __y2))))

__x2 in

let (self, __y3) =

self#list

(fun self (((__x1, __x2, __x3) as __value)) ->

let __y1 = __x1 in

let __y2 = __x2 in

let (self, __y3) = self#expression __x3

in

(self,

(if

(__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else (__y1, __y2, __y3))))

__x3 in

let (self, __y4) = self#class_expr __x4

in

(self,

(if

(__x2 == __y2) &&

((__x3 == __y3) && ((__x4 == __y4) && (__x1 == __y1)))

then __value

else Tcl_let (__y1, __y2, __y3, __y4)))

| Tcl_constraint (__x1, __x2, __x3, __x4, __x5) ->

let (self, __y1) = self#class_expr __x1 in

let (self, __y2) =

self#option (fun self -> self#class_type) __x2 in

let (self, __y3) = self#list (fun self v -> (self, v)) __x3 in

let (self, __y4) = self#list (fun self v -> (self, v)) __x4 in

let __y5 = __x5

in

(self,

(if

(__x2 == __y2) &&

((__x3 == __y3) &&

((__x4 == __y4) && ((__x5 == __y5) && (__x1 == __y1))))

then __value

else Tcl_constraint (__y1, __y2, __y3, __y4, __y5)))

method class_structure : class_structure -> ('self * class_structure) =

fun __value ->

let (self, cstr_pat) = self#pattern __value.cstr_pat in

let (self, cstr_fields) =

self#list (fun self -> self#class_field) __value.cstr_fields in

let cstr_type = __value.cstr_type in

let cstr_meths = __value.cstr_meths

in

(self,

(if

(__value.cstr_fields == cstr_fields) &&

((__value.cstr_type == cstr_type) &&

((__value.cstr_meths == cstr_meths) &&

(__value.cstr_pat == cstr_pat)))

then __value

else

{

cstr_pat = cstr_pat;

cstr_fields = cstr_fields;

cstr_type = cstr_type;

cstr_meths = cstr_meths;

}))

method class_field : class_field -> ('self * class_field) =

fun __value ->

let (self, cf_desc) = self#class_field_desc __value.cf_desc in

let cf_loc = __value.cf_loc

in

(self,

(if (__value.cf_loc == cf_loc) && (__value.cf_desc == cf_desc)

then __value

else { cf_desc = cf_desc; cf_loc = cf_loc; }))

method class_field_kind :

class_field_kind -> ('self * class_field_kind) =

fun __value ->

match __value with

| Tcfk_virtual __x1 ->

let (self, __y1) = self#core_type __x1

in (self, (if __x1 == __y1 then __value else Tcfk_virtual __y1))

| Tcfk_concrete __x1 ->

let (self, __y1) = self#expression __x1

in (self, (if __x1 == __y1 then __value else Tcfk_concrete __y1))

method class_field_desc :

class_field_desc -> ('self * class_field_desc) =

fun __value ->

match __value with

| Tcf_inher (__x1, __x2, __x3, __x4, __x5) ->

let __y1 = __x1 in

let (self, __y2) = self#class_expr __x2 in

let (self, __y3) = self#option (fun self v -> (self, v)) __x3 in

let (self, __y4) =

self#list

(fun self (((__x1, __x2) as __value)) -> (self, __value))

__x4 in

let (self, __y5) =

self#list

(fun self (((__x1, __x2) as __value)) -> (self, __value))

__x5

in

(self,

(if

(__x2 == __y2) &&

((__x3 == __y3) &&

((__x4 == __y4) && ((__x5 == __y5) && (__x1 == __y1))))

then __value

else Tcf_inher (__y1, __y2, __y3, __y4, __y5)))

| Tcf_val (__x1, __x2, __x3, __x4, __x5, __x6) ->

let __y1 = __x1 in

let __y2 = __x2 in

let __y3 = __x3 in

let __y4 = __x4 in

let (self, __y5) = self#class_field_kind __x5 in

let __y6 = __x6

in

(self,

(if

(__x2 == __y2) &&

((__x3 == __y3) &&

((__x4 == __y4) &&

((__x5 == __y5) &&

((__x6 == __y6) && (__x1 == __y1)))))

then __value

else Tcf_val (__y1, __y2, __y3, __y4, __y5, __y6)))

| Tcf_meth (__x1, __x2, __x3, __x4, __x5) ->

let __y1 = __x1 in

let __y2 = __x2 in

let __y3 = __x3 in

let (self, __y4) = self#class_field_kind __x4 in

let __y5 = __x5

in

(self,

(if

(__x2 == __y2) &&

((__x3 == __y3) &&

((__x4 == __y4) && ((__x5 == __y5) && (__x1 == __y1))))

then __value

else Tcf_meth (__y1, __y2, __y3, __y4, __y5)))

| Tcf_constr (__x1, __x2) ->

let (self, __y1) = self#core_type __x1 in

let (self, __y2) = self#core_type __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else Tcf_constr (__y1, __y2)))

| Tcf_init __x1 ->

let (self, __y1) = self#expression __x1

in (self, (if __x1 == __y1 then __value else Tcf_init __y1))

method module_expr : module_expr -> ('self * module_expr) =

fun __value ->

let (self, mod_desc) = self#module_expr_desc __value.mod_desc in

let mod_loc = __value.mod_loc in

let mod_type = __value.mod_type in

let mod_env = __value.mod_env

in

(self,

(if

(__value.mod_loc == mod_loc) &&

((__value.mod_type == mod_type) &&

((__value.mod_env == mod_env) &&

(__value.mod_desc == mod_desc)))

then __value

else

{

mod_desc = mod_desc;

mod_loc = mod_loc;

mod_type = mod_type;

mod_env = mod_env;

}))

method module_type_constraint :

module_type_constraint -> ('self * module_type_constraint) =

fun __value ->

match __value with

| Tmodtype_implicit -> (self, __value)

| Tmodtype_explicit __x1 ->

let (self, __y1) = self#module_type __x1

in

(self,

(if __x1 == __y1 then __value else Tmodtype_explicit __y1))

method module_expr_desc :

module_expr_desc -> ('self * module_expr_desc) =

fun __value ->

match __value with

| Tmod_ident (__x1, __x2) -> (self, __value)

| Tmod_structure __x1 ->

let (self, __y1) = self#structure __x1

in

(self, (if __x1 == __y1 then __value else Tmod_structure __y1))

| Tmod_functor (__x1, __x2, __x3, __x4) ->

let __y1 = __x1 in

let __y2 = __x2 in

let (self, __y3) = self#module_type __x3 in

let (self, __y4) = self#module_expr __x4

in

(self,

(if

(__x2 == __y2) &&

((__x3 == __y3) && ((__x4 == __y4) && (__x1 == __y1)))

then __value

else Tmod_functor (__y1, __y2, __y3, __y4)))

| Tmod_apply (__x1, __x2, __x3) ->

let (self, __y1) = self#module_expr __x1 in

let (self, __y2) = self#module_expr __x2 in

let (self, __y3) = self#module_coercion __x3

in

(self,

(if (__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else Tmod_apply (__y1, __y2, __y3)))

| Tmod_constraint (__x1, __x2, __x3, __x4) ->

let (self, __y1) = self#module_expr __x1 in

let __y2 = __x2 in

let (self, __y3) = self#module_type_constraint __x3 in

let (self, __y4) = self#module_coercion __x4

in

(self,

(if

(__x2 == __y2) &&

((__x3 == __y3) && ((__x4 == __y4) && (__x1 == __y1)))

then __value

else Tmod_constraint (__y1, __y2, __y3, __y4)))

| Tmod_unpack (__x1, __x2) ->

let (self, __y1) = self#expression __x1 in

let __y2 = __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else Tmod_unpack (__y1, __y2)))

method structure : structure -> ('self * structure) =

fun __value ->

let (self, str_items) =

self#list (fun self -> self#structure_item) __value.str_items in

let str_type = __value.str_type in

let str_final_env = __value.str_final_env

in

(self,

(if

(__value.str_type == str_type) &&

((__value.str_final_env == str_final_env) &&

(__value.str_items == str_items))

then __value

else

{

str_items = str_items;

str_type = str_type;

str_final_env = str_final_env;

}))

method structure_item : structure_item -> ('self * structure_item) =

fun __value ->

let (self, str_desc) = self#structure_item_desc __value.str_desc in

let str_loc = __value.str_loc in

let str_env = __value.str_env

in

(self,

(if

(__value.str_loc == str_loc) &&

((__value.str_env == str_env) &&

(__value.str_desc == str_desc))

then __value

else

{ str_desc = str_desc; str_loc = str_loc; str_env = str_env; }))

method structure_item_desc :

structure_item_desc -> ('self * structure_item_desc) =

fun __value ->

match __value with

| Tstr_eval __x1 ->

let (self, __y1) = self#expression __x1

in (self, (if __x1 == __y1 then __value else Tstr_eval __y1))

| Tstr_value (__x1, __x2) ->

let __y1 = __x1 in

let (self, __y2) =

self#list

(fun self (((__x1, __x2) as __value)) ->

let (self, __y1) = self#pattern __x1 in

let (self, __y2) = self#expression __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else (__y1, __y2))))

__x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else Tstr_value (__y1, __y2)))

| Tstr_primitive (__x1, __x2, __x3) ->

let __y1 = __x1 in

let __y2 = __x2 in

let (self, __y3) = self#value_description __x3

in

(self,

(if (__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else Tstr_primitive (__y1, __y2, __y3)))

| Tstr_type __x1 ->

let (self, __y1) =

self#list

(fun self (((__x1, __x2, __x3) as __value)) ->

let __y1 = __x1 in

let __y2 = __x2 in

let (self, __y3) = self#type_declaration __x3

in

(self,

(if

(__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else (__y1, __y2, __y3))))

__x1

in (self, (if __x1 == __y1 then __value else Tstr_type __y1))

| Tstr_exception (__x1, __x2, __x3) ->

let __y1 = __x1 in

let __y2 = __x2 in

let (self, __y3) = self#exception_declaration __x3

in

(self,

(if (__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else Tstr_exception (__y1, __y2, __y3)))

| Tstr_exn_rebind (__x1, __x2, __x3, __x4) -> (self, __value)

| Tstr_module (__x1, __x2, __x3) ->

let __y1 = __x1 in

let __y2 = __x2 in

let (self, __y3) = self#module_expr __x3

in

(self,

(if (__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else Tstr_module (__y1, __y2, __y3)))

| Tstr_recmodule __x1 ->

let (self, __y1) =

self#list

(fun self (((__x1, __x2, __x3, __x4) as __value)) ->

let __y1 = __x1 in

let __y2 = __x2 in

let (self, __y3) = self#module_type __x3 in

let (self, __y4) = self#module_expr __x4

in

(self,

(if

(__x2 == __y2) &&

((__x3 == __y3) &&

((__x4 == __y4) && (__x1 == __y1)))

then __value

else (__y1, __y2, __y3, __y4))))

__x1

in

(self, (if __x1 == __y1 then __value else Tstr_recmodule __y1))

| Tstr_modtype (__x1, __x2, __x3) ->

let __y1 = __x1 in

let __y2 = __x2 in

let (self, __y3) = self#module_type __x3

in

(self,

(if (__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else Tstr_modtype (__y1, __y2, __y3)))

| Tstr_open (__x0, __x1, __x2) -> (self, __value)

| Tstr_class __x1 ->

let (self, __y1) =

self#list

(fun self (((__x1, __x2, __x3) as __value)) ->

let (self, __y1) = self#class_declaration __x1 in

let (self, __y2) =

self#list (fun self v -> (self, v)) __x2 in

let __y3 = __x3

in

(self,

(if

(__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else (__y1, __y2, __y3))))

__x1

in (self, (if __x1 == __y1 then __value else Tstr_class __y1))

| Tstr_class_type __x1 ->

let (self, __y1) =

self#list

(fun self (((__x1, __x2, __x3) as __value)) ->

let __y1 = __x1 in

let __y2 = __x2 in

let (self, __y3) = self#class_type_declaration __x3

in

(self,

(if

(__x2 == __y2) && ((__x3 == __y3) && (__x1 == __y1))

then __value

else (__y1, __y2, __y3))))

__x1

in

(self,

(if __x1 == __y1 then __value else Tstr_class_type __y1))

| Tstr_include (__x1, __x2) ->

let (self, __y1) = self#module_expr __x1 in

let (self, __y2) = self#list (fun self v -> (self, v)) __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else Tstr_include (__y1, __y2)))

method module_coercion : module_coercion -> ('self * module_coercion) =

fun __value ->

match __value with

| Tcoerce_none -> (self, __value)

| Tcoerce_structure __x1 ->

let (self, __y1) =

self#list

(fun self (((__x1, __x2) as __value)) ->

let __y1 = __x1 in

let (self, __y2) = self#module_coercion __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)

then __value

else (__y1, __y2))))

__x1

in

(self,

(if __x1 == __y1 then __value else Tcoerce_structure __y1))

| Tcoerce_functor (__x1, __x2) ->

let (self, __y1) = self#module_coercion __x1 in

let (self, __y2) = self#module_coercion __x2

in

(self,

(if (__x2 == __y2) && (__x1 == __y1)