On 08.01.23 12:29, thebluepandabear wrote:
> ```D
> interface ICustomDrawable {
>      void render(sfRenderWindow* renderWindow);
> }
[...]> class Button : ICustomDrawable {
[...]
> }
[...]
> class StackLayout : ICustomDrawable {
[...]
>      ICustomDrawable[] _children;
> }
> ```
> 
> For some reason, when I want to cast the `children` (property), only the second example works:
> 
> 1.
> 
> ```D
> foreach (Button button; cast(Button[])(_boardSizeRow.children)) {
>      button.update(event, _renderWindow);
> }
> ```
> 
> 2.
> 
> ```D
> foreach (Button button; to!(Button[])(_boardSizeRow.children)) {
>      button.update(event, _renderWindow);
> }
> ```

Two things you need to know:

1. While an interface reference implicitly converts to a compatible class reference, the resulting pointer is slightly different.

----
interface I {}
class C : I {}
void main()
{
    C c = new C;
    I i = c;
    import std.stdio;
    writeln(cast(void*) c); /* e.g. 7F3C140A7000 */
    writeln(cast(void*) i); /* e.g. 7F3C140A7010 */
}
----

2. Casting from one array type to another is done "as a type paint"[1]. The elements of the array are reinterpreted, not converted.

But reinterpreting interface references as class references won't work, because the pointers will be wrong. You need to convert each element of the array (which is what `to` does).


[1] https://dlang.org/spec/expression.html#cast_array

On Sunday, 8 January 2023 at 11:29:10 UTC, thebluepandabear wrote:
> ...

There is an explanation here: https://forum.dlang.org/post/tqukutfzeaxedunuvkum@forum.dlang.org

But in any case I'd like to point it out that I think you could do that foreach without casting or std.conv by just omitting the type of the variable you're iterating:

import std.stdio, std.conv;

interface IDog {
    void bark();
}

class Dog: IDog{
    string s;
    this(string _s){s = _s;}
    void bark(){writeln(s);}
}

class List{
    IDog[] dogs;
    void add(T)(T d){ dogs ~= d;  }
}

void main(){
    auto d1 = new Dog("meaw!");
    auto d2 = new Dog("wof!");
    auto l = new List();
    l.add(d1);
    l.add(d2);

    foreach(d; l.dogs){ // No type informed for "d"
        d.bark();
    }
}

Prints:

meaw!
wof!

Matheus.

On Sunday, 8 January 2023 at 12:35:38 UTC, matheus wrote:
> On Sunday, 8 January 2023 at 11:29:10 UTC, thebluepandabear wrote:
>> ...
>
> There is an explanation here: https://forum.dlang.org/post/tqukutfzeaxedunuvkum@forum.dlang.org
>
> But in any case I'd like to point it out that I think you could do that foreach without casting or std.conv by just omitting the type of the variable you're iterating:
>
> import std.stdio, std.conv;
>
> interface IDog {
>     void bark();
> }
>
> class Dog: IDog{
>     string s;
>     this(string _s){s = _s;}
>     void bark(){writeln(s);}
> }
>
> class List{
>     IDog[] dogs;
>     void add(T)(T d){ dogs ~= d;  }
> }
>
> void main(){
>     auto d1 = new Dog("meaw!");
>     auto d2 = new Dog("wof!");
>     auto l = new List();
>     l.add(d1);
>     l.add(d2);
>
>     foreach(d; l.dogs){ // No type informed for "d"
>         d.bark();
>     }
> }
>
> Prints:
>
> meaw!
> wof!
>
> Matheus.

The `foreach` worked for that case since `bark` is a method of `IDog`. `update` is not so a conversion to `Button[]` is needed.

I will look at your resource, thanks.

On Sunday, 8 January 2023 at 12:39:37 UTC, thebluepandabear wrote:
> ...
> The `foreach` worked for that case since `bark` is a method of `IDog`. `update` is not so a conversion to `Button[]` is needed.
>

In that case, you could do a casting like this:

import std.stdio, std.conv;

interface IDog {
    void bark();
}

class Dog: IDog{
    string s;
    this(string _s){s = _s;}
    void bark(){writeln(s);}
    void update(string _s){ s ~= " - " ~ _s; }
}

class List{
    IDog[] dogs;
    void add(T)(T d){ dogs ~= d;  }
}

void main(){
    auto d1 = new Dog("meaw!");
    auto d2 = new Dog("wof!");
    auto l = new List();
    l.add(d1);
    l.add(d2);

    foreach(i,d; l.dogs){ // I'm using 'i' just to show each update.
        (cast(Dog)d).update(to!string(i));
        d.bark();
    }
}

Prints:

meaw! - 0
wof! - 1

Matheus.