Many to one

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

@@ -1,8 +1,7 @@
 package enumeratum
 
-import scala.language.experimental.macros
-
 import scala.collection.immutable._
+import scala.language.experimental.macros
 
 /**
   * All the cool kids have their own Enumeration implementation, most of which try to
@@ -38,20 +37,20 @@ trait Enum[A <: EnumEntry] {
   /**
     * Map of [[A]] object names to [[A]]s
     */
-  lazy final val namesToValuesMap: Map[String, A] =
+  lazy val namesToValuesMap: Map[String, A] =
     values.map(v => v.entryName -> v).toMap
 
   /**
     * 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
+    namesToValuesMap.map{ case (k, v) => k.toLowerCase -> v }
 
   /**
     * 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
+    namesToValuesMap.map{ case (k, v) => k.toUpperCase() -> v }
 
   /**
     * Map of [[A]] to their index in the values sequence.

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

@@ -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)
   }
 

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

@@ -317,6 +317,12 @@ 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
+        a [NoSuchElementException] should be thrownBy MultiEnum.withName("One")
+        MultiEnum.withName("eins") shouldBe MultiEnum.One
+        MultiEnum.withName("two") shouldBe MultiEnum.Two
       }
     }
   }

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

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