I'm struggling with this code. Why countUntil won't work with aliases?

import std.traits : EnumMembers;
import std.algorithm : countUntil;

enum Test: string {
    One = "one",
    Two = "two",
    Three = "three"
}

struct MyStruct {
    Test test = Test.Three;
}

void main() {
    auto myStruct = MyStruct();

    // this works as expected
    auto idx = countUntil!(e => e == myStruct.test)([EnumMembers!Test]);

    // this triggers error: app.d(22): Error: none of the overloads of template `std.algorithm.searching.countUntil` are callable using argument types `!((e) => e == myAlias)(Test[])`
    alias myAlias = MyStruct.test;
    auto idx2 = countUntil!(e => e == myAlias)([EnumMembers!Test]);
}

On Wednesday, 23 October 2024 at 12:32:09 UTC, Anton Pastukhov wrote:

import std.traits : EnumMembers;
import std.algorithm : countUntil;

enum Test: string {
    One = "one",
    Two = "two",
    Three = "three"
}

struct MyStruct {
    Test test = Test.Three;
}

void main() {
    auto myStruct = MyStruct();

    // this works as expected
    auto idx = countUntil!(e => e == myStruct.test)([EnumMembers!Test]);

    // this triggers error: app.d(22): Error: none of the overloads of template `std.algorithm.searching.countUntil` are callable using argument types `!((e) => e == myAlias)(Test[])`
    alias myAlias = MyStruct.test;
    auto idx2 = countUntil!(e => e == myAlias)([EnumMembers!Test]);
}

The problem is that there's a compilation error inside the body of your lambda, but it doesn't get displayed, because it happens inside a __traits(compiles) check (inside countUntil).

Attempting to call the lambda on its own, without using countUntil, reveals the error:

    alias myAlias = MyStruct.test;
    alias myLambda = e => e == myAlias;
    myLambda(Test.One);
    // Error: accessing non-static variable `test` requires an instance of `MyStruct`

There are two possible solutions to this. One is to make MyStruct.test a static variable:

// Solution #1
struct MyStruct {
    static Test test = Test.Three;
}

The other is to use an instance of MyTest instead of an alias:

    // Solution #2
    MyStruct myInstance;
    auto idx2 = countUntil!(e => e == myInstance.test)([EnumMembers!Test]);

On Wednesday, 23 October 2024 at 12:46:24 UTC, Paul Backus wrote:

Thanks, that's a good catch. alias myAlias = MyStruct.test is really just a typo, I meant alias myAlias = myStruct.test, so I actually have an instance. It's still not compiling

On Wednesday, 23 October 2024 at 13:00:15 UTC, Anton Pastukhov wrote:

You can't use an alias to refer to a member variable like this. When you write

alias myAlias = myStruct.test;

...it is silently rewritten by the compiler to

alias myAlias = MyStruct.test;

So, in reality, there is no difference between the two versions.

On Wednesday, 23 October 2024 at 12:46:24 UTC, Paul Backus wrote:

// Solution #1
struct MyStruct {
    static Test test = Test.Three;
}

The code also compiles like this. In this case, can we say that there are 3 solutions or are static and enum actually the same thing?

struct MyStruct {
  enum test = Test.Three
}

SDB@79

On Wednesday, 23 October 2024 at 12:32:09 UTC, Anton Pastukhov wrote:

import std.traits : EnumMembers;
import std.algorithm : countUntil;

enum Test: string
{
    One = "one",
    Two = "two",
    Three = "three"
}

If it were me, I would equip my type with aliases like below. But for some reason I don't understand, the enum Numbers works, while the enum Test which is of type string doesn't!

import std.traits : EnumMembers;
import std.algorithm : countUntil;

enum Test: string
{
    One = "one",
    Two = "two",
    Three = "three"
}

enum Numbers: size_t
{
    One = 1, Two, Three
}

struct MyStruct(T) {
  enum tMax = T.max;
  size_t idx;
}

alias myType = Numbers; // Test; // not works!
void main()
{
  alias myAlias = MyStruct!myType;

  auto rng = [EnumMembers!myType];
  auto idx = rng.countUntil!(e => e == myAlias.tMax);

  auto myStruct = myAlias(idx);
  assert(myStruct.idx == 2);
}

SDB@79

On Wednesday, 23 October 2024 at 14:50:44 UTC, Paul Backus wrote:

alias myAlias = myStruct.test;

alias myAlias = MyStruct.test;

Is it intended behavior? Is it documented somewhere? I'm looking here https://dlang.org/spec/declaration.html#alias and it states: "An AliasDeclaration creates a symbol name that refers to a type or another symbol". myStruct.test is a symbol.

On Wednesday, 23 October 2024 at 17:18:47 UTC, Anton Pastukhov wrote:

alias myAlias = myStruct.test;

alias myAlias = MyStruct.test;

Its intended and probably the right decision, but good luck finding relivent docs.

id suggest passing a=>a.test to whatever function instead of trying to control the alias formally

On Wednesday, 23 October 2024 at 18:05:15 UTC, monkyyy wrote:

What's the motivation behind it? For me, it looks like a weird edge case but I'm just probably missing something here