Record fields are simply offsets in a struct, so the type must be fully known when compiling the code. It would not be possible to compile a function that could work on two different types of struct that both happened to have a .info field.

There's a functional update construct for objects:

http://caml.inria.fr/pub/docs/manual-ocaml/objectexamples.ht...

It works like { r with field = value }.

Instead, try taking a look at the store-comonad mechanism I've got below: https://news.ycombinator.com/item?id=9213482

  (* Create a basic lens type *)
  type ('a, 'b) t = {
    get : 'a -> 'b;
    set : 'b -> 'a -> 'a
  }
  
  (* A base lens, kind of like a base class *)
  type 'a myrecord_lens = {
      foo : ('a,int) t;
      label : ('a,string) t
  }
  
  (* Record 1 *)
  type myrecord1 = {
      foo : int;
      bar : float;
      label : string
  }
  let myrecord1 = {
      foo = 1;
      bar = 2.3;
      label = "myrecord1"
  }
  let foo_lens = { 
      get = (fun x -> x.foo); 
      set = (fun v x -> { x with foo = v })
  }
  let bar_lens = { 
      get = (fun x -> x.bar); 
      set = (fun v x -> { x with bar = v })
  }
  let label_lens = { 
      get = (fun x -> x.label); 
      set = (fun v x -> { x with label = v })
  }
  let myrecord1_lens = {
      foo = foo_lens; 
      label = label_lens
  }
  
  (* Record 2 *)
  type myrecord2 = {
      foo : int;
      buz : string;
      label : string
  }
  let myrecord2 = {
      foo = 4;
      buz = "five";
      label = "myrecord2"
  }
  let foo_lens = { 
      get = (fun x -> x.foo); 
      set = (fun v x -> { x with foo = v })
  }
  let buz_lens = { 
      get = (fun x -> x.buz); 
      set = (fun v x -> { x with buz = v })
  }
  let label_lens = { 
      get = (fun x -> x.label); 
      set = (fun v x -> { x with label = v })
  }
  let myrecord2_lens = {
      foo = foo_lens; 
      label = label_lens
  }
  
  (* Write a generic function to work with these objects*)
  let myfunc (myrecord:'a) (lens:'a myrecord_lens) =
      let _ = Printf.printf "Working with: %s\n" (lens.label.get myrecord) in
      (lens.foo.get myrecord) + 1
  
  (* Get some results *)
  let _ = myfunc myrecord1 myrecord1_lens
  let _ = myfunc myrecord2 myrecord2_lens

  val myfunc : 'a -> 'a myrecord_lens -> int = <fun>
  Working with: myrecord1
  - : int = 2
  Working with: myrecord2
  - : int = 5

As a final note, there is an OCaml lens library to help with this, but you're still mostly stuck writing lenses by hand:

https://github.com/avsm/ocaml-lens

Also, Jane Street has fieldslib, which does some interesting things with record types. It doesn't have exactly what I described above, but it does help in many cases and they have some nice macros to help generate getters and setters:

https://github.com/janestreet/fieldslib

Truly what you want is the "pre-applied" lens or the store comonad

    type ('i, 'j) store = { get : 'j; set : 'j -> 'i };;

    let o = object
      val slot = 3
      method slot = 
        { get = slot
        ; set = fun slot' -> {< slot = slot' >}
        }
    end

    val o : < slot : ('a, int) store > as 'a

    # o#slot.get;;
    - : int = 3
    # (o#slot.set 10)#slot.get;;
    - : int = 10
    # o#slot.set o#slot.get;;
    - : < slot : ('a, int) store > as 'a = <obj>