Select random Enumeration by value - scala

Question

So i have this Enumeration:
object MyEnum extends Enumeration {
val a = Value(0, "Valid")
val b = Value(1, "Valid")
val c = Value(2, "Not Valid")
val d = Value(3, "Not Valid")
}
This Enumeration contains 2 types: Valid and Not valid.
Is it possible to select random MyEnum by value ?
For example i want to select a random MyEnum that is Valid.

Answer 1

Even when Yuval answer is correct and the solution will work, using Enumeration for encoding additional property is not recommended. By using name field for encoding the type as "Valid" or "Not Valid" (or any other classification) of your Values you are loosing build in ability of Enumeration class to reconstruct the enum value instances from String via .withName method:
// result will be always `a` for "Valid" and `b` for "Not Valid"
// it will throw an NoSuchElementException for any other string
MyEnum.withName(someString)
To put it simple when you are simply misusing name field for classification of your enum value instances. If this is not a problem in your code you're a lucky guy, but anyway document the misuse very precisely.
Enumeration was intended to express simple values, which have an index and can have nice human readable name. That's it, no more, no less.
Rule of thumb is, that when you have an enum which needs another fields it is better to model that using sealed hierarchy of case objects or case classes. Something like that (just an example for your particular case):
// Hierarchy is sealed, thus you will get can pattern match with check for exhaustiveness
sealed trait MyEnum {
def id: Int
def name: String
def valid: Boolean
}
// Helper case class, which allows to not define
private case class Value(id: Int, name: String, valid: Boolean) extends MyEnum
object MyEnum {
// Your values
val A: MyEnum = Value(0, "My A", true)
val B: MyEnum = Value(1, "My B", true)
val C: MyEnum = Value(0, "My A", false)
val D: MyEnum = Value(1, "My B", false)
// Re-implementation of methods contained in Enumeration, pick what you need
val values: Seq[MyEnum] = Seq(A, B, C, D)
// You can implement your own semantics, e.g. no Exception rather Option
def withName(name: String): Option[MyEnum] = values.find( _.name == name )
// Methods already for your example
val valids: Seq[MyEnum] = values.filter( _.valid )
// Or with randomization build in to enum
def randomValid: MyEnum = valids(util.Random.nextInt(valids.length))
}
In addition you will get more type safety:
// More type safety, fn simple does not compile
def fn(value: MyEnum) = value match {
case MyEnum.A => true
}
<console>:14: warning: match may not be exhaustive.
It would fail on the following input: Value(_, _, _)
def fn(value: MyEnum) = value match {
^
fn: (value: MyEnum)Boolean
Your milage may vary, because possibilities for writing an enum in Scala are almost endless :) In my example I'm showing only one of many possible implementations. If you have many values above mentioned approach can be impractical.
To know more about drawbacks of using Enumeration see "Scala Enumerations" blog post. Beware that solution in the end of article is not silver bullet and has problems with pattern matching exhaustiveness checking as Enumeration does.
Enjoy

Answer 2

This should do what you need:
val valids = MyEnum.values.filter { _.toString.equalsIgnoreCase("Valid") }.toSeq
val selected = valids(util.Random.nextInt(valids.length))
println(s"Selected $selected with id: ${selected.id}")

Answer 3

You can use scala Random:
scala.util.Random.shuffle(MyEnum.values.toList).find(_.toString.equalsIgnoreCase("Valid"))
and it will return an Option