[Issue 1807] ENHANCEMENT: Let IFTI "see through" templates to simple aliases

Apr 17, 2018

ag0aep6g

Apr 18, 2018

Oct 11, 2019

Dec 24, 2020

Dec 24, 2020

[Issue 1807] ENHANCEMENT: Let IFTI "see through" templates to simple aliases

Sep 17, 2022

Oct 11, 2022

Oct 11, 2022

Dec 17, 2022

Mar 22, 2023

Mar 23, 2023

https://issues.dlang.org/show_bug.cgi?id=1807 --- Comment #9 from Walter Bright <bugzilla@digitalmars.com> --- Proposed DIP: https://github.com/dlang/DIPs/blob/master/DIPs/other/DIP1023.md Proposed Implementation: https://github.com/dlang/dmd/pull/9778 --

https://issues.dlang.org/show_bug.cgi?id=1807 John Hall <john.michael.hall@gmail.com> changed: What |Removed |Added ---------------------------------------------------------------------------- CC| |john.michael.hall@gmail.com --- Comment #10 from John Hall <john.michael.hall@gmail.com> --- (In reply to Walter Bright from comment #9) > Proposed DIP: > > https://github.com/dlang/DIPs/blob/master/DIPs/other/DIP1023.md > > Proposed Implementation: > > https://github.com/dlang/dmd/pull/9778 DIP 1023 has been postponed. --

October 11, 2022

[Issue 1807] ENHANCEMENT: Let IFTI "see through" templates to simple aliases

Posted by John Hall

Permalink

John Hall

Permalink

https://issues.dlang.org/show_bug.cgi?id=1807

--- Comment #11 from John Hall <john.michael.hall@gmail.com> ---
Creating a new type with an alias this'ed parameter is similar conceptually to a template alias. The new type is implicitly convertible to the target of the alias this and can be used wherever that original type was used. However, since it is a separate type, it can't called called where the alias is used.

```d
struct TemplateType(T) {}

//alias TemplateAlias(T) = TemplateType!T;
struct TemplateAlias(T) {
    TemplateType!T x;
    alias x this;
}

void templateFunction(T)(TemplateType!T arg) {}
void templateAliasFunction(T)(TemplateAlias!T arg) {}

void main()
{
    TemplateType!int inst;
    TemplateAlias!int ainst;

    templateFunction(inst);
    templateFunction(ainst);
    templateAliasFunction(inst); //doesn't compile
    templateAliasFunction(ainst);
}
```

Perhaps what is needed is some kind of mechanism like alias this...not in the sense of implicit conversion but in terms the programmer having the tools to tell the compiler what to do.

The idea would be that your template alias would include an additional template (with some rudimentary sketch below), call it `opResolveAlias`, that would let the compiler know the relationships going in reverse (so instead of from the alias to the alias target, this would be going from the alias target to the alias). The compiler could then make use of that information to make sure the function call can properly occur (with type inference as needed).

So for instance, if you have a function that accepts a `TemplateAlias!T` parameter, but pass in a `TemplateType!int` parameter, then currently the compiler doesn't look through the `TemplateAlias!T` to see that `TemplateType!int` is the same. However, if the compiler knows that a `TemplateType!int` is the same as `TemplateAlias!int`, then it would be better able to proceed.

```d
template TemplateAlias(T) {
    alias TemplateAlias = TemplateType!T;

    template opResolveAlias(alias U)
        if(is(U == TemplateType!V, V))
    {
        alias opResolveAlias = TemplateAlias!V;
    }
}
```

For simple cases like this, the compiler could generate its own `opResolveAlias`, but in the more general case it would be up to the user to provide it if it is important to them.

Issue 16486 has an example of a more complicated template alias [1] that should still be able to have this approach applied:

```d
template TestAlias(T)
{
    static if (is(T == float)) alias TestAlias = TestType!int;
    else alias TestAlias = string;

    // new part:
    template opResolveAlias(alias U)
    {
        static if (is(U == TestType!int)) {
            alias opResolveAlias = TestAlias!float;
        } else static if (is(U == string)) {
            alias opResolveAlias = TestAlias!int; //could put anything there
that's not float...not the most elegant
        }
    }
}
```

[1] https://issues.dlang.org/show_bug.cgi?id=16486#c1

--

https://issues.dlang.org/show_bug.cgi?id=1807 Iain Buclaw <ibuclaw@gdcproject.org> changed: What |Removed |Added ---------------------------------------------------------------------------- Priority|P2 |P4 --

Forums