Many to one

enumeratum-core/src/main/scala/enumeratum/Enum.scala

@@ -3,6 +3,7 @@ package enumeratum
 import scala.language.experimental.macros
 
 import scala.collection.immutable._
+import scala.collection.breakOut
 
 /**
   * All the cool kids have their own Enumeration implementation, most of which try to
@@ -38,20 +39,20 @@ trait Enum[A <: EnumEntry] {
   /**
     * Map of [[A]] object names to [[A]]s
     */
-  lazy final val namesToValuesMap: Map[String, A] =
-    values.map(v => v.entryName -> v).toMap
+  lazy val namesToValuesMap: Map[String, A] =
+    values.map(v => v.entryName -> v)(breakOut)
 
   /**
     * Map of [[A]] object names in lower case to [[A]]s for case-insensitive comparison
     */
   lazy final val lowerCaseNamesToValuesMap: Map[String, A] =
-    values.map(v => v.entryName.toLowerCase -> v).toMap
+    values.map(v => v.entryName.toLowerCase -> v)(breakOut)
 
   /**
     * Map of [[A]] object names in upper case to [[A]]s for case-insensitive comparison
     */
   lazy final val upperCaseNameValuesToMap: Map[String, A] =
-    values.map(v => v.entryName.toUpperCase -> v).toMap
+    values.map(v => v.entryName.toUpperCase -> v)(breakOut)
 
   /**
     * Map of [[A]] to their index in the values sequence.

enumeratum-core/src/main/scala/enumeratum/EnumEntry.scala

@@ -31,8 +31,8 @@ object EnumEntry {
    *
    * http://stackoverflow.com/a/19832063/1814775
    */
-  private val regexp1: Pattern    = Pattern.compile("([A-Z]+)([A-Z][a-z])")
-  private val regexp2: Pattern    = Pattern.compile("([a-z\\d])([A-Z])")
+  private val regexp1: Pattern = Pattern.compile("([A-Z]+)([A-Z][a-z])")
+  private val regexp2: Pattern = Pattern.compile("([a-z\\d])([A-Z])")
   private val replacement: String = "$1_$2"
 
   // Adapted from Lift's StringHelpers#snakify https://github.com/lift/framework/blob/a3075e0676d60861425281427aa5f57c02c3b0bc/core/util/src/main/scala/net/liftweb/util/StringHelpers.scala#L91
@@ -62,63 +62,71 @@ object EnumEntry {
     * Stackable trait to convert the entryName to Capital_Snake_Case .
     */
   trait CapitalSnakecase extends EnumEntry {
-    override def entryName: String                 = stableEntryName
+    override def entryName: String = stableEntryName
+
     private[this] lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString("_")
   }
 
   /**
     * Stackable trait to convert the entryName to Capital-Hyphen-Case.
     */
   trait CapitalHyphencase extends EnumEntry {
-    override def entryName: String                 = stableEntryName
+    override def entryName: String = stableEntryName
+
     private[this] lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString("-")
   }
 
   /**
     * Stackable trait to convert the entryName to Capital.Dot.Case.
     */
   trait CapitalDotcase extends EnumEntry {
-    override def entryName: String                 = stableEntryName
+    override def entryName: String = stableEntryName
+
     private[this] lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString(".")
   }
 
   /**
     * Stackable trait to convert the entryName to Capital Words.
     */
   trait CapitalWords extends EnumEntry {
-    override def entryName: String                 = stableEntryName
+    override def entryName: String = stableEntryName
+
     private[this] lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString(" ")
   }
 
   /**
     * Stackable trait to convert the entryName to CamelCase.
     */
   trait Camelcase extends EnumEntry {
-    override def entryName: String                 = stableEntryName
+    override def entryName: String = stableEntryName
+
     private[this] lazy val stableEntryName: String = super.entryName.split("_+").map(s => capitalise(s.toLowerCase)).mkString
   }
 
   /**
     * Stackable trait to convert the entryName to UPPERCASE.
     */
   trait Uppercase extends EnumEntry {
-    override def entryName: String                 = stableEntryName
+    override def entryName: String = stableEntryName
+
     private[this] lazy val stableEntryName: String = super.entryName.toUpperCase
   }
 
   /**
     * Stackable trait to convert the entryName to lowercase.
     */
   trait Lowercase extends EnumEntry {
-    override def entryName: String                 = stableEntryName
+    override def entryName: String = stableEntryName
+
     private[this] lazy val stableEntryName: String = super.entryName.toLowerCase
   }
 
   /**
     * Stackable trait to uncapitalise the first letter of the entryName.
     */
   trait Uncapitalised extends EnumEntry {
-    override def entryName: String                 = stableEntryName
+    override def entryName: String = stableEntryName
+
     private[this] lazy val stableEntryName: String = uncapitalise(super.entryName)
   }
 
@@ -167,6 +175,9 @@ object EnumEntry {
     */
   trait LowerCamelcase extends EnumEntry with Camelcase with Uncapitalised
 
+  abstract class MultiEnum(override val entryName: String,
+                           val alternateNames: String*) extends EnumEntry
+
   /**
     * Helper implicit class that holds enrichment methods
     */

enumeratum-core/src/test/scala/enumeratum/EnumSpec.scala

@@ -317,6 +317,11 @@ class EnumSpec extends FunSpec with Matchers {
         UncapitalisedEnum.withName("goodBye") shouldBe UncapitalisedEnum.GoodBye
         UncapitalisedEnum.withName("SIKE") shouldBe UncapitalisedEnum.Sike
         UncapitalisedEnum.withName("a") shouldBe UncapitalisedEnum.a
+
+        MultiEnum.withName("One") shouldBe MultiEnum.One
+        MultiEnum.withName("1") shouldBe MultiEnum.One
+        MultiEnum.withName("eins") shouldBe MultiEnum.One
+        MultiEnum.withName("Two") shouldBe MultiEnum.Two
       }
     }
   }

enumeratum-core/src/test/scala/enumeratum/Models.scala

@@ -227,6 +227,19 @@ object UncapitalisedEnum extends Enum[UncapitalisedEnum] {
 
 }
 
+case object MultiEnum extends Enum[MultiEnum] {
+  import scala.collection.breakOut
+  val values = findValues
+
+  override val namesToValuesMap: Map[String, MultiEnum] =
+    values.flatMap { n =>
+      (n.entryName -> n) +: n.alternateNames.map(name => name -> n)
+    }(breakOut)
+
+  case object One   extends MultiEnum("one", "1", "eins")
+  case object Two   extends MultiEnum("two", "2", "zwei")
+}
+
 object Wrapper {
 
   sealed trait SmartEnum extends EnumEntry