# Ruby idiom for enum? **URL:** \ **Category:** ruby-talk\ **Created:** [28 August 2005 04:40 UTC](https://rubytalk.org/t/ruby-idiom-for-enum/20444 "2005-08-28T04:40:45Z")\ **Posts on this page:** 6\ **Page:** 1
**Author:** ![David\_Brady](https://avatars.discourse-cdn.com/v4/letter/d/50afbb/32.png) [@David\_Brady](https://rubytalk.org/u/David_Brady)\ **Post date:** [28 August 2005 04:40 UTC](https://rubytalk.org/t/ruby-idiom-for-enum/20444/1 "2005-08-28T04:40:45Z")
Okay, one more question from a C++ leopard trying to change his spots: I want to set up a program that uses some predefined values to determine its logic. For example, a method could analyze some data and return "Good", "Fair", "Poor", or "Out of Bounds" based on a set of thresholds. I want to be able to refer to these values by name in my code, so constants or symbols make a good choice here. But I also want to build a sort of rule set around these values: some function returns values in the range of (0.0..1.0) and I want to be able to say that 0.8 is the minimum score for "Good", etc. I also want the word "Good" stored in a specific single place so that I don't make any typos each time I need to print the description. In C++, I would use an enum for each of the values, then build arrays of floats and strings indexed by those enums to hold the thresholds and descriptions. What's the Ruby idiom for this? Perhaps Struct followed by some initializer arrays? This seems like a good start but I end up wanting to build a set of constants first to use as keys to a hash containing the Structs. Perhaps the Structs should be the constants themselves, like: Struct.new("RatingData", name, threshold, description) RATING\_GOOD = Struct::RatingData( :Good, 0.8, "Good Rating" ) RATING\_FAIR = Struct::RatingData( :Fair, 0.5, "Fair Rating" ) ...etc. The analyze\_data could return RATING\_GOOD if things were fine. So: rating = analyze\_data data puts "Analysis: #{rating.description}" Though this doesn't let me treat the values as though they are ordered, e.g. puts "\*\*\* Warning: Rating below Fair \*\*\*" if rating \< RATING\_FAIR Thoughts? -dB > **···** > > -- > David Brady > [ruby-talk@shinybit.com](mailto:ruby-talk@shinybit.com) > I'm having a really surreal day... OR AM I? ---
**Author:** ![Robert\_K1](https://yyz1.discourse-cdn.com/flex029/user_avatar/rubytalk.org/robert_k1/32/1830_2.png) [@Robert\_K1](https://rubytalk.org/u/Robert_K1)\ **Post date:** [28 August 2005 10:19 UTC](https://rubytalk.org/t/ruby-idiom-for-enum/20444/2 "2005-08-28T10:19:21Z")
There are several possible solutions: Use an enum lib maybe there's something in the RAA [http://raa.ruby-lang.org/search.rhtml?search=enum](http://raa.ruby-lang.org/search.rhtml?search=enum) Or create a Hash with nested Arrays RATINGS = {   :good =\> [0.8, "Good Rating"],   :bad =\> [0.1, "Bad Rating"] } I'd probably go with your struct approach with some additional code for creation of a single rating that will also register all ratings somewhere and with some algorithm for determining the rating. For example, if you place your constants in class Struct::RatingData you can easily get all ratings via Struct::RatingData.constants. If you need efficient rating assignment from a float value and if there are many ratings then you might want to store ratings ordered by the threshold to use binary search on the ratings to find the correct one. Just some thoughts. Kind regards robert > **···** > > 2005/8/28, David Brady \: > > > Okay, one more question from a C++ leopard trying to change his spots: > > > > I want to set up a program that uses some predefined values to determine > > its logic. For example, a method could analyze some data and return > > "Good", "Fair", "Poor", or "Out of Bounds" based on a set of > > thresholds. I want to be able to refer to these values by name in my > > code, so constants or symbols make a good choice here. But I also want > > to build a sort of rule set around these values: some function returns > > values in the range of (0.0..1.0) and I want to be able to say that 0.8 > > is the minimum score for "Good", etc. I also want the word "Good" > > stored in a specific single place so that I don't make any typos each > > time I need to print the description. > > > > In C++, I would use an enum for each of the values, then build arrays of > > floats and strings indexed by those enums to hold the thresholds and > > descriptions. > > > > What's the Ruby idiom for this? > > > > Perhaps Struct followed by some initializer arrays? This seems like a > > good start but I end up wanting to build a set of constants first to use > > as keys to a hash containing the Structs. Perhaps the Structs should be > > the constants themselves, like: > > > > Struct.new("RatingData", name, threshold, description) > > > > RATING\_GOOD = Struct::RatingData( :Good, 0.8, "Good Rating" ) > > RATING\_FAIR = Struct::RatingData( :Fair, 0.5, "Fair Rating" ) > > > > ...etc. The analyze\_data could return RATING\_GOOD if things were fine. So: > > > > rating = analyze\_data data > > puts "Analysis: #{rating.description}" > > > > Though this doesn't let me treat the values as though they are ordered, e.g. > > > > puts "\*\*\* Warning: Rating below Fair \*\*\*" if rating \< RATING\_FAIR > > > > Thoughts? ---
**Author:** ![Brian\_Schroder1](https://avatars.discourse-cdn.com/v4/letter/b/2bfe46/32.png) [@Brian\_Schroder1](https://rubytalk.org/u/Brian_Schroder1)\ **Post date:** [28 August 2005 11:53 UTC](https://rubytalk.org/t/ruby-idiom-for-enum/20444/3 "2005-08-28T11:53:00Z")
Simply expanding on your thoughts: --------8\<--------8\<-------- module RATING   RatingData = Struct.new(:name, :threshold, :description)   class RatingData     include Comparable     def \<=\>(o)       if o.respond\_to?:threshold   self.threshold \<=\> o.threshold       else   self.threshold \<=\> o       end     end   end      GOOD = RatingData.new( :Good, 0.8, "Good Rating" )   FAIR = RatingData.new( :Fair, 0.5, "Fair Rating" )   POOR = RatingData.new( :Poor, 0.2, "Poor Rating" ) end rating = RATING::POOR puts "Analysis: #{rating.description}" puts "\*\*\* Warning: Rating below Fair \*\*\*" if rating \< RATING::FAIR --------8\<--------8\<-------- would be a possibility. Throw in some metaprogramming and it can get really nice. regards, Brian > **···** > > On 28/08/05, David Brady \ wrote: > > > Okay, one more question from a C++ leopard trying to change his spots: > > > > I want to set up a program that uses some predefined values to determine > > its logic. For example, a method could analyze some data and return > > "Good", "Fair", "Poor", or "Out of Bounds" based on a set of > > thresholds. I want to be able to refer to these values by name in my > > code, so constants or symbols make a good choice here. But I also want > > to build a sort of rule set around these values: some function returns > > values in the range of (0.0..1.0) and I want to be able to say that 0.8 > > is the minimum score for "Good", etc. I also want the word "Good" > > stored in a specific single place so that I don't make any typos each > > time I need to print the description. > > > > In C++, I would use an enum for each of the values, then build arrays of > > floats and strings indexed by those enums to hold the thresholds and > > descriptions. > > > > What's the Ruby idiom for this? > > > > Perhaps Struct followed by some initializer arrays? This seems like a > > good start but I end up wanting to build a set of constants first to use > > as keys to a hash containing the Structs. Perhaps the Structs should be > > the constants themselves, like: > > > > Struct.new("RatingData", name, threshold, description) > > > > RATING\_GOOD = Struct::RatingData( :Good, 0.8, "Good Rating" ) > > RATING\_FAIR = Struct::RatingData( :Fair, 0.5, "Fair Rating" ) > > > > ...etc. The analyze\_data could return RATING\_GOOD if things were fine. So: > > > > rating = analyze\_data data > > puts "Analysis: #{rating.description}" > > > > Though this doesn't let me treat the values as though they are ordered, e.g. > > > > puts "\*\*\* Warning: Rating below Fair \*\*\*" if rating \< RATING\_FAIR > > > > Thoughts? > > -- > [http://ruby.brian-schroeder.de/](http://ruby.brian-schroeder.de/) > > Stringed instrument chords: [http://chordlist.brian-schroeder.de/](http://chordlist.brian-schroeder.de/) ---
**Author:** ![Ara.T.Howard6](https://avatars.discourse-cdn.com/v4/letter/a/958977/32.png) [@Ara.T.Howard6](https://rubytalk.org/u/Ara.T.Howard6)\ **Post date:** [28 August 2005 14:58 UTC](https://rubytalk.org/t/ruby-idiom-for-enum/20444/4 "2005-08-28T14:58:52Z")
> Okay, one more question from a C++ leopard trying to change his spots: > > I want to set up a program that uses some predefined values to determine its > logic. For example, a method could analyze some data and return "Good", > "Fair", "Poor", or "Out of Bounds" based on a set of thresholds. I want to > be able to refer to these values by name in my code, so constants or symbols > make a good choice here. But I also want to build a sort of rule set around > these values: some function returns values in the range of (0.0..1.0) and I > want to be able to say that 0.8 is the minimum score for "Good", etc. I > also want the word "Good" stored in a specific single place so that I don't > make any typos each time I need to print the description. > > In C++, I would use an enum for each of the values, then build arrays of > floats and strings indexed by those enums to hold the thresholds and > descriptions. > > What's the Ruby idiom for this? you could use enums : it's easy enough to do clearly in ruby    [http://groups.google.com/group/comp.lang.ruby/browse\_thread/thread/6f37e998434e65e5/ea5a7cc77156ee36?q=ara+howard+enum&rnum=1#ea5a7cc77156ee36](http://groups.google.com/group/comp.lang.ruby/browse_thread/thread/6f37e998434e65e5/ea5a7cc77156ee36?q=ara+howard+enum&rnum=1#ea5a7cc77156ee36) > Perhaps Struct followed by some initializer arrays? This seems like a good > start but I end up wanting to build a set of constants first to use as keys > to a hash containing the Structs. Perhaps the Structs should be the > constants themselves, like: > > Struct.new("RatingData", name, threshold, description) > > RATING\_GOOD = Struct::RatingData( :Good, 0.8, "Good Rating" ) > RATING\_FAIR = Struct::RatingData( :Fair, 0.5, "Fair Rating" ) > > ...etc. The analyze\_data could return RATING\_GOOD if things were fine. So: > > rating = analyze\_data data > puts "Analysis: #{rating.description}" > > Though this doesn't let me treat the values as though they are ordered, e.g. i often do something like this:      harp:~ \> cat a.rb      class C        module RATING          LIST = [            GOOD = 'GOOD',            FAIR = 'FAIR',            POOR = 'POOR',          ]        end        RAITINGS = RATING::LIST      end      p C::RATING::GOOD      p C::RAITINGS      C::RAITINGS.each{|r| p r}      harp:~ \> ruby a.rb      "GOOD"      ["GOOD", "FAIR", "POOR"]      "GOOD"      "FAIR"      "POOR" remember - the main reason to use ints for enums in c/c++ is to be able to use '==' with the variables but a language like ruby can do just as well with strings. > puts "\*\*\* Warning: Rating below Fair \*\*\*" if rating \< RATING\_FAIR > > Thoughts? in any case, reading over your description i'd be inclined to wrap Raitings as as objects and design a class generator that sets appropriate constants to configurable raitings, something like:      harp:~ \> cat a.rb      module RuleSet        class Raiting          include Comparable          attr 'description'          attr 'value'          def initialize d, v            @description, @value = String(d), Float(v)          end          def \<=\> other            ov = other.value rescue other            value \<=\> ov          end          def to\_s            "#{ description }(#{ value })"          end          alias inspect to\_s        end        module ClassMehods          attr 'raitings'          def inspect; raitings.inspect; end          def to\_s; raitings.inspect; end        end        module InstanceMethods        end        class \<\< self          def new(spec = {'good' =\> 0.8, 'fair' =\> 0.5, 'poor' =\> 0.2,})            klass = Class::new {              include InstanceMethods              extend ClassMehods              @raitings =              %w( good fair poor ).each do |k|                c = k.upcase                ks = k.to\_s                ki = ks.intern                keys = [k, ki, ks.downcase, ks.upcase]                v = nil                keys.each{|k| v = spec[k] and break}                r = Raiting::new k, v                const\_set c, r                @raitings \<\< r              end            }          end          alias new        end      end      rule\_set = RuleSet::new      p rule\_set::raitings      p(rule\_set::GOOD \< 42)      p rule\_set::GOOD.description      p rule\_set::GOOD.value      rs =        RuleSet[          :good =\> 42,          :fair =\> 41,          :poor =\> 40,        ]      p rs      p(rs::GOOD == 42)      harp:~ \> ruby a.rb      [good(0.8), fair(0.5), poor(0.2)]      true      "good"      0.8      [good(42.0), fair(41.0), poor(40.0)]      true hth. -a > **···** > > # On Sun, 28 Aug 2005, David Brady wrote: -- > > > email :: ara [dot] t [dot] howard [at] noaa [dot] gov > > phone :: 303.497.6469 > > Your life dwells amoung the causes of death > > Like a lamp standing in a strong breeze. --Nagarjuna > > =============================================================================== ---
**Author:** ![Florian\_Gross2](https://avatars.discourse-cdn.com/v4/letter/f/b4bc9f/32.png) [@Florian\_Gross2](https://rubytalk.org/u/Florian_Gross2)\ **Post date:** [28 August 2005 15:04 UTC](https://rubytalk.org/t/ruby-idiom-for-enum/20444/5 "2005-08-28T15:04:13Z")
David Brady wrote: > In C++, I would use an enum for each of the values, then build arrays of floats and strings indexed by those enums to hold the thresholds and descriptions. That's also possible in Ruby, but I think it is a better idea to aggregate all the data into the enum member itself. Here's Ruby code for doing C++ style enums: > # Represents a C# style enumeration of known values. > # > # Usage: > # Color = Enum.new(:Red, :Green, :Blue) > # Color.is\_a?(Enum) # =\> true > # Color::Red.inspect # =\> "Color::Red" > # Color::Green.is\_a?(Color) # =\> true > # Color::Green.is\_a?(Enum::Member) # =\> true > # Color::Green.index # =\> 1 > # Color::Blue.enum # =\> Color > # values = [[255, 0, 0], [0, 255, 0], [0, 0, 255]] > # values[Color::Green] # =\> [0, 255, 0] > # Color[0] # =\> Color::Red > # Color.size # =\> 3 > # > # Enums are enumerable. Enum::Members are comparable. > class Enum \< Module >   class Member \< Module >     attr\_reader :enum, :index > >     def initialize(enum, index) >       @enum, @index = enum, index >       # Allow Color::Red.is\_a?(Color) >       extend enum >     end > >     # Allow use of enum members as array indices >     alias :to\_int :index >     alias :to\_i :index > >     # Allow comparison by index >     def \<=\>(other) >       @index \<=\> other.index >     end > >     include Comparable >   end > >   def initialize(\*symbols, &block) >     @members = >     symbols.each\_with\_index do |symbol, index| >       # Allow Enum.new(:foo) >       symbol = symbol.to\_s.sub(/^[a-z]/) { |letter| letter.upcase }.to\_sym >       member = Enum::Member.new(self, index) >       const\_set(symbol, member) >       @members \<\< member >     end >     super(&block) >   end > >   def (index) @members[index] end >   def size() @members.size end >   alias :length :size > >   def first(\*args) @members.first(\*args) end >   def last(\*args) @members.last(\*args) end > >   def each(&block) @members.each(&block) end >   include Enumerable > end But I think it is not the best match in this case. > Struct.new("RatingData", name, threshold, description) > > RATING\_GOOD = Struct::RatingData( :Good, 0.8, "Good Rating" ) > RATING\_FAIR = Struct::RatingData( :Fair, 0.5, "Fair Rating" ) This sounds good, but I'd go with a module: module Rating    Good = Struct::RatingData.new(:Good, 0.8, "Good Rating")    Fair = Struct::RatingData.new(:Fair, 0.5, "Fair Rating") end That seems more Rubyish to me. ---
**Author:** ![Patrick\_Hurley1](https://avatars.discourse-cdn.com/v4/letter/p/b77776/32.png) [@Patrick\_Hurley1](https://rubytalk.org/u/Patrick_Hurley1)\ **Post date:** [28 August 2005 15:09 UTC](https://rubytalk.org/t/ruby-idiom-for-enum/20444/6 "2005-08-28T15:09:20Z")
Try this link: [http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/150439](http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/150439) See if it helps pth > **···** > > On 8/28/05, Brian Schröder \ wrote: > > > On 28/08/05, David Brady \ wrote: > > \> Okay, one more question from a C++ leopard trying to change his spots: > > \> > > \> I want to set up a program that uses some predefined values to determine > > \> its logic. For example, a method could analyze some data and return > > \> "Good", "Fair", "Poor", or "Out of Bounds" based on a set of > > \> thresholds. I want to be able to refer to these values by name in my > > \> code, so constants or symbols make a good choice here. But I also want > > \> to build a sort of rule set around these values: some function returns > > \> values in the range of (0.0..1.0) and I want to be able to say that 0.8 > > \> is the minimum score for "Good", etc. I also want the word "Good" > > \> stored in a specific single place so that I don't make any typos each > > \> time I need to print the description. > > \> > > \> In C++, I would use an enum for each of the values, then build arrays of > > \> floats and strings indexed by those enums to hold the thresholds and > > \> descriptions. > > \> > > \> What's the Ruby idiom for this? > > \>