不同的表达类型

Question

这是我一再遇到的设计问题。假设您正在构建编译器，如何在树中存储类型？

考虑一个简单的Expr和Type层次结构，并假设Plus和Equals是多态的（例如，加上||中的布尔值）

trait Type
case object BoolType extends Type
case object IntType extends Type
case object Untyped extends Type

trait Expr { var tpe : Type = Untyped }

case class Var(id : String) extends Expr
case class Plus(l : Expr, r : Expr) extends Expr
case class Equals(l : Expr, r : Expr) extends Expr
// ...

进一步假设我在构造表达式树时不知道标识符的类型，因此无法通过构造知道类型。现在典型的类型检查功能可能如下所示：

def typeCheck(env : Map[String,Type])(expr : Expr) : Expr = expr match {
  case Var(id) =>
    expr.tpe = env(id)
    expr

  case Plus(l,r) =>
    val tl = typeCheck(env)(l)
    val tr = typeCheck(env)(r)
    assert(tl == tr)
    expr.tpe = tl
    expr

  // etc.
}

这写起来相当简单，但有两个主要问题：

Expr是可变的。没人喜欢变异。
无法区分已键入和无类型的表达式。我无法编写一个函数，其签名指定其参数必须是一个类型化的表达式。

所以我的问题如下。什么是好方法（我不敢说设计模式）来定义可能无类型的树，以便：

我只需要定义一次Expr层次结构。
键入的和非类型化的树具有不同的类型，我可以选择使它们不兼容。

编辑：还有一个要求是它应该适用于类型系统具有无限且不可预测的类型（例如：case class ClassType(classID : String) extends Type）。

Answer 1

这是类型级编程的完美用例！

首先，我们需要一个类型级Option，以便我们可以根据类型级None表示非类型化树，并在类型级别上键入X类型的树Some[X]：

// We are restricting our type-level option to
// only (potentially) hold subtypes of `Type`.
sealed trait IsTyped
sealed trait Untyped extends IsTyped
sealed trait Typed[T <: Type] extends IsTyped

接下来，我们将列出我们的类型系统层次结构：

sealed trait Type

// We can create complicated subhierarchies if we want.
sealed trait SimpleType extends Type
sealed trait CompoundType extends Type

sealed trait PrimitiveType extends Type
sealed trait UserType extends Type

// Declaring our types.
case object IntType extends SimpleType with PrimitiveType

case object BoolType extends SimpleType with PrimitiveType

// A type with unbounded attributes.
case class ClassType(classId: String) extends CompoundType with UserType

// A type that depends statically on another type.
case class ArrayType(elemType: Type) extends CompoundType with PrimitiveType

现在，剩下的就是声明我们的表达式树：

sealed trait Expr[IT <: IsTyped] { val getType: Option[Type] }

// Our actual expression types.
case class Var[IT <: IsTyped](id: String, override val getType: Option[Type] = None) extends Expr[IT]

case class Plus[IT <: IsTyped](l: Expr[IT], r: Expr[IT], override val getType: Option[Type] = None) extends Expr[IT]

case class Equals[IT <: IsTyped](l: Expr[IT], r: Expr[IT], override val getType: Option[Type] = None) extends Expr[IT]

case class ArrayLiteral[IT](elems: List[Expr[_ :< IsTyped]], override val getType: Option[Type] = None) extends Expr[IT]

修改

一个简单但完整的类型检查功能：

def typeCheck(expr: Expr[Untyped], env: Map[String, Type]): Option[Expr[Typed[_ :< Type]]] = expr match { case Var(id, None) if env isDefinedAt id => Var[Typed[_ <: Type]](id, Some(env(id))) case Plus(r, l, None) => for { lt <- typeCheck(l, env) IntType <- lt.getType rt <- typeCheck(r, env) IntType <- rt.getType } yield Plus[Typed[IntType]](lt, rt, Some(IntType)) case Equals(r, l, None) => for { lt <- typeCheck(l, env) lType <- lt.getType rt <- typeCheck(r, env) rType <- rt.getType if rType == lType } yield Equals[Typed[BoolType]](lt, rt, Some(BoolType)) case ArrayLiteral(elems, None) => { val elemst: List[Option[Expr[Typed[_ <: Type]]]] = elems map { typeCheck(_, env) } val elemType: Option[Type] = if (elemst.isEmpty) None else elemst map { elem => elem map { _.getType } } reduce { (elemType1, elemType2) => for { et1 <- elemType1 et2 <- elemType2 if et1 == et2 } yield et1 } if (elemst forall { _.isDefined }) elemType map { et => ArrayLiteral[Typed[ArrayType]](elemst map { _.get }, ArrayType(et)) } else None } case _ => None }

Answer 2

要使其不可变，您可以组成新的Expr而不是更改其内容。案例类有copy method，您可以将其用于此目的。

trait Type
case object BoolType extends Type
case object IntType extends Type
case object Untyped extends Type

class Expr[A <: Type](tpe : Type = Untyped)

case class Var[A <: Type](id : String, tpe : Type = Untyped) extends Expr[A](tpe)
case class Plus[A <: Type](l : Expr, tpe : Type = Untyped) extends Expr[A](tpe)
case class Equals[A <: Type](l : Expr, tpe : Type = Untyped) extends Expr[A](tpe)

现在你可以自由地做各种各样的好事：

val x = Var("name")
val y = x.copy(tpe = IntType)

然而，它现在是不可改变的。您可以通过匹配tpe来确定是否输入它来解决您的问题，因为它是Var，Plus和Equals的参数之一。它们也有不同的类型，它们的类型会随着tpe的变化而改变。

Answer 3

这只是一个想法。

首先，如果你想要不可变，显然你必须摆脱变量tpe。

不同的表达类型

只需制作两个层次结构，一个使用TypedExpression <: Expression，另一个使用UntypedExpression <: Expression。这种方法可能会产生两个几乎相同的类层次结构。

制作类型参数信号类型

为了消除两个层次结构的开销（并得到一些类型样板文件），您可以创建一个层次结构并为a bool type添加一个类型参数：

sealed trait TBool
sealed trait TTrue extends TBool
sealed trait TFalse extends TBool

trait Expression[T <: TBool]{
  //ensure that this gets only called on typed expressions
  def getType(implicit e: T =:= TTrue): Type
  def typeMe(m: Map[String,Type]): Expression[TTrue] = this.asInstanceOf[Expression[TTrue]]
}

如果你这样做，我真的不知道你将会遇到多少问题。但这就是我想要的。

设计不可变，可打字的树木

3 个答案:

不同的表达类型

制作类型参数信号类型