Why does scala have "new"?

17 replies

Tue, 2009-09-01, 18:48

David Flemström

Joined: 2009-08-10,

p, li { white-space: pre-wrap; }Hello all,

I was just thinking about Scala in general the other day, and was just wondering:
What is the reason for having the "new" keyword in Scala?
For when you think about it, is "new" really a good solution for any functional or object oriented programming language? Since:

You can't really override/inherit a constructor so it's not object-oriented
A constructor isn't really a function or an object or anything general really, not even with Scala's "method to function" promotion because constructors aren't even methods; you still have to create a new function for the constructor if you want to treat it like a function, by which I mean that "new SomeClass _" doesn't work and because of that you have to write "x => new SomeClass(x)".
You cannot describe a type that depends on a constructor. For example, "def func[T](x: { def this(x: Int, y: Int): T }) = ..." isn't possible.

Wouldn't it make more sense to make all classes abstract (from the Java programmer's POV) and move the creation of objects into a class's companion object, creating a factory apply method instead, like what's being done with case classes already? So you would write:

class SomeClass(var x: Int)

val y = SomeClass(3) //automatically generated constructor
val constructor = SomeClass.apply _

The way "extends" would work with the alternative system is that it would be followed by a function that will return some type, and that type is what the class extends. There might be problems with traits, but I think they would be solvable. Example:

trait SomeTrait
class OtherClass extends SomeClass(3) with SomeTrait
//SomeClass(3) becomes SomeClass.apply(3) above

This would even allow for more freedom than "new" gives you, since you can extend a class and use a factory method for the inherited class' initialization. E.g.:

class A(var x: Int)
def factory(x: Int, logmsg: String) = { println(logmsg); A(x) }
class B extends factory(3, "hello")

...and because the constructors are methods/functions, you can create interesting generics that depend on constructors:

trait Vector2[T](x: T, y: T)
class Vector2Int(x: Int, y: Int) extends Vector2[Int](x, y)
def create[T](obj: { def apply(x: T, y: T): Vector2[T] }) = obj(2, 3)
val vec = create(Vector2Int) //companion object is being passed

You could probably even make constructor methods in the companion object implicit (introduce "implicit class X"?), so that this would be possible:

trait Stateful[S] {
def state: S
}
clone[S, T <: Stateful[S]](s: T)(implicit creator: S => T): T =
creator(s.state)

//This is a bad example; a better one would be related to serialization
class S(val state: Int) extends Stateful[Int]
//or: implicit class S ...

val x = new S(3)
val y = clone(x)

What is the problem with this system (because I know there has to be one, right)?

Disclaimer: I want to highlight the fact that this e-mail just is philosophical. I don't argue that the Scala language should switch construction/inheritance system, I'm just discussing alternatives because I think it's interesting to see how purely functional or object oriented a language could become, in theory.