Monkey(patch)ing around

On Thu, Jan 22, 2009 at 1:38 PM, Jorge Ortiz wrote:
> Currently, the following code:
>
> case class Foo(bar: String)
>
> translates to something like:
>
> class Foo(bar: String) { /* hashCode, toString, equals, Product stuff,
> accessors, etc */ }
> object Foo extends (String => Foo) {
> def apply(bar: String): Foo = new Foo(bar)
> /* unapply */
> }
>
> Would it be possible to make the following code:
>
> implicit case class PimpedString(private val s: String) {
> def allcaps = s.map(_.toUpperCase).mkString
> }
>
> translate to something like:
>
> class PimpedString(private val s: String) {
> def allcaps = s.map(_.toUpperCase).mkString
> /* ... */
> }
> implicit object PimpedString extends (String => PimpedString) {
> def apply(s: String): PimpedString = new PimpedString(s)
> /* unapply */
> }

It would be possible, and it would easy monkeypatching.
I am just not 100% sure yet that's a good thing...

Cheers

Hi Jorge,

Jorge Ortiz wrote:
> What does everyone think?

I kind of agree, and I actually proposed much the same thing a while
back, but I'm happy living without it.

Given,

implicit case class Foo(x : Int) { ... }

I think there's a case for this translating to either:

implicit def intToFoo(x : Int) : Foo = Foo(x)
case class Foo(x : Int) { ... }

or, as you suggested,

implicit object Foo { ... }
case class Foo(x : Int) { ... }

Unfortunately, I think people might use such syntax for the purposes of
the former, when they don't actually want (or expect) the more
Pandora's-box-esque effects of the latter...

Nevertheless, I don't want to kill off the discussion early, if anyone
else has any thoughts on it.

Cheers,
Jon