Subtyping of an enum

[Anton Fediushin]

On Monday, 15 April 2019 at 10:06:30 UTC, XavierAP wrote:
> On Monday, 15 April 2019 at 08:39:24 UTC, Anton Fediushin wrote:
>>
>> Hello! I am currently trying to add a custom `toString` method
>
> Several remarks... First of all, strings can be compared 
> (alphabetically) as well as integers, e.g.
> assert("foo" > "bar")
> Perhaps not your use case, but worth noting.

I already know that but defining enum with strings would break my 
code:
```
assert(Enum.foo < Enum.bar);
```
Would never succeed.

>
> You have defined your sub-typing the opposite way that you 
> wanted it to work: every `Enum` is an `internal`, but the other 
> way around an `internal` may not work as an `Enum`. Your `fun` 
> would in principle work if it were defined with an `internal` 
> but passed an `Enum`... Of course you have defined `internal` 
> as nested private so no... But then how did you want anything 
> to work if no one outside Enum knows the super-type?

Isn't this how subtyping works for integers and other types? For 
example, you have subtyped an integer and added some new methods 
to it?

>
> You obviously need to re-think your problem and your design :)

The problem here is that I want to keep methods that are related 
to an enum inside of this enum for purely aesthetic and 
organizational purposes.

>
>> Obvious solution is to wrap an enum in a structure and utilize 
>> 'alias this' for subtyping like this:
>
> Actually the obvious solution (not sure if it otherwise works 
> for you) would be to take advantage of D's Uniform Function 
> Call Syntax [1] and define toString as a global function that 
> can be called as a method:
>
> enum Fubar { foo, bar }
>
> string toString(Fubar fb)
> {
> 	return "It works.";
> }
>
> void main()
> {
> 	import std.stdio;
> 	writeln(Fubar.foo.toString);
> }
>
> _________
> [1] 
> https://tour.dlang.org/tour/en/gems/uniform-function-call-syntax-ufcs

This is what I am doing now, I was just curious if there was a 
better solution. These global functions pollute global namespace. 
I know that I could put them into an own module and 'public 
import' just my enum because these methods would rarely be used 
by the other components of my application. If I would want to use 
them though, I'd have to import that ugly module and never forget 
to call `writeln(a.toString)` instead of `writeln(a)` or else 
it'll do not what I wanted.

And once more, what I want to achieve is purely about overall 
code organization. I mean, if structs (data) can have functions 
(methods) that are performed on them, why an enum (single value) 
cannot have own methods performed on it?