[Caml-list] Re: Higher order functors over tuples

[Ivan Gotovchits <ivg@ieee.org>]

oleg@okmij.org writes:
> That seems to be the right problem for existentials -- which exist in
> OCaml under the name of objects. Methods are the interface and fields
> are private data. Of course we can get by with mere records -- but if
> we have objects anyway we might as well use them.

Yes, but objects suffer from two slight problems: lower performance due
to dynamic method dispatching and some issues with type system. Well,
not an issues really, but I think that you understood me. Though it
seems that this problems do not outweight the power of object system,
that was gracefully demonstrated by you.

In my real application I do shifted to objects. Though I still define
modules and then use functors as factories, producing objects of the
particular types. I'm not sure that this dual solution worths, but I
feel myself more comfortable with modules, rather than objects.

And, by the way, I've met the following signatures many times in
different frameworks written in different languages (matlab functional
objects, GnuRadio blocks, to name a few):

>>    module type Generator =
>>    sig
>>      type t
>>      type r
>>      val create: unit  -> t
>>      val result: t -> r option
>>      val step:   t -> t option
>>    end

extended with Transformer and Consumer:

  module type Consumer = 
  sig 
    type t
    type d
    val push: d -> t -> t
    val step: t -> t option
  end

  module type Transformer =
  sig
    type t
    type d
    type r
    val push: d -> t -> t
    val step: t -> t option
    val result: t -> r option
    (* or include Transformer and Consumer in ocaml 3.12+ *)        
  end

Haven't you seen this pattern in functional programming? May be it can
be expressed in a more natural way using FP idioms?


-- 
         (__) 
         (oo) 
   /------\/ 
  / |    ||   
 *  /\---/\ 
    ~~   ~~   
...."Have you mooed today?"...