list of objects

list of objects

[Julian Assange]

I have a variety of signature schemes for text. I'd like to have
a list of these schemes, so I can do such things as:

        List.map (fun x -> x#make text) schemes

Neither classes or modules are first class objects. However, 
objects are. So, my first thought was to create something along the lines
of 

        let schemes = [new scheme_11; ...; new scheme_n]

Since the objects are functional (at least so far) this seems like an
acceptable approach. 

  class virtual signature =
  object 
  end
    
  class ['a] plain =
  object (self)
    inherit signature
    method make s = s
    method digest s = Digest.string (self#make s)
    method compare (a:'a) b = a = b
  end
    
  class ['a] simple =
  object
    inherit ['a] plain 
    method make s = string_filter (alphabetize >> lower) s
  end

let sig_list = [new plain; new simple] 

On compilation, this produces:

The type of this expression, '_a Sigs.plain list,
contains type variables that cannot be generalized

However sending the exact same code to the top level,
produces:
module Sigs :
  sig
    val vanilla : 'a -> 'a
    val lower : char option -> char option
    val alphabetize : char option -> char option
    val string_filter : (char option -> char option) -> string -> string
    class virtual signature : object end
    class ['a] plain :
      object
        method compare : 'a -> 'a -> bool
        method digest : string -> Digest.t
        method make : string -> string
      end
    class ['a] simple :
      object
        method compare : 'a -> 'a -> bool
        method digest : string -> Digest.t
        method make : string -> string
      end
  end
val sig_list : '_a Sigs.plain list = [<obj>; <obj>]

Works just fine! What gives?

Re: list of objects

[Xavier Leroy]

Your approach looks reasonable.  As for your question:

> let sig_list = [new plain; new simple] 
> On compilation, this produces:
>   The type of this expression, '_a Sigs.plain list,
>   contains type variables that cannot be generalized
> However sending the exact same code to the top level,
> produces:
> val sig_list : '_a Sigs.plain list = [<obj>; <obj>]
> Works just fine! What gives?

The '_a is a non-generalized type variable, i.e. an unknown type that
will be determined later at first use.  (See the FAQ
http://caml.inria.fr/FAQ/FAQ_EXPERT-eng.html for more detailed
explanations.)

For separately-compiled units, the notion of "first use" is unclear,
since the unit can be referenced by several other separately-compiled
units, which could each instantiate the unknown type in different
ways.  So, to keep things simple, the compiler requires that no
non-generalized type variables remain in the types inferred for
definitions of a compilation unit.

Thus, you need to put either a .mli file giving the type you want for
sig_list, or a type constraint on the definition of sig_list:
        let sig_list = ([new plain; new simple] : t Sigs.plain list)
with the type you want for "t".

Hope this helps,

- Xavier Leroy