Functional programming with Scala

Functional Programming with Scala

Neelkanth Sachdeva
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

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 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 Lion
trait Deer
trait Catch
trait FullTummy

def catch(hunter: Lion, prey: deer): Lion with Catch
def eat(consumer: Lion with Catch): Lion with FullTummy
val 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 can’t 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 <- 2 to i.intValue)
resultantValue *= h
resultantValue
}

for (i <- 1 to 10)
println("factorial of " + i + " is " + factorialWithLoop(i))

Functional Approach

def factorial_Functional(i: BigInt): BigInt = i match {
case _ if i == 1 => i
case _ => i * factorial_Functional(i - 1)
}

for (i <- 1 to 10)
println("factorial of " + i + " is " + factorial_Functional(i))
How short and effective it is ..... !

Introduction to implicits

Scala provides an implicit keyword that can be used in two ways:
→ method or variable definitions
→ method parameter lists

scala> def findAnInt(implicit x : Int) = x
findAnInt: (implicit x: Int)Int

scala> findAnInt
<console>:7: error: could not find implicit value for parameter x: Int
findAnInt
^

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

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

scala> findAnInt
res3: 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...isn’t 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 true
The 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.
Scala’s collections also split into three dichotomies:
→ Immutableand 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 don’t 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
}
// 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)
KnolXadd(2)(9)("Wowwwwwww !")
}
}
Output should be :
The Total Sum is 11 Wowwwwwww !

Using foldLeft method :

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

Let us have a feel of some XML as well

Introduction to

Working with XML

Semi-structured data

→ XML is a form of semi-structured data.
→ It is more structured than plain strings, because it
organizes the contents of the data into a tree
→ Semi-structured data is very helpful any time you need to
serialize program data for saving in a file or shipping
across a network.
→ XML is the most widely used on the Internet. There are
XML tools on most operating systems, and most
programming languages have XML libraries available

XML overview

// Illegal XML
One <pod>, two <pod>, three <pod> zoo
// Also illegal
<pod>Three <peas> in the </pod></peas>

//Ok
<pod>Three <peas></peas> in the </pod>

Scala lets you type in XML as a literal anywhere that an expression is valid :

scala> <a>
This is some XML.
Here is a tag: <atag/>
</a>
res0: scala.xml.Elem =
<a>
This is some XML.
Here is a tag: <atag></atag>
</a>

scala> <a> {"hello"+", world"} </a>
res1: scala.xml.Elem = <a> hello, world </a>

Can we Try Something ?

scala> val yearMade = 1955
yearMade: Int = 1955
scala>
<a> { if (yearMade < 2000) <old>{yearMade}</old>
else xml.NodeSeq.Empty }
</a>
res2: scala.xml.Elem =
<a> <old>1955</old>
</a>

Functional programming with Scala

More Related Content

What's hot (20)

Similar to Functional programming with Scala (20)

Recently uploaded (20)

Functional programming with Scala