允许Scala / Java

Question

我想将域实体中的属性（如在域驱动设计中）定义为具有最大长度的String类型。不同的属性将具有不同的最大长度（以便它可以匹配数据库列数据类型）。例如描述将是VARCHAR2（50），而长描述将是VARCHAR2（200）。

是否可以定义一个带整数的类型，如VARCHAR2（50）这样的参数？所以我只需要为所有这些类型定义一个类并将其用于不同的属性？ val描述：TextValue（50） val longDescription：TextValue（200）

Answer 1

您正在寻找一种名为“文字类型”的概念。他们按照以下方式进行工作： http://docs.scala-lang.org/sips/pending/42.type.html 您现在可能可以将其用作实验性功能。

我发现社区中至少有一个实现。不知道它是否有效： https://github.com/jeremyrsmith/literal-types

Answer 2

我不认为你可以使用Java类型系统做这样的事情（代码后处理除外，请参阅最后的想法）。 Scala类型系统功能更强大，因此您可以尝试遵循一些途径。

无形Nat

一个明显的方向是尝试使用Nat provided by shapeless，这大致是自然数的类型编码。您可以像这样使用它来定义给定最大长度的TextValue：

import shapeless._
import shapeless.ops.nat._
import shapeless.syntax.nat._


case class TextValue[N <: Nat] private(string: String)

object TextValue {
  // override to make the one generated by case class private
  private def apply[N <: Nat](s: String) = ???

  def unsafe[N <: Nat](s: String)(implicit toIntN: ToInt[N]): TextValue[N] = {
    if (s.length < Nat.toInt[N]) new TextValue[N](s)
    else throw new IllegalArgumentException(s"length of string is ${s.length} while max is ${Nat.toInt[N]}")
  }

  implicit def convert[N <: Nat, M <: Nat](tv: TextValue[N])(implicit less: NatLess[N, M]): TextValue[M] = new TextValue[M](tv.string)
}


// N < M
trait NatLess[N <: Nat, M <: Nat]

object NatLess {
  implicit def less[N <: Nat]: NatLess[N, Succ[N]] = new NatLess[N, Succ[N]] {}

  implicit def lessSucc[N <: Nat, M <: Nat](implicit prev: NatLess[N, M]): NatLess[N, Succ[M]] = new NatLess[N, Succ[M]] {}
}

然后你可以像这样使用它：

def test(): Unit = {
  val Twenty = Nat(20)
  type Twenty = Twenty.N
  val Thirty = Nat(30)
  type Thirty = Thirty.N

  val tv20: TextValue[Twenty] = TextValue.unsafe[Twenty]("Something short")
  val tv30: TextValue[Thirty] = TextValue.unsafe[Thirty]("Something short")

  val tv30assigned: TextValue[Thirty] = tv20
  //val tv20assigned: TextValue[Twenty] = tv30 // compilation error
}

这种方法的问题是Nat显着延长了编译时间。如果您尝试将Nat编译成数百个，则需要几分钟时间，而且我不确定您是否可以通过这种方式编译数千个。您还可以在Limits of Nat type in Shapeless

找到一些详细信息

手工制作Nat

Nat的编译时间非常糟糕，因为数字是使用一种具有许多Succ[_]包装的Church encoding进行编码的。在实践中，您很可能不需要介于1和最大长度之间的所有值，因此仅明确列出您需要的值的手工制作版本可能对您更好：

sealed trait Nat {
  type N <: Nat
}

// N < M
trait NatLess[N <: Nat, M <: Nat]

object NatLess {

  implicit def transitive[N <: Nat, M <: Nat, K <: Nat](implicit nm: NatLess[N, M], mk: NatLess[M, K]): NatLess[N, K] = new NatLess[N, K] {}
}

trait ToInt[N <: Nat] {
  val intValue: Int
}

object Nat {

  def toInt[N <: Nat](implicit toInt: ToInt[N]): Int = toInt.intValue

  sealed abstract class NatImpl[N <: Nat](val value: Int) extends Nat {
    implicit def toInt: ToInt[N] = new ToInt[N] {
      override val intValue = value
    }
  }

  /////////////////////////////////////////////
  sealed trait Nat50 extends Nat {
    type N = Nat50
  }

  object Nat50 extends NatImpl(50) with Nat50 {
  }

  /////////////////////////////////////////////
  sealed trait Nat100 extends Nat {
    type N = Nat100
  }

  object Nat100 extends NatImpl(100) with Nat100 {
  }

  implicit val less50_100: NatLess[Nat50, Nat100] = new NatLess[Nat50, Nat100] {}

  /////////////////////////////////////////////
  sealed trait Nat200 extends Nat {
    type N = Nat200
  }

  object Nat200 extends NatImpl(200) with Nat200 {
  }

  implicit val less100_200: NatLess[Nat100, Nat200] = new NatLess[Nat100, Nat200] {}
  /////////////////////////////////////////////

}

使用此类自定义Nat且非常相似TextValue

case class TextValue[N <: Nat] private(string: String)

object TextValue {
  // override to make the one generated by case class private
  private def apply[N <: Nat](s: String) = ???

  def unsafe[N <: Nat](s: String)(implicit toIntN: ToInt[N]): TextValue[N] = {
    if (s.length < Nat.toInt[N]) new TextValue[N](s)
    else throw new IllegalArgumentException(s"length of string is ${s.length} while max is ${Nat.toInt[N]}")
  }

  implicit def convert[N <: Nat, M <: Nat](tv: TextValue[N])(implicit less: NatLess[N, M]): TextValue[M] = new TextValue[M](tv.string)
}

你可以轻松编译这样的东西

def test(): Unit = {

  val tv50: TextValue[Nat.Nat50] = TextValue.unsafe[Nat.Nat50]("Something short")
  val tv200: TextValue[Nat.Nat200] = TextValue.unsafe[Nat.Nat200]("Something short")


  val tv200assigned: TextValue[Nat.Nat200] = tv50
  // val tv50assigned: TextValue[Nat.Nat50] = tv200 // compilation error
}

请注意，此时200的最大长度不会以任何显着的方式影响编译时间。

使用隐含的运行时检查

如果所有检查都只是运行时，您可以使用完全不同的方法。然后，您可以定义trait Validator和class ValidatedValue，例如：

trait Validator[T] {
  def validate(value: T): Boolean
}

case class ValidatedValue[T, V <: Validator[T]](value: T)(implicit validator: V) {
  if (!validator.validate(value))
    throw new IllegalArgumentException(s"value `$value` does not pass validator")
}

object ValidatedValue {
  implicit def apply[T, VOld <: Validator[T], VNew <: Validator[T]](value: ValidatedValue[T, VOld])(implicit validator: VNew): ValidatedValue[T, VNew] = ValidatedValue(value.value)
}

并将MaxLength支票定义为

abstract class MaxLength(val maxLen: Int) extends Validator[String] {
  override def validate(value: String): Boolean = value.length < maxLen
}

object MaxLength {

  implicit object MaxLength50 extends MaxLength(50)

  type MaxLength50 = MaxLength50.type
  type String50 = ValidatedValue[String, MaxLength50]

  implicit object MaxLength100 extends MaxLength(100)

  type MaxLength100 = MaxLength100.type
  type String100 = ValidatedValue[String, MaxLength100]
}

然后你可以像这样使用它：

def test(): Unit = {
  import MaxLength._

  val tv50: String50 = ValidatedValue("Something short")
  val tv100: String100 = ValidatedValue("Something very very very long more than 50 chars in length")
  val tv100assigned: String100 = tv50
  val tv50assigned: String50 = tv100 // only runtime error
}

注意，这次最后一行将编译，并且只会在运行时失败。

这种方法的好处可能是您可以对任意类使用检查，而不仅仅使用String。例如，您可以创建类似NonNegativeInt的内容。同样，通过这种方法，您理论上可以将多个检查合并为一个（但将MaxLength转换为特征并创建扩展多个特征的类型）。在这种情况下，您可能希望validate返回cats.data.Validated或至少List[String]之类的内容，以便根据不同的原因积累多个错误。

使用宏进行运行时检查

我没有这种方法的现成代码，但想法是你定义an annotation that is processed by a macro。您可以使用它来注释类的字段。并且你编写了一个宏，它将重新编写类的代码，以便在字段的setter中验证最大长度（或其他条件取决于注释）。

这是您可能相对容易implement in Java的唯一解决方案。