Lambda in different languages

Transcription

1 Lambda in different languages A simple example of a higher order function in Racket 1 ( define (f g) (g 2 3)) ( define ( square n) (* n n)) ( test (f +) 5) ( test (f *) 6) ( test (f ( lambda (x y) (+ ( square x) ( square y)))) 13)

2 The same example can be written in JavaScript like this: 2 function f(g) { return g (2,3) ; } function square (x) { return x*x; } console. log (f( function (x,y) { return square (x) + square (y); })); In Perl: 3 sub f { my ( $g) return $g - >(2,3) ; } sub square { my ( $x) return $x * $x; } print f( sub { my ($x, $y) return square ( $x) + square ( $y); });

3 In Ruby: 4 def f(g) g. call (2,3) end def square (x) x*x end puts f( lambda { x,y square (x) + square (y)}); Recent versions of C++ and Java also have lambda http: //www2.research.att.com/~bs/c++0xfaq.html#lambda

4 Using Functions as Objects Using higher order functions to mimic accessors/attributes 5 ( define (f x) ( lambda () x)) ( define a (f 2)) (a) ; 2 ( define b (f 3)) (b) ; 3

5 Why stop at one level? 6 ( define aa (f a)) (aa) ; #< procedure > ( this is a) (( aa)) ; 2

6 Making pairs out of functions 7 ( define ( kons x y) ( lambda (b) (if b x y))) ( define ( furst x) (x #t)) ( define ( rust x) (x #f)) ( define a ( kons 1 'alpha )) ( define b ( kons 'beta 4)) ( test ( furst a) 1) ( test ( rust b) 4) ( test ( rust a) 'alpha )

7 We can replace the if with more function shenanigans: 8 ( define ( kons x y) ( lambda (s) (s x y))) ( define ( furst x) (x ( lambda (x y) x))) ( define ( rust x) (x ( lambda (x y) y))) ( define a ( kons 1 'alpha )) ( define b ( kons 'beta 4)) ( test ( furst a) 1) ( test ( rust b) 4) ( test ( rust a) 'alpha )

8 Using our new data structures : 9 ( define numlst ( kons 1 ( kons 2 ( kons 3 #f)))) ( define ( sum lst ) (if lst (+ ( furst lst ) ( sum ( rust lst ))) 0)) ( test ( sum numlst ) 6)

9 Let s try to add types 10 ( define ( kons [x : 'a] [y : 'b]) : (( 'a 'b -> 'c) -> 'c) ( lambda (s) (s x y))) ( define ( furst x) (x ( lambda (x y) x))) ( define ( rust x) (x ( lambda (x y) y))) ( define pair ( kons 1 2)) ( test ( furst pair ) 1) ( test ( rust pair ) 2) ; trouble ( define lst ( kons 1 #f))

10 Maybe the types are more tractable with the if version 11 ( define ( kons x y) ( lambda (b) (if b x y))) ( define ( furst x) (x #t)) ( define ( rust x) (x #f)) ; what is the type of kons now? ( define lst ( kons 1 #f))

11 Finally in JavaScript: 12 function kons (x,y) { return function (s) { return s(x, y); } } function furst (x) { return x( function (x,y){ return x; }); } function rust (x) { return x( function (x,y){ return y; }); } a = kons (1,2) ; b = kons (3,4) ; console. log ('a=<'+ furst (a)+','+ rust (a)+'>'); console. log ('b=<'+ furst (b)+','+ rust (b)+'>');

12 Finally in JavaScript: function kons (x,y) { return function (s) { return s(x, y); } } function furst (x) { return x( function (x,y){ return x; }); } function rust (x) { return x( function (x,y){ return y; }); } a = kons (1,2) ; b = kons (3,4) ; console. log ('a=<'+ furst (a)+','+ rust (a)+'>'); console. log ('b=<'+ furst (b)+','+ rust (b)+'>'); 1. So there might be a reason the type system includes a listof primitive

13 Currying A curried function is a function that accepts one argument and returns a function that accepts the rest. common with H.O. functions like map, where we want to fix one argument. 13 ( define ( plus [x : number ]) : ( number -> number ) ( lambda (y) (+ x y))) ( map ( plus 1) ( list 1 2 3))

14 Currying A curried function is a function that accepts one argument and returns a function that accepts the rest. common with H.O. functions like map, where we want to fix one argument. 13 ( define ( plus [x : number ]) : ( number -> number ) ( lambda (y) (+ x y))) ( map ( plus 1) ( list 1 2 3)) 1. See also tutorial 6

15 It s easy to write functions for translating between normal and curried versions. 14 ;; convert a 2- argument function to a curried one ( define ( currify [f : ('a 'b -> 'c)]) : ('b -> 'c) ( lambda (x) ( lambda (y) (f x y)))) ( define plus ( currify +)) ( test (( plus 1) 2) 3) ( test ( map ( plus 1) ( list 1 2 3)) ( list 2 3 4)) ( test ( map (( currify +) 1) ( list 1 2 3)) ( list 2 3 4))

16 When dealing with such higher-order code, the types are very helpful, since every arrow corresponds to a function: 15 ( has-type currify : (( 'a 'b -> 'c) -> ('a -> ('b -> 'c))))

17 The examples of Tutorial 6 (plotting with combinators) simulate run time code generation. there are some situations where we can essentially memoize when using curried functions. Suppose we want a function that receives two inputs x,y and returns fib(x)*y. We use a slow fib, to make a point. 16 ( define ( fib n) (if (<= n 1) n (+ ( fib (- n 1)) ( fib (- n 2)))))

18 The function we want is: 17 ( define ( bogus x y) (* ( fib x) y)) If we currify it as usual, we get: 18 ( define ( bogus x) ( lambda (y) (* ( fib x) y)))

19 And try this several times: 19 ( define bogus30 ( bogus 30) ) ( time ( map bogus30 ( build- list 40 ( lambda ( x) x)))) But in the definition of bogus, notice that (fib x) does not depend on y so we can rewrite it a little differently: 20 ( define ( bogus x) ( let ([ fibx ( fib x)]) ( lambda (y) (* fibx y))))

20 and trying the above again is much faster now: 21 ( define bogus30 ( bogus 30) ) ( time ( map bogus30 ( build- list 40 ( lambda ( x) x))))