Intro to Functional Programming in Scala

Scala 101
Beyond Java: JVM FP, July 2014
Shai Yallin, Wix.com
audience.filter(_.usesJava).foreach { member =>
sayHi(member)
}

A short overview of Scala’s features
• A functional/OO programming language that runs on the JVM
• Everything is an object – no primitive types
• Functions are first-class members, every function is a value,
including what is usually an operator*
• Scala is statically-typed and supports type inference
* Some of these are synthetic functions

A short overview of Scala’s features
• Lambda expressions, closures and currying naturally
• Pattern matching
• Multiple inheritance through Traits
• Comprehensive collections library

Determinism via Immutability
Scala encourages everything to be immutable by default:
• Variables (vals)
• Collections
• Value objects (using Case Classes)

Better type safety
• Scala is statically and strongly typed; type inference keeps the
code lean and mean
• Stricter generics (in comparison to Java) provide better compile-
time checks
• Advanced features include structural types and type aliases

Case Classes
Good software engineering makes use of value objects. These need to
encapsulate the way they represent their state, to provide information hiding
and to be easy to maintain.
case class Person(
firstName: String,
lastName: String,
age: Int)
val authorOfPascal = Person("Niklaus", "Wirth", 80)

Case classes give us:
Factory methods Person("Niklaus", "Wirth", 80)
Hashcode authorOfPascal.hashCode == 1423465897
Equals authorOfPascal.equals(authorOfModula) == true
Copy val happyBirthday =
authorOfPascal.copy(age = 81)
Pattern matching Wait for it :-)

Collections
Some collection types:
• Seq (abstract ordered sequence)
• List (linked list)
• Set (yeah, it’s a set)
• Map (dictionary/hash)
A collection can be:
• Immutable / Mutable
• Synchronous / Parallel

Collections
With type inference, trivial to instantiate
val numbers = List(1, 2, 3)
val numbers2 = 1 :: 2 :: 3 :: Nil
val firstNames = Set("john", "mary", "muhammad”)
val caloriesPer100gr = Map(
"bacon" -> 541,
"fries" -> 312,
"lettuce" -> 15 )

Collection functions++ ++: +: /: /:
:+ :: ::: : addString
aggregate andThen apply applyOrElse asInstanceOf
canEqual collect collectFirst combinations companion
compose contains containsSlice copyToArray copyToBuffer
corresponds count diff distinct drop
dropRight dropWhile endsWith exists filter
filterNot find flatMap flatten fold
foldLeft foldRight forall foreach genericBuilder
groupBy grouped hasDefiniteSize head headOption
indexOf indexOfSlice indexWhere indices init
inits intersect isDefinedAt isEmpty isInstanceOf
isTraversableAgain iterator last lastIndexOf lastIndexOfSlice
lastIndexWhere lastOption length lengthCompare lift
map mapConserve max maxBy min
minBy mkString nonEmpty orElse padTo
par partition patch permutations prefixLength
product productArity productElement productIterator productPrefix
reduce reduceLeft reduceLeftOption reduceOption reduceRight
reduceRightOption repr reverse reverseIterator reverseMap
reverse_::: runWith sameElements scan scanLeft
scanRight segmentLength seq size slice
sliding sortBy sortWith sorted span
splitAt startsWith stringPrefix sum tail
tails take takeRight takeWhile to
toArray toBuffer toIndexedSeq toIterable toIterator
toList toMap toSeq toSet toStream
toString toTraversable toVector transpose union
unzip unzip3 updated view withFilter

Pattern matching
abstract class Gender
case object Male extends Gender
case object Female extends Gender
abstract class MaritalStatus
case object Single extends MaritalStatus
case object Married extends MaritalStatus
case object Divorced extends MaritalStatus
case object Widowed extends MaritalStatus
case class Person(
firstName: String, lastName: String, age: Int,
gender: Option[ Gender ], maritalStatus: Option[ MaritalStatus ])

Pattern matching
def salutation(p: Person) =
(p.gender, p.maritalStatus) match {
case (Some(Male ), _ ) => "Mr."
case (Some(Female), Some(Single) ) => "Miss"
case (Some(Female), None ) => "Ms."
case (Some(Female), _ ) => "Mrs."
case _ => "Unknown"
}

Functions as 1st-class members
val people = Set(
Person("Niklaus", "Wirth", 80),
Person("Anders", "Hejlsberg", 53),
Person("Martin", "Odersky", 55),
Person("Kenneth", "Thompson", 71))
val toddlers = people.filter(person: Person => person.age <= 3)
val minors = people.filter(person => person.age < 18)
val seniorCitizens = people.filter(_.age >= 65)
val isSenior = { person: Person => person.age >= 65}
val alsoSeniorCitizens = people filter isSenior

No nulls
Scala urges us to declare a possible return value using the Option[T] monad; an
option can be either Some(value) or None, and allows us to assume to it can
never be null. We can use collection semantics to consume an Option[T].
case class Person(
firstName: Option[String],
lastName: Option[String],
age: Option[Int])
val completelyUnknown = Person(None, None, None)
val anonymousAdult = Person(None, None, Some(25))
val agelessPerson = Person(Some("John”), Some("Doe"), None)
def ageOf(p: Person): Int = p.age // Won't compile!
def unsafeAgeOf(p: Person): Int = p.age.get // What if age is unknown?
def ageOrZero(p: Person): Int = p.age.getOrElse(0)

Multiple Inheritance with Traits
Similar (but better than) Java 8’s interfaces with default
methods, a Scala class can extend multiple Traits; in case
of collision, the right-most trait wins.

Example: Logging
import org.slf4j._
class ClassWithLogs {
private val log = LoggerFactory.getLogger(this.getClass)
def getNormalizedName(person: Person) = {
log.info("getNormalizedName called")
log.debug("Normalizing " + person)
val normalizedName = person.firstName.toUpperCase.trim
log.debug("Normalized name is: " + normalizedName)
normalizedName
}
}
x1000 classes
Eagerly evaluated

Example: Logging
trait Logging {
private val log = LoggerFactory.getLogger(this.getClass)
protected def logInfo(message: => String) =
if (log.isInfoEnabled) log.info (message)
protected def logDebug(message: => String) =
if (log.isDebugEnabled) log.debug(message)
protected def logWarn(message: => String) =
if (log.isWarnEnabled) log.warn (message)
protected def logError(message: => String) =
if (log.isErrorEnabled) log.error(message)
}
By-name parameters
(lazily evaluated)

Questions?
shaiy@wix.com
http://www.shaiyallin.com
@shaiyallin

Intro to Functional Programming in Scala

Recommended

More Related Content

What's hot (20)

Similar to Intro to Functional Programming in Scala (20)

Recently uploaded (20)

Intro to Functional Programming in Scala

Editor's Notes