TypeTag vs Simple Pattern Match

Question

Improbably missing some points regarding typeTag . I would like to get an explanation to the difference between the following code examples, also useful cases of typeTag , and a bit more explanation about its needs.

  @throws[IllegalArgumentException]("if types mismatched and not equals to ComparableRelationDataType")
 def eval[T](checkedValue: T, checkedWithValue: T): Boolean = (checkedValue, checkedWithValue) match {
    case (x: String, y: String) if ruleValue.dataType == ComparableRelationDataType.String => ruleValue.eval[String](x, y)
    case (x: BigDecimal, y: BigDecimal) if ruleValue.dataType == ComparableRelationDataType.Numeric =>ruleValue.eval[BigDecimal](x, y)
    case (x: Boolean, y: Boolean) if ruleValue.dataType == ComparableRelationDataType.Boolean => ruleValue.eval[Boolean](x, y)
    case (x: Instant, y: Instant) if ruleValue.dataType == ComparableRelationDataType.Instant => ruleValue.eval[Instant](x, y)
    case _ => throw new IllegalArgumentException(s"Illegal ComparableRelationDataType on ${ruleValue.dataType}")
  }

and

  @throws[IllegalArgumentException]("if classTag not equals to ComparableRelationDataType")
  def eval[T](checkedValue: T, checkedWithValue: T)(implicit tag: TypeTag[T]) : Boolean = {
    ruleValue.dataType match {
      case ComparableRelationDataType.String if typeOf[String] =:= typeOf[T] => ruleValue.eval[String](checkedValue.asInstanceOf[String], checkedWithValue.asInstanceOf[String])
      case ComparableRelationDataType.Numeric if typeOf[BigDecimal] =:= typeOf[T]  => ruleValue.eval[BigDecimal](checkedValue.asInstanceOf[BigDecimal], checkedWithValue.asInstanceOf[BigDecimal])
      case ComparableRelationDataType.Instant if typeOf[Instant] =:= typeOf[T] => ruleValue.eval[Instant](checkedValue.asInstanceOf[Instant], checkedWithValue.asInstanceOf[Instant])
      case ComparableRelationDataType.Boolean if typeOf[Boolean] =:= typeOf[T] => ruleValue.eval[Boolean](checkedValue.asInstanceOf[Boolean], checkedWithValue.asInstanceOf[Boolean])
      case _ => throw new IllegalArgumentException(s"Illegal ComparableRelationDataType, got TypeTag: ${typeOf[T]} on ${ruleValue.dataType}")
    }
  }

Thanks!

---

Edit 1:

ruleValue.eval Code:

 def eval[T <% Comparable[T]](checkedValue: T, checkedWithValue: T) : Boolean = {
    operator match {
      case GreaterThan => checkedValue.compareTo(checkedWithValue) > 0
      case GreaterThanEquals => checkedValue.compareTo(checkedWithValue) >= 0
      case LowerThanEquals => checkedValue.compareTo(checkedWithValue) <= 0
      case LowerThan => checkedValue.compareTo(checkedWithValue) < 0
      case Equals => checkedValue.compareTo(checkedWithValue) == 0
      case NotEquals => checkedValue.compareTo(checkedWithValue) != 0
    }
  }

ComparableRelationDataType:

sealed trait ComparableRelationDataType extends EnumEntry
object ComparableRelationDataType extends Enum[ComparableRelationDataType] {
  case object String extends ComparableRelationDataType
  case object Numeric extends ComparableRelationDataType
  case object Instant extends ComparableRelationDataType
  case object Boolean extends ComparableRelationDataType
  override def values: immutable.IndexedSeq[ComparableRelationDataType] = findValues
}

---

Edit 2: Outsource API usage:

  // ComparableRelation
      case rp @ ComparableRelationRulePart(ComparableRelationExpression(relationType, _), ComparableRelationHeader(name, otherName)) =>
        import scala.reflect.runtime.universe._
        def evalRelationOn[T](implicit r: Reads[T], tag: TypeTag[T]) = {
          val checkedValue = deepSearch(payload, name)
          val checkedWithValue = deepSearch(payload, otherName)
          (checkedValue.asOpt[T],checkedWithValue.asOpt[T]) match {

            // Found values on Payload
            case (Some(checkedValue), Some(checkedWithValue)) =>
              val tryRes = scala.util.Try(rp.eval[T](checkedValue, checkedWithValue))
              tryRes.fold(
                // Should not happen!
                exOccurred => {
                  logger.error(s"Failure occurred on RelationRulePart for values: [$checkedValue,$checkedWithValue] on actionRuleId: ${actionRule._id} with ex: ${exOccurred.getMessage}")
                  Metrics.errorsCounter("RelationRulePart", "actionRuleId" -> actionRule._id).increment()
                  (false, Some(Left(s"$name && $otherName"))) // Left is unmatched, there will be unmatched with &&.
                },
                status => (status, collectName(status, Some(Unit), name)) // Some(Unit) since its succeed/failed
              )

            // Cannot find some of the values on Payload
            case (Some(_), None) => (false, Some(Right(otherName)))
            case (None, Some(_)) => (false, Some(Right(name)))
            case (None, None) => (false, Some(Right(s"$name && $otherName")))
          }
        }
        relationType match {
          case ComparableRelationDataType.String => evalRelationOn[String]
          case ComparableRelationDataType.Numeric => evalRelationOn[BigDecimal]
          case ComparableRelationDataType.Instant => evalRelationOn[Instant]
          case ComparableRelationDataType.Boolean => evalRelationOn[Boolean]
        }
    }

In overall, its just a rule service:

Input: I'm uploading Rules to the system Runtime: JsValue arrived, and checked for these rules, I'm parsing the data from the value in Runtime.