PowerPoint Presentation

Functional Programming with Scala

Neelkanth Sachdeva Software Consultant Knoldus Software LLP neelkanthsachdeva.wordpress.com

Programming Languages

One approach to the software crisis is to introduce new programming languages that supports following : Reusability Clear , Concise and High performance code.

Rapid prototyping

Reduces time and cost for development

Why Scala ?

Scala programming language

Born from the mind of Martin Odersky.

A good mix of : Object orientation functional programming A powerful type system code

Eligent and powerful code then other languages

Scala features :

Scala attempts to blend three dichotomies of thought into one language. These are:

Functional programming and object-oriented programming

Expressive syntax and static typing

Advanced language features and rich Java integration Let us understand these one-by-one :-

Functional programming and object
oriented programming

Functional programming is style of programming in which the basic method of computation is the application of functions to arguments.

Functional programming puts special emphasis on the verbs of a program & Object-oriented programming puts special emphasis on nouns and attaches verbs to them.

The two approaches are almost inverses of each other, with one being top down and the other bottom up.

Functional programming approaches software as the combination and application of functions.

It tends to decompose software into behaviors, or actions that need to be performed, usually in a bottom-up fashion.

Didn't understood...Have a look ?

Scenerio : A Lion catches a deer and eats it.

The OOPS approach :

class Deer class Lion { def catch(d: Deer): Unit = ... def eat(): Unit = ... } val lion = new Lion val deer = new Deer lion.catch(deer) lion.eat()

Functional programming approach

trait Liontrait Deertrait Catchtrait FullTummy

def catch(hunter: Lion, prey: deer): Lion with Catchdef eat(consumer: Lion with Catch): Lion with FullTummyval story = (catch _) andThen (eat _)story(new Lion, new Deer)

Static typing and expressiveness

The Scala type system allows expressive code.

Scala made a few simple design decisions that help make it expressive:

- Changing sides of type annotation- Type inference- Scalable syntax- User-defined implicits

Transparently working with the JVM

Seamless integration with Java and the JVM

Using Java libraries from Scala is seamless because Java idioms map directly into Scala idioms.

libraries written in Java can be imported into Scala as is.

Recursion

Recursion plays a larger role in pure functional programming than in imperative programming, in part because of the restriction that variables are immutable. For example, you cant have loop counters, which would change on each pass through a loop. One way to implement looping in a purely functional way is with recursion. Lets have a look : Calculating factorials provides a good example. Here is an imperative loop implementation.

Imperative loop implementation

def factorialWithLoop(i: BigInt): BigInt = { var resultantValue = BigInt(1) for (h i * factorial_Functional(i - 1) }

for (i def findAnInt(implicit x : Int) = xfindAnInt: (implicit x: Int)Int

scala> findAnInt:7: error: could not find implicit value for parameter x: IntfindAnInt^

The findAnInt method is called without specifying any argument list. The compiler complains that it cant find an implicit value for the x parameter. Well provide one, as follows:

scala> implicit val test = 5test: Int = 5

scala> findAnIntres3: Int = 5

Avoid call site evaluation ?Sometimes we want arguments not be evaluated at call site : def executeMe(msgString: () => String) { println(msgString()) }Now calling the method like :executeMe(() => "This" + " is" + " not"+ " looking" + " good!")

Not looking good...isnt it?

How we can do this in a good way :We can use => in a type annotation to define a by-name parameter.

// by-name parameter def iAmOk(msgString: => String) { println(msgString) }

Now calling it as : /* * Using by-name Parameter */ iAmOk("This" + " is" + " an" + " use"+" case"+ " by-name" + " param.")

Partial Functions :

Need not be defined on its whole domain

PartialFunction is a subtype of Function1: trait PartialFunction [-A, +B] extends A => B

Use isDefinedAt to determine whether a partial function is defined for a given value or not.

Using isDefinedAt :object KnolXPartialFunction { // defined a map val KnolXMap = Map(1 -> "Neelkanth", 2 -> "Sachdeva") def main(args: Array[String]) { val booleanAnswer1 = KnolXMap.isDefinedAt(1) println("The Answer is " + booleanAnswer1) val booleanAnswer2 = KnolXMap.isDefinedAt(3) println("The Answer is " + booleanAnswer2) }}Output should be as :The Answer is trueThe Answer is false

Use a block of case alternatives to define a partial function literal :

scala> (a to f).zipWithIndex filter {| case (_, i) => i % 2 == 0| }Result should be like this :

res0: ... = Vector((a,0), (c,2), (e,4))

Using the right collection

The Scala collections library is the single most impressive library in the Scala ecosystem. The Scala collections provide many ways of storing and manipulating data, which can be overwhelming. Because most of the methods defined on Scala collections are available on every collection.

Scalas collections also split into three dichotomies:

Immutable and mutable collections

Eager and delayed evaluation

Sequential and parallel evaluation

The collection hierarchy

Traversable : The Traversable trait is defined in terms of the foreach method.This method is an internal iterator---that is, the foreach method takes a function that operates on a single element of the collection and applies it to every element of the collection. Travers-able collections dont provide any way to stop traversing inside the foreach.

Iterable : The Iterable trait is defined in terms of the iterator method. This returns an external iterator that you can use to walk through the items in the collection.

scala> val names = Iterable("Josh", "Jim")

names: Iterable[java.lang.String] = List(Josh, Jim)

Seq : The Seq trait is defined in terms of the length and apply method. It represents collections that have a sequential ordering. We can use the apply method to index into the collection by its ordering. The length methodreturns the size of the collection.

scala> val x = Seq(2,1,30,-2,20,1,2,0)

x: Seq[Int] = List(2, 1, 30, -2, 20, 1, 2, 0)

scala> x.tails map (_.take(2)) filter (_.length > 1) map (_.sum) toList

res0: List[Int] = List(3, 31, 28, 18, 21, 3, 2)

LinearSeq: The LinearSeq trait is used to denote that a collection can be split into a head and tail component.

IndexedSeq: The IndexedSeq trait is similar to the Seq trait except that it implies that random access of collection elements is efficient that is, accessing elements of a collectionshould be constant or near constant.

scala> val x = IndexedSeq(1, 2, 3)

x: IndexedSeq[Int] = Vector(1, 2, 3)

scala> x.updated(1, 5)

res0: IndexedSeq[Int] = Vector(1, 5, 3)

Set

Map

Some special & powerful collection methods:

sliding : Groups elements in fixed size blocks by passing a sliding window over them .

Curried methods : A method can have more than one parameter list, which is called currying2 .

foldLeft : foldLeft transforms a collection into a single value.

Using sliding method :object KnolXSliding {def KnolXSlide = { 1 to 6 sliding 4 foreach println } def main(args: Array[String]) { // Call the sliding method KnolXSlide }}Output should be :Vector(1, 2, 3, 4)Vector(2, 3, 4, 5)Vector(3, 4, 5, 6)

Using Curried methods :

object KnolXCurried { // Passing more then one parameters def KnolXadd(a: Int)(b: Int)(c: String) = println("The Tota Sum is "+ (a + b) + " " + c) def main(args: Array[String]) { KnolXadd(2)(9)("Wowwwwwww !") }}Output should be :The Total Sum is 11 Wowwwwwww !

Using foldLeft method :

object KnolXfoldLeft { def main(args: Array[String]) { val addAll = Seq(1, 2, 3).foldLeft(0)(_ + _) println("Sum is"+addAll) }}Output should be :Sum is 6

Thank You