Re: Ada Interfaces and the Liskov Substitution Principle

[Maciej Sobczak <see.my.homepage@gmail.com>]

On 29 Maj, 19:07, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
wrote:

> > We are talking about real:
>
> > X := Y;
>
> Huh, how are going to design a non-referential container of T'Class?

I don't. :-)
Polymorphism and references come hand in hand if you need the ability
to reassign. Copy-initialization is the only place where you can
safely get away with "values" of T'Class.
I think that the mess has its source in the push to have T'Class
behaving like normal value.


> > I say that you need one type String, that possibly uses strategy
> > internally to delegate details like encoding. You don't need encoding
> > to "leak out" at the level of types that the final user operates on.
>
> That would be indeed a mess. How would you pass an UTF-8 string to GTK+
> which knows nothing about your fancy patterns?

Then it should know. Otherwise there is no way it can interpret
correctly what I pass as parameters, unless you want to have
"implicit" conversions for parameters.

> Why don't you use the
> advantages of the types system?

I do use it, I just don't elevate implementation details to the level
of type that is handled directly by the user.

> > You can (and should) have dispatching internally in the implementation
> > of operations of String. I'm not proposing any case statements here!
>
> Here you are. What is the difference between internally and externally
> dispatching assignments?

Assignment is an operation that is meaningful syntactically - that's
why it is so tempting. Internally you can have anything else,
including regular subprogram calls that will do necessary conversions.

> >> Why a fixed string
> >> shouldn't be assigned to an unbounded one and reverse?
>
> > Of course it should!
>
> q.e.d.
>
> > What about template methods? ;-)
>
> Static polymorphism is exactly what I am trying to get rid of... (:-))

Here you are. :-)
Then we will never get into any agreement.

> Static polymorphism does not allow mixing types.

?

> Further you cannot design
> a library for formatting strings which would not be generic itself.

1. So?
2. Yes, I can. Just use arbitrary string type for formatting and then
convert to the destination type.

> Generics is a dead end.

Hm...

> > Looks like you guys need *real* templates. ;-)
>
> Surely they have them ... for formatting RM texts. See the difference?
> (:-))

:-)

> > But then the compiler would need to either force you to implement the
> > whole square of assignment operations, or use run-time checks to
> > discover whether the assignment within a given pair of leaf types is
> > provided.
> > The former is unrealistic with evolving or open-ended hierarchies, the
> > latter smells more like Python than Ada.
>
> The latter is what Ada does now, and I agree that this is not Ada (TM).

Agreed.

> The former is quite possible and IMO is the only right way to go. Note that
> the language should also allow declaring symmetries of the methods to
> reduce the number of independent variants.

Yes, but that reduces the complexity by a constant only, the problem
is still fundamentally squared.

--
Maciej Sobczak
http://www.msobczak.com/