Referential Transparency, Higher Order functions, Lazy Evaluation, and Pattern Matching are key concepts in Functional Programming. Referential Transparency means that equal expressions can be replaced with each other without changing the program's behavior. Higher Order functions allow functions to be passed as arguments to other functions and returned as results. Lazy Evaluation delays evaluating arguments until their values are needed to avoid unnecessary computation. Pattern Matching allows decomposing and analyzing data structures.

1. ______ _ _ _
| ____| | | (_) | |
| |__ _ _ _ __ ___| |_ _ ___ _ __ __ _| |
| __| | | | '_ / __| __| |/ _ | '_ / _` | |
| | | |_| | | | | (__| |_| | (_) | | | | (_| | |
|_| __,_|_| |_|___|__|_|___/|_| |_|__,_|_|
_____ _
| __ (_)
| |__) | __ ___ __ _ _ __ __ _ _ __ ___ _ __ ___ _ _ __ __ _
| ___/ '__/ _ / _` | '__/ _` | '_ ` _ | '_ ` _ | | '_ / _` |
| | | | | (_) | (_| | | | (_| | | | | | | | | | | | | | | | (_| |
|_| |_| ___/ __, |_| __,_|_| |_| |_|_| |_| |_|_|_| |_|__, |
__/ | __/ |
|___/ |___/
____ __ __ __ __ __ ____ __ _ _ __ ____ __ ____ __ __ _
( _ / _ ( ) / _ _( )( ) ( / _ ( / ) / ( / _ ( _ / _ ( (
) _ (/ / (_// / ) )( ) D (/ / / ( O )) D (/ ) // / /
(____/_/_/____/_/_/____/(__) (____/_/_/_)(_/ __/(____/_/_/(___)_/_/_)__)

2. http://eli.thegreenplace.net/wp-content/uploads/2008/05/tc_000.png

3. http://sites.google.com/site/andrewsporfotilio/_/rsrc/1226818616654/Home/math_400.jpg

4. Functional Programming is a style whose
underlying model of computation is the
function.
f(x)

5. Referential Transparency
Higher Order functions
Lazy Evaluation
Pattern Matching
http://picasaweb.google.com/damodaran.balaji/DevCampChennaiJuly2010#5493004664487949618

6. Lambda Calculus
Continuations
Monads
Type Inference

7. Referential Transparency
Higher Order functions
Lazy Evaluation
Pattern Matching

8. Referential Transparency
“Equals can be replaced
with equals”
http://2.bp.blogspot.com/_DS3VD3b2euI/TRIcIUzduDI/AAAAAAAAAGA/Xp2E6kPxZCc/s1600/Pascal+the+chameleon+from+tangled+rapunzel+disney+cartoon.jpg

9. Referential Transparency
“Equals can be replaced with equals”
f(x) = g(x) + 5
h(x) = x * f(x)

10. Referential Transparency
“Equals can be replaced with equals”
f(x) = g(x) + 5
h(x) = x * f(x)
h(x) = x * (g(x) + 5)

11. public class ReferentiallyOpaque {
private int x = 0;
static int f(int y) {
return x += y;
}
public static void main(String[] args) {
ReferentiallyOpaque ro = new ReferentiallyOpaque();
System.out.println(ro.f(5));
System.out.println(ro.f(5));
}
}

12. public class ReferentiallyOpaque {
private int x = 0;;
static int f(int y) {
return x += y;
}
public static void main(String[] args) {
ReferentiallyOpaque ro = new ReferentiallyOpaque();
System.out.println(ro.f(5));
System.out.println(ro.f(5));
}
}
5
10

13. public class Example {
public static void main(String[] args) {
StringBuffer buffer = new StringBuffer("Hello World");
System.out.println(buffer.reverse());
System.out.println(buffer.reverse());
}
}

14. public class Example {
public static void main(String[] args) {
StringBuffer buffer = new StringBuffer("Hello World");
System.out.println(buffer.reverse());
System.out.println(buffer.reverse());
}
}
dlroW olleH
Hello World

15. public class Example {
public static void main(String[] args) {
StringBuffer buffer = new StringBuffer("Hello World");
StringBuffer s1 = buffer.reverse();
StringBuffer s2 = buffer.reverse();
System.out.println(s1 + " " + s2);
}
}

16. public class Example {
public static void main(String[] args) {
StringBuffer buffer = new StringBuffer("Hello World");
StringBuffer s1 = buffer.reverse();
StringBuffer s2 = buffer.reverse();
System.out.println(s1 + " " + s2);
}
}
Hello World Hello World

17. Varying Variables
Global State

18. • Looping
• File I/O
• Modify Data
• Do more than one thing?
http://paulafanclub.com/wp-content/uploads/2010/12/confused.jpg

19. Looping
static int factorial(int number) {
int f = 1;
for (int i = number; i > 0; i--)
f = f * i;
return f;
}

20. Looping
Recursion
static int factorial(int number) {
int f = 1;
for (int i = number; i > 0; i--)
f = f * i;
return f;
}
static int factorial(int number) {
return (number == 1) ?
number :
number * factorial(number - 1);
}
http://www.shrink4men.com/wp-content/uploads/2010/11/dog-chasing-its-tail.jpg

21. Modifying data
static List<Integer> addToList(List<Integer> integers, int a) {
integers.add(a);
return integers;
}
Mutable data structures

22. Modifying data
Immutable
static List<Integer> addToList(List<Integer> integers, int a) {
integers.add(a);
return integers;
}
let addToList list a =
list @ [a]
> let g = [1;2;3;];;
val g : int list = [1; 2; 3]
> addToList g 4;;
val it : int list = [1; 2; 3; 4]
> g;;
val it : int list = [1; 2; 3]
>
http://4.bp.blogspot.com/_RpRScqAI8e4/SbNPgumsqPI/AAAAAAAAAK4/ZK8ZsfKJCmQ/s400/wolverine+hugh+jackman.jpg

23. Referential Transparency
Higher Order functions
Lazy Evaluation
Pattern Matching

24. Higher Order functions
“Functions as first class values”
http://www.dreamstime.com/looking-up-to-the-sky-thumb4655038.jpg

25. Higher Order functions
“Functions that can be passed as arguments”
def square(x):
return x * x
def add(function, x):
return function(x) + function(x)
print add(square, 5)

26. Higher Order functions
“Functions that can be returned as results”
function addNumber(x) {
return function(y) {
return x + y
}
}
var add4With = addNumber(4)
var add5With = addNumber(5)
add4with(8)
add5with(8)
12
13

27. Higher Order functions
“Functions that can be returned as results”
function addNumber(x) {
Lambda Functions
return function(y) {
return x + y
}
}
var add4With = addNumber(4)
var add5With = addNumber(5)
add4with(8)
add5with(8)
12
13

28. Higher Order functions
“Functions that can be returned as results”
function addNumber(x) {
Lambda Functions
return function(y) {
return x + y
}
}
var add4With = addNumber(4)
var add5With = addNumber(5)
add4with(8)
Functions stored in
add5with(8)
data structures
12
13

29. Higher Order functions
“Currying”
let add x y =
x + y
val add : int -> int -> int
> let add5 = add 5;;
val add5 : (int -> int)
> add5 4;;
val it : int = 9
>

30. Referential Transparency
Higher Order functions
Lazy Evaluation
Pattern Matching

31. Lazy Evaluation
“Arguments in a function call are evaluated at most once.”
http://www.arngren.dk/image/Wallpaper/Comic/Calvin%20Hobbes/Sleeping1024.jpg

32. Lazy Evaluation
“Ability to invoke expressions only when its value is needed.”
static void Main(string[] args)
{
var lazy = new Lazy<int>(() =>
{
Console.WriteLine("calculating...");
return 6 * 7;
});
Console.WriteLine(lazy.Value);
Console.WriteLine(lazy.Value);
}

33. Lazy Evaluation
“Ability to invoke expressions only when its value is needed.”
static void Main(string[] args)
{
var lazy = new Lazy<int>(() =>
{
Console.WriteLine("calculating...");
return 6 * 7;
});
Console.WriteLine(lazy.Value);
Console.WriteLine(lazy.Value);
}
calculating...
42
42

34. Lazy Evaluation
“Memoization”
function Lazy_Memoized(def) {
var cache = [];
return function(i) {
return (i in cache) ? cache[i] :
(cache[i] = def.call(arguments.callee, i));
};
}
var factorial = new Lazy_Memoized(function(i) {
return i <= 1 ? i : i * this(i - 1);
});
factorial(6)

35. Lazy Evaluation
“Ability to create infinite sequence in data structures”
http://softwarezku.co.cc/wp-content/uploads/2010/09/Visual-Studio-2010-Logo.png

36. Referential Transparency
Higher Order functions
Lazy Evaluation
Pattern Matching

37. Pattern Matching
“Writing several equations defining the same function”
http://softwareandfinance.com/images/vcpp-trig1.jpg

38. Pattern Matching
A typical function definition
f(x) = 1, when x = 0
= 3x + ex, when x > 0

39. Pattern Matching
A typical function definition
fac :: Integer -> Integer
fac 0 = 1
fac n | n > 0 = n * fac(n-1)
let rec factorial = function
| 0 -> 1
| n -> n * factorial(n - 1)

42. References
• Concepts, Evolution and Application of Functional Programming Languages – Paul
Hudak
• http://msdn.microsoft.com/en-us/library/dd547125.aspx - Pattern Matching in
F#
• http://appden.com/javascript/lazy-list-comprehensions-in-javascript-a-lazy-
evalution/
• http://images.google.com
• http://en.wikipedia.org
• http://www.haskell.org/haskellwiki/Haskell
• http://homepages.inf.ed.ac.uk/wadler/