允许在 Scala/Java 中参数化 classes/types
Allowing parameterized classes/types in Scala/Java
我想将域实体（如在域驱动设计中）中的属性定义为具有最大长度的字符串类型。不同的属性会有不同的最大长度（以便匹配数据库列的数据类型）。例如描述将为 VARCHAR2(50)，而长描述将为 VARCHAR2(200)。
是否可以定义一个以整数作为参数的类型，如 VARCHAR2(50)？这样我只需要为所有这些类型定义一个 class 并将其用于不同的属性？
val 描述：TextValue(50)
val longDescription: TextValue(200)
您正在寻找一个名为 "Literal Types" 的概念。他们正在按照以下方式进行工作：
http://docs.scala-lang.org/sips/pending/42.type.html
您现在也许可以将其用作实验性功能。
而且我从社区中找到了至少一个实现。不知道行不行：
https://github.com/jeremyrsmith/literal-types
我不认为你可以使用 Java 类型系统来做这样的事情（代码 post-processing 除外，请参阅最后一个想法）。 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
}
请注意，这次最后一行将编译并且只会在运行时失败。
这种方法的一个好处可能是您可以对任意 class 进行检查，而不仅仅是 String。例如，您可以创建类似 NonNegativeInt 的内容。同样，使用这种方法，理论上您可以将多个检查合并为一个（但将 MaxLength 变成一个特征并创建一个扩展多个特征的类型）。在这种情况下，您可能希望 validate 到 return 之类的 cats.data.Validated 或至少 List[String] 因不同原因累积多个错误。
使用宏进行运行时检查
我没有这种方法的现成代码，但想法是您定义 an annotation that is processed by a macro。您可以使用它来注释 classes 的字段。并且您编写了一个宏，它将以这种方式重新编写 class 的代码，以验证字段 setter 中的最大长度（或其他条件取决于注释）。
这是您可能也可以相对轻松地implement in Java的唯一解决方案。
我想将域实体（如在域驱动设计中）中的属性定义为具有最大长度的字符串类型。不同的属性会有不同的最大长度（以便匹配数据库列的数据类型）。例如描述将为 VARCHAR2(50)，而长描述将为 VARCHAR2(200)。
是否可以定义一个以整数作为参数的类型，如 VARCHAR2(50)？这样我只需要为所有这些类型定义一个 class 并将其用于不同的属性？ val 描述：TextValue(50) val longDescription: TextValue(200)
您正在寻找一个名为 "Literal Types" 的概念。他们正在按照以下方式进行工作： http://docs.scala-lang.org/sips/pending/42.type.html 您现在也许可以将其用作实验性功能。
而且我从社区中找到了至少一个实现。不知道行不行： https://github.com/jeremyrsmith/literal-types
我不认为你可以使用 Java 类型系统来做这样的事情（代码 post-processing 除外，请参阅最后一个想法）。 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
}
请注意，这次最后一行将编译并且只会在运行时失败。
这种方法的一个好处可能是您可以对任意 class 进行检查，而不仅仅是 String。例如，您可以创建类似 NonNegativeInt 的内容。同样，使用这种方法，理论上您可以将多个检查合并为一个（但将 MaxLength 变成一个特征并创建一个扩展多个特征的类型）。在这种情况下，您可能希望 validate 到 return 之类的 cats.data.Validated 或至少 List[String] 因不同原因累积多个错误。
使用宏进行运行时检查
我没有这种方法的现成代码，但想法是您定义 an annotation that is processed by a macro。您可以使用它来注释 classes 的字段。并且您编写了一个宏，它将以这种方式重新编写 class 的代码，以验证字段 setter 中的最大长度（或其他条件取决于注释）。
这是您可能也可以相对轻松地implement in Java的唯一解决方案。