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?

On Monday, 28 April 2025 at 04:59:24 UTC, Orion wrote:

Alias is the proper way, there's specifications for them to work as a way to overload whereas with enum there's no support. Rememeber that

enum e = (int x) => x;

is a shortcut to

enum e
{
    e = (int x) => x
}

so always use alias.

On Monday, 28 April 2025 at 04:59:24 UTC, Orion wrote:

aliases for types, overload sets

enum for litterals

On Monday, 28 April 2025 at 20:05:34 UTC, monkyyy wrote:

According to me that's a very bad advice. I'm more on "never enum". Do you have any example where enum is better ?

On Monday, 28 April 2025 at 22:16:47 UTC, user1234 wrote:

enum N=1024;

int[N] array1;
int[N] array2;

On Monday, 28 April 2025 at 22:47:35 UTC, monkyyy wrote:

this is totally unrelated to the topic. i.e function as expressions.

On Monday, 28 April 2025 at 04:59:24 UTC, Orion wrote:

A lambda is basically syntax sugar for a local function declaration. So when you write this:

fun((float x) => 0.5 + x);

...the compiler replaces it internally with code that looks like this:

auto __lambda(float x) => 0.5 + x;
fun(&__lambda);

When the lambda is generic, the compiler generates a template function instead of a regular function:

// Before:
range.map!(x => 0.5 + x);

// After:
auto __lambda(T)(T x) => 0.5 + x;
range.map!(__lambda);

So, when you use alias to give a name to a lambda, what you are really doing is giving a name to this internal function or template that the compiler replaces the lambda with.

Of course, at that point, you might as well just write a named function directly:

// Instead of this:
alias m = (float x) => 0.5 + x;

// You can just write this:
auto m(float x) => 0.5 + x;