Question

我似乎遇到了很多问题，学习在Scala中使用不可变的主体，其中一个是克隆（或者更确切地说是派生）来自相关对象的概念。

其中一个问题是混合特征的概念 - 例如

trait helper //modifies some kind behavior.. assume we want to to continue down the line

class A (val x:int) {

 def add(y:int) = new A(x + y)
}

Example extends App {

 val a =new A(5) with helper
 val b = a.add(10)  // mixed trait disappears

}

现在这只是一个非常复杂的问题的一个非常简单的版本，我今天已经围绕各种类，工厂方法来隐藏A类等等。如果我们只处理一个特性，我知道我可以简单地测试为它，并根据需要发送它。但如果可能存在3个或更多特征，我该怎么办呢？我必须测试所有不切实际的组合。

如何在坚持功能设计原则的同时，实例化（克隆）具有各种特征的现有对象和/或修改它的某些方面？

非常感谢， - 蒂姆

Answer 1

集合使用隐式构建器，它们知道如何根据您的开始生成目标类型。这两种类型并不总是相同的。

有许多关于类型安全构建器的相关帖子可以控制可以生成的内容，例如： http://nullary.blogspot.com/2011/10/builder-pattern-revisited-in-scala.html

如果你有一系列混合类型，那么相关的问题是： Polymorphic updates in an immutable class hierarchy

在值轴上，跟踪值而不是编码类型 What is the Scala equivalent to a Java builder pattern?

更新：在游戏时间内出现类似的东西。在ML和here中描述了在模式中使用RE。

package object interpat {
  implicit class MySContext (val sc : StringContext) {
    object mys {
      def apply (args : Any*) : String = sc.s (args : _*)
      def unapplySeq (s : String) : Option[Seq[String]] = {
        val regexp = sc.parts.mkString ("(.+)").r
        regexp.unapplySeq (s)
      }
    }
  }
  implicit class SBContext (val sc : StringContext) {
    def sb(args: Any*): SB = new SB(sc.s (args : _*))
  }
  implicit class toHasPattern(sb: SB) {
    def /(pp: String) = new SB(sb.s) with HasPattern {
      val p = pp
    }
  }
  implicit class toHasRepl(hasp: SB with HasPattern) {
    def /(rr: String) = new SB(hasp.s) with HasPattern with HasRepl with Updateable {
      val p = hasp.p
      val r = rr
    }
  }
  // disallow it
  implicit class noway(hasr: SB with HasPattern with HasRepl) {
    def /(rr: String) = ???
  }
  implicit class noway2(hasr: SB with HasPattern with HasRepl) {
    def /(rr: String) = ???
  }
}

使用类型参数控制含义的用法和替代方法。

package interpat {
  import scala.util.Try
  object I { def unapply(x: String): Option[Int] = Try(x.toInt).toOption }

  trait XX {
    type HasIt
    type Yes <: HasIt
    type No <: HasIt
  }
  object XX extends XX {
    implicit class XContext (val sc : StringContext) {
      def x(args: Any*) = new X[No, No] {
        val s = sc.s(args : _*)
      }
    }
    implicit class xPat(x: X[No, No]) {
      def /(pp: String) = new X[Yes, No] with HasPattern {
        val s = x.s
        val p = pp
      }
    }
    implicit class xRep(x: X[Yes, No] with HasPattern) {
      def /(rr: String) = new X[Yes, Yes] with HasPattern with HasRepl {
        val s = x.s
        val p = x.p
        val r = rr
        override def toString = s replaceAll (p, r )
      }
    }
    implicit class xable(xx: X[Yes, Yes]) {
      def x = xx.toString
    }
  }
  import XX._

  trait X[HasP <: HasIt, HasR <: HasIt] {
    def s: String
  }

  trait HasPattern {
    def p: String
  }

  trait HasRepl {
    def r: String
  }

  trait Updateable { this: HasPattern with HasRepl =>
    def update(p: String, r: String)
    override def toString = {
      update(p, r)
      super.toString
    }
  }

  class SB(val s: String) {
    final val sb = new StringBuilder(s)
    def update(p: String, r: String): Unit =
      sb.replace(0, sb.length, sb.toString.replaceAll(p, r))
    override def toString = sb.toString
  }

  object Test extends App {
    val msg = "The sky is blue" match {
      case mys"The $thing is $colour" => mys"A $colour thing is $thing"
      case _ => "no match"
    }
    println (msg)
    val mys"The $thing is $colour" = "The sky is blue"
    Console println s"$thing / $colour"
    val mys"The ${I(number)} is blue" = "The 3 is blue"
    Console println s"$number"
    //sb"The sky is blue".update("blue","red")
    // no way to get a value out!
    sb"The sky is blue"("blue") = "red"
    val ugh = sb"The sky is blue"
    ugh("blue") = "red"
    Console println ugh
    val sx = sb"The sky is $colour" / "blue" / "red"
    Console println sx
    //sb"The sky is $colour" / "blue" / "red" / "yellow"
    Console println sx
    Console println x"The sky is $colour" / "blue" / "red"
    Console println (x"The sky is $colour" / "blue" / "red").x
    //Console println x"The sky is $colour" / "blue" / "red" / "yellow"
  }
}

不可改变的阶级和特征？

1 个答案: