Upcoming SlideShare
×

# Principles of functional progrmming in scala

374 views

Published on

a short outline on necessity of functional programming and principles of functional programming in Scala.
In the article some keyword are used but not explained (to keep the article short and simple), the interested reader can look them up in internet.

Published in: Education
1 Like
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No
• Be the first to comment

Views
Total views
374
On SlideShare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
8
0
Likes
1
Embeds 0
No embeds

No notes for slide

### Principles of functional progrmming in scala

1. 1. Principles of Functional Progrmming in Scala • Moor’s Law • Clock frequency has not raised. • More Complex programs. • Growing in data
2. 2. Cuncurrency and Parallelism non-determinism Interference Horizontal-scaling among vertical-scaling
3. 3. Example var x = 0 async{ x = x+1 } async{ x = x*2 } // the answer could be 0, 1 or 2 Non-determinism = parallel processing+ mutable values
4. 4. Paradigm In science, a paradigm describes distinct concepts or thought patterns in some scientific discipline. Main programming paradigms: imperative programming functional programming logic programming
5. 5. Imparative paradigm modifying mutable variables, using assignments and control structures such as if-thenelse, loops, break, continue, return.
6. 6. Fucntional Paradigm Immutable states Functions without side-effects Everything is function Functions are expressions not statements
7. 7. Referential transparency once a variable is given a value it never changes. no side effects are possible. Functions are building blocks  functions are free side-effect function call does not affect other functions and it just computes its own output for a specific input sin (pi) = 0 Functions are expressions not statements
8. 8. FP is inspired by mathematics Neither theories nor functions have mutable values. You can combine functions to make more complex functions The result of a function or a theory does not change for different input. (a+b)^2 = a^2 + b^2 + 2*a*b This state doesn’t change for different inputs.
9. 9. Functional Languages Pure(restricted) Functional languages ( no imperative structure) like: Pure Lisp, XSLT, XPath, XQuery, FP,Haskell (without I/O Monad or UnsafePerformIO) Wider sense : Lisp, Scheme, Racket, Clojure SML, Ocaml, F# , Haskell (full language) , Scala , Smalltalk, Ruby
10. 10. What is scala? Scala is a statically typed JVM language that has transparent interoperability with Java. Both object oriented and functional language
11. 11. Why Scala? Lightweight syntax Combines functional and object-oriented approaches Advanced type system: everything has a type Strong type inference Performance comparable to Java Fully interoperable with Java
12. 12. Example of Scala High-level syntax Scala form class person(val name: String , val age: Int) { ...} Java form class person { private String name; private int age; Peron(String name, int age) { this.name = name; this.age = age; } }
13. 13. continue val list = List(2,5,4) val newList = (list map(x => x*x)) sortWith(_ > _) //newList = list(4,16,25) Java form ??? val people: Array[Person] val (minors,adults) = people partition (_.age < 18) Java form ???
14. 14. Subsitution Model The idea underlying this model is that all evaluation does is reduce an expression to a value. It can be applied to all expressions, as long as they have no side effects. Lambda calculus
15. 15. Non-primitive expression A non-primitive expression is evaluated as follows: 1. Take the leftmost operator 2. Evaluate its operands (left before right) 3. Apply the operator to the operands (2 * pi) * radius (2 * 3.14159) * radius 6.28318 * radius 6.28318 * 10 62.8318
16. 16. Parameterized functions substitution 1. Evaluate all function arguments, from left to right 2. Replace the function application by the function’s right-hand side, and, at the same time 3. Replace the formal parameters of the function by the actual arguments
17. 17. Example 1. 2. 3. 4. 5. 6. 7. 8. sumOfSquares(3, 2+2) sumOfSquares(3, 4) square(3) + square(4) 3 * 3 + square(4) 9 + square(4) 9+4*4 9 + 16 25
18. 18. Scala Substitution model What if right hand side does not terminate ? two elements for storing expressions in Scala: def and val def loop: Boolean = loop def x = loop //it is ok val x = loop // it will lead to an infinite loop. As you see the difference between val and def becomes apparent when the right hand side does not terminate. Val is changed to its value when it is defined but the value of def is substituted where it is used.
19. 19. val & def continue def: 1. can have parameters def cube(x: Int): Int = x*x*x 2. Call-by-name val: 1. The value of it is substituted as it is defined. In other words: call-by-value
20. 20. Call-by-name function parameters sumOfSquares(x: Int , y: => Int) sumOfSquares(3, 2+2) square(3) + square(2+2) 3 * 3 + square(2+2) 9 + square(2+2) 9 + (2+2) * (2+2) 9 + 4 * (2+2) 9+4*4 25
21. 21. Higher-Order functions Functions are expressions so they can be: Defined anywhere included in other functions sent to other functions as parameters Returned from other functions def fact(x: Int) = if(x ==0) 1 else x*fact(x-1) def cube(x: Int) = x*x def processOnSums( f: Int => Int , a: Int , b: Int) = f(a) + f(b) processOnSums(cube, 2 , 3 ) // Output = 2*2 + 3*3 anonymous function: x=> x*x processOnSums(fact , 2 , 3 ) // Output: 2*1 + 3*2*1
22. 22. Currying def sum(f: Int => Int, a: Int, b: Int): Int = if (a > b) 0 else f(a) + sum(f, a + 1, b) def sumInts(a: Int, b: Int) = sum(x=>x, a, b) def sumCubes(a: Int, b: Int) = sum(x=> x*x, a, b) def sumFactorials(a: Int, b: Int) = sum(x=>fact(x), a, b) Can we make it even shorter???
23. 23. continue def sum(f: Int => Int): (Int, Int) => Int = { def sumF(a: Int, b: Int): Int = if (a > b) 0 else f(a) + sumF(a + 1, b) sumF } Sum returns another function We can define like this: def sumInts = sum(x => x) def sumCubes = sum(x => x * x * x) def sumFactorials = sum(fact) sumCubes(1, 10) + sumFactorials(10, 20) Even shorter???
24. 24. continue The answer is yes. sum (cube) (1, 10) Write once, program many times. ..
25. 25. Classes Two kinds of instant field initialization: Class myClass(input1: Int, input2: Int) { Val a = input1 Vab b = input2 } class myClass(val input1: Int, val input2: Int){…}
26. 26. Auxiliary Constructors In order to create auxiliary constructors, define method this with required parameters. Class myClass(input1: Int, input2: Int) { def this(input1: Int) = this (input1, 0) }
27. 27. Inheritance Inheritance rules so similar to java Traits are alternative for interfaces Why do we need a new structure ? In java classes can have only one super class, but what if a class need to inherit from several supertypes ??? This is why scala introduces traits.
28. 28. Trait trait super { val a = 5 def b = a*2 def c(x: Int) = a*x } class sub extends Object with super{…}
29. 29. Class Hierarchies
30. 30. Imports Int  scala.Int Boolean  scala.Boolean Object  java.lang.Object require  scala.Predef.require assert  scala.Predef.assert
31. 31. Object Definition The same as java. with new notation Val myList = new List(1,2,3) The other form: Val myList = List(1,2,3) What happened? Whre is new? We will see…
32. 32. Singletone Objects What is singleton object and why do we need it? The reason we used singleton classes was to create just one object of a certain type. Scala gives us a powerful tool called singleton object that ease the procedure we used to do with singleton classes in java.
33. 33. Example object myObject { def +(x: java.lang.String) = x + " and " } def names = myObject + "Ehsan" + "Sana" println(names) //output Ehsan and Sana
34. 34. Apply Method Still don’t know how compiler translates this: Val myList = List(1,2,3) We can create a new object just as we call a function with implenting apply method. Reason: We are just trying to show the use of apply method as a handy way of closing the gap between functions and objects in Scala.
35. 35. Implementation of Apply Method for List object List extends List { def apply[A](xs: A*): List[A] //Creates a list with the specified elements. }
36. 36. Immutable Collections Lists Maps a fundamental structure in many functional languages is the immutable linked list.
37. 37. List Implementation List(List(1, 2)),List(3)