类型安全的层次结构

Question

我想写一个API，让我可以轻松创建分层键，如

/ foo / bar / baz

为此，我创建了以下类：

sealed trait Key {
  def path: String

  def /(key: String): Node = Node(this, key)
}

case object Root extends Key {
  override def path: String = ""
}

final case class Node(parent: Key, key: String) extends Key {
  override def path: String = s"${parent.path}/$key"
}

它工作得很好：

Root / "foo" / "bar"

现在，我也希望能够像这样包含 'placeholders'：

Root / "foo" / %

然后这将 return 一些东西，当一个字符串被应用时 returns 一个 Key 替换给定值的对象，即

(Root / "foo" / %)("bar") == Root / "foo" / "bar"

请记住，这应该适用于 n 级，如下所示：

Root / % / "foo" / % / "bar"

Answer 1

这可能不是很有效，但它可以满足您的要求。

请注意，在回答我自己的评论时，我决定

(Root / % / "foo" / % / "bar")("baz") == (Root / % / "foo" / "baz" / "bar")

但要获得不同的结果并没有太大的改变。

object % // only for nicer API

trait Slashable[T <: Slashable[T]] {
  def /(key: String): T
  def /(p: %.type): PlaceHeld[T] = PlaceHeld[T](str => /(str))
}

case object Root extends Key {
  override def path: String = ""
}

sealed trait Key extends Slashable[Key] {
  def path: String

  def /(key: String): Node = Node(this, key)
}


final case class Node(parent: Key, key: String) extends Key {
  override def path: String = s"${parent.path}/$key"
}

case class PlaceHeld[T <: Slashable[T]](replace: String => T) extends Slashable[PlaceHeld[T]]{
  def /(key: String) = PlaceHeld(str => replace(str)./(key))
  def apply(key: String) = replace(key)
}

编辑

您可能想用简单的（包装的）Seq:

替换您的基本类型（没有占位符）

case class Key(pathSeq: Seq[String]) extends Slashable[Key] {
  def path = pathSeq.mkString("/")
  def /(key: String) = Key(pathSeq :+ key)
}

object Root extends Slashable[Root] { 
  def path = ""                       //this is because we cannot do 
  def /(key: String) = Key(Seq(key))  //Root extends Key(Seq())
}

类型安全的层次结构

Typesafe Hierarchichal Structure

scala

type-safety