That would be an answer for Haskell (though a proper one would refer to fmap), but it does not work like that in OCaml. You do know some OCaml, right?

But if it's so obvious, then you can say how it works for the following concrete example:

  module type S = sig
    type t
    val f: t -> int
  end
  
  module F = functor (X: S) -> struct
    type s = X.t * X.t
    let g x = X.f x + X.f x
  end
  
  module A : S = struct
    type t = float
    let f x = int_of_float x
  end
  
  module B : S = struct
    type t = int
    let f x = 2*x
  end
  
  module X = F(A)
  module Y = F(B)

The point is: In the ML module system there is no equivalent to fmap: (A -> B) -> (F A -> F B), i.e. the functor action on morphisms. So, functors in Haskell and OCaml are different things. If you want to claim otherwise, you'll have to make an actual argument for it.