"self =>" <- What's that for?

A self type annotation can provide an alias for 'this', a self type, or both.

Just using the alias is roughly the same as:

trait T {
private[this] val self = this
}

-jason

http://stackoverflow.com/questions/4017357/difference-between-this-and-s...

On Sat, Nov 20, 2010 at 3:45 PM, Philipp Dörfler
wrote:
> Greetings,
>
> When looking for that weird += method, I came across this strange line in
> scala.collection.generic.Addable:
>
> trait Addable[A, +Repr <: Addable[A, Repr]] { self =>
>
> What does the "self =>" stand for? After that a normal trait declaration
> follows as if nothing happened. It looks to me a bit like a self type, but
> where did the type part go?
>
> Kind regards
> --
> ~ Philipp
>

self in this case is just an arbitrary symbol that acts as placeholder for Addable.this (you could name it "me" or "addable" etc.). this is often useful when code is nested and the meaning of 'this' becomes ambivalent, e.g.

class MyFrame extends JFrame {
frame =>

getContentPane().add( new JButton( "Hide" ) {
addActionListener( new ActionListener {
def actionPerformed( e: ActionEvent ) {
// this.setVisible( false ) --> shadowed by JButton!
frame.setVisible( false )
}
})
})
}

another use case is with a specific type annotation when using mix-ins:

trait FrameCanCenter {
me: JFrame =>

def center {
me.setLocationRelativeTo( null )
}
}

this means you can only use FrameCanCenter as a mix-in for an object that is a JFrame, hence it is guaranteed that we can call setVisible on the compound object.

scala> new FrameCanCenter {}
:10: error: illegal inheritance;
self-type java.lang.Object with FrameCanCenter does not conform to FrameCanCenter's selftype FrameCanCenter with javax.swing.JFrame
new FrameCanCenter {}
^

whereas this is allowed:

scala> val f = new JFrame( "Hallo" ) with FrameCanCenter; f.setSize( 200, 200 ); f.setVisible( true )
scala> f.center // ok

best, -sciss-

Am 20.11.2010 um 14:45 schrieb Philipp Dörfler:

> Greetings,
>
> When looking for that weird += method, I came across this strange line in scala.collection.generic.Addable:
>
> trait Addable[A, +Repr <: Addable[A, Repr]] { self =>
>
> What does the "self =>" stand for? After that a normal trait declaration follows as if nothing happened. It looks to me a bit like a self type, but where did the type part go?
>
> Kind regards

On Saturday November 20 2010, Philipp Dörfler wrote:
> Greetings,
>
> When looking for that weird += method, I came across this strange
> line in scala.collection.generic.Addable:
>
> trait Addable[A, +Repr <: Addable[A, Repr]] { self =>
>
>
> What does the "self =>" stand for? After that a normal trait
> declaration follows as if nothing happened. It looks to me a bit like
> a self type, but where did the type part go?

In that simple form, "self" becomes an alias for "this."

The construct, called a "self type" (the word "self" is not special or
reserved, any name may be used) admits a type constraint. E.g.

trait Picky { self: Tasty => ... }

In this formulation, trait Picky may only be mixed in to a type that
includes Tasty.

> Kind regards

Randall Schulz

(correction)
hence it is guaranteed that we can call _setLocationRelativeTo_ on the compound object.

Am 20.11.2010 um 14:59 schrieb Sciss:

> this means you can only use FrameCanCenter as a mix-in for an object that is a JFrame, hence it is guaranteed that we can call setVisible on the compound object.