Минусы ООП

(* box 1 *)
module List_stack :
  (* public *)
  sig
    exception Empty_stack
    type 'a t
    val make : unit -> 'a t
    val push : 'a -> 'a t -> unit
    val pop  : 'a t -> 'a
  end = struct
 
    exception Empty_stack
 
    type 'a t = 'a list ref
 
    let make () = ref []
 
    let push x st =
      st := x :: !st
 
    let pop st =
      match !st with
      | [] -> raise Empty_stack
      | head :: rest ->
        begin
          st := rest ;
          head
        end
 
  end
 
 
 
(* box 2 *)
module Array_stack :
  (* public *)
  sig
    exception Empty_stack
    type 'a t
    val make : unit -> 'a t
    val push : 'a -> 'a t -> unit
    val pop  : 'a t -> 'a
  end = struct
 
    (* public impl *)
 
    exception Empty_stack
 
    type 'a t =
      { mutable items : 'a option array
      ; mutable count : int
      }
 
    (* private *)
 
    let grow_factor = 1.6
    let init_capacity = 10
 
    let grow src =
      let old_cap = Array.length src in
      let new_cap = int_of_float (grow_factor *. float_of_int old_cap) in
      let dst = Array.make new_cap None in
      Array.blit src 0 dst 0 old_cap ;
      dst
 
    let ensure_cap s =
      if s.count < Array.length s.items
      then ()
      else s.items <- grow s.items
 
    (* public impl *)
 
    let make () =
      { items = Array.make init_capacity None
      ; count = 0
      }
 
    let push x s =
      ensure_cap s ;
      Array.set s.items s.count (Some x) ;
      s.count <- s.count + 1
 
    let pop s =
      if s.count = 0
      then raise Empty_stack
      else
        s.count <- s.count - 1 ;
        match Array.get s.items s.count with
        | None   -> raise (Failure "unreachable")
        | Some x ->
          begin
            Array.set s.items s.count None ;
            x
          end
 
  end
 
 
 
(* interface *)
module type Stack =
  sig
    exception Empty_stack
    type 'a t
    val make : unit -> 'a t
    val push : 'a -> 'a t -> unit
    val pop  : 'a t -> 'a
  end
 
 
 
(* box 3 *)
module Main (Stack : Stack) =
  struct
 
    let main () =
      let s = Stack.make () in
      for i = 1 to 3 do
        Stack.push i s
      done ;
      for i = 1 to 3 do
        Stack.pop s |> Printf.printf "%d "
      done ;
      Printf.printf "\n"
 
  end
 
let _ =
  let module M1 = Main (List_stack) in
  let module M2 = Main (Array_stack) in
  M1.main () ;
  M2.main ()

module List_stack : Stack =
  struct
    (* impl *)
  end