Scala style opinions sought: Is this user or abuse?

Why not just

import KeyName._

def expect (controlSeq:KeyName*) (keySeq:String) = KeySeq (controlSeq, keySeq)

expect (control, alt, shift) (“xs”)

or other versions like:

“xs” with (control, alt, shift) // some RichString stuff

Lazy as I am, the point is that since the modifiers are many, just keep the respective class (KeyName) as is and mess with the syntax instead

From: scala-debate [at] googlegroups [dot] com [mailto:scala-debate [at] googlegroups [dot] com] On Behalf Of Kenneth McDonald
Sent: March-27-11 7:59 PM
To: scala-debate [at] googlegroups [dot] com
Subject: [scala-debate] Scala style opinions sought: Is this user or abuse?

I'm doing AWT event processing with Scala. One of the things I want to achieve is easy specifications of events (I'm very influenced by Tk in this regard), while at the same time maintaining some degree of compile-time checking. So in this vein, I've defined the following:

class Modifiers(val modifiers: HashSet[KeyName]) {

            def control = new Modifiers(modifiers + KeyName.control)

            def alt = new Modifiers(modifiers + KeyName.alt)

            def shift = new Modifiers(modifiers + KeyName.shift)

            def meta = new Modifiers(modifiers + KeyName.meta)

            def apply(keys: String) = KeySeq(modifiers, keys)

}

object control extends Modifiers(HashSet(KeyName.control))

object alt extends Modifiers(HashSet(KeyName.alt))

object shift extends Modifiers(HashSet(KeyName.shift))

object meta extends Modifiers(HashSet(KeyName.meta))

which allows users of the lib to write something like

control.alt("x")

to specify holding down control-alt and pressing x, or

control("xs")

to indicate holding down control while pressing x and then s. (Hey, I still remember a few Emacs commands, after all these years.)

I'm curious as to what people think of doing things like this in Scala, and if there are any recommendations for better ways to achieve the same effect. On one hand, this is easy and preserves some degree of compile-time checking. On the other hand, it does seem like I'm putting Scala through backflips a bit.

Thanks,

Ken

Ah, that should be "use" rather than "user" in the title. Sigh.

I'm doing AWT event processing with Scala. One of the things I want to achieve is easy specifications of events (I'm very influenced by Tk in this regard), while at the same time maintaining some degree of compile-time checking. So in this vein, I've defined the following:
class Modifiers(val modifiers: HashSet[KeyName]) { def control = new Modifiers(modifiers + KeyName.control) def alt = new Modifiers(modifiers + KeyName.alt) def shift = new Modifiers(modifiers + KeyName.shift) def meta = new Modifiers(modifiers + KeyName.meta) def apply(keys: String) = KeySeq(modifiers, keys) }
object control extends Modifiers(HashSet(KeyName.control)) object alt extends Modifiers(HashSet(KeyName.alt)) object shift extends Modifiers(HashSet(KeyName.shift)) object meta extends Modifiers(HashSet(KeyName.meta))
which allows users of the lib to write something like
control.alt("x")
to specify holding down control-alt and pressing x, or
control("xs")
to indicate holding down control while pressing x and then s. (Hey, I still remember a few Emacs commands, after all these years.)
I'm curious as to what people think of doing things like this in Scala, and if there are any recommendations for better ways to achieve the same effect. On one hand, this is easy and preserves some degree of compile-time checking. On the other hand, it does seem like I'm putting Scala through backflips a bit.
Thanks, Ken

-- 
Tony Morris
http://tmorris.net/