Re: Private names

I've found a solution using one factory object per Message subtype.

abstract class MessageFactory[M] {
        def make(): M
}

class Message{
        var name:String=""
        def setName(newname:String) {name=newname}
        def send()=println(name)
}
implicit object MessageMessageFactory extends MessageFactory[Message] {
        def make()=new Message()
}

class SubMessage extends Message {
        var t:String=""
        def setType(newtype:String) {t=newtype}
        override def send()=println(name+" ("+t+")")
}
implicit object SubMessageMessageFactory extends
MessageFactory[SubMessage] {
        def make()=new SubMessage()
}

def sendMessage[T <: Message](setter:T=>unit)(implicit factory:
MessageFactory[T]) {
        var msg:T=factory.make()
        setter(msg)
        msg.send()
}

sendMessage[Message] { m =>
        m.setName("foo")
        m.setName("bar")
}
sendMessage[SubMessage] { m =>
        m.setType("count")
        m.setName("Update")
}

I'd say you couldn't do it with less syntax, it's safe and it's very
readable. However, each message needs a factory method attaching to it
which is a little annoying, but very workable.

What do you think?

Also, a note to Scala writers - would it be possible to compile "new
T()", where T is a type variable, into a factory method like I've done
here?

One other thing: The technique you described below is not very safe,
since if you mistype the name of one of the parameters, the compiler
will give no error, but your code will not work (suppose you wrote "val
displaYYYName = somename", displayName will still equal null)

Robin