[Issue 17953] inout-like mechanism to infer function attributes from callback attributes

[d-bugmail at puremagic.com]

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

Bastiaan Veelo <Bastiaan at Veelo.net> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |Bastiaan at Veelo.net

--- Comment #2 from Bastiaan Veelo <Bastiaan at Veelo.net> ---
This came up again at the DLF quarterly meeting April 5, 2024, with industry
partners, and Walter asked to make sure there is a feature request. As
discussed there:

For arguments and return types of various mutability we have the `inout`
keyword that saves us from having to define multiple function overloads[1]. A
similar solution for other attributes does not exist.

For example, if you have foreach loops over a struct S both in a @nogc context
and with an allocating loop body,
```d
void f()
{
    S s;
    foreach (a; s)
        allocating(a);
}

void g() @nogc
{
    S s;
    foreach (a; s)
        nonallocating(a);
}

void allocating(int) {}

void nonallocating(int) @nogc {}
```

then S needs both of these opApply overloads:

```d
    int opApply(scope int delegate(int) dg);
    int opApply(scope int delegate(int) @nogc dg) @nogc;
```

Similar for @safe, nothrow, pure and their permutations.

Templating opApply[2] can help in many of these cases, but problems arise when
classes and inheritance get involved[3].

There is a DIP for argument dependent attributes[4] but work on it has stalled.

[1] https://dlang.org/spec/const3.html#inout
[2] https://dlang.org/spec/statement.html#template-op-apply
[3] https://youtu.be/9lOtOtiwXY4?si=KME_ZddnrecMdWOJ&t=359
[4] https://github.com/dlang/DIPs/pull/198

--