Hi,

I've simulated objects with records like this in the past in when I
didn't need method resolution, and this thread made me worry about the
execution speed of such a pattern compared to ocaml objects.
So I made a little comparison between records and classes to do this
task (the code follows my message). Here is the result :

benjamin@benjamin-laptop:~/Work/Stuff$ ocamlopt classesvsrecords.ml -o
classesvsrecords && ./classesvsrecords
Classes: build = 1.316082, apply = 2.324145
Records: build = 1.872116, apply = 2.320145

Basically, objects are created faster than records (I think that an
object is created in O(1) whereas a record takes O(number of closures)
to be filled). Calls take the same time.

So, if you have to allocate a great number of values, then I think you
should consider using objects, otherwise, records wrapping the values
seem to be a correct option.

  Benjamin.

(* classes *)

let show l = List.map (fun x -> x#show) l

class integer x =
  object
    method show = print_int x
    method to_string = string_of_int x
  end

class floating x =
  object
    method show = print_float x
    method to_string = string_of_float x
  end
    
(* records *)

type element = { show : unit -> unit ; to_string : unit -> string }

let wrap_int x = {
  show = (fun () -> print_int x) ; 
  to_string = (fun () -> string_of_int x)
}

let wrap_float x = {
  show = (fun () -> print_float x) ;
  to_string = (fun () -> string_of_float x)
}
  
(* bench *)

let test_classes () =
  let rec build_classes n acc =
    if n <= 0 then
      acc
    else
      build_classes
	(pred n)
	((new floating (float_of_int n))
	 :: (new integer n)
	 :: acc)
  in
  let t1 = Sys.time () in
  let list = build_classes 1000000 [] in
  let t2 = Sys.time () in
    List.iter (fun x -> ignore (x#to_string)) list ;
    t2 -. t1, Sys.time () -. t2

let test_records () =
  let rec build_records n acc =
    if n <= 0 then
      acc
    else
      build_records
	(pred n)
	((wrap_float (float_of_int n))
	 :: (wrap_int n)
	 :: acc)
  in
  let t1 = Sys.time () in
  let list = build_records 1000000 [] in
  let t2 = Sys.time () in
    List.iter (fun x -> ignore (x.to_string ())) list ;
    t2 -. t1, Sys.time () -. t2

let _ =
  let tci, tca = test_classes ()
  and tri, tra = test_records () in
  Printf.printf
    "Classes: build = %f, apply = %f\nRecords: build = %f, apply = %f
\n" 
    tci tca tri tra


Le mardi 13 novembre 2007 à 21:39 +0000, Dmitri Boulytchev a écrit :
> Are structures allowed? :)
> 
> type t = {show : unit -> string}
> 
> let show l = List.map (fun x -> x.show ()) l
> 
> let integer  x = {show = fun () -> string_of_int   x}
> let floating x = {show = fun () -> string_of_float x}
> let boolean  x = {show = fun () -> string_of_bool  x}
> 
> let _ =
>   List.iter
>     (Printf.printf "%s\n")
>     (show
>        [
>      integer 10;
>          floating 3.14;
>          boolean true;
>        ]
>     )
> 
>     OCaml does not have Haskell-style existential types (I don't exactly
> know why, but can
> presume that they may interfere with objects, which  considered to be
> much more worthy).
>      I like modules and functors very much, too, but, first, modules are
> not "first-class
> citizens", and second, there may be no need to re-implement all your
> stuff to
> start using objects --- OCaml is fairy orthogonal language.
> 
>     Best regards,
>     DB.
> 
>     P.S. Objects are efficient :)
>    
> 
> 
> > Ahh, right!  Sorry, I forgot to mention I'm looking for a possible
> > solution
> > without classes.
> >
> > I ask because most of my code base is modules and functor based and it
> > would
> > be a pain to convert over.  Also because performance is typically
> > better with
> > just functions and data types.
> >
> > I feel like a solution without the OO side is possible through perhaps an
> > analog of existential types?
> >
> > Peng
> >
> > On Tuesday 13 November 2007 04:14:06 pm Dmitri Boulytchev wrote:
> >
> > >    Try using classes for this purpose:
> >
> > >let show l = List.map (fun x -> x#show) l
> >
> > >class integer x =
> > >  object
> > >    method show = string_of_int x
> > >  end
> >
> > >class floating x =
> > >  object
> > >    method show = string_of_float x
> > >  end
> >
> > >class boolean x =
> > >  object
> > >    method show = string_of_bool x
> > >  end
> >
> >
> > >let _ =
> > >  List.iter
> > >    (Printf.printf "%s\n")
> > >    (show
> > >       [
> > >     new integer 10;
> > >         new floating 3.14;
> > >         new boolean true;
> > >       ]
> > >    )
> >
> > >    Best regards,
> > >    Dmitri Boulytchev,
> > >    St.Petersburg State University.
> >
> > >>Hi,
> > >>
> > >>Is there a way to create lists in which the elements may be of
> > >>differing types but which all have some set of operations defined
> > >>(eg. tostr) in common?  One can then imagine mapping over such lists
> > >>with "generic" versions of those common operations.  Here's a concrete
> > >>example of what I mean:
> > >>
> > >>  module Int = struct
> > >>    type t = int
> > >>    let show x = string_of_int x
> > >>  end
> > >>  module Float = struct
> > >>    type t = float
> > >>    let show x = string_of_float x
> > >>  end
> > >>  module Bool = struct
> > >>    type t = bool
> > >>    let show x = string_of_bool x
> > >>  end
> > >>
> > >>  let xs = [`Int 1; `Float 2.0; `Bool false]
> > >>  let showany x = match x with
> > >>
> > >>    | `Int x -> Int.show x
> > >>    | `Float x -> Float.show x
> > >>    | `Bool x -> Bool.show x
> > >>
> > >>  ;;
> > >>  List.map showany xs;;
> > >>
> > >>Essentially we have ints, floats and bools.  All these types can be
> > >>shown.  It would be nice to be able to create a list of them [1; 2.0;
> > >>false] that you can then map a generalized show over.  In the above
> > >>example, I used polymorphic variants in order to get them into the
> > >>same list and then had to define my own generalized show function,
> > >>"showany".  This is fine as there is only one shared operation but if
> > >>there is a large set of these common operations, it becomes
> > >>impractical to define a generalized version for each of them.
> > >>
> > >>I've come across a way to do this in haskell using what they call
> > >>"existential types".
> > >>
> > >>  http://www.haskell.org/haskellwiki/Existential_type
> > >>
> > >>I don't really understand existential types however and don't know if
> > >>OCaml has them nor how to use them.
> > >>
> > >>So.  How can one do this in OCaml?  Is there perhaps a camlp4
> > >>extension that can do this?  Is there a possible functor trick that
> > >>can take N modules as arguments and spit out a new module with a
> > >>generalized type that can take on any of the types in the arguments
> > >>and also make generalized versions of operations common to the N
> > >>modules?  Are there existential types or equivalents in OCaml?  If so
> > >>how does one go about using them?
> > >>
> > >>Thanks in advance to anyone who forays into this bundle of questions.
> > >>
> > >>Peng
> >
> > >_______________________________________________
> > >Caml-list mailing list. Subscription management:
> > >http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
> > >Archives: http://caml.inria.fr
> > >Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> > >Bug reports: http://caml.inria.fr/bin/caml-bugs
> >
> >
> >
> 
> _______________________________________________
> Caml-list mailing list. Subscription management:
> http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
> Archives: http://caml.inria.fr
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs
> 
> 
> _______________________________________________
> Caml-list mailing list. Subscription management:
> http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
> Archives: http://caml.inria.fr
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs