And
Color.BLUE could be equal to Chess.KING

(Enums are not just about constant values, they’re about type safety)

In this regard, symbols could be seen as “top level” enums. However, the advantage of putting related constants inside a class is that it adds semantics to your application. The constants can appear logically grouped instead of floating in the air on their own. Of course, I’m not saying that these custom enums should replace symbols. I just find it useful to group things that are related together.

@Badaud,

As you can see in my exemple, I don’t create any instance of class Color. I only work with the object Color, which is an instance of class Class. Also, you’ll note that i don’t write Color.BLUE but Color::BLUE, which triggers the const_missing method. It would be equivalent of doing : Color.const_missing(:BLUE) but there won’t be any point to access it that way! Finally, I don’t quite understand your claim about type safety. This was a practical example illustrating how to create an enum-like class in ruby. If for some reason Color::BLUE and Chess::KING would be equal… then so what? Those are integers values after all. The purpose (in this example at least) was to use an enum as a set of constants logically grouped together. (Like if “Color” was a namespace)

Colors = { :blue => 1, :red => 2, :yellow => 5 }

With your code, you would have to create an instance of Hash class everytime you would want to use the collection. If “Colors” is a local variable, it would goes out of scope pretty quick. If it is an instance variable, you would still have one hash for every instances of the class that contains it. What is the other option? To make your hash global? hmm.. bad idea

If you use a class like i did and define your methods as class methods, you work with a single instance everytime : The instance of class “Class” called Color.

If you’re worried about Colors being a variable, freeze it.

Plus, if you write : Colors = { :blue => 1, :red => 2, :yellow => 5 }, you’re violating a ruby coding convention which says that you must only use lowercase for naming a local / instance variable.

So, to be nice you would have to write : colors = { :blue => 1, :red => 2, :yellow => 5 } and thus indicating clearly to the outside world that colors is a “single instance of something” instead of just “being something” on it’s own. That’s why I prefer using an enum-like class over using an instance of Hash class.

The convention is that variables start with a lower case letter, local or not. Enumerations are (usually) treated as constant, which is why I named Colors with an initial capital.

Actually not a convention at all but a feature of the language. In this case the name ‘Colors’ becomes a constant because it begins with a capital.

This is an interesting use of const_missing. You’ve given me a bit to think about here.

Second, I would suggest using a constant hash instead of @hash if it isn’t going to change.

So I’d suggest:

module Color
COLORS = [:blue, :red:, :yellow]
end

or instead of defining each at all, just do Color::COLORS.each and it’s built right in.

In C#, if you declare a method parameter to be some kind of enum, then you have to pass EXACTLY the MEMBER of that enum. So in C#, enums is more than just some constants grouped in one place, but it also has type information. If you pass different kind of enum than the one that method expected, then the compiler will happily report it as error to you.

But I think is quite impossible to do it in Ruby (actually, I haven’t thinking about it :D), because usually we don’t pay much attention to type information of an object. Event worse, actually Ruby has different concept about type (type-is-all-about-what-an-object-can-do vs type-is-all-about-object-class-hierarchy)

Most of the time, I only need the kind of enum described in this article… or I don’t need an enum at all. I just like to “group names under a common namespace” for code readability. I rarely need something fancier.

Thanks for your comment

class Status
Complete=0
Queued=1
Ready=2
Processing=3
Waiting=4
end

now say I have an instance of this status:

status=Status::Waiting

How could I get this as a string that says “Waiting”? Even thought status is 4. Maybe create a class method in Status called to_string or something?

That’s a good question. Instead of using a Fixnum as the value, you could use a Hash :

class Status
Complete={:value => 0, :string => “complete”}
Queued={:value => 1, :string => “queued”}
Ready={:value => 2, :string => “ready”}
Processing={:value => 3, :string => “processing”}
Waiting={:value => 4, :string => “waiting”}
end

status = Status::Waiting
status[:value] # output : 4
status[:string] # output : waiting

There might be better ways to achieve what you want, but I think this solution would work fine.

enum_attr :gear, %w(reverse ^neutral first second third)