I think the recursive modules definitions do not = completely propagate safe definitions: I get

Exception: = Undefined_recursive_module ("SimpleLayer.ml", 104, 23)

with the attached code.

Chris D.

module type LAYER =3D

sig

type topT

type topV

val topInj : string -> = topT

val topOp : topT -> = topV

val topExt : topV -> = string

type t

type v

val inj : string -> t

val op : t -> v

val ext : v -> string

end

(* base module -- no lower layer present, empty types, all = operations are errors *)

(* *** ``safe'' module (section 7.8 of refman) *** = *)

module MakeBase =3D

functor (Above : LAYER) ->

struct

type topT =3D Above.topT

type topV =3D Above.topV

let topInj =3D fun x -> Above.topInj = x(*safe*)

let topOp =3D fun x -> Above.topOp x = (*safe*)

let topExt =3D fun x -> Above.topExt = x(*safe*)

type t =3D = EmptyT &= nbsp; (* wouldn't revised syntax be nice *)

type v =3D EmptyV

let inj =3D fun _ -> raise (Failure = "inj")

let op =3D fun _ -> raise (Failure "op")

let ext =3D fun _ -> raise (Failure "ext")

end

(* an intermediate level *)

module MakeMiddle =3D

functor (Below : LAYER) ->

functor (Above : LAYER) = ->

struct

type topT =3D Above.topT

type topV =3D Above.topV

let topInj =3D Above.topInj

let topOp =3D = Above.topOp

let topExt =3D Above.topExt

type t =3D

| BelowT of = Below.t

| OneT of char

| TwoT of char * = topT

= ;

type v =3D

| BelowV of = Below.v

| StringV of = string

= ;

let inj =3D fun s -> (* = <T> ::=3D 1_ [OneT _] | 2_? [TwoT _ ?] | <Below.T> = *)

match (String.get s 0) = with

| '1' -> OneT (String.get s = 1)

| '2' -> TwoT(String.get s 1, = topInj (String.sub s 2 ((String.length s)-2)))

| _ -> BelowT = (Below.inj s)

let op =3D

function

| BelowT t -> = BelowV (Below.op t)

| OneT(c) -> = StringV ("1" ^ (String.make 1 c))

| TwoT(c,t) -> = StringV ("2" ^ (String.make 1 c) ^ (topExt (topOp = t)))

= ;

let ext =3D

function

| BelowV v -> = Below.ext v

| StringV s -> = s

end

(* imagine there were more levels -- maybe even tree/graph = structured *)

(* top level -- close the open recursion of topInj and topExt = *)

(* *** ``safe'' module (section 7.8 of refman) *** = *)

module MakeTop =3D

functor (Below : LAYER) ->

struct

type t =3D Below.t

type v =3D Below.v

let inj =3D fun x -> Below.inj x (*safe*)

let op =3D fun x -> Below.op x (*safe*)

let ext =3D fun x -> Below.ext x (*safe*)

type topT =3D t

type topV =3D v

let topInj =3D fun x -> inj x = (*safe*)

let topOp =3D fun x -> op x = (*safe*)

let topExt =3D fun x -> ext x = (*safe*)

end

(* simplest test *)

module rec B : LAYER =3D MakeBase(T)

and T : LAYER =3D = MakeTop(B)

(* simple test *)

module rec B : LAYER =3D MakeBase(M)

and M : LAYER =3D = MakeMiddle(B)(T)

(* imagine there were more levels = *)

and T : LAYER =3D = MakeTop(M);;

T.topOp (T.topInj "2x1x");;

T.topExt (T.topOp (T.topInj "2x1x"))