The biggest issue is that the code you *want* is not really how scala generic work, more like C++ templates. In C++, templates are evaluated at call sites, and needed code is generated for you. In scala, the code is compiled and then call sites make use of this generic form (i.e. there is erasure).
So.... I don't think you can define a type that will use the specific copy method of the class (i.e. with all the appropriate defaults), without going through some extra hoops. You have to ensure that you're using normal runtime-polymorphism.
sealed trait Shape[T <: Shape] {
def color : String
def copy(color : String) : T
}
case class Circle(radius : Int, color : String) extends Shape {
override def copy(color : String) = Circle(radius,color)
}
class PaintingWorkshop[S<:Shape]{
val color="red"
var shapes=new scala.collection.mutable.ListBuffer[S]()
def put(shape:S){
shapes+=shape.copy(color="red")
}
}
scala> val pw = new PaintingWorkshop[Circle]
pw: PaintingWorkshop[Circle] = PaintingWorkshop@1e88c7f
scala> val x = Circle(5,"red")
x: Circle = Circle(5,red)
scala> pw.put(x)
scala> pw.shapes
res2: scala.collection.mutable.ListBuffer[Circle] = ListBuffer(Circle(5,red))
================================================
An alternative to this would be start using some implicit magic.
//This trait exists solely for the Painting Workshop
trait ShapeCopier[T] {
def copy(shape : T)(color : String) :T
}
class PaintingWorkshop {
val color="red"
var shapes=new scala.collection.mutable.ListBuffer[Shape]()
//An implicit copier trait needs to be available with information on how to copy a shape correctly
def put[S <: Shape](shape:S)(implicit copier : ShapeCopier[S]){
shapes+=copier.copy(shape)(color="red")
}
}
case class Circle(radius : Int, color : String)
case class Square(length : Int, width : Int, color : String)
//Ideally we'd place implicits in the companion objects, but for now we'll put it in a package object
package object painting {
implicit val circleCopier = new ShapeCopier[Circle] {
def copy(shape : Circle)(color : String) = shape.copy(color = color)
}
implicit val squareCopier = new SquareCopier[Square] {
def copy(shape : Square)(color : String) = shape.copy(color = color)
}
}
Either way, it's not quite the same as in C++ where the compiler will write the code for you.
Anyway, as an aside, the PaintingWorkshop (as defined) is not very useful. If it's designed to work against shapes, the Type constraints on it limit it to only working with a particular shape subclass. Perhaps describing the goal you're trying to achieve would be more useful?
On Mon, Dec 21, 2009 at 11:20 PM, Naftoli Gugenheim
<[hidden email]> wrote:
I think you can write [S <: Shape{ def copy ... } ]
2009/12/20 Kevin Wright
<[hidden email]>
A couple of problems here:
1. case classes shouldn't subclass other case classes. This can cause lots of problems and is formally deprecated in 2.8
Make Shape into an abstract class
sealed abstract class Shape {
def color:String
}
2. why is the shapes collection both a var and a mutable collection?
This mixes of idioms, choose one or the other
To answer your original question, to copy the object you can pattern match on it:
def put(shape:S) : Unit =
shapes += shape match {
case s:Circle => s.copy(color="red")
case s:Square => s.copy(color="red")
}
There's no need to match the default case as Shape is sealed and you want the compiler to help you out here and warn of shapes you've missed
Hi list -
I have some code like this -
case class Shape(val color:String)
case class Circle(val radius:Int,override val color:String) extends Shape(color)
case class Square(val size:Int,override val color:String) extends Shape(color)
class PaintingWorkshop[S<:Shape]{
val color="red"
var shapes=new scala.collection.mutable.ListBuffer[S]()
def put(shape:S){
shapes+=shape.copy(color="red") //error
}
}
Compiler dose not like it, saying found type Shape but required S, at the line i marked.
--
Kevin Wright
mail/google talk:
[hidden email]wave:
[hidden email]
skype: kev.lee.wright
twitter: @thecoda
Locked
