module - programacion - Manejo de conflictos de nombres de tipos al incluir dos módulos en OCaml

ocaml lenguaje de programacion

Question

¿Alguien puede ayudarme con el ejercicio 12.5 del libro de Jason Hickey?

Básicamente, la pregunta es cómo evitar el siguiente problema conflictivo debido a "incluir" en la práctica. Gracias.

# module type XSig = sig
type t
val x : t
end;;
# module A : XSig = struct
type t = int
let x = 0
end;;
# module B : XSig = struct
type t = int
let x = 1
end;;
# module C = struct
include A
include B
end;; 

Answer 1

No sé qué dice exactamente la pregunta, pero con respecto a su fragmento de código, hay varias formas muy diferentes de interpretar lo que intenta hacer.

Lo que está haciendo actualmente es sellar A y B bajo dos firmas abstractas e incompatibles, y luego tratar de mezclarlas en un módulo, solo para tener un conflicto de nombre.

Tal vez solo quieres evitar el conflicto de nombres. La solución más simple, por supuesto, no es usar los mismos nombres para los dos tipos At y Bt . Entonces puedes "no incluir B ":

module C = struct
include A
let x_b = B.x
end

La mejor solución es usar OCaml 3.12 sustitución destructiva para firmas, with type t := foo , para enmascarar el tipo t del módulo B :

module C = struct
include A
type u = B.t (* rename B.t into ''u'' to avoid name conflict *)
include (B : XSig with type t := u) (* replaces ''t'' by ''u'' *)
end

También puede desear que los tipos para los módulos A y B sean compatibles. En este caso, no debe sellarlos con tipos abstractos.

module type XSig = sig
type t
val x : t
end
module A = struct
type t = int
let x = 0
end
(* if you want to check that A can be sealed by XSig, do it here,
outside the main declaration *)
let _ = (module A : XSig)
module B = struct
type t = int
let x = 1
end
module C = struct
include (A : XSig with type t := int)
include (B : XSig with type t := int)
end
(* module C : sig
val x = int
end *)

En este ejemplo, los dos tipos At y Bt son eliminados por la sustitución destructiva := . Si desea que su módulo C tenga un tipo t , puede escribir cualquiera de los siguientes:

module C = struct
type t = int
include (A : XSig with type t := t)
include (B : XSig with type t := t)
end

o, utilizando la sustitución no destructiva (cambia la definición del tipo en lugar de eliminarlo):

module C = struct
include (A : XSig with type t = int)
include (B : XSig with type t := t)
end

Consulte la página del manual para ver el type type t := ... sustitución destructiva type type t := ... para obtener más detalles, y el del clásico with type t = ... construcción para comparar.