Restructure 2 functors to avoid double implementation

Question

(* I would like to reformulate a question that I posted previously to make it clearer and attract more attention... I think the question is still interesting... *)

I have defined a module type ZONE as follows:

(* part of zone.ml *)
module type ZONE =
sig
  type info
  type prop
  type t = { s: string; p: prop; i: info }
  val f1 : t -> string
end

where i: info is used to contain various information, which help avoid repeat calculation. It will not be always the same because it is up to the Prop from which a Zone is built. For instance, here is a functor to build a module Zone of type ZONE from a module of type PROP, with a basic info:

(* part of zone.ml *)
module ZoneFun (Prop : PROP) = struct
  type info = { a: int }
  type prop = Prop.t
  type t = { s: string; p: prop; i: info }
  let f0 z = "f0"
  ...
end

Here is another functor to build a module Zone of type ZONE, with a relatively more complicated info:

(* zoneFunPrec.ml *)
module ZoneFunPrec (Prop: PROP) (Prec: ZONESM) = struct
  type info = { a: int; b: Prec.t }
  type prop = Prop.t
  type t = { s: string; p: prop; i: info }
  let get_prec z = z.info.prec
  let f0 z = "f0"
  ...
end

Then I can use the functors as follows:

module ZoneC = ZoneFun(PropC)
module ZoneA = ZoneFunPrec(PropA)(ZonesmB)

The problem is that, type info and get_prec (ZoneFun has it, whereas ZoneFunPrec hasn't) are the only differences of these 2 functors; their type prop and type t are same, their functions f0, f1... (there are quite several) are exactly same too.

So I am wondering how to avoid from implementing f0, f1, etc. twice...

Does anyone have an idea of restructuring the modules/functors to achieve this and make them meaningful?

Please try the problem as small as possible and make it compilable. Your code contains too much meaningless details to answerers, not complete, and not compilable. ZoneFunPrec(ProcC) is wrong. It must be ZoneFun(ProcC) — camlspotter

camlspotter camlspotter · Accepted Answer · 2013-09-25T11:00:57

Create a module which only contains the shared patterns:

module Shared = struct
  type prop = Prop.t
  type t = { s: string; p: prop; i: info }
  let f0 z = "f0"
  ...
end

I believe here your real f0 is more complex and depends on other things in your code. (Otherwise it can be just defined outside of the context separately.)

This module Shared is not really compilable since it contains some free names like Prop and info. Change it to a functor which takes these names from its parameter:

module MakeShared(A : sig
  module Prop : sig
    type t
  end
  type info
end) = struct
  type prop = Prop.t
  type t = { s : string; p : prop; i : info }
  let f0 z = "f0"
  ...
end

You may need more things in the signature for A. It depends on the code you omitted.

You can use this MakeShared functor in the body of ZoneFun and ZoneFunPrec to avoid code duplication. It should be like:

module ZoneFun (Prop : PROP) = struct
  type info = { a: int }
  type info_ = info
  include MakeShared(struct
    module Prop = Prop
    type info = info_
  end)
end

Here the type alias info_ is required to avoid the cyclic recusvie type definition type info = info. Unlike module which is not recursive therefore module Prop = Prop works as intended, type declaration is always recursive.

This is one way to refactor your code. There may be others but it is not very clear from your pseudo code. For example you may be able to use MakeShared not inside the functor but where you create an actual instance module:

module ZoneC = struct
  include SmallerZoneFun(PropC)
  include MakeShared(...)
end

Restructure 2 functors to avoid double implementation

2 Answers