不可变的类和特征？
我似乎遇到了很多问题，学习如何与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个或更多特征的上升，我该怎么办？ 我将不得不测试所有不切实际的组合。
如何实例化（克隆）具有各种特征的现有对象和/或在遵守功能设计原则的同时修改它的某些方面？
非常感谢， - 蒂姆
Collections使用隐式的构建器，知道如何根据您的目标创建您的目标类型。 这两种类型并不总是一回事。
有很多关于类型安全建设者的相关文章，它们控制着可以产生的内容，例如http://nullary.blogspot.com/2011/10/builder-pattern-revisited-in-scala.html
一个相关的问题是如果你有一个混合类型的集合：在不可变类层次结构中的多态更新
在数值轴上，跟踪值而不是编码类型什么是与Java构建器模式等价的Scala？
更新：在玩游戏的时候，类似的东西刚刚出现。 在ML和这里描述在模式中使用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"
}
}