Intro to Functional Programming Workshop (code4lib)
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

Intro to Functional Programming Workshop (code4lib)

on

  • 2,926 views

 

Statistics

Views

Total Views
2,926
Views on SlideShare
1,441
Embed Views
1,485

Actions

Likes
2
Downloads
36
Comments
1

4 Embeds 1,485

http://francescoagati.wordpress.com 1477
http://articulate.nantasket.com 3
http://translate.googleusercontent.com 3
https://francescoagati.wordpress.com 2

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

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
  • Treats programming as the evaluation of mathematical processes Based on what's call the lambda calculus.  Mention this is turing complete way of representing a programing language with only anonymous function
  • But what does this mean? Every function returns a value, that's what functions do they map one value to another. given an input a function always returns the same value in general it's more about stating what your problem is.
  • The big this this all entails is there are no 'Side Effects' in functional programming. When you call a function nothing about the world changes, can you say this is true about OOP?  This is much more meaningful that it may seem at first. If a variable is declared (and the usually aren't) it can never change it's value. This is even true for something like 'i' in a 'for loop' or the value a while loop checks... so that mean there are not classic iterators: no for loops, and no while loops.
  • So why do all this? Number one reason by far for me is the really amazing abstractions you can come up with. For programming side effect free is an awesome guarantee There a lot of potential research that we can get some great and easy parallization from all this There are already functional features in languages like C#, python, ruby, LINQ. If you understand FP you can pick these things up a lot faster Big ideas are starting to come from the fp community.  When google release mapreduce, anyone with a background in lisp for functional programming would have instantly be able to guess roughly how the process worked.
  • So I'm going to talk about 2 languages tonight side by side. Haskell is an amazing language, but it has a reputation for being very difficult to learn.  As much as I would like to pretend that this is not the case, it really can be.  Tonight I'm sticking to just a small subset of haskells expressiveness to go over the essentials of functional programming.  Get started with haskell isn't really so bad once you know the basics and understand fp a little better.
  • Now JavaScript has the opposite problem. Most people view it as simply a mediocre clientside language. But it's actually an amazingly powerful language, and also probably the most functional of all mainstream languages. I want to show you that functional programming isn't really that hard, it's just different.  I'm willing to bet that most anyone in the room has already used some really powerful functional features of javascript without even knowing it.
  • Before we begin I want to just mentions lists a bit.  Functional programmin, with no standard loops, is very heavily based on recursion, and so it also relies heavily on lists. Here are some basic operations on a list that you'll need to be familiar with.  They go by many other names.
  • The first essential feature of functional programming, is what is refered to as a 'first class function' This is one of the easiest concepts to grasp, it seemly means that functions can be treated just like any other object, and most importantly that they can be passed just like arguments.
  • so first we're going to put together a simple function this one adds '2' to a  number and this one addes '3' this are both in haskell and should be very simple to understand.  any questions
  • Now we're going to make the opposite function, that is a function that takes a function and applies it to a predetermined argument. So arg is '2' takes whatever function you pass it and gives it the argument '2'
  • How many of you have ever written any javascript at all? Everyone that just raised there hands has used a lambda function. All a lambda function is is an unnamed or anonymous function.  I'll show you in a bit how common these are in javascript Lambda functions are the core of funtional programming, although the can be all but removed from some languages. Initially what they offer may seem of limited use, but as we go on you should see how the become pretty essential. If you're insane you can literarly usual solely lambda functions to do all of your computation, you can even implment addition and subtraction without numbers.  Hell you can even implment recursion in using only unnamed functions.
  • Now these examples are stupidly simple, but you'll see lambda popping up all over this presentaiton in various forms. so here we're defining a function, add4, as a lambda <walk through notation? Now also notice how we can pass this function as a first class function directly to our previous argIsX function
  • Here some everyday javascript, these snippets are just pulled straight from standard javascript tutorials.  You've probably written code like this if you've ever done any javascript.
  • Closures sound more complicated then they are.  Closures let us capture some variable in the scope of a function we return... Examples will do you much better than me describing it.
  • So here's add5 for reference. Now this pattern of addX is pretty obvious, there must be a way to abstract this away right? so we can make this functioncalled makeAdder that takes a values. here is the same code 2 different ways, in put cases we're returning a function that has this value we based enclosed in it. Now we can make adders more easily. So you can see in the about put the function we returned remembers what value we passed to it. This also demonstrates another important property of lambda functions.
  • okay so proper first class functions, lambdas and closure are the core of functional programming.  coupled with recursion you're pretty much done. However these are really just the primative of functional programming.  Next we're going to answer what's probably the biggest question you have.  Since we throw out all the iterators I know of, how the hell do I get any actual work done? That brings us to higher order functions, by definiton these are just functions that take functions as an argument, but there are some that form the basis of how you should think about problems in fp.
  • Map is the most obvious, it solve the problem of the vast majority of iteration that you do.   map takes a function and a list and returns a new list with that function applied to every item in it. From here on out I'm going to show you how higher order functions work in haskell, and how there implemented in javascript
  • this is actually a pretty easy concept. so in the first example double all takes a list, and the applys times 2 to each item, so it doubles every item in the list. square all does the same thing but squares them square and add just shows off how we can use our lambda again and upperCase takes a string an applies toUpper to each letter in that string, a string is afterall just a list of characters.
  • just a note on haskell here, you can actually leave out the arguments on both sides if we're missing an arguement we essentially create a closure waiting for that argument. We'll talk more about this later.
  • filter does what the name sounds like, it takes a function which performs a test and only returns values that pass.
  • so this first case selects every item that is even the next selects every one that is evenly divisible by 17  And this last is a little different.  This is a neat trick called function composition.  what we do is apply the rightmost function and then send it's value to the left most.  this makes it very easy to define complicated functions by composing them. explain output
  • Folds are very poweful, but also the most likely to give you a headache until you undertand them.  There are actually several types of folds, we're going to focus on what's call a left fold, foldl or often reduce (in ruby it's called inject). fold takes a function, and initial value, and a list of values and 'folds' all the values of that list into a single value.
  • The simpliest and most obious use of fold it to some values ina list, see here our function is 'add' and our intial value is 0. This reverse is actually a bit more tricky, I'll actually walk you through this. finally I'll show you some more function composition. we can define sumOfSquare 2 ways, the first more verbose maps square to a list, and the folds it just like sum, The second composes our sum and squareAll functions.
  • here I'll walk you through the recursion for the fold revers.
  • Many of you may know of Joel Spolsky, he's one of the people behind stack over flow A few years ago he wrote about the functional properties of javascript and gave this as his implementation of map. But we can see here that this implementation itself is not functional.  In some cases this is meaningless, but notice what happens to the array we're passing?   In a purely functional work the original array will ALWAYS be untouched, in this case the original array is deleted.
  • Once again Spolsky also implemented this, but once again it's not functional. However this time it is less damaging and probably more effiience.  Some languages let you choose when you want to be functional, choose wisely.
  • Finally we'll discuss function currying. what happens in any language you know when you call a function that takes 3 arguements with only 2 arguement? Error right?  Well not in haskell, in haskell you get a new function waiting for the 3rd arguement. let's look at some examples
  • here I'll defiine a new version of add that takes 2 arguments If I call it with only one then I get a function waiting for the next argument, you can see this is even easier than our earlier example that build closures
  • what's crazy is that you can actually implement this functionality in javascript

Intro to Functional Programming Workshop (code4lib) Presentation Transcript

  • 1. var λ; Introduction to Functional Programming  with JavaScript (and a little Haskell) Will Kurt Will Kurt, Creative Commons Attribution-ShareAlike 3.0
  • 2. "A language that doesn't effect how you think about programming is not worth learning" --Alan Perlis
  • 3. So what is Functional Programming? http://www.flickr.com/photos/foundphotoslj/466713478/
  • 4. What does this mean?
    • http://www.flickr.com/photos/61417318@N00/4908148942/
  • 5. No Side Effects!
    • http://www.flickr.com/photos/rka/1733453/
  • 6. http://www.flickr.com/photos/23912576@N05/3056871500/
  • 7. Haskell! http://www.flickr.com/photos/micurs/4870514382/
  • 8. JavaScript!!! http://www.flickr.com/photos/jurvetson/96972777/
  • 9. Rules for Today λ
  • 10. Lists!!!
    • first( [1,2,3,4]) -> 1  (aka: car, head)
    • rest( [1,2,3,4] ) -> [2,3,4] (aka: cdr, tail)
    • empty( [1,2,3,4] ) -> false (aka: null?, nil? empty?,[])
    • empty( [ ] ) -> true
    • build( 1 , [2,3,4]) -> [1,2,3,4]  (aka: cons, ':' )
    • build( [1] , [2,3,4]) -> [[1],2,3,4]
  • 11. Recursion! "If you already know what recursion is, just remember the answer. Otherwise, find someone who is standing closer to Douglas Hofstadter than you are; then ask him or her what recursion is." -- Andrew Plotkin
  • 12. Exercise set 1a 10 minutes
  • 13. Answers to set 1a
  • 14. problem 1
    • var fact = function(x) {
    •      return(
    •        (x===1) ? 1 :
    •        x*fact(x-1)   
    •      );
    • }
    • function fact (x) {
    •      if(x==1){
    •              return 1;
    •        } else {
    •          return x*fact2(x-1);
    •        }
    • }
  • 15. problem 2
    • var fib = function(x){
    •      return(
    •            (x==0) ? 0 :
    •            (x==1) ? 1 :
    •            fib(x-1)+fib(x-2)
    •      );
    • }
  • 16. problem 2 continued...
    • var fib_answers = []
    • fib_answers[0] = 0;
    • fib_answers[1] = 1;
    • var fibm = function (x) {
    •      return fib_mem(x,fib_answer);
    • }
    • var fib_mem = function(x,m){
    •      if(m[x] != undefined){
    •          return m[x];
    •      } else {
    •          m[x] = fib_mem(x-1,m)+fib_mem(x-2,m);
    •           return m[x];
    •      }
    • }
  • 17. problem 2 last one I swear (also very functional)...
    • var fib3wrapper = function(c){
    •      return fib3(c,1,0);
    • }
    • var fib3 = function(c,last1,last2){
    •      return(
    •              (c==2) ? last1+last2:
    •              fib3(c-1,last1+last2,last1)
    •      );
    • }
  • 18. Exercise set 1b 10 minutes
  • 19. Answers to set 1b
  • 20. problem 1
    • var length = function (xs) {
    •      return(
    •            empty (xs) ? 0 :
    •            1 + length( rest (xs))
    •      );
    • };
  • 21. problem 2
    • var nth = function(n,xs){
    •      return(
    •          empty(xs) ? [] :
    •          (n == 0) ? first(xs) :
    •          nth(n-1, rest(xs))
    •      );
    • };
  • 22. problem 3
    • var removeAll = function (x, xs) {
    •      return(
    •          empty(xs) ?  [ ]  :
    •          (x == first(xs)) ?  removeAll(x,   
    •                                  rest(xs)) :
    •          build( first(xs),
    •                removeAll(x,rest(xs)))
    •      );
    • };
  • 23. First class functions http://www.flickr.com/photos/richardmoross/2211308689/
  • 24. First Class Functions (Haskell)
    • add2 x = 2 + x
    • add3 x = 3 + x
    • > add2 5
    • 7
    • > add3 5
    • 8
  • 25. First Class Functions (Haskell)
    • argIs2 func = (func) 2
    • argIs3 func = (func) 3
    • > argIs2(add2)
    • 4
    • > argIs2(add3)
    • 5
    • > argIs3(add2)
    • 5
    • > argIs3(add3)
    • 6
  • 26. Lambda Functions
    • http://www.flickr.com/photos/jeremymates/2362399109/
  • 27. Lambda Function (Haskell)
    • add4 = (x -> 4+x)
    • >argIs2( (x -> 4+x) )
    • 6
  • 28. Lambda Function (JavaScript)
    • $.ajax({ url: "test.html", context: document.body, success: function(){
    •         $(this).addClass("done");
    •       } });
    • $("#exec").click( function(){
    •   $(&quot;#results&quot;).prepend(&quot;<li>Normal Handler</li>&quot;);
    • } );
  • 29. Exercise set 2 10 minutes
  • 30. Answers to set 2
  • 31. problem 1
    • var argIs2 = function(func) {
    •      return func(2);
    • }
  • 32. problem 2
    • argIs2(function(x){ add(2,x);} );
  • 33. problem 3
    • var flip = function (func) {
    •        return(
    •                  function(x,y){
    •                          func(y,x);
    •                  }
    •        );
    • };
  • 34. Break! 5 minutes
  • 35. Closures
    • http://www.flickr.com/photos/theredproject/3431459572/
  • 36. Closures (Haskell)
    • add5 = (+5)
    • makeAdder val = (+val)
    • makeAdderWithLambda val = (x->x+val)
    • add6 = makeAdder 6
    • add7 = makeAdderWithLambda 7
    • > add5 5
    • 10
    • > add6 5
    • 11
    • > add7 5
    • 12
  • 37. Exercise set 3 5 minutes
  • 38. Answers to set 3
  • 39. problem 1
    • var makeAdder = function (x) {
    •      return(
    •          function(y) {
    •                    return add(x,y);
    •                }
    •      );
    • };
  • 40. problem 2
    • var apiClosure = function(apiKey){
    •      return(
    •          function(x){
    •              return apiSearch(apiKey,x);
    •          }
    •      );
    • };
  • 41. problem 3
    • var compose = function (f1,f2) {
    •      return(
    •          function(x){
    •              f1(f2(x));
    •          }
    •      );
    • };
  • 42. Higher Order Functions
    • http://www.flickr.com/photos/73416633@N00/2425022159/
  • 43. Map
    • http://www.flickr.com/photos/rosenkranz/3052214847/
  • 44. Map (Haskell)
    • doubleAll xs = map (*2) xs
    • squareAll xs = map (^2) xs
    • squareAndAdd xs = map (x->x*x+x) xs
    • upperCase s = map toUpper s
    • > doubleAll [1,2,3,4]
    • [2,4,6,8]
    • > squareAll [1,2,3,4]
    • [1,4,9,16]
    • > squareAndAdd [1,2,3,4]
    • [2,6,12,20]
    • > upperCase &quot;doggie&quot;
    • &quot;DOGGIE&quot;
  • 45. Map (Haskell)
    • doubleAllv2 = map (*2)
    • squareAllv2 = map (^2)
    • squareAndAddv2 = map (x->x*x+x)
  • 46. Exercise set 4a 5 minutes
  • 47. Answers to set 4a
  • 48. problem 1
    • var map = function (func, xs) {
    •      return(
    •          empty(xs) ?  [ ]  :
    •          build(  func (first(xs)),
    •                    map  (func,  rest (xs))));
    •      );
    • };
  • 49. problem 2
    • map(function(x){
    •                  return x*x},
    •          xs);
  • 50. Filter
  • 51. Filter (Haskell)
    • evenList xs = filter even xs
    • mod17list xs = filter (== (`mod` 17) 0) xs
    • doubleEvens xs = (doubleAll . evenList) xs
    • > evenList [1,2,3,4,5,6]
    • [2,4,6]
    • > mod17list [1..100]
    • [17,34,51,68,85]
    • > doubleEvens [0,3..27]
    • [0,12,24,36,48]
  • 52. Exercise set 4b 10 minutes
  • 53. Answers to set 4b
  • 54. problem 1
    • var filter = function (test,xs){
    •      return(
    •          empty(xs) ? [ ] :
    •          test(first(xs)) ? filter(test, rest(xs)) :
    •          build(first(xs),filter(test,rest(xs)))
    •      );
    • };
  • 55. problem 2
    • var removeAll = function(x,xs){
    •      return(
    •          filter( function(y){
    •                            return y == x},
    •                  xs )
    •      );
    • };
  • 56. Foldl (Reduce) http://en.wikipedia.org/wiki/File:Sermon_in_the_Deer_Park_depicted_at_Wat_Chedi_Liem-KayEss-1.jpeg
  • 57. Foldl (Haskell)
    • mySum xs = foldl (+) 0 xs
    • sumOfSquares xs = foldl (+) 0 (map (^2) xs)
    • sumOfSquaresv2 = (mySum . squareAll)
    • > mySum [1..2000000]
    • 2000001000000
    • > sumOfSquares [1..10]
    • 385
    • > sumOfSquaresv2 [1..10]
    • 385
  • 58. Foldl (Haskell)
    • myReverse xs = foldl (x y -> y:x) [] xs
    • myReverse [1,2,3]
    • foldl (x y -> y:x) [] [1,2,3]
    • .. ([] 1 -> 1:[]) .. => [1]
    • foldl (x y -> y:x) [1] [2,3]
    • .. ([1] 2 -> 2:[1]) .. => [2,1]
  • 59. Exercise set 4c 5 minutes
  • 60. Answers to set 4c
  • 61. problem 1
    • var foldl = function (step, init, xs) {
    •      return( 
    •          empty(xs) ?  init   :
    •          foldl( step ,
    •                  step(init,first(xs)),
    •                  rest(xs)
    •      );
    • };
  • 62. problem 2
    • var sum = function(xs) {
    •      return  foldl(add,0,xs);
    • };
  • 63. Map (JavaScript) 'The Spolsky Map' function spolsky_map(fn, a)     {         for (i = 0; i < a.length; i++)         {             a[i] = fn(a[i]) ;         }     } note the side effects
  • 64. The Spolsky Reduce (foldl) function spolsky_reduce(fn, a, init)     {         var s = init;         for (i = 0; i < a.length; i++)             s = fn( s, a[i] );         return s;     }
  • 65. Break 5 minutes
  • 66. Exercise 5a 5 minutes
  • 67. Answers to set 5a
  • 68. problem 1
    • var last = compose(first,reverse);
  • 69. problem 2
    • var reverse = function (xs) {
    •      return foldl(flip(build),[ ],xs);
    • };
  • 70. Standard Deviation
    • 1. calculate the arithmetic mean of the list
    • 2. subtract the mean from all the numbers in the list
    • 3. square the number in that list
    • 4. calculate the sum of the list
    • 5. divide the sum by length of list by 1
    • 6. get the square root of this number 
  • 71. Standard Deviation
    • 1. calculate the arithmetic mean of the list
    • mean xs = sum xs / fromIntegral(length xs)
    • 2. subtract the mean from all the numbers in the list
    • deviations xs = map (x -> x - m ) xs
    •                  where m = mean xs
    • 3. square the numbers in that list
    • squareDeviations xs = map(^2) devs
    •                        where devs = deviations xs
    • 4. calculate the sum of the list sumSquareDeviations xs = (sum .
    • squareDeviations) xs
    • 5. divide the sum by length of list minus 1
    • 6. get the square root of this number 
    • sd xs = sqrt $ sumSqDev / lsub1
    •   where sumSqDev = sumSquareDeviations xs
    •        lsub1 = fromIntegral $ ((-1+) . length)xs
  • 72. Exercise 5b 10 minutes
  • 73. Answers to set 5b
  • 74. Standard Deviation (JavaScript)
    • var mean = function (xs){
    •      return(sum(xs)/flength(xs));
    • };
    • var deviations = function (xs) {
    •      var m = mean(xs);//we can remove this 
    •      return  map(function(x){return x-m;},xs);
    • };
    • var squareDeviations = function(xs){
    •      return  map(square,deviations(xs));
    • };
  • 75. Standard Deviation (JavaScript)
    • var sumSqDeviations = compose(sum,squareDeviations);
    • var sd = function(xs){
    •      return  Math.sqrt(     (sumSqDeviations(xs)/(length(xs)-1)));
    • };
  • 76. Standard Deviation
    • Haskell
    • > sd [1,4,5,9,2,10]
    • 3.65604522218567
    • JavaScript
    • > sd([1,4,5,9,2,10]);
    • 3.65604522218567
  • 77. Function Currying
  • 78. Currying (Haskell)
    • myAdd x y = x + y
    • add8 = myAdd 8
    • add9  = (+9)
    • > myAdd 8 9
    • 17
    • > add8 9
    • 17
    • > add9 8
    • 17
  • 79. Currying (JavaScript)
    • var curry = function (f,a) {
    •      return(
    • function(){
    •      var args =  Array.prototype.slice.call(arguments);  
    •      args.unshift(a);
    •      return f.apply(this, args);
    • }
    •      );
    • };
  • 80. Currying (JavaScript) purely functional
    • var curry = function (f,a) {
    •      return(
    • function(){
    •     return(
    • ( function( args ){
    •     return f.apply(this, build(a,args));
    • } )
    • (Array.prototype.slice.call(arguments))
    •     );
    • }
    •      );
    • };
  • 81. Currying (JavaScript) 
    • var add_three = function(a,b,c){
    •      return a+b+c;
    • };
    • >f1 = curry(add_three,1);
    • >f1(2,3)
    • 6
    • >f2 = curry(curry(add_three,1),2);
    • >f2(3)
    • 6
  • 82. Exercise 6 10 minutes
  • 83. Answers to set 6
  • 84. problem 1
    • var makeAdder = curry(add,x);
    • var apiClosure = curry(apiSearch,apiKey);
  • 85. problem 2
    • var unrealisticFunction = function (a, b){
    •      (function(c){
    •          return((function(d){
    •                                  if(c<d){
    •                                            return c+d;
    •                                            }else{
    •                                            return c*d;
    •                                            }
    •                      };)(c+a)
    •          );
    •      })(a*b)
    • };
  • 86. Thanks! email: wckurt@gmail.com twitter: willkurt
  • 87. Still have time? awesome!
  • 88. Haskell vs JavaScript
  • 89. Types!!!
    • areaOfTrapezoid :: Float -> Float -> Float -> Float
    • areaOfTrapezoid h b1 b2 = 0.5*h*(b1+b2)
    • evenList :: (Integral a) => [a] -> [a]
    • evenList xs  = filter even xs
  • 90. Lazy Evaluation!!!
    •   [2,4..] !! 108
    • > 218
  • 91. Pattern Matching
    • patternMatch [a,b,c] = b ++ c ++ a
    • patternMatch [a,b] = a ++ b
    • patternMatch [] = &quot;no list&quot;
    • patternMatch as = &quot;a larger list&quot;
  • 92. Pattern Matching
    • patternMatch [&quot;a&quot;,&quot;b&quot;,&quot;c&quot;]
    • >&quot;bca&quot;
    • patternMatch [&quot;a&quot;,&quot;b&quot;]
    • >&quot;ab&quot;
    • patternMatch [ ]
    • >&quot;no list&quot;
    • patternMatch [&quot;a&quot;,&quot;b&quot;,&quot;c&quot;,&quot;d&quot;]
    • >&quot;a larger list&quot;
  • 93. Who actually uses this stuff? http://cufp.org/
  • 94. Ocaml
  • 95.  
  • 96.  
  • 97. more @ http://www.scala-lang.org/node/1658
  • 98. Haskell
  • 99. ... continued more @ http://haskell.org/haskellwiki/Haskell_in_industry