Introductiontoprogramminginscala

IntroductiontoProgrammingin Scala

Hungai Amuhinda @hungai hungaikev hungaikev.in hungaikevin@gmail.com

❖ Introduction ❖ Scala OOP FP Concepts ❖ ❖ ❖ Collections Agenda

What is Scala: Scalaisthebestwaytowritescalable,resilientandmaintainable softwareontheJVM(primarily).Itstypesystemhelpsavoidbugs withoutgettinginyourway.It'sOOformodularity&extensibility;FPfor compositionthatyoucanreasonabout.

Scala Concepts • Scala is an object oriented language in pure form: every value is an object and every operator is a method. • “ + ”, “ - ”, “ * ”, “ / ” are all methods

Scala Concepts • Everythingisanexpression • Expressionisaninstructiontoexecutesomethingthatwillreturna value. • Anexpressionevaluatestoaresultorresultsinavalue • Expressions, Types and Values are the fundamental building blocks for Scala Programs. Understanding these concepts is necessary to build a mental model of how Scala programs work.

Scala Concepts In the Scala console or worksheet enter "Hello world!" and press return (in the console) or save the worksheet. You should see an interaction similar to this:

In your console type “Hello world!”.toUpperCase Scala Concepts

Compile time and Runtime • Two distinct stages that a Scala program goes through: first it is compiled, and if it compiles successfully it can then be run or evaluated. • It is important to understand that compile time and runtime really are distinct, as it is this distinction that allows us to properly understand the difference between types and values. • Compilation is a process of checking that a program makes sense.

WhatareTypes • Types are restrictions on our programs that limit how we can manipulate objects. • We have already seen two types, String and Int, and seen that we can perform different operations depending on the type. • The most important point about types is that expressions have types but values do not.

Scala’sBasicDataTypes ● Double ● String ● Float ● Char ● Boolean ● Byte ● Short ● Int ● Long

Scala Class Hierarchy scala.Any scala.AnyVal scala.AnyRef scala.Int scala.List scala.String scala.Byte scala.Seq scala.Boolean scala.Map scala.Char

Take Home Points. • WemustbuildamentalmodelofScalaprogramsifwearetouseScala. Threefundamentalcomponentsofthismodelare expressions,types,and values. • Expressionsarethepartsofaprogramthatevaluatetoavalue.Theyare themajorpartofaScalaprogram. • Expressionshavetypes,whichexpresssomerestrictionsonprograms. Duringcompiletimethetypesofourprogramsarechecked.Iftheyare inconsistentthencompilationfailsandwecannotevaluate,orrun,our program.

● Static ● Inferred(TypeInference) ● Structural ● Strong Scala Concepts(Advanced TypeSystem)

(Worksheet) Demo04 Program with Scala Work with worksheets ● IntelliJ ● Scala IDE or Eclipse with Scala Plugin ● Ensime

Program with Scala (Main) Demo01 object Demo1 { def main (args: Array[String]): Unit = { println(“Hello Everyone”) println(“Welcome to today’s workshop”) } }

Program with Scala (App) Demo02 object Demo2 extends App { val todaysEvent = “Nairobi JVM” lazy val fun = (0 to 4).map(x => “fun”).mkString(“ ”) println(“Hello world”) println(“Welcome to ” + todaysEvent + “! n”) }

Scala Concepts ❖ var, val ❖ If expressions ❖ def ❖ Block expressions ❖ While - Loops ❖ For - Loops ❖ Nested Function ❖ Recursion vs Tail recursion ❖ Pattern Matching

Scala Concepts Demo05 ❖ val - value A value is an expression that cannot be changed any further (Immutable) It's similar to final in Java ❖ var - variable Something that is able or likely to change or be changed (Mutable)

Expression with Semicolon? = “scala” one Demo06 val x = 5566 val y = 87 val java = “Java” ; val scala If you have multiple expressions in line, you will need semicolons(;). Otherwise you don't need it.

The syntax for a conditional expression is: If(condition) trueExpression else falseExpression Where: 1. condition is an expression with Boolean type 2. trueExpression is the expression evaluated if condition evaluates to true 3. falseExpression is the expression evaluated if condition evaluates to false If Expressions Demo02

If Expressions Demo07 ❖ If has return value (expression) ❖ Scala has no ternary operator (? : ) val value = 0 val negative = If (value < 0 ) true else false Everything is an expression

“def” starts a function definition Result type of function Function name braces Demo08 Parameters Equals sign def max (x: Int, y: Int): Int = { If (x > y) x else y } Function body in Curly def

def Demo09 def max (x: Int, y: Int): Int = { If (x > y) return x else return y }

def y Demo010 def max (x: Int, y: Int) = { If (x > y) x else } No Result type

def Demo011 def max (x: Int, y: Int) = If (x > y) x else No Curly brackets y

Summary of def ❖ You don't need a return statement - Last expression of a block will be the return value ❖ You don't need return type in method or function definition. - Scalac will infer your return type in most cases. Its a good habit to have a return type, especially if your API has a public interface ❖ You don't need curly brackets - If you have multiple lines of code, using curly brackets ({ }) is a good habit

Block expressions (Curly brackets) return value, then it will be assign result to Demo012 val n = 5 val factorial = { var result = 1 for (i <- 1 to n ) result = result * i result } Last expression (result) in block will be the “factorial”

Demo013 WhileLoop var n = 10 var sum = 0 while (n > 0) { sum = sum + 1 n = n - 1 }

Demo014 For-Loop var sum = 0 for (i <- 1 to 10) { sum += 1 } println(sum)

Nested Function Demo015 def min (x: Int, y: Int): Int = { def max (x: Int, y: Int) = { if (x > y) x else y } if (x >= max(x,y)) y else x }

Recursion vs Tail - recursion Demo016 def factorial(n : Int): BigInt = { If (n == 0) 1 else n * factorial(n - 1) } factorial (15) factorial (150) factorial(15000) // java.lang.StackOverflowError

Recursion vs Tail - recursion factorial(15000) Demo017 def factorial(n : Int): BigInt = { def helpFunction(acc : BigInt, n: Int) : BigInt = { If (n == 0) acc else helpFunction(acc * n , n -1 ) } helpFunction(1,n) “Tail - Recursion” }

Recursion vs Tail - recursion import scala.annotation.tailrec “Add annotation is a good habit. Compiler can check whether or not it can bedef factorial(n : Int): BigInt = { @tailrec optimised. ” def helpFunction(acc : Int, n: Int) : BigInt = { If (n == 0) acc else helpFunction(acc * n , n -1 ) } helpFunction(1,n) “You have to add a return type, when the function is recursive” } factorial(15000) Demo018

Pattern Matching - It can match anything Pattern matching is a feature that is very common in functional languages ❖ It matches a value against an expression ❖ Each pattern points to an expression It's similar to “switch case” but its more general. There are some differences: - No fall through - Each condition needs to return a value(Everything in scala is an expression)

Pattern Matching Demo019 def matchString(x : String): String = { x match { case “Dog” => x case “Cat” => “Not a cat person” case _ => “Neither Dog or Cat” } matchString(“Dog”) matchString(“Human”)

Scala (Object Oriented) v Classes v Extends , with, override v Abstract classes v Objects, v Companion objects v Traits v Case classes

Classes Demo020 Primary Constructor valin constructor willgiveyoua getter class Employee(id : Int, val name: String, address: String, var salary: Long ) var in constructor will give you a getter and setter val employee = new Employee(1,”Hungai”,”Kakamega”,40L)

Extends, with, override. Single inheritance enables a derived class to inherit properties and behaviour from a single parent class ❖ Scala is single inheritance like Java. ❖ Scala - extends = Java - extends ❖ Scala - with = Java - implements ❖ Scala - override = Java - @Override

Abstract classes. Abstract classes are just like normal classes but can have abstract methods and abstract fields In scala, you don't need the keyword abstract for methods and fields in an abstract class

Abstract classes. def speaks : Unit Demo021 abstract class Animal (val name: String) { val footNumber: Int val fly : Boolean Subclasses should be in the same file. } class Dog(name: String) extends Animal (name) { override val footNumber : Int = 4 override val fly = false override def speak : Unit = println(“Spark”) } class Bird(name : String) extends Animal(name) { override val footNumber : Int = 2 override val fly = true override def speaks: Unit = println(“chatter”) }

Objects. • A singleton object is declared using the object keyword. • When a singleton object shares the same name with a class it's referred to as a Companion object. • A companion object and its classes can access each others private methods or fields

Singleton Object. Demo022 object MathUtil { def doubleHalfUp(precision: Int, origin: Double): Double { val tmp = Math.pow(10,precision) Math.round(origin * tmp)/ tmp } }

Case Classes. Case classes are just regular classes that are : ➔ Immutable by default ➔ Decomposable through pattern matching ➔ Compared by structural equality instead of by reference. When you declare a case class the scala compiler does the following for you: ➔ Creates a class and its companion object Implements the ‘apply’ method that you can use a factory. This lets you create instances of the class without the ‘new’ keyword

Case classes. Demo023 abstract class Notification case class Email(sourceEmail: String, title: String, body: String) extends Notification. case class SMS (sourceNumber: String, message: String) extends Notification. case class VoiceRecording(contactName: String, link: String) extends Notification. val emailNotification = Email(“h@hungaikev.in”,”Scavannah”,”Todays lesson”) println(emailNotification)

Demo012 Alonzo Church 1930 TheLambdaCalculus. ❖ Theoretical foundation ❖ Pure functions - no state ❖ Not a programming language

Lambda Ca lculus. Variable Expressions ƛx . x + 1 Function Application

Lambda Ca lculus. Demo024 ƛx . x + 1 // Scala Translation { x : Int => x + 1 }

Scala (Functional) ❖ Functional Concepts ❖ First class functions ❖ Anonymous functions ❖ Higher order functions

Functional Concepts. Demo012 Immutability (Referential Transparency - Expressions always evaluates to the same result in any context) - No side effects (Modifies state, Not predictable) ❖ Functions as values - Functions as objects Higher order functions - Input: Takes one or more functions as parameters, Output: Returns a function as result

Demo012 Anonymous functions (Lambdas).

Anonymous functions. Demo025 ((x : Int ) => x * x) (0 until 10).map ((value: Int) => value * value) (0 until 10).map (value => value * value ) (0 until 10).map (value => value + 1) (0 until 10).map (_ + 1)

High-order Functions. Demo026 def calculateTax(rate: BigDecimal => BigDecimal, salary: BigDecimal) : BigDecimal = { rate(salary) } val kenyaTax = (salary: BigDecimal) => { if (salary > 413201) salary * 0.396 else salary * 0.3 } val tzTax: BigDecimal => BigDecimal = _ * 0.25 calculateTax(kenyaTax,413201) calculateTax(tzTax,100)

High-order Functions. Demo027 def calculateTax(rate: BigDecimal => BigDecimal, salary: BigDecimal) : BigDecimal = { rate(salary) } def kenyaTax (salary: BigDecimal) = { calculateTax(x => if (salary > 413201) salary * 0.396 else salary * 0.3, salary ) } def tzTax(salary: BigDecimal ) = calculateTax( _ * 0.25, salary) kenyaTax(413202) tzTax(100)

High-order Functions. Demo028 def calculateTax(rate: BigDecimal => BigDecimal) : (BigDecimal ) => BigDecimal = { rate } def kenyaTax = calculateTax(x => if (x > 413201) x * 0.396 else x * 0.3 ) def tzTax = calculateTax( x => x * 0.25) kenyaTax(413202) tzTax(100) calculateTax(kenyaTax)(413202) calculateTax(tzTax)(100)

High-order Functions - Curry. Demo029 def calculateTax(rate: BigDecimal => BigDecimal) (salary : BigDecimal ) : BigDecimal = { rate (salary) } def kenyaTax(salary : BigDecimal) = calculateTax(x => if (x > 413201) x * 0.396 else x * 0.3 )(salary) def tzTax(salary : BigDecimal) = calculateTax( x => x * 0.25)(salary) kenyaTax(413202) tzTax(100)

Collections ❖ ❖ Concept of Collections ❖ Hierarchy of Collections - Immutable - Mutable ❖ Immutable List

Collections. ❖ Scala supports mutable collections and immutable collections. A mutable collection can be updated or extended in place. This means you can change, add or remove elements as a side effect. Immutable collections never change. You have still operations that stimulate additions, removals, updates by creating a new collection and leave the old unchanged.

Hierarchy ofImmutable Collections

Hierarchy of mutable Collections

val list1 = List(1,2,3) Demo030 // Construct a List Pronounced “cons” val list2 = 1 :: 2 :: 3 :: 4 :: 5 :: Nil val list3 = List(“apples”, “oranges”,”bananas”) val list4 = List(5,5,6,6) ::: List(8,7) Immutable List

Demo031 val list = List(4,3,0,1,2) ➔ list.head ➔ list.sortWith(_ > _) ➔ list.tail ➔ list.map(x => x * 2) ➔ list.length ➔ list.map(_ * 2) ➔ list.max ➔ list.reduce((x,y) => x + y) ➔ list.min ➔ list.filter(_ % 2 == 0) ➔ list.sum ➔ list.groupBy(x => x % 2 == 0) ➔ list.contains(2) ➔ list.drop ➔ list.reverse ImmutableList(API)

Summary of Scala. ❖ Keep it simple ❖ Don’t pack too much in one expression ❖ Find meaningful names ❖ Prefer functional ❖ Careful with mutable objects

Further Reading $ References. ❖ ScalaOfficial Docs ❖ Cousera-MartinOdesky ❖ CreativeScala ❖ ScalaSchool byTwitter ❖ Scala101byLightbend

Introductiontoprogramminginscala

More Related Content

What's hot

Similar to Introductiontoprogramminginscala

Recently uploaded

Introductiontoprogramminginscala