0

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

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

4

2 回答 2

1

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

无形Nat

一个明显的方向是尝试使用Natshapeless 提供的，粗略地说是自然数的一种类型编码。您可以像这样使用它来定义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数百个，则需要几分钟，我不确定您是否可以通过这种方式编译数千个。您还可以在无形中的 Nat 类型限制中找到一些详细信息

手工制作Nat

的编译时间Nat非常糟糕，因为数字是使用一种带有多对多包装器的Church 编码进行编码的。Succ[_]在实践中，您很可能不需要 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]以不同原因累积多个错误的内容。

使用宏进行运行时检查

对于这种方法，我没有现成的代码，但想法是您定义一个由宏处理的注释。您可以使用它来注释类的字段。并且您编写了一个宏，它将重写类的代码，从而验证字段设置器中的最大长度（或其他取决于注释的条件）。

这是您可能也可以相对容易地在 Java中实现的唯一解决方案。

于 2018-01-10T19:06:03.457 回答
1

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

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

于 2018-01-10T12:36:43.627 回答