KEMBAR78
Functional programming basics | PDF
______                _   _                   _
| ____|               | | (_)                 | |
| |__ _   _ _ __   ___| |_ _ ___ _ __     __ _| |
| __| | | | '_  / __| __| |/ _ | '_  / _` | |
| | | |_| | | | | (__| |_| | (_) | | | | (_| | |
|_|   __,_|_| |_|___|__|_|___/|_| |_|__,_|_|


 _____                                               _
| __                                               (_)
| |__) | __ ___   __ _ _ __ __ _ _ __ ___ _ __ ___ _ _ __     __ _
| ___/ '__/ _  / _` | '__/ _` | '_ ` _ | '_ ` _ | | '_  / _` |
| |   | | | (_) | (_| | | | (_| | | | | | | | | | | | | | | | (_| |
|_|   |_| ___/ __, |_| __,_|_| |_| |_|_| |_| |_|_|_| |_|__, |
                  __/ |                                       __/ |
                 |___/                                       |___/
           ____   __   __      __     __ __      ____    __   _ _    __ ____   __   ____   __    __ _
         (  _  / _ ( )     / _ _( )( )      (      / _ ( / ) / (      / _ ( _  / _ ( ( 
          ) _ (/     / (_//     / )  )(    ) D (/      / / ( O )) D (/     )   //    /     /
         (____/_/_/____/_/_/____/(__)    (____/_/_/_)(_/ __/(____/_/_/(___)_/_/_)__)
http://eli.thegreenplace.net/wp-content/uploads/2008/05/tc_000.png
http://sites.google.com/site/andrewsporfotilio/_/rsrc/1226818616654/Home/math_400.jpg
Functional Programming is a style whose
underlying model of computation is the
function.




          f(x)
Referential Transparency
     Higher Order functions
     Lazy Evaluation
     Pattern Matching




http://picasaweb.google.com/damodaran.balaji/DevCampChennaiJuly2010#5493004664487949618
Lambda Calculus
Continuations
Monads
Type Inference
Referential Transparency
Higher Order functions
Lazy Evaluation
Pattern Matching
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
Referential Transparency
“Equals can be replaced with equals”


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


        f(x) = g(x) + 5
        h(x) = x * f(x)

        h(x) = x * (g(x) + 5)
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));
    }
}
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
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());
    }
}
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
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);
    }
}
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
Varying Variables
Global State
•    Looping
                                                             •    File I/O
                                                             •    Modify Data
                                                             •    Do more than one thing?




http://paulafanclub.com/wp-content/uploads/2010/12/confused.jpg
Looping



static int factorial(int number) {
   int f = 1;
   for (int i = number; i > 0; i--)
       f = f * i;
   return f;
}
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
Modifying data



static List<Integer> addToList(List<Integer> integers, int a) {
   integers.add(a);
   return integers;
}




                Mutable data structures
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
Referential Transparency
Higher Order functions
Lazy Evaluation
Pattern Matching
Higher Order functions
“Functions as first class values”




                    http://www.dreamstime.com/looking-up-to-the-sky-thumb4655038.jpg
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)
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
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
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
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
>
Referential Transparency
Higher Order functions
Lazy Evaluation
Pattern Matching
Lazy Evaluation
“Arguments in a function call are evaluated at most once.”




       http://www.arngren.dk/image/Wallpaper/Comic/Calvin%20Hobbes/Sleeping1024.jpg
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);
   }
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
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)
Lazy Evaluation
         “Ability to create infinite sequence in data structures”




http://softwarezku.co.cc/wp-content/uploads/2010/09/Visual-Studio-2010-Logo.png
Referential Transparency
Higher Order functions
Lazy Evaluation
Pattern Matching
Pattern Matching
      “Writing several equations defining the same function”




http://softwareandfinance.com/images/vcpp-trig1.jpg
Pattern Matching
A typical function definition


f(x) = 1, when x = 0
      = 3x + ex, when x > 0
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)
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/

Functional programming basics

  • 1.
    ______ _ _ _ | ____| | | (_) | | | |__ _ _ _ __ ___| |_ _ ___ _ __ __ _| | | __| | | | '_ / __| __| |/ _ | '_ / _` | | | | | |_| | | | | (__| |_| | (_) | | | | (_| | | |_| __,_|_| |_|___|__|_|___/|_| |_|__,_|_| _____ _ | __ (_) | |__) | __ ___ __ _ _ __ __ _ _ __ ___ _ __ ___ _ _ __ __ _ | ___/ '__/ _ / _` | '__/ _` | '_ ` _ | '_ ` _ | | '_ / _` | | | | | | (_) | (_| | | | (_| | | | | | | | | | | | | | | | (_| | |_| |_| ___/ __, |_| __,_|_| |_| |_|_| |_| |_|_|_| |_|__, | __/ | __/ | |___/ |___/ ____ __ __ __ __ __ ____ __ _ _ __ ____ __ ____ __ __ _ ( _ / _ ( ) / _ _( )( ) ( / _ ( / ) / ( / _ ( _ / _ ( ( ) _ (/ / (_// / ) )( ) D (/ / / ( O )) D (/ ) // / / (____/_/_/____/_/_/____/(__) (____/_/_/_)(_/ __/(____/_/_/(___)_/_/_)__)
  • 2.
  • 3.
  • 4.
    Functional Programming isa 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.
  • 7.
    Referential Transparency Higher Orderfunctions 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 canbe replaced with equals” f(x) = g(x) + 5 h(x) = x * f(x)
  • 10.
    Referential Transparency “Equals canbe 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.
  • 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(intnumber) { 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 Orderfunctions Lazy Evaluation Pattern Matching
  • 24.
    Higher Order functions “Functionsas first class values” http://www.dreamstime.com/looking-up-to-the-sky-thumb4655038.jpg
  • 25.
    Higher Order functions “Functionsthat 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 “Functionsthat 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 Orderfunctions Lazy Evaluation Pattern Matching
  • 31.
    Lazy Evaluation “Arguments ina function call are evaluated at most once.” http://www.arngren.dk/image/Wallpaper/Comic/Calvin%20Hobbes/Sleeping1024.jpg
  • 32.
    Lazy Evaluation “Ability toinvoke 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 toinvoke 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 Orderfunctions 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 typicalfunction definition f(x) = 1, when x = 0 = 3x + ex, when x > 0
  • 39.
    Pattern Matching A typicalfunction 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/