Dear OCaml users,

consider the following microbenchmark:

<snip>
class s (z : string)  (y : int)  (x : int) =
  object method z = z method y = y method x = x
end

type t = { x : int; y : int; z : string}

let foo_s _ =
 (new s) "Example" 0 1

let foo_t _ = {x=1; y=0; z="Example"}

let one_s _ = (foo_s ())#x

let one_t _ = (foo_t ()).x

let fac =
  let rec fac n =
    let f =
      let rec f n a = if n <= 1 then a else f (n - (one_s ())) (n * a)  in
f (* change one_t to one_s or vice-versa *)
       in
    f n 1  in
  fac
let bench =
  let rec bench n a =
    if n <= 0
    then a
    else (let x = a && ((fac 20) == (20 * (fac 19)))  in bench (n - 1) x)
in
  bench
let test = bench 10000000 true
let main _ = test
</snip>

If I run it with ocamlopt 4.05.0+flambda and -O3, the version that uses
one_s takes about 7.5s whereas the one with one_t uses 0.35s. I know that
object method lookup is more costly than records, of course. This
particular case baffles me, though. Why is the class not completely inlined?

Also as a related question, is there a way to have the lookup semantics of
methods without the open recursion part? That is, can I have a class that
consists of values, not methods? It would love to have open tuples in some
cases. For example, I'd like to write a function that takes a tuple of any
length, because it only needs the first element.

thanks,

Christoph