scala quick introduction
TRANSCRIPT
AGENDAA little bit about ScalaBasic syntaxObject-oriented ScalaFunctional Scala
Live code
SCALAGeneral purpose programming languageMultiparadigm: object-oriented & functionalStatically typedRuns on the JVMCreated by Martin OderskyFirst release in 2004
GET STARTED WITH SCALABinaries
scala-lang.org/download
SBT scala-sbt.org/download
IDE Scala IDE (Eclipse), IntelliJ, NetBeans
SBTA build tool for Scala, Java and more
scala-sbt.org
FIRST APPobject HelloWorld {
def main(args: Array[String]): Unit = { println("Hello, World!") } }
BASIC SYNTAXval name: String = "John"
var age: Int = 30 i = 31
def add(x: Int, y: Int): Int = { x + y }
STRING INTERPOLATIONval name: String = "John"
println(s"Hello $name")
MULTILINE STRINGSval text: String = """ |This text spans |multiple lines. """.stripMargin
STATICALLY TYPED LANGUAGEvar name: String = "John" name = "Mark"
name = 2 // compilation error !!!
def add(x: Int, y: Int): Int = x + y
add(1, "two") // compilation error !!!
TYPE INFERENCEval name = "John"
val age = 30
def add(x: Int, y: Int): Int = x + y
val sum = add(1, 2)
OBJECT-ORIENTED SCALAEverything is an object
val x = 10
x.toString
CLASSESabstract class Vehicle { def move(): Unit }
class Car extends Vehicle { override def move(): Unit = { println("driving") } }
TRAITStrait Diving { val deep = 100
def dive(): String = s"diving $deep meters" }
class Car extends Vehicle with Diving { override val deep = 200
override def move(): Unit = { println(dive()) } }
OBJECTSobject SeeDiving { val MaxDepth = 500
def pressure(depth: Int): Double = depth / 10 * 0.99 }
class Car extends Vehicle with Diving { override val deep: Int = SeeDiving.MaxDepth
override def move(): Unit = { println(dive() + s" with ${SeeDiving.pressure(deep)} atm") } }
CASE CLASSES// declare case class User(email: String, password: String)
// create val admin = User("[email protected]", "buddy")
// access fields val adminEmail = admin.email
// create copy val otherAdmin = admin.copy(email = "[email protected]")
// compare assert(admin != otherAdmin)
PATTERN MATCHINGval result = something match { case "value" => "it's String equal to 'value'"
case 10 => "it's Int equal to 10"
case s: String => "it's String with value: " + s
case _ => "it's something else" }
PATTERN MATCHING AND CASE CLASSESval result = user match { case User("[email protected]", "buddy") => "it's administrator"
case User(email, password) => "it's " + email + ", his password is: " + password }
FUNCTIONAL SCALA
FUNCTIONAL PROGRAMMINGPure functionsNo side effects
FIRST-CLASS FUNCTIONSFunction is a first-class citizen
Can be assigned to a variableCan be passed as an argument of a functionCan be returned from a function
HIGH-ORDER FUNCTIONSTake other functions as an argumentReturn functions as a result
SCALA FUNCTIONS// function type (Int, Int) => Int
// anonymous function (x: Int, y: Int) => x + y
ASSIGNING FUNCTION TO A VARIABLEcase class Student(name: String, grade: Int)
val goodStudent: Student => Boolean = student => student.grade > 3
assert(goodStudent(Student("John", 4)) == true)
assert(goodStudent(Student("Adam", 3)) == false)
PASSING FUNCTION TO A HIGH-ORDERFUNCTION
// List high-order function def count(predicate: Student => Boolean): Int
val students = List(Student("John", 4), Student("Adam", 3))
val counter = students.count(goodStudent)
assert(counter == 1)
RETURNING FUNCTION FROM A HIGH-ORDERFUNCTION
// high-order function def gradeHigherThen(threshold: Int): Student => Boolean = student => student.grade > threshold
val above3 = gradeHigherThen(3)
val above4 = gradeHigherThen(4)
val counter = students.count(above3)
PARTIAL FUNCTIONStrait PartialFunction[-A, +B] extends (A => B) { def isDefinedAt(x: A): Boolean }
val improveGrade: PartialFunction[Student, Student] = { case student if student.name == "John" => student.copy(grade = 5) }
SCALA COLLECTIONSImmutable/mutableOperated by pure functions
LISTSval numbers = List(2, 3)
val moreNumbers = 1 :: numbers // List(1, 2, 3)
moreNumbers.count(n => n > 2) // 1
val oddNumbers = moreNumbers.filter(n => n % 2 != 0) // List(1, 3)
val squares = moreNumbers.map(n => n * n) // List(1, 4, 9)
SETSval letters = Set("a", "b", "a", "c") // Set(a, b, c)
val moreLetters = letters + "d" // Set(a, b, c, d)
val upperLetters = moreLetters.map(l => l.toUpperCase) // Set(A, B, C, D)
MAPSval students = Map("John" -> 4, "Adam" -> 3)
val moreStudents = students + ("Robert" -> 5)
moreStudents.map { case (name, grade) => name -> (grade + 1) }
AND THERE IS MOREFuturesImplicitsType ClassesGeneric Classes...
LEARN MOREscala-lang.orgProgramming in Scala, First Edition - artima.com/pins1edThe Neophyte's Guide to Scala -danielwestheide.com/scala/neophytes.htmlTwitter's Scala School - twitter.github.io/scala_schoolscala-exercises.org
COURSERAFunctional Programming Principles in ScalaFunctional Program Design in Scala
THANK YOUQUESTIONS ???