�ݺ�ߣ

Function: def
def foo(x: Int)(y: Int): Int = x + y
foo(1)(2) //3
Если перед вызовом стоит ссылка на
функцию, произойдет ее вызов

Function: apply
object foo {
def apply(x: Int)(y: Int): Int = {
x + y
}
}
foo(1)(2) //3
На самом деле перед вызовом может быть
любое выражение.

Function: update
Еще синтаксический сахар:
class A {
def update(x: Int, y: String) = y.length - x
}
val foo: A = new A
foo(1) = "text"
foo.update(1, "text")

Collections: Arrays
Array.empty[Int]
Array.ofDim[Int](2)
new Array[Int](2)
Array(1, 2, 3)
val a = Array.fill(1, 2)(0)
a(1)(2)
a.apply(1)(2)
a(0).update(1, 2)
a(0)(1) = 2
for (arr <- a; elem <- arr) print(elem)

Collections: Lists
List.empty[Int]
List(1, 2, 3)
val a = 1 :: 2 :: 3 :: Nil
1 :: a
a.updated(1, 1)
a ::: a

Case classes
case class A(x: Int)
Автоматически добавляет property для
параметров, а также методы:
equals, hashCode, toString
Методы companion object:
apply, unapply

By name parameters
Еще один синтаксический сахар:
def foo(x: => Int) = {
print(x)
print(x)
}
foo(1)

By name parameters
На самом деле это:
def foo(x: () => Int) = {
print(x())
print(x())
}
foo(() => 1)
Можно ли объявлять у case class?

Default parameters
Для некоторых параметров можно
определить дефолтное значение:
def foo(x: Int = 1, y: Int = 2) = x + y
foo(1)

Default parameters
Что получится здесь?
class C {
def sum(x: Int = 1, y: Int = 2): Int = x + y
}
class D extends C {
override def sum(y: Int = 3, x: Int = 4): Int = super.sum(x, y)
}
val d: D = new D
val c: C = d
c.sum(x = 0)
d.sum(x = 0)

Repeated parameters
Последний параметр может быть
повторяющимся:
def foo(x: Int, y: String*) = {
x + y.length
}
foo(1, "a", "b")
foo(1, List("a", "b"): _*)

Repeated parameters
Для совместимости с Java:
import scala.annotation.varargs
def foo(x: Int, @varargs y: String*) = {
x + y.length
}

Named parameters
Можно вызывать в любом порядке:
def foo(x: Int, y: Int) = x + y
foo(y = 1, x = 2)
Или проаннотировать значение:
def foo(isImportant: Boolean, x: Int) {}
foo(isImportant = false, 2)

Local functions
Можно объявлять функции локально:
object Main {
def main(args: Array[String]) {
def calc() {}
calc()
}
}

Local functions
Служит это двум целям:
1. Список параметров будет короче, так как
локальная функция видит окружение.
2. Дополнительный уровень инкапсуляции.

FunctionN, apply
trait Function2[-T1, -T2, +R] extends AnyRef { self =>
def apply(v1: T1, v2: T2): R
def curried: T1 => T2 => R = {
(x1: T1) => (x2: T2) => apply(x1, x2)
}
def tupled: Tuple2[T1, T2] => R = {
case Tuple2(x1, x2) => apply(x1, x2)
}
override def toString() = "<function2>"
}

Functions shorthands
По умолчанию анонимная функция:
(x: Int) => x + 1
Но если есть ожидаемое значение:
val fun: Int => Int = x => x + 1
Можно записать даже короче:
val fun: Int => Int = _ + 1

Placeholder syntax
Можно использовать несколько переменных:
val sum: (Int, Int) => Int = _ + _
Например, как несколько из параметров:
def foo(x: Int, y: Int, z: Int) = x + y + z
val z: (Int, Int) => Int = foo(_, y = 2, _)
z(1, 2)
Или что-то совсем мудреное:
val x: (String, Int, Int) => String = _.substring(_, _)

Eta-expansion
Есть еще одна возможность написать
анонимную функцию:
def inc(x: Int): Int = x + 1
val l: List[Int] = List(1, 2, 3)
l.map(x => inc(x))
l.map(inc(_))
l.map(inc _)
l map inc

Partial functions
Специальный синтаксис:
val x: Int => Int = { case x => x + 1 }
val y: (Int, Int) => Int = {
case (x, y) => x + y
}
val f: PartialFunction[Any, String] = {
case i: Int => i.toString
}

Pattern matching
Простые случаи как расширенный switch:
val x: Any
x match {
case 1 =>
case '1' =>
case "1" =>
case _ =>
}

Variables patterns
Паттерны в виде идентификатора со
строчной буквы задают переменную:
"text" match {
case text =>
case text: String =>
case text@name =>
}

More...
Можно расширять как угодно:
"scala.course@gmail.com" match {
case Email(name, domain) => //code
case _ =>
}

Unapply
object Email {
def unapply(s: String): Option[(String, String)] = {
val parts = s split '@'
if (parts.length == 2) {
Some(parts(0), parts(1))
} else None
}
}

Unapply
def unapply(m: MatchedType): Boolean
def unapply(m: MatchedType): Option[A]
def unapply(m: MatchedType): Option[(A1, A2, …, An)]

�ݺ�ߣ

Scala #3

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Scala #3 (20)

Scala #3