Re: Ada Interfaces and the Liskov Substitution Principle

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

On 30 Maj, 10:43, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
wrote:

> > 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.
>
> Are you going to sell me pointers, right here, in c.l.a? (:-))

Don't you call them access variables? :-)

> Referential semantics is an implementation detail.

No, it is not. It gives you explicitly the possibility to "reseat" the
referer as well as sharing semantics. These are not details.
Even with strings, you might want to share the strategy for character
encoding.

> But it would be in vain, because assigning class-wide
> references in this context is semantically equivalent to assigning the
> targets.

Which I say should be banned, because the targets are not statically
known.

> >> 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.
>
> It cannot, it is ANSI C.

Then you need to call it somehow - anyway. How is the proliferation of
string types supposed to help here?

> I don't see any handling required. But let it be, then how is it different
> from your void * approach?

When did I say void*? It is spelled "interface".

> When you create a void * you have to somehow
> specify the hidden parameter of the case-statement:
>
>    void * X = Create_UTF8 ("foo");
>
> With types you just specify the type of the object instead:
>
>    X : UTF8_String := "foo";

Which - again - is not an assignment.
Just a reminder - we are talking about:

X := Y;

> The question is how do I do dispatching assignment?

Just don't. :-)

> Your point was that I shall not do it publicly. But, may I dispatch
> privately?

Privately you can dispatch to your internal strategies to get
character conversions, buffers, etc.

> >> Static polymorphism does not allow mixing types.
>
> > ?
>
> Instances from a statically polymorphic class of types are unrelated types.
> You cannot have any polymorphic object from that class, only specific
> objects. For the same reason you cannot have any class-wide operation from
> that class.

So?

> >> Further you cannot design
> >> a library for formatting strings which would not be generic itself.
>
> > 1. So?
>
> Write an editor for such strings, store a string, send it over the network,
> do anything after uninstalling the compiler ...

Still don't see the problem.

> > 2. Yes, I can. Just use arbitrary string type for formatting and then
> > convert to the destination type.
>
> Why should I bother to have UTF-8 or ASCII strings if anything is
> Wide_..._Wide_Unbounded anyway?

The Wide_..._Wide_Unbounded can be useful as an intermediary format
for conversion between other types, which themselves might still be
very useful providing their own characteristics.

> What are you going to do if the endianess
> of Wide x n Character does not fit your machine?

And why should I bother with endianness here?

> Whatever pattern you use, you will have to deal with this number of
> cases.

Or I just delegate to locale and conversion library that is part of my
operating system.
On my system I can have LOTS of different locales:

$ locale -a | wc -l
502

Do you really expect me to have 502 classes in my program just for
strings?

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