enum functions

[Steven Schveighoffer]

On 1/10/23 7:55 AM, Adam D Ruppe wrote:
> On Sunday, 8 January 2023 at 18:42:58 UTC, Salih Dincer wrote:
>> I'm wondering 2 things; firstly, does having an enum mean there is no 
>> auto-return? Or could it be CTFE?
> 
> It means nothing. The keyword tells the parser a function is about to 
> begin, which triggers return type inference (exactly the same as 
> `auto`), but otherwise it is completely ignored.

Mostly correct. `enum` is a storage class, which means a *declaration* 
is about to begin. Once the declaration is decided as a function 
definition, type inference is performed, and the storage class is 
checked to see how it affects the declaration. In some cases, there is 
an effect, in some there is not.

```d
static foo() {} // static does nothing here
final bar() {} // final does nothing here
enum baz() {} // enum does nothing here
__gshared fun() {} // __gshared does nothing here

struct S
{
    // return type is int *, `this` (unused) is const
    const foo() { return new int; }
    // same for immutable, shared, inout
}
```

Aside from the const/immutable/shared/inout storage classes (which do 
affect semantics, but maybe in slightly confusing ways) there are some 
which are pretty obvious and also work with type inference:

1. deprecated
2. extern
3. abstract
4. override
5. synchronized
6. auto
7. scope
8. nothrow
9. pure
10. ref

-Steve