Version française
Home     About     Download     Resources     Contact us    
Browse thread
subtyping and inheritance
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Jerome Vouillon <Jerome.Vouillon@i...>
Subject: Re: subtyping and inheritance
Hello,

> My specific problem is: I have a program with classes for "terminal"
> and "nonterminal" symbols. Both inherit from a base class "symbol". The
> symbol class inherits from a class "ord", which defines a virtual method
> "compare". This allows me to compare terminals with terminals and
> nonterminals with nonterminals, but it also allows comparison between
> symbols (all three classes redefine "compare").
> 
> Look at this graph:
> 
>          ord                ->  defines virtual method "compare"
>           |
>         symbol              ->  redefines "compare"
>        /      \
>    terminal  nonterminal    ->  both redefine "compare"
> 
> But the problem is: I will never be able to compare terminals and
> nonterminals with each other, because the appropriate comparison method
> as defined in "symbol" has been "forgotten" - it is redefined in all
> child classes. Thus, I am not able to coerce them to "symbol".
> 
> I have worked around this with the following inheritance scheme:
> 
>     ---- ord -----          ->  defines virtual method "compare"
>     |            |
>     |   symbol   |          ->  has a method "compare_symbol"
>     |  /      \  |
>    terminal  nonterminal    ->  both redefine "compare"
> 
> Although it is now possible to coerce terminals and nonterminals
> to symbols and have them thus compared via "compare_symbol", I am not
> content with this scheme: I would really like to have all methods from
> "ord" in "symbol", which all make use of the virtual "compare" method.

I think the method "compare" in class "ord" need not be a binary method: its
argument type can probably instead be a type parameter of the class.
    class virtual ['a] ord = object
      method virtual compare : 'a -> bool
      (* ... *)
    end;;
Then, the method "compare" can be given the type "symbol -> bool" in
class "symbol" (and its subclasses) :
    class symbol = object (self)
      inherit [symbol] ord
      method x = "x"
      method compare other = self#x = other#x
    end;;
    class terminal = object
      inherit symbol
      method x = "a"
      method y = "y"
    end;;
This way, you can compare objects from the class "symbol" and any of
its subclasses.
    # new terminal#compare new symbol;; 
    - : bool = false
    # new terminal#compare (new terminal :> symbol);;
    - : bool = true

Regards,

-- Jerome