www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - interface inference

reply Antonio <antoniocabreraperez gmail.com> writes:
```d
interface I {
         bool check();
}
class A : I {
         bool check() =>true;
}
class B : I {
         bool check() =>false;
}

I aOrB(bool check) => check ? new A() : new B();

void main()
{
   assert( aOrB(true).check );
}
```

Compiler error:

```d
x.d(11): Error: cannot implicitly convert expression `check ? new 
A : new B` of type `object.Object` to `x.I`
```

Basically, the ternary conditional ```?:``` result type is not 
inferred even if the type returned by the two possibilities are 
the same.

**Is it a bug or the expected behaviour?**
Nov 23 2023
next sibling parent reply Antonio <antoniocabreraperez gmail.com> writes:
On Thursday, 23 November 2023 at 19:17:20 UTC, Antonio wrote:

 ```d
 interface I {
         bool check();
 }
 class A : I {
         bool check() =>true;
 }
 class B : I {
         bool check() =>false;
 }

 I aOrB(bool check) => check ? new A() : new B();

 void main()
 {
   assert( aOrB(true).check );
 }
 ```

 Compiler error:

 ```d
 x.d(11): Error: cannot implicitly convert expression `check ? 
 new A : new B` of type `object.Object` to `x.I`
 ```



I'm forced to explicitly write the cast this way

```d
I aOrB(bool check) => check ? cast(I) new A() : cast(I) new B();
```

But it is not necessary when I write same code using 
if/else/return statements

```d
I aOrB(bool check){
   if(check)
     return new A();
   else
     return new B();
}
```


**Is it the expected behaviour for ternary conditional?**
Nov 28 2023
parent reply Dom DiSc <dominikus scherkl.de> writes:
On Tuesday, 28 November 2023 at 11:01:14 UTC, Antonio wrote:

 ```d
 I aOrB(bool check){
   if(check)
     return new A();
   else
     return new B();
 }
 ```

 **Is it the expected behaviour for ternary conditional?**


Here the compiler knows what type to return (from the function 
signature).
But the ternary operator doesn't know this, so its arguments need 
to be of the same type (or implicitly convert to a common type).
Nov 28 2023
parent Antonio <antoniocabreraperez gmail.com> writes:
On Tuesday, 28 November 2023 at 14:10:30 UTC, Dom DiSc wrote:

 On Tuesday, 28 November 2023 at 11:01:14 UTC, Antonio wrote:

 ```d
 I aOrB(bool check){
   if(check)
     return new A();
   else
     return new B();
 }
 ```

 **Is it the expected behaviour for ternary conditional?**


 Here the compiler knows what type to return (from the function 
 signature).
 But the ternary operator doesn't know this,


Why?... ternary operators should deduce returning type the same 
way


 need to be of the same type (or implicitly convert to a common 
 type).


It is a common type: the ```I``` interface.

In fact, if you use  ```abstract class``` instead 
```interface```, it works:

```d
abstract class I { bool check(); }
class A : I { override bool check() =>true; }
class B : I { override bool check() =>false;}

I aOrB(bool check) => check ? new A() : new B();

void main()
{
   assert( aOrB(true).check );
}
```

Why ternary operator accepts covariance rules applied to base 
class, but not applied to interface?


About cast(I)... it allows "illegal" castings causing runtime 
segmentation faults if not used carefully:

```d
class X { string xname() =>"I'm x"; }
class Y { string yname() =>"I'm y"; }
void main(){
   (cast(Y) new X()).yname;  // Runtime segmentation fault
}
```

This is another good reason to avoid using cast when possible.
Nov 28 2023
prev sibling parent reply Paul Backus <snarwin gmail.com> writes:
On Thursday, 23 November 2023 at 19:17:20 UTC, Antonio wrote:

 Basically, the ternary conditional ```?:``` result type is not 
 inferred even if the type returned by the two possibilities are 
 the same.

 **Is it a bug or the expected behaviour?**


Known bug, first reported in 2009: 
https://issues.dlang.org/show_bug.cgi?id=3543
Nov 28 2023
parent Antonio <antoniocabreraperez gmail.com> writes:
On Tuesday, 28 November 2023 at 15:46:18 UTC, Paul Backus wrote:

 On Thursday, 23 November 2023 at 19:17:20 UTC, Antonio wrote:

 Basically, the ternary conditional ```?:``` result type is not 
 inferred even if the type returned by the two possibilities 
 are the same.

 **Is it a bug or the expected behaviour?**


 Known bug, first reported in 2009: 
 https://issues.dlang.org/show_bug.cgi?id=3543


Thanks Paul (again :-) )

Oh my!!!

I wrote this question ```"On Thursday, 23 November 2023 at 
19:17:20 UTC, Antonio wrote:"```

And the original bug was ```Reported: 	2009-11-23 03:24 UTC by 
nfxjfg ```

***The same date!!!! :-)... 14 years before***
Nov 28 2023