A monolithic recursive solu#on A monolithic solu#on that counts up - PowerPoint PPT Presentation

Mo#va#ng problem: ssm35 (sum-of-squares-of-multiples-of-3-or-5 n) Compositional Programming Return the sum of the squares of the all the mul#ples of 3 and 5 between 1 and n, inclusive. Since sum-of-squares-of-multiples-of-3-or-5 is a very long name, we’ll abbreviate it to ssm35 . For example, what should (ssm35 10) return? CS251 Programming Languages Fall 2016, Lyn Turbak Department of Computer Science Wellesley College Composition 2 A monolithic recursive solu#on A monolithic solu#on that counts up This starts at n, counts down to 0, and then This version uses a helper function to generate the numbers from sums up the squares of the multiples of 3 and 5 1 up to n. But it sums the squares from highest to lowest rather on the way out of the recursion. than lowest to highest. (define (ssm35-monolithic-count-up n) (define (ssm35-monolithic-count-down n) (define (helper num) (if (= n 0) (if (> num n) 0 0 (if (or (divisible-by? n 3) (if (or (divisible-by? num 3) (divisible-by? n 5)) (divisible-by? num 5)) (+ (* n n) (+ (* num num) (ssm35-monolithic-count-down (- n 1))) (helper (+ num 1))) (ssm35-monolithic-count-down (- n 1))))) (helper (+ num 1))))) (helper 1)) > (ssm35-monolithic-count-down 10) 251 > (ssm35-monolithic-count-up 10) 251 Composition 3 Composition 4

Signal-processing style of programming Composi#on in Racket This version decomposes the problem into steps that generate, (define (o f g) map, filter, and accumulate intermediate lists. It uses higher- ( λ (x) (f (g x)))) order list operators to manipulate the lists. (define (inc x) (+ x 1)) (define (ssm35-holo n) (define (dbl y) (* y 2)) (foldr + 0 (map ( λ (x) (* x x)) > ((o dbl inc) 5) (filter ( λ (num) (or (divisible-by? num 3) (divisible-by? num 5))) > ((o inc dbl) 5) (range 1 (+ n 1)))))) > (ssm35-holo 10) 251 Composition 5 Composition 6 Composi#on style of programming The iden#ty func#on id (define id ( λ (x) x))) (define ssm35-compose (o ( λ (squares) > ((o id inc) 5) (foldr + 0 squares)) (o ( λ (filtered-nums) > ((o dbl id) 5) (map ( λ (x) (* x x)) filtered-nums)) (o ( λ (nums) (filter ( λ (num) (or (divisible-by? num 3) (divisible-by? num 5))) nums)) (o ( λ (hi) (range 1 hi)) inc))))) > (ssm35-compose 10) 251 Composition 7 Composition 8

Composing lists of func#ons ssm35 with o-list (define ssm35-compose-list (define (o-list funlist) (o-list (list ( λ (squares) (foldr o id funlist)) (foldr + 0 squares)) ( λ (filtered-nums) (define (dbl x) (* x 2)) (map ( λ (x) (* x x)) filtered-nums)) (define (inc y) (+ y 1)) ( λ (nums) (define (sq z) (* z z)) (filter ( λ (num) (or (divisible-by? num 3) (divisible-by? num 5))) nums)) > ((o-list (list dbl inc sq)) 5) ( λ (hi) (range 1 hi)) inc))) > (ssm35-compose-list 10) 251 Composition 9 Composition 10 Recall Currying Racket’s built-in curry func#on A curried binary func#on takes one argument at a #me. > (((curry *) 2) 5) (define (curry2 binop) 10 ( λ (x) ( λ (y) (binop x y))) > ((curry * 2) 5) (define curried-mul (curry2 *)) 10 > ((curried-mul 5) 4) Haskell Curry > (map (curry * 3) '(7 2 5)) '(21 6 15) > (my-map (curried-mul 3) (list 1 2 3)) > (define (triple a b c) (list a b c)) > (my-map ((curry2 pow) 4) (list 1 2 3)) > (map (curry triple 1 2) '(7 2 5)) > (my-map ((curry2 (flip2 pow)) 4) (list 1 2 3)) '((1 2 7) (1 2 2) (1 2 5)) > (define lol (list (list 2 3) (list 4) (list 5 6 7))) > (map (curry triple 8 9) '(7 2 5)) > (map ((curry2 cons) 8) lol) '((8 9 7) (8 9 2) (8 9 5)) > (map (??? 8) lol) > (map (curry triple 8) '(7 2 5)) ‘((2 3 8) (4 8) (5 6 7 8)) '(#<procedure:curried> #<procedure:curried> #<procedure:curried>) Composition 11 Composition 12

Uncurrying (no built-in Racket func#on) Defining func#ons without any λ s (define map-scale (define (uncurry2 curried-binop) (uncurry2 (o (curry2 map) (curry2 *)))) ( λ (x y) ((curried-binop x) y))) > (define curried-* (curry2 *)) > (map-scale 5 (range 10)) '(0 5 10 15 20 25 30 35 40 45) > (map (curried-* 3) (range 10)) '(0 3 6 9 12 15 18 21 24 27) (define map-cons > (define mul (uncurry2 curried-*)) (uncurry2 (o (curry2 map) (curry2 cons)))) > (mul 3 4) > (map-cons 17 '((1 2 3) (4) () (5 6))) 12 '((17 1 2 3) (17 4) (17) (17 5 6)) (define (uncurry3 curried-ternop) ( λ (x y z) (((curried-ternop x) y) z))) Composition 13 Composition 14 Some#mes argument flipping is helpful Handling func#ons using same arg > once (define (flip2 binop) (define (dup-arg curried-binop) ( λ (x y) (binop y x))) ( λ (x) ((curried-binop x) x))) > (filter ((curry2 divisible-by?) 5) > ((dup-arg (curry2 *)) 5) (range 1 21)) '(1 5) > (filter ((curry2 (flip2 divisible-by?)) 5) (range 1 21)) '(5 10 15 20) Composition 15 Composition 16

and and or need special handling (why?) o-and and o-or > (((curry2 and) (> 251 100)) (divisible-by? 251 3)) (define (o-and f g) and: bad syntax in: and ( λ (x) (and (f x) (g x)))) > (((curry2 ( λ (b1 b2) (and b1 b2))) (> 251 100)) (define (o-or f g) (divisible-by? 251 3)) ( λ (x) (or (f x) (g x)))) #f > ((o-and ( λ (n) (> n 100)) > (((curry2 ( λ (b1 b2) (and b1 b2))) (< 251 100)) ( λ (n) (divisible-by? n 3))) (divisible-by? 251 0)) 251) remainder: undefined for 0 #f > ((o-and ( λ (n) (< n 100)) ( λ (n) (divisible-by? n 0))) 251) #f Composition 17 Composition 18 Defining ssm35 without any λ s (define ssm35-no-lambdas (o-list (list (curry foldr + 0) ((curry2 map) (dup-arg (curry2 *))) ((curry2 filter) (o-or ((curry2 (flip2 divisible-by?)) 3) ((curry2 (flip2 divisible-by?)) 5))) ((curry2 range) 1) ((curry2 +) 1)))) > (ssm35-no-lambdas 10) 251 Composition 19