On Sunday, April 27, 2025 10:59:24 PM MDT Orion via Digitalmars-d-learn wrote:
> In which programming scenarios should alias be used instead of enum?
>
> So far I have only found a simplified notation of a generic
> lambda:
> alias id = (x) => x; x; , which does not work in the case of enum.
>
> There is also a difference in overloading a non-generic lambda:
>
> alias m = (int x) => x;
> alias m = (float x) => 0.5 + x;
> - alias overloads a function with the same name.
>
> enum e = (int x) => x;
> ///enum e = (float x) => x; //error
> - enum does not.
>
> At the compiler level, enum lambda is represented as a literal. But how is alias represented? As an expression?

Aliases create an alternate name for a symbol (including types), whereas
enums are values which have no address (rather their value is essentially
copy-pasted when they're used).

So, enums are essentially variables except that they have no storage associated with them, whereas aliases just give names to things. And the name of an alias is replaced with the original name whenever the alias is used.

So, if you alias a function, it makes sense that you can have overloads. It's just the same function with a different name. Lambdas are a bit weird in that respect in that they're anonymous, but the alias is giving them names, and as such overloading makes sense.

However, an enum must be a value, and a function is not a value. A function pointer could be, but a function cannot be - and neither can a lambda, because a lambda is an anonymous function, not a function pointer. Basically, if it doesn't make sense for something to be assigned to a variable, then it doesn't make sense for it to be an enum.

- Jonathan M Davis

Yes. But at the same time, defining a function via alias is a 1st class function, unlike a standard function definition!

alias af = (int x) => x;
auto sf(int x) => x;

auto v = af;
auto p = &sf;

This means that the definitions are not equivalent.

In essence, an alias function behaves like a lambda function assigned to a variable, but at the same time there is the possibility of adhoc overloading, which is only possible for a regular/standard function.

On Friday, 2 May 2025 at 13:55:46 UTC, Orion wrote:
> Yes. But at the same time, defining a function via alias is a 1st class function, unlike a standard function definition!
>
> alias af = (int x) => x;
> auto sf(int x) => x;
>
> auto v = af;
> auto p = &sf;
>
> This means that the definitions are not equivalent.
>
> In essence, an alias function behaves like a lambda function assigned to a variable, but at the same time there is the possibility of adhoc overloading, which is only possible for a regular/standard function.

This is still a continuation of aliases are for types, enums for literals

```d
alias F=(i)=>i+1;
import std;
void main(){
	F(3).writeln;
	F(3.14).writeln;
}
```
F cant be enum here, because the type inference comes latter
taking a pointer needs to be literal