Hi all,
Suppose I want to make a function that takes a module parameter. I can think of two ways to do it: either I wrap the function inside a functor:
module On_monad (M : Monad.S) = struct
let map_m x ~f = (* something using M *)
end
module OM = On_monad (M)
let foo = OM.map_m (* ... *)
Or I pass the module as a first-class module into the function:
let map_m (module M : Monad.S) x ~f = (* something using M *)
let foo = map_m (module M) (* ... *)
What I don’t know is the relative performance and idiomatic-ness tradeoff of these two solutions. Is there always a noticeable performance hit to using first-class modules? Naively I presume that the latter will need resolving at run-time whereas the former can be resolved at compile time, but I don’t actually know what the OCaml compiler would do.
Furthermore, since the second alternative is significantly easier to work with in situations where I only use map_m
with monad M
once, are there perf reasons against adding doing this the first way (and maybe adding more functions to On_monad
, and then writing a helper function as follows?
let map_m (module M) x ~f =
let module OM = On_monad (M) in
OM.map_m x ~f