User defined implicit conversion

User defined implicit conversion

[Alain De Vos]

Casting from one type to another is a real pain.
Does the functionality "User defined implicit conversion" exists?
If not are there strategies, general rules, to limit conversion to a minimum ?

We don't want as concatination :
result := to_type_a (from_type_a (X) & from_type_a (Y)) ;
when you could have :
result := X & Y ;

Re: User defined implicit conversion

[Simon Wright]

Alain De Vos <devosalain71@gmail.com> writes:

> Casting from one type to another is a real pain.
> Does the functionality "User defined implicit conversion" exists?
> If not are there strategies, general rules, to limit conversion to a
> minimum ?
>
> We don't want as concatination :
> result := to_type_a (from_type_a (X) & from_type_a (Y)) ;
> when you could have :
> result := X & Y ;

   function "&" (L : Type_X, R : Type_Y) return Type_A;
   function "&" (L : Type_Y, R : Type_X) return Type_A;

which means that the tiresome manipulation only has to happen in one
place. Well, two places, unless you say

   function "&" (L : Type_Y, R : Type_X) return Type_A
   is (R & L);

Re: User defined implicit conversion

[Egil H H]

On Wednesday, October 30, 2019 at 8:43:05 PM UTC+1, Alain De Vos wrote:
> Casting from one type to another is a real pain.
> Does the functionality "User defined implicit conversion" exists?
> If not are there strategies, general rules, to limit conversion to a minimum ?
> 
> We don't want as concatination :
> result := to_type_a (from_type_a (X) & from_type_a (Y)) ;
> when you could have :
> result := X & Y ;


If they are all type_a, as indicated in the example, 
you should be able to do just
result := X & Y;

Maybe you forgot to make the operator visible?
use type type_a;

Re: User defined implicit conversion

[Randy Brukardt]

"Alain De Vos" <devosalain71@gmail.com> wrote in message 
news:d9269cae-93e5-428c-9c7c-a7a1f5679806@googlegroups.com...
> Casting from one type to another is a real pain.
> Does the functionality "User defined implicit conversion" exists?
> If not are there strategies, general rules, to limit conversion to a 
> minimum ?
>
> We don't want as concatination :
> result := to_type_a (from_type_a (X) & from_type_a (Y)) ;
> when you could have :
> result := X & Y ;

The only reason you would have that is if you forgot to define "&" for 
Type_A. Depending on the definition of Type_A, that's unlikely to happen 
automatically.

Ergo, adding
      function "&" (Left, Right : Type_A) return Type_A is
              (to_type_a (from_type_a (X) & from_type_a (Y)));

Solves the problem in typical use.

Implicit conversion itself is the same is eliminating strong typing. If you 
really want that, you probably need to use subtypes rather than types. That 
is, "Type_A" should be a subtype rather than a type.

For example, instead of:

     type Type_A is new String;

use:

     Subtype Type_A is String;

And now you never need to use a type conversion between Type_A and String.

                                           Randy.

Re: User defined implicit conversion

[Dmitry A. Kazakov]

On 2019-10-30 22:26, Randy Brukardt wrote:

> Implicit conversion itself is the same is eliminating strong typing.

It depends, but arbitrary conversions certainly do.

> If you
> really want that, you probably need to use subtypes rather than types. That
> is, "Type_A" should be a subtype rather than a type.
> 
> For example, instead of:
> 
>       type Type_A is new String;
> 
> use:
> 
>       Subtype Type_A is String;
> 
> And now you never need to use a type conversion between Type_A and String.

This is a restriction imposed by Ada 83 in order to be able to generate 
such null-conversions. Actually it is not null, a subtype can add a 
constraint and then the conversion must include constraint check.

A more general case is when a subtype can have an independent 
representation and user-defined conversions:

    subtype UTF8_String is String;
       -- The conversion must recode Latin-1 to UTF-8

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: User defined implicit conversion

[AdaMagica]

Am Mittwoch, 30. Oktober 2019 20:43:05 UTC+1 schrieb Alain De Vos:
>  are there strategies, general rules, to limit conversion to a minimum ?

Yes, a good design. If you need many type conversions, there definitely is something wrong in your design.

Re: User defined implicit conversion

[G. B.]

Randy Brukardt <randy@rrsoftware.com> wrote:
> "Alain De Vos" <devosalain71@gmail.com> wrote in message 
> news:d9269cae-93e5-428c-9c7c-a7a1f5679806@googlegroups.com...
>> Casting from one type to another is a real pain.

> For example, instead of:
> 
>      type Type_A is new String;
> 
> use:
> 
>      Subtype Type_A is String;
> 
> And now you never need to use a type conversion between Type_A and String.

Implicit conversion introduces implicit knowledge, shared by authors of a
program. So, weak types should help employees stay safe in their jobs if
they have the knowledge.