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.