This lesson covers:
The first few weeks will cover basic syntax and concepts, then we'll start to open it up with more exercises.
Scala is not just a nicer Java. You should learn it with a fresh mind; you will get more out of these classes.
1 + 1
_1 is an automatically created value name given by the interpreter to the result of your expression. It has the type Int and contains the integer 2.
(Almost) everything in Scala is an expression.
You can give the result of an expression a name.
val two = 1 + 1
You cannot change the binding to a val.
If you need to change the binding, you can use a var instead.
var name = "steve"
name = "marius"
You can create functions with def.
def addOne(m: Int): Int = m + 1
In Scala, you need to specify the type signature for function parameters. The interpreter happily repeats the type signature back to you.
val three = addOne(2)
You can leave off parens on functions with no arguments.
def three() = 1 + 2
three()
three
You can create anonymous functions.
val f = (x: Int) => x + 1
This function adds 1 to an Int named x.
f(1)
You can pass anonymous functions around or save them into vals.
val addOne = (x: Int) => x + 1
addOne(1)
If your function is made up of many expressions, you can use {} to give yourself some breathing room.
def timesTwo(i: Int): Int = {
println("hello world")
i * 2
}
This is also true of an anonymous function.
(i: Int) => {
println("hello world")
i * 2
}
You will see this syntax often used when passing an anonymous function as an argument.
You can partially apply a function with an underscore, which gives you another function. Scala uses the underscore to mean different things in different contexts, but you can usually think of it as an unnamed magical wildcard. In the context of { _ + 2 } it means an unnamed parameter. You can use it like so:
def adder(m: Int, n: Int) = m + n
val add2 = adder(2, _:Int)
add2(3)
You can partially apply any argument in the argument list, not just the last one.
Sometimes it makes sense to let people apply some arguments to your function now and others later.
Here's an example of a function that lets you build multipliers of two numbers together. At one call site, you'll decide which is the multiplier and at a later call site, you'll choose a multiplicand.
def multiply(m: Int)(n: Int): Int = m * n
You can call it directly with both arguments.
multiply(2)(3)
You can fill in the first parameter and partially apply the second.
val timesTwo = multiply(2) _
timesTwo(3)
You can take any function of multiple arguments and curry it. Let's try with our earlier adder
(adder _).curried
There is a special syntax for methods that can take parameters of a repeated type. To apply String's capitalize function to several strings, you might write:
def capitalizeAll(args: String*) = {
args.map { arg =>
arg.capitalize
}
}
capitalizeAll("rarity", "applejack")
class Calculator {
val brand: String = "HP"
def add(m: Int, n: Int): Int = m + n
}
val calc = new Calculator
calc.add(1, 2)
calc.brand
Contained are examples are defining methods with def and fields with val. Methods are just functions that can access the state of the class.
Constructors aren't special methods, they are the code outside of method definitions in your class. Let's extend our Calculator example to take a constructor argument and use it to initialize internal state.
class Calculator(brand: String) {
/**
* A constructor.
*/
val color: String = if (brand == "TI") {
"blue"
} else if (brand == "HP") {
"black"
} else {
"white"
}
// An instance method.
def add(m: Int, n: Int): Int = m + n
}
Note the two different styles of comments.
You can use the constructor to construct an instance:
val calc = new Calculator("HP")
calc.color
Our BasicCalculator example gave an example of how Scala is expression-oriented. The value color was bound based on an if/else expression. Scala is highly expression-oriented: most things are expressions rather than statements.
Functions and methods are largely interchangeable. Because functions and methods are so similar, you might not remember whether that thing you call is a function or a method. When you bump into a difference between methods and functions, it might confuse you.
class C {
var acc = 0
def minc = { acc += 1 }
val finc = { () => acc += 1 }
}
val c = new C
c.minc // calls c.minc()
c.finc // returns the function as a value:
When you can call one "function" without parentheses but not another, you might think Whoops, I thought I knew how Scala functions worked, but I guess not. Maybe they sometimes need parentheses? You might understand functions, but be using a method.
In practice, you can do great things in Scala while remaining hazy on the difference between methods and functions. If you're new to Scala and read [explanations of the differences](https://www.google.com/search?q=difference+scala+function+method"), you might have trouble following them. That doesn't mean you're going to have trouble using Scala. It just means that the difference between functions and methods is subtle enough such that explanations tend to dig into deep parts of the language.
class ScientificCalculator(brand: String) extends Calculator(brand) {
def log(m: Double, base: Double) = math.log(m) / math.log(base)
}
See Also Effective Scala points out that a Type alias is better than extends if the subclass isn't actually different from the superclass. A Tour of Scala describes Subclassing.
class EvenMoreScientificCalculator(brand: String) extends ScientificCalculator(brand) {
def log(m: Int): Double = log(m, math.exp(1))
}
You can define an abstract class, a class that defines some methods but does not implement them. Instead, subclasses that extend the abstract class define these methods. You can't create an instance of an abstract class.
abstract class Shape {
def getArea():Int // subclass should define this
}
class Circle(r: Int) extends Shape {
def getArea():Int = { r * r * 3 }
}
val s = new Shape
val c = new Circle(2)
traits are collections of fields and behaviors that you can extend or mixin to your classes.
trait Car {
val brand: String
}
trait Shiny {
val shineRefraction: Int
}
class BMW extends Car {
val brand = "BMW"
}
One class can extend several traits using the with keyword:
class BMW extends Car with Shiny {
val brand = "BMW"
val shineRefraction = 12
}
See Also Effective Scala has opinions about trait.
When do you want a Trait instead of an Abstract Class? If you want to define an interface-like type, you might find it difficult to choose between a trait or an abstract class. Either one lets you define a type with some behavior, asking extenders to define some other behavior. Some rules of thumb:
trait t(i: Int) {}; the i parameter is illegal.You are not the first person to ask this question. See fuller answers at stackoverflow:Scala traits vs abstract classes, Difference between Abstract Class and Trait, and Programming in Scala: To trait, or not to trait?.
Earlier, you saw that we defined a function that took an Int which is a type of Number. Functions can also be generic and work on any type. When that occurs, you'll see a type parameter introduced with the square bracket syntax. Here's an example of a Cache of generic Keys and Values.
trait Cache[K, V] {
def get(key: K): V
def put(key: K, value: V)
def delete(key: K)
}
Methods can also have type parameters introduced.
def remove[K](key: K)