Scala - brief intro

Strengths of Scala Java replacement? The answer doesn’t matter! Brief intro to Scala - Razvan Cojocaru – Nov’08 & Mar’09

Overview
Brief syntax – at least 30% off Java
Smart compiler != dumb programmer
Compiles into bytecode, runs on JVM  access to all Java libraries and, more importantly, APIs
C++ is back! …mean as ever!
Multiple inheritance, operator overloading, true generics, pass functions around, simple syntax
Scala is better: true multi-paradigm
Functional programming
Scalable language
Not for the faint of heart!

Smart Compiler
Makes up constructors, getX/setX stuff
class Point (x:Int,y:Int)
Figures out types for values/variables and functions etc
def getX = x
Lots of shortcuts in the syntax, i.e no {} for method bodies

Smart compiler != dumb programmer
Class Point {
int x;
int y;
public Point (int ax, int ay) {
this.x = ax;
this.y = ay;
}
public int getX () { return x; }
public int getY () { return y; }
public int setX (int x) {
if (x <= 0)
throw new IllegalArgumentException(“blah”);
else
this.x=x }
public int setY (int y) { this.y=y }
}
Class Point ( var x:int, var y:int)
def x_= (ax:Int) =
require (ax > 0); x=ax
To overwrite the assign, is actually a little more complicated:
def + (p:Point) =
new Point (x+p.x, y+p.y)
Guess who ^^^ Guess who ^^^

Constructor/field generation
class SimplerPoint (
private var ix : Int,
private var iy :Int)
{
def x = ix
def y = iy
def x_= ( ax :Int) { require( ax >0); ix = ax }
def y_= ( ay :Int) { require( ay >0); iy = ay }
}
class Point (ax:Int, ay:Int)
{
private[this] var ix :Int = ax
private[this] var iy :Int = ay
def x = ix
def y = iy
def x_= (ax:Int) { require(ax>0); ix =ax }
def y_= (ay:Int) { require(ay>0); iy =ay }
}
// check this out !!!
class Point (ax:Int, ay:Int)
{
require(ax>0); // class body is in fact c-tor
private[this] var ix :Int = ax
def x_= (ax:Int) { require(ax>0); ix =ax }
}
Ix/iy are both constructor and fields Classic: ax/ay are just args for constructor

Traits
Like multiple inheritance
More like “polymorphic composition”…if that pairing makes sense 
Simplify coding a lot, for classes with multiple “traits”.
No interfaces
There are abstract classes, though
An abstract trait (all methods abstract) is equivalent to a Java interface

Traits - features
As opposed to interfaces, traits can implement methods
No “controllers” etc
No replication of code.
With single inheritance, you decide on a base class and then REWRITE every time the methods of other implemented interfaces
“ idiot controller” syndrome: keep algorthms in different classes, to avoid rewriting them, see next slide
TODO: read about the “linearization” to avoid diamond inheritance
Same as “mixin” in Ruby
Trait vs. Class ? Semantics …

Traits vs interfaces
interface Centered {
public Point getCenter () { return x; }
}
class IdiotController {
public void offset (Centered s, Point offsetBy) {…}
}
class MyShape extends Drawable implements Centered {
//…
public Point getCenter () { return c; }
}
//…in a java file far far away:
New IdiotController().offset (myShape, new Point (3,4))
trait Centered () {
var center:Point
def offset (offsetBy:Point) = center += offsetBy
}
Class MyShape extends Drawable with Centered {
}
//…in a scala file anywereh in the galaxy
myShape.offset ((3,4))

The screwyness of it
trait AnotherCentered {
def center:Point
def offset (offsetBy:Point) = center += offsetBy
}
class AnotherShape extends AnotherCentered {
override val center:Point = new Point(0,0)
}
// type parameters
Class MyContainer [T :> SomeBaseClass] {
var internal = new List[T]
def += (t:T) = internal += t
}
Values/variables and functions share the same namespace
Generics
Uses [] instead of ()
(use () instead of [] as well)
Operator overloading

The screwyness of it (2)
var greeting = "“
for (i <- 0 until args.length)
greeting += (args(i) + " ")
// It’s the same as:
val range = 0.until(args.length)
for (i <- range)
greeting += (args(i) + " ")
// should use this instead…remember Java
// Callback<T>? … ok…now forget it!
args.foreach (x => greetings += x)
expect (true) {
“ Samba pa ti” == new String (“Samba pa ti”)
}
.
For “for” is not “for”
But, “equals” is actually “equals”

Functional…ity
Functional language – Lisp family
Function literals
Lambda stuff and currying
It’s fashionable, sounds cool and it’s even useful sometimes…
Syntactic sweetness

Functional…ity
// a function typedef
type Fun = (String,String) => String
// a function literal assigned to a value/variable
val aFun = (x,y) => x+y
aFun ( aFun (“this”, “is”), “cool”)
// function literal passed to a function:
myArray.foreach ( x => println x )
myArray.sort (<)
myArray.sort ( (x,y) => x < y )
Functions themselves are objects!
You can pass them to other functions,
Assign to variables etc
… remember C++ pointers to functions)

The Cool and the Screwy
Abstract VAL implements a DEF
… or vice-versa
Partially applied functions
Extend the language syntax
Interpreted AND/OR compiled
Can setup SCALA-only desktop environment with scripted etc…

Quirks
No statics
funny implementation of singletons instead
… as “companion objects”
Can’t define as many constructors as you want…use factories instead, which is also perfect usage of the singletons above…

Quirks
// as a value
val abs = if (x < 0) 0–x else x
// or as a function – remember?
val absfun = (x:int) => if (x < 0) 0–x else x
myValue.asInstanceOf [OtherClass]
implicit def itos (x:Int) : String = String.valueOf(x)
// check this out:
def repeat[T] (n: Int) ( what: => T ): List[T] = ...
repeat(5) { println(“I will be quiet in class."))) }
Every statement block returns a value
Typecasts :
Implicit type conversions
Special syntax:

Apply() and bound functions
//simple OBJECT to time a statement… note this is not a class !!! apply() behaves differently
object Time { def apply[T] ( action: => T ): (T, Long) = {
startTimer()
val resp = action()
val time = stopTimer()
(resp, time)
}
// using it:
val (response, ms) = Time(Http.get("http://scala-blogs.org/"))
// it works because the http.get(xxx) above is a bound function not an actual call
Time(x) is defined via the apply() method
Special syntax to bind tuples
The Http.get() is NOT a call but a bound function

UnitTests
class TestRazElement extends JUnit3Suite {
def testA =
expect ("roota") { doc a "name" }
def testXpe =
expect ("11") { doc xpe "/root/parent[@name='1']/child[@name='11']" a "name" }
}
Several ways to write tests. Compatible with JUnit, NGUnit etc

Apply() and bound functions
//simple OBJECT to time a statement… note this is not a class !!! apply() behaves differently
object Time { def apply[T] ( action: => T ): (T, Long) = {
startTimer()
val resp = action()
val time = stopTimer()
(resp, time)
}
// using it:
val (response, ms) = Time(Http.get("http://scala-blogs.org/"))
// it works because the http.get(xxx) above is a bound function not an actual call
Time(x) is defined via the apply() method
Special syntax to bind tuples
The Http.get() is NOT a call but a bound function

String pattern matching
// note the triple double quotes “ “ “
val pat = """(w+):(w+) (.*)""".r
// bind 3 vals at once
val pat(who, cmd, args) = “john:go someplace”
// or just iterate
for (s <- pat findAllIn input)
println(s)
Same patterns as java
Special syntax to bind multiple variables at once

What Next?
Read more (I like what the stuff the links on the next page point to). There’s a lot more to Scala than what I had the time and interest to show here!
Start playing with Scala in Eclipse (plugin kinda sucks) or NetBeans (great plugin, especially on a dark background) or vi(m).
Have Fun!

Links
Good brief Scala intro:
http://www.codecommit.com/blog/scala/roundup-scala-for-java-refugees
The scala wiki:
http:// scala.sygneca.com /
Download new verions:
http://www.scala-lang.org /
More goodies:
http://www.devoxx.com/download/attachments/1705916/D8_U_08_06_01.pdf
http://www.slideshare.net/michael.galpin/introduction-to-scala-for-java-developers-presentation
http://www.slideshare.net/jboner/pragmatic-real-world-scala-45-min-presentation

Scala - brief intro

by Razvan Cojocaru on Feb 13, 2009

Accessibility

Categories

Tags

Upload Details

Usage Rights

1 Embed 1

Statistics

Scala - brief intro — Presentation Transcript