Se ha denunciado esta presentación.
Se está descargando tu SlideShare. ×

Functional Programming With Scala

Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Próximo SlideShare
Clojure basics
Clojure basics
Cargando en…3
×

Eche un vistazo a continuación

1 de 30 Anuncio

Más Contenido Relacionado

Presentaciones para usted (20)

Anuncio

Similares a Functional Programming With Scala (20)

Más de Knoldus Inc. (20)

Anuncio

Más reciente (20)

Functional Programming With Scala

  1. 1. Functional Programming with Scala Neelkanth Sachdeva Software Consultant Knoldus Software LLP neelkanthsachdeva.wordpress.com
  2. 2. 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
  3. 3. Why Scala ?
  4. 4. 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
  5. 5. Scala features :
  6. 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 Java integration Let us understand these one-by-one :-
  7. 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. 8. 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()
  9. 9. 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)
  10. 10. 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
  11. 11. 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.
  12. 12. 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.
  13. 13. 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))
  14. 14. 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 ..... !
  15. 15. 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 ^
  16. 16. 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
  17. 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...isn’t it?
  18. 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. 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. 20. 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
  21. 21. 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))
  22. 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. Scala’s collections also split into three dichotomies: → Immutableand mutable collections → Eager and delayed evaluation → Sequential and parallel evaluation
  23. 23. 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)
  24. 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) toList res0: List[Int] = List(3, 31, 28, 18, 21, 3, 2)
  25. 25. 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
  26. 26. 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.
  27. 27. 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)
  28. 28. 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 !
  29. 29. 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
  30. 30. Thank You

×