Extending Case Object - scala

Question

I am new to Scala so apologies if its dumb question:
I have some common status that I won't to have enum(trait) for
Trait A
Object A {
case object A1 extends A
case object A2 extends A
val vectA = Vector(A1,A2)
}
I have 2 children who need additional statuses
Trait B extends A
Object B extends A{
case object B1 extends B
case object B2 extends B
val cVect = Vector(B1,B2) ++ A.vectA
def apply(status: String): C = {
cVect.find(_.toString == status).getOrElse("error")
}
}
Trait C extends A
Object C extends A{
case object C1 extends C
case object C2 extends C
val cVect = Vector(C1,C2) ++ A.vectA
def apply(status: String): C = {
cVect.find(_.toString == status).getOrElse("error")
}
}
Basically, I have apply method that will take string and return be Trait of Type B or C
so expecting
val x = B.apply("A1") to return B type enum.
I may be doing something completely wrong so please provide me right approach to deal with such situation

Answer 1

You probably want to do something like this:
sealed trait A
sealed trait ACompanion {
def vect: Vector[A]
final def apply(status: String): Option[A] =
vect.find(_.toString.toLowerCase == status.toLowerCase)
}
object A extends ACompanion {
final case object A1 extends A
final case object A2 extends A
override final val vect: Vector[A] = Vector(A1, A2)
}
sealed trait B extends A
object B extends ACompanion {
final case object B1 extends B
final case object B2 extends B
override final val vect: Vector[A] = Vector(B1, B2) ++ A.vect
}
sealed trait C extends A
object C extends ACompanion {
final case object C1 extends C
final case object C2 extends C
override final val vect: Vector[A] = Vector(C1, C2) ++ A.vect
}
Note that apart from fixing some typos, using sealed and creating a trait for the companions to reduce code duplication. The main change was understanding that vect will always be a Vector[A]; and thus find returns an Option[A].
This is because even for B or C, you are adding extra cases but you need to also provide the original A cases, thus your return type will need to the the least upper bound of those which is just A
You can see the code running here.