1. Functional Programming with ScalaNeelkanth
SachdevaConsultantKnoldus Software
LLPneelkanthsachdeva.wordpress.com
2. Programming LanguagesOne approach to the software crisis is
to introduce newprogramming languages that supports following
:Reusability Clear , Concise and High performance code. Rapid
prototyping Reduces time and cost for development
3. Why Scala ?
4. Scala programming languageBorn from the mind of Martin
Odersky.A good mix of : Object orientation functional programming A
powerful type system code Eligent and powerful code then
otherlanguages
5. Scala features :
6. 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 Javaintegration Let us understand these
one-by-one :-
7. 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.
8. Didnt understood...Have a look ?Scenerio : A Lion catches a
deer and eats it. The OOPS approach :class Deerclass Lion { def
catch(d: Deer): Unit = ... def eat(): Unit = ... } val lion = new
Lion val deer = new Deer lion.catch(deer)lion.eat()
9. Functional programming approachtrait Liontrait Deertrait
Catchtrait FullTummydef 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)
10. Static typing and expressivenessThe 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
11. Transparently working with the JVM Seamless integration
with Java and the JVM Using Java libraries from Scala is
seamlessbecause Java idioms map directly into Scalaidioms.
libraries written in Java can be imported into Scala as is.
12. RecursionRecursion plays a larger role in pure
functionalprogramming than in imperative programming, in
partbecause of the restriction that variables are immutable.For
example, you cant have loop counters, which wouldchange on each
pass through a loop. One way toimplement looping in a purely
functional way is withrecursion.Lets have a look :Calculating
factorials provides a good example. Here is animperative loop
implementation.
13. Imperative loop implementationdef 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)Intscala> findAnInt:7: error:
could not find implicit value for parameter x: IntfindAnInt^
16. The findAnInt method is called without specifying
anyargument list. The compiler complains that it cant find
animplicit value for the x parameter. Well provide one,
asfollows:scala> implicit val test = 5test: Int = 5scala>
findAnIntres3: Int = 5
17. 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?
18. 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.")
19. 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.
20. Using isDefinedAt :object KnolXPartialFunction {// defined
a mapval 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
21. Use a block of case alternatives to define apartial
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))
22. 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: Immutableand
mutable collections Eager and delayed evaluation Sequential and
parallel evaluation
23. The collection hierarchyTraversable : The Traversable trait
is defined in terms of theforeach method.This method is an internal
iterator---that is, theforeach method takes a function that
operates on a singleelement of the collection and applies it to
every element of thecollection. Travers-able collections dont
provide any way tostop traversing inside the foreach.Iterable : The
Iterable trait is defined in terms of the iteratormethod. This
returns an external iterator that you can use towalk through the
items in the collection.scala> val names = Iterable("Josh",
"Jim")names: Iterable[java.lang.String] = List(Josh, Jim)
24. 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) toListres0: List[Int] = List(3,
31, 28, 18, 21, 3, 2)
25. LinearSeq: The LinearSeq trait is used to denote that
acollection can be split into a head and tail component.IndexedSeq:
The IndexedSeq trait is similar to the Seq traitexcept that it
implies that random access of collectionelements is efficient that
is, accessing elements of acollectionshould 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)SetMap
26. Some special & powerful collection methods: sliding :
Groups elements in fixed size blocks by passing asliding 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.
27. Using sliding method :object KnolXSliding {def KnolXSlide =
{1 to 6 sliding 4 foreach println}def main(args: Array[String]) {//
Call the sliding methodKnolXSlide}}Output should be :Vector(1, 2,
3, 4)Vector(2, 3, 4, 5)Vector(3, 4, 5, 6)