Dinamic case match in Scala based on fixed elements in a list

Question

Assume I have a List of possibles Credit Card

val availableCreditsCard = List(MasterCardCreditCard, VisaCreditCard)

Both those classes extends a trait called CreditCard

Now, I want to create a method, called isValid that accept the trait CreditCard

Something like:

  def isValid(creditCard: CreditCard): Boolean = {
    creditCard match {
      case t: MasterCardCreditCard => MasterCardCreditCardPayment.isValid(t)
      case s: VisaCreditCard => VisaCreditCardPayment.isValid(s)
    }
  }

Both MasterCardCreditCardPayment and VisaCreditCardPayment extends a trait called CreditCardPayment.

So, now, my question is, what if I want to add a new possible CreditCard (Amex), with his own CreditCardPayment (AmexCreditCardPayment), but just change the list availableCreditsCard and doesn't touch the match/case inside the isValid method?

Is it possible to create dinamically this match/case based on the list availableCreditsCard?

EDIT

This is the CreditCardPayment trait.

trait CreditCardPayment[CreditCard] {
  def isValid(creditCard: CreditCard): Boolean
  def checkCVV(creditCard: CreditCard): Boolean
}

and an example of VisaCreditCardPayment

object VisaCreditCardPayment extends CreditCardPayment[VisaCreditCard] {

  override def isValid(creditCard: VisaCreditCard): Boolean = {
    val listValidCreditCard = loadFile()
    listValidCreditCard.contains(creditCard)
  }

  //Implemented because it the trait, not necessary
  override def checkCVV(creditCard: VisaCreditCard): Boolean = {
    val listCreditCard = loadFile()
    val cvvToCheck = creditCard.cvv
    listCreditCard.exists(_.cvv == cvvToCheck)
  }
}

Now, your suggestion is, inside the isValid method, use a case t => CreditCardPayment.isValid(t). This is not even actual possible, since CreditCardPayment is a trait :(

Answer 1

If you want it "dynamic", just use inheritance rather than implementing it "on the side":

   sealed trait CreditCard {
      def isValid: Boolean
   }

   class MasterCard extends CreditCard {
      def isValid = MasterCardCreditCardPayment.isValid(this)
   }
   class Visa extends CreditCard {
      def isValid = VisaCreditCardPayment.isValid(this)
   }

Now, you can just do def isValid(c: CreditCard) = c.isValid, no need for any match statements to keep in sync.

And when you add Amex:

   class Amex extends CreditCard {
       def isValid = AmexCreditCardPayment.isValid(this)
   }

The isValid(amex) will just work, nothing needs to be updated.

Answer 2

Complementing Dima's answer. Since, you always want to delegate the isValid logic to the appropriate Payment. I will present you two ways to do not redefine the method in each sub-class.

One method using F-Bounded Polymorphism, which will require quite a boilerplate code for each sub-class, and it is not completely typesafe - thus may not worth the work.
And the second using typeclasses, which will be more typesafe, and will require less boilerplate for each new card.
For a more detailed discussion about F-Bounded vs Typeclasses, read this article.

Using F-Bounded

sealed trait CreditCardPayment[CC <: CreditCard[CC]] {
  def isValid(creditCard: CC): Boolean
  def checkCVV(creditCard: CC): Boolean
}

object VisaCreditCardPayment extends CreditCardPayment[VisaCreditCard] {
  private final val validCreditCards: List[VisaCreditCard] = ???

  override def isValid(creditCard: VisaCreditCard): Boolean =
    validCreditCards.contains(creditCard)

  override def checkCVV(creditCard: VisaCreditCard): Boolean =
    validCreditCards.exists(_.cvv == creditCard.cvv)
}

object MasterCreditCardPayment extends CreditCardPayment[MasterCreditCard] {
  private final val validCreditCards: List[MasterCreditCard] = ???

  override def isValid(creditCard: MasterCreditCard): Boolean =
    validCreditCards.contains(creditCard)

  override def checkCVV(creditCard: MasterCreditCard): Boolean =
    validCreditCards.exists(_.cvv == creditCard.cvv)
}

sealed trait CreditCard[CC <: CreditCard[CC]] { self: CC =>
  def paymentMethod: CreditCardPayment[CC]

  def cvv: String

  final def isValid: Boolean =
    paymentMethod.isValid(this)
}

final class VisaCreditCard (override val cvv: String) extends CreditCard[VisaCreditCard] {
  override final val paymentMethod: CreditCardPayment[VisaCreditCard] = VisaCreditCardPayment
}

final class MasterCreditCard (override val cvv: String) extends CreditCard[MasterCreditCard] {
  override final val paymentMethod: CreditCardPayment[MasterCreditCard] = MasterCreditCardPayment
}

Using Typeclasses

sealed trait CreditCardPayment[CC <: CreditCard] {
  def isValid(creditCard: CC): Boolean
  def checkCVV(creditCard: CC): Boolean
}

sealed trait CreditCard {
  def cvv: String
}

// Provides the 'isValid' & 'checkCVV' extension methods to any CredictCard.
implicit class CreditCardOps[CC <: CreditCard](val self: CC) extends AnyVal {
  def isValid(implicit payment: CreditCardPayment[CC]): Boolean =
    payment.isValid(self)

  def checkCVV(implicit payment: CreditCardPayment[CC]): Boolean =
    payment.checkCVV(self)
}

final class VisaCreditCard (override val cvv: String) extends CreditCard

object VisaCreditCard {
    final implicit val VisaCreditCardPayment: CreditCardPayment[VisaCreditCard] = new CreditCardPayment[VisaCreditCard] {
      final val validCreditCards: List[VisaCreditCard] = ???

      override def isValid(creditCard: VisaCreditCard): Boolean =
        validCreditCards.contains(creditCard)

      override def checkCVV(creditCard: VisaCreditCard): Boolean =
        validCreditCards.exists(_.cvv == creditCard.cvv)
    }
}

final class MasterCreditCard (override val cvv: String) extends CreditCard

object MasterCreditCard {
  final implicit val MasterCreditCardPayment: CreditCardPayment[MasterCreditCard] = new CreditCardPayment[MasterCreditCard] {
    final val validCreditCards: List[MasterCreditCard] = ???

    override def isValid(creditCard: MasterCreditCard): Boolean =
      validCreditCards.contains(creditCard)

    override def checkCVV(creditCard: MasterCreditCard): Boolean =
      validCreditCards.exists(_.cvv == creditCard.cvv)
  }
}

Using the typeclass approach you can also define the isValid method for CreditCards as a function instead.
(This way you do not need to define and import the CreditCardOps implicit / value class).

def isValid[CC <: CreditCard](cc: CC)(implicit payment: CreditCardPayment[CC]): Boolean =
  payment.isValid(cc)