• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Functional programming with Scala
 

Functional programming with Scala

on

  • 936 views

Functional programming with Scala

Functional programming with Scala

Statistics

Views

Total Views
936
Views on SlideShare
749
Embed Views
187

Actions

Likes
0
Downloads
4
Comments
0

4 Embeds 187

http://neelkanthsachdeva.wordpress.com 171
https://neelkanthsachdeva.wordpress.com 10
http://www.linkedin.com 5
https://www.linkedin.com 1

Accessibility

Categories

Upload Details

Uploaded via as OpenOffice

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Functional programming with Scala Functional programming with Scala Presentation Transcript

    • Functional Programming with ScalaNeelkanth SachdevaConsultantKnoldus Software LLPneelkanthsachdeva.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 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 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.
    • Didnt 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 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)
    • 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
    • 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.
    • RecursionRecursion plays a larger role in pure functionalprogramming than in imperative programming, in partbecause of the restriction that variables are immutable.For example, you can’t 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.
    • Imperative loop implementationdef 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 Approachdef 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 implicitsScala provides an implicit keyword that can be used in two ways:→ method or variable definitions→ method parameter listsscala> def findAnInt(implicit x : Int) = xfindAnInt: (implicit x: Int)Intscala> findAnInt<console>: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 can’t find an implicit value for the x parameter. We’ll provide one, as follows:scala> implicit val test = 5test: Int = 5scala> 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...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 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. Scala’s collections also split into three dichotomies:→ Immutableand mutable collections→ Eager and delayed evaluation→ Sequential and parallel evaluation
    • The collection hierarchyTraversable : 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) toListres0: 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)SetMap
    • 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
    • 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 XMLOne <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 = 1955yearMade: Int = 1955scala><a> { if (yearMade < 2000) <old>{yearMade}</old>else xml.NodeSeq.Empty }</a>res2: scala.xml.Elem =<a> <old>1955</old></a>
    • Thank You