Currently, thanks to UFCS, we can define most functions in module scope and make them act as if they were member functions. However this doesn't work nicely when you have multiple functions with the same name in different modules, for example:

-----
module a;
import b;
struct A { }
void test(A a) { }

void main()
{
    B b;
    b.test();
}
-----

-----
module b;
struct B { }
void test(B b) { }
-----

$ dmd -c a.d
> a.d(9): Error: function a.test (A a) is not callable using argument types (B)

This is D's protection against function hijacking. The diagnostic should improve, but that's beside the point.

To work around this (without being forced to merge overloads with alias declarations), one can define these functions inside the structures, and there will be no errors:

-----
module a;
import b;
struct A { void test() { } }

void main()
{
    B b;
    b.test();
}
-----

-----
module b;
struct B { void test() { } }
-----

$ dmd -c a.d
>

This could also be considered a more "tightly" coupling.

However, we cannot use this with enums because enums cannot have functions as members. So the following code becomes an error:

-----
module a;
import b;

enum EA { a }

void test(EA a) { }

void main()
{
    EB eb;
    eb.test();
}
-----

-----
module b;

enum EB { b }

void test(EB eb) { }
-----

$ dmd -c a.d
> a.d(11): Error: function a.test (EA a) is not callable using argument types (EB)

The way to work around this is to merge the overloads with alias declarations.

But if functions inside of enums were allowed, then we could have a simpler workaround for the function hijacking protection.

Unfortunately I can't think of a way to make the syntax look nice, for example:

-----
enum E 
{ 
    a,
    b,
    c,
    void test() { }  // looks awkward
}
-----

It looks weird to have a function embedded next to the members.