Re: Ada Interfaces and the Liskov Substitution Principle

[Stefan Lucks <lucks@th.informatik.uni-mannheim.de>]

On Thu, 24 May 2007, Dmitry A. Kazakov wrote:

> On Thu, 24 May 2007 13:12:56 +0200, Stefan Lucks wrote:

>> You are using a very broad and generalised interpretation of the LSP. My
>> interpretation -- and I believe this is the common and usual one -- is
>> that "X: in T" in the parameterlist of a subprogram does not deal with
>> some "artificial" type "in T", just with "T".
>
> If it dealt with T, then the following program were legal:
>
>   procedure Foo (X : in out T);
>
>   procedure Bar (X : in T) is
>   begin
>      Foo (X):  -- Fortunately illegal in Ada
>   end Bar;

The "X: in T" part in Bar's contract means "I (Bar) will abstain from 
using certain properties X might have" (where "certain properties" are 
well defined, but I am too lazy to describe them explicitely).

When calling "Foo(X)", Bar is trying to break this contract -- and 
fortunately, the compiler stops that attemtped fraud.

Note that ther is a difference between "I will abstain from using" and "I 
don't provide", and the LSP is all about the second. The fact that inside 
Bar, the programmer is forced to obey the promise made in the parameter 
list is not in violation of the LSP.

> Yes, but then LSP should be re-formulated appropriately. And there is
> nothing automatically wrong in disallowing operations. I would like to see
> it in Ada.

Is there any language that allows that? I am dreaming of something like

   type Base is new Some_Tagged_Type with ...;
     procedure Primitive_1(...);
     procedure Primitive_2(...);

   type Super is new Base with out Primitive_2; -- this is not Ada!
     -- Super "inherits" Primitive_1 from Base, but not Primitive_2.

   B: Base;
   S: Super;

   procedure Class_Wide_Base (Object: Base'Class);
   procedure Class_Wide_Super(Object: Super'Class);

   Class_Wide_Base(B);   -- legal, of course;
   Class_Wide_Super(S);  -- also legal, of course;
   Class_Wide_Super(B);  -- this should be legal!!
   Class_Wide_Base(S);   -- this should be illegal!

This would allow to "take away" operations without actually violating LSP 
(as I understand LSP). Perhaps the following would in also do the job (of 
course, I could not define S of type Super, but well ...):

   type Super is interface Base with out Primitive_2;



-- 
Stefan Lucks      (moved to Bauhaus-University Weimar, Germany)
------  I  love  the  taste  of  Cryptanalysis  in  the  morning!  ------