title: CS450 layout: true author: Tiago Cogumbreiro lecture: 4 abstract: Recursion, nested definitions sep: &nbsp;☽&nbsp; <img id="logo" src="data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8"?>
<svg id="a" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 124.8 59.6"><defs><style>.b{fill:#005a8b;}</style></defs><path class="b" d="M6.45,43.91c1.38,0,2.52-.32,3.4-.97,.88-.65,1.32-1.52,1.32-2.61,0-.78-.27-1.47-.81-2.05-.54-.58-1.25-.95-2.15-1.09,1.69-.51,2.53-1.52,2.53-3.03,0-.95-.37-1.71-1.12-2.27-.75-.56-1.81-.84-3.19-.84H.28v12.85H6.45Zm-3.38-10.54h2.94c.65,0,1.14,.11,1.46,.32,.32,.21,.49,.57,.49,1.06,0,.93-.65,1.4-1.95,1.4H3.07v-2.77h0Zm0,5.01h2.97c1.49,0,2.24,.54,2.24,1.62s-.75,1.6-2.24,1.6H3.07v-3.21h0Zm10.7,4.43c.92,.92,2.07,1.39,3.45,1.39s2.59-.45,3.49-1.34c.89-.89,1.34-2.07,1.34-3.54s-.45-2.62-1.35-3.52c-.9-.9-2.06-1.35-3.48-1.35s-2.56,.45-3.47,1.35c-.91,.9-1.36,2.07-1.36,3.52s.46,2.57,1.38,3.5h0Zm3.45-.69c-.66,0-1.18-.24-1.55-.71-.37-.47-.56-1.16-.56-2.07s.19-1.61,.56-2.1c.37-.5,.89-.74,1.55-.74s1.18,.25,1.55,.74c.37,.5,.56,1.2,.56,2.1s-.19,1.59-.56,2.07c-.37,.47-.89,.71-1.55,.71h0Zm7.26,1.32c.8,.48,1.75,.72,2.84,.72,1.32,0,2.36-.27,3.12-.82,.76-.54,1.14-1.28,1.14-2.21,0-1.51-1.05-2.46-3.16-2.86l-1.27-.24c-.49-.09-.82-.19-1-.32-.18-.13-.27-.32-.27-.58s.11-.48,.34-.64c.23-.16,.55-.24,.96-.24,.92,0,1.54,.43,1.85,1.29l2.15-.97c-.25-.58-.7-1.07-1.37-1.49-.67-.42-1.5-.62-2.51-.62-1.21,0-2.17,.26-2.88,.79-.71,.53-1.06,1.23-1.06,2.11s.24,1.48,.73,1.89c.48,.42,1.26,.73,2.32,.94l1.3,.26c.42,.09,.71,.21,.88,.36,.17,.15,.26,.36,.26,.62s-.13,.49-.38,.66c-.25,.17-.59,.26-1.02,.26-.77,0-1.29-.17-1.56-.51-.28-.36-.46-.7-.53-1.03l-2.37,.75c.18,.8,.68,1.43,1.48,1.91h0Zm9.98-.2c.42,.44,.99,.66,1.71,.66h3.07v-2.07h-1.98c-.28,0-.49-.06-.62-.19-.13-.13-.19-.33-.19-.62v-4.31h2.39v-1.98h-2.39v-2.88h-2.61v2.88h-1.93v1.98h1.93v4.79c0,.72,.21,1.3,.62,1.74h0Zm6.76-.43c.92,.92,2.07,1.39,3.45,1.39s2.59-.45,3.49-1.34c.89-.89,1.34-2.07,1.34-3.54s-.45-2.62-1.35-3.52c-.9-.9-2.06-1.35-3.48-1.35s-2.56,.45-3.47,1.35c-.91,.9-1.36,2.07-1.36,3.52s.46,2.57,1.38,3.5h0Zm3.45-.69c-.66,0-1.18-.24-1.55-.71-.37-.47-.56-1.16-.56-2.07s.19-1.61,.56-2.1c.37-.5,.89-.74,1.55-.74s1.18,.25,1.55,.74c.37,.5,.56,1.2,.56,2.1s-.19,1.59-.56,2.07c-.37,.47-.89,.71-1.55,.71h0Zm9.16,1.78v-4.35c0-1.15,.2-1.97,.61-2.46,.27-.33,.68-.5,1.23-.5,.98,0,1.47,.58,1.47,1.73v5.58h2.61v-6.15c0-1.05-.25-1.87-.76-2.44-.51-.58-1.26-.86-2.27-.86-1.28,0-2.27,.56-2.96,1.69v-1.41h-2.53v9.18h2.61Z"/><path class="b" d="M1.86,25.7c1.05,.95,2.44,1.43,4.19,1.43s3.1-.48,4.17-1.43c1.06-.95,1.6-2.25,1.6-3.87v-7.84h-2.79v7.4c0,2.24-.99,3.36-2.97,3.36-.98,0-1.72-.28-2.22-.85-.5-.57-.75-1.4-.75-2.51v-7.4H.29v7.84c0,1.63,.52,2.92,1.57,3.87h0Zm15.5,1.14v-10.46l3.54,10.46h2.48l3.58-10.48v10.48h2.79V13.99h-4.41l-2.15,6.26c-.4,1.21-.73,2.12-.97,2.74-.24-.61-.57-1.52-.97-2.74l-2.11-6.26h-4.57v12.85h2.79Zm15.13-.44c.55,.49,1.24,.73,2.07,.73,1.38,0,2.43-.54,3.14-1.63,.1,.89,.65,1.34,1.65,1.34h2v-1.98h-.81c-.25,0-.4-.03-.46-.09-.06-.06-.09-.21-.09-.46v-3.36c0-1.17-.35-2.06-1.06-2.66-.7-.6-1.72-.9-3.04-.9-1.25,0-2.27,.28-3.06,.83-.79,.55-1.22,1.21-1.29,1.98l2.35,.51c.23-.97,.91-1.45,2.02-1.45,1,0,1.51,.42,1.51,1.27v.35c-.89,.09-1.67,.21-2.32,.36-.65,.15-1.25,.36-1.78,.63-.53,.27-.94,.62-1.22,1.06-.28,.44-.43,.96-.44,1.56,0,.78,.28,1.42,.83,1.91h0Zm4.39-1.73c-.37,.37-.83,.55-1.38,.55-.8,0-1.19-.33-1.19-.99,0-.54,.26-.93,.77-1.17,.51-.24,1.3-.43,2.35-.57v.59c0,.7-.18,1.23-.55,1.6h0Zm6.38,1.71c.8,.48,1.75,.72,2.84,.72,1.32,0,2.36-.27,3.12-.82,.76-.54,1.14-1.28,1.14-2.21,0-1.51-1.05-2.46-3.16-2.86l-1.27-.24c-.49-.09-.82-.19-1-.32-.18-.13-.27-.32-.27-.58s.11-.48,.34-.64c.23-.16,.55-.24,.96-.24,.92,0,1.54,.43,1.85,1.29l2.15-.97c-.24-.58-.7-1.07-1.37-1.49-.67-.42-1.5-.62-2.51-.62-1.21,0-2.17,.26-2.88,.79-.71,.53-1.07,1.23-1.07,2.11s.24,1.47,.72,1.89c.48,.42,1.26,.73,2.32,.94l1.3,.26c.42,.09,.71,.21,.88,.36,.17,.15,.26,.36,.26,.62s-.13,.49-.38,.66c-.25,.17-.59,.26-1.02,.26-.77,0-1.29-.17-1.56-.51-.28-.35-.46-.7-.53-1.03l-2.37,.75c.18,.8,.68,1.43,1.48,1.91h0Zm9.45,0c.8,.48,1.75,.72,2.84,.72,1.32,0,2.36-.27,3.12-.82,.76-.54,1.14-1.28,1.14-2.21,0-1.51-1.05-2.46-3.16-2.86l-1.27-.24c-.49-.09-.82-.19-1-.32-.18-.13-.27-.32-.27-.58s.11-.48,.34-.64c.23-.16,.55-.24,.96-.24,.92,0,1.54,.43,1.85,1.29l2.15-.97c-.24-.58-.7-1.07-1.37-1.49-.67-.42-1.5-.62-2.51-.62-1.21,0-2.17,.26-2.88,.79-.71,.53-1.07,1.23-1.07,2.11s.24,1.47,.73,1.89c.48,.42,1.26,.73,2.32,.94l1.3,.26c.42,.09,.71,.21,.88,.36,.17,.15,.26,.36,.26,.62s-.13,.49-.38,.66c-.25,.17-.59,.26-1.02,.26-.77,0-1.29-.17-1.56-.51-.28-.35-.46-.7-.53-1.03l-2.37,.75c.18,.8,.68,1.43,1.48,1.91h0Z"/><path class="b" d="M123.56,37.95c0-5.44,0-10.89,0-16.33,0-.53-.02-1.06-.04-1.6-.05-1.15-.22-2.29-.47-3.41-1.66-7.41-7.23-13.36-14.5-15.5-1.66-.49-3.36-.78-5.1-.82-.54-.01-1.08,0-1.62,0h-36.56v.4c0,7.18,0,14.36,0,21.54,0,5.25,0,10.51,0,15.76,0,.66,.04,1.33,.08,1.99,.09,1.32,.34,2.61,.69,3.88,1.78,6.46,6.71,11.78,13,14.06,2.38,.86,4.83,1.26,7.36,1.26,5.2,0,10.4,0,15.6,0,.84,0,1.67-.04,2.51-.09,1.04-.06,2.06-.24,3.07-.49,5.22-1.32,9.35-4.21,12.39-8.64,1.68-2.44,2.74-5.14,3.27-8.06,.23-1.3,.32-2.61,.32-3.93h0Zm-20.01-23.79c-.03,.87-.12,1.72-.34,2.56-.3,1.19-.83,2.26-1.68,3.15-.68,.72-1.5,1.24-2.41,1.63-1.07,.46-2.19,.73-3.35,.89-1.26,.18-2.53,.22-3.81,.21-.63,0-1.26,0-1.88,0h-.31V8.19c0-.63,.01-1.26,.11-1.88,.02-.11,.04-.22,.06-.33,.08-.44,.33-.72,.78-.85,.55-.16,1.12-.29,1.69-.34,.67-.06,1.34-.1,2.01-.1,1.32,0,2.62,.18,3.88,.64,2.44,.88,4.03,2.58,4.79,5.06,.38,1.23,.5,2.49,.45,3.77h0Zm2.39,20.48c.32,1.32,.41,2.67,.33,4.02-.06,1.11-.24,2.2-.61,3.25-.87,2.48-2.55,4.2-4.94,5.25-1.01,.44-2.07,.73-3.16,.89-.94,.15-1.89,.22-2.84,.19-.87-.03-1.74-.09-2.58-.35-.94-.29-1.57-.9-1.9-1.83-.23-.66-.35-1.35-.4-2.05-.04-.7-.07-1.39-.07-2.09,0-4.75,0-9.49,0-14.24v-.4c.12,0,.21-.01,.29-.01,1.12,0,2.23-.01,3.35,.01,2.02,.05,4.01,.29,5.95,.88,.99,.3,1.93,.7,2.81,1.25,1.97,1.22,3.2,2.97,3.75,5.21h0Zm15.64,3.79c-.04,4.84-1.74,9.07-5.01,12.64-2.57,2.81-5.72,4.67-9.42,5.58h0c-.91,.23-1.84,.4-2.78,.45-.71,.04-1.43,.09-2.14,.09-5.35,0-10.7,.01-16.05,0-3.78,0-7.26-1.05-10.41-3.13-1.68-1.11-3.14-2.46-4.4-4.04-1.03-1.29-1.63-2.77-1.89-4.4-.18-1.13-.22-2.26-.12-3.39,.1-1.16,.24-2.32,.36-3.49,.12-1.11,.25-2.22,.39-3.33,.13-1.1,.26-2.2,.39-3.3,.11-.96,.22-1.92,.34-2.88,.11-.95,.23-1.9,.34-2.86,.11-.96,.23-1.92,.34-2.88,.11-.95,.23-1.9,.34-2.86,.08-.65,.15-1.3,.24-1.95,.03-.19-.03-.32-.18-.44-.38-.3-.75-.63-1.13-.93-.12-.09-.18-.2-.18-.35,0-.89,0-2.67,0-2.67v-.27h2.45v-4.6h-1.2s2.78-2.17,4.08-3.14c.13-.1,.29-.34,.29-.54-.01-.8,0-1.56,0-2.36,0-.08,0-.16,0-.24,.02-.11,.08-.19,.18-.22,.03-.01,.06-.02,.1-.02,.14,0,.25,.09,.27,.23,.01,.08,0,.16,0,.23,0,.82,.02,1.54,0,2.36,0,.2,.14,.44,.27,.54,1.29,.96,4.11,3.14,4.11,3.14h-1.2v4.6h2.46s0,.29,0,.69c0,.58,0,1.62,0,2.24,0,.14-.05,.24-.16,.34-.41,.33-.8,.67-1.21,1-.12,.09-.16,.19-.14,.34,.1,.87,.19,1.73,.29,2.6,.1,.88,.19,1.75,.28,2.63,.1,.89,.2,1.79,.29,2.68,.09,.88,.19,1.75,.28,2.63,.1,.89,.19,1.79,.29,2.68,.1,.88,.19,1.75,.28,2.63,.1,.9,.2,1.8,.29,2.7,.09,.88,.19,1.75,.28,2.63,.1,.89,.19,1.79,.29,2.68,.09,.88,.19,1.75,.28,2.63,.12,1.13,.19,2.28,.47,3.39,.09,.35,.19,.71,.32,1.05,.5,1.35,1.44,2.26,2.78,2.76,.74,.27,1.51,.43,2.29,.52,1.19,.13,2.38,.2,3.58,.15,1.26-.05,2.53-.1,3.79-.2,1.88-.16,3.73-.45,5.55-.92,.61-.16,1.21-.33,1.81-.53,2.11-.7,4.08-1.66,5.86-3,1.92-1.44,3.48-3.19,4.54-5.36,.68-1.41,1.09-2.9,1.25-4.46,.2-1.97,.04-3.9-.6-5.78-.76-2.22-2.12-4-3.99-5.42-1.48-1.12-3.12-1.91-4.86-2.5-.49-.17-1-.31-1.5-.47-.08-.03-.16-.05-.31-.09,.13-.07,.21-.11,.29-.15,1.17-.55,2.28-1.21,3.29-2.02,2.31-1.84,3.8-4.19,4.28-7.12,.52-3.13,.03-6.1-1.62-8.84-.1-.16-.22-.34-.36-.53-.83-1.06-2.26-2.39-2.3-2.46,.08,.02,.16,.04,.24,.07,5.41,1.89,9.26,5.47,11.54,10.73,.66,1.53,1.08,3.13,1.29,4.78,.1,.77,.16,1.55,.16,2.32,.01,5.8,.05,11.61,0,17.41h0ZM75,14.04s1.98,0,2.98,0c0-1.55,0-4.61,0-4.61h-2.98v4.6h0Zm42.41,45.14v-2.54h.95v-.34h-2.28v.34h.95v2.54h.38Zm1.7,0v-2.45l.83,2.45h.34l.84-2.41v2.41h.37v-2.88h-.51l-.69,2c-.07,.2-.12,.36-.15,.46-.03-.09-.07-.24-.14-.43l-.68-2.04h-.57v2.88h.37Z"/></svg>" height="64" /> .bottom-bar[ {{title}} {{sep}} {{abstract}} {{sep}} Lecture {{lecture}} {{sep}} {{author}} ] --- class: middle # {{title}} ## Structure of Higher Level Languages ### Lecture {{lecture}}: {{abstract}} ### {{author}} --- class: impact # Exercises with lists --- class: full # A template of recursion .col-6[ ### Copying a list ```scheme (define (copy l) (match l [(list) ; input = '() `(list)` ; expected output = '() ] [(cons h l) ; input = (list 1 2 3) ; h = 1 ; l = (list 2 3) (define result (copy l)) ; result = (list 2 3) `(cons h result)` ; expected output = (list 1 2 3) ])) ``` ] .col-6[ ### Notes - `(define (copy l) l)` would be a simpler solution, but we're trying to illustrate a **recursion pattern**. - Remember to write the expected inputs and outputs for a given example - **Part in yellow:** given the expected inputs, how would you build the expected output? ] --- # Lists: example 1 ### Summation of all elements of a list ## Spec ```scheme (require rackunit) (check-equal? 10 (sum-list (list 1 2 3 4))) (check-equal? 0 (sum-list (list))) ``` --- # Lists: example 1 ### Summation of all elements of a list <div class="col-7" markdown> ## Solution ```scheme (define (sum l) (match l [(list) ; input = '() `0`] ; expected output = 0 [(cons h l) ; input = '(1 2 3 4) ; h = 1 ; l = '(2 3 4) ; result = (sum (list 2 3 4)) = 2 + 3 + 4 = 9 (define result (sum l)) `(+ h result)` ])) ; expected output = (+ 1 9) = 10 ``` </div> .col-5[ ## Notes - We use the same pattern as in `copy` - Again, the expression being returned combines `h` and `result` ] --- # Spot the error! (#1) ```scheme #lang racket (define (sum-list l) (match l [empty 0] [(cons h l) (+ h (sum-list l))])) ``` --- # Spot the error! (#1) ```scheme #lang racket (define (sum-list l) (match l [`empty` 0] [(cons h l) (+ h (sum-list l))])) ``` - For `match` consider `empty` to be defined as `(define empty (list))`, not as a keyword - Pattern `empty` means: anything you find assign it to a variable called `empty`; same as writing `[x 0]` - The first branch matches with anything you give it, so this function never recurses --- # Spot the error! (#2) ```scheme #lang racket (define (sum-list l) (match l [(list) 0] [(cons h t) (+ h (sum-list l))])) ``` --- # Spot the error! (#2) ```scheme #lang racket (define (sum-list l) (match l [(list) 0] [(cons h t) (+ h (sum-list `l`))])) ``` - We wanted to recurse on `t`, but instead recursed on the original list `l` - This leads to an **infinite loop** - **Good practice:** use `l` as the rest of the list, and make this error impossible. --- # Spot the error! (#3) ```scheme #lang racket (define (sum-list l) (match l [(list) 0] [(h l) (+ h (sum-list l))])) ``` --- # Spot the error! (#3) ```scheme #lang racket (define (sum-list l) (match l [(list) 0] [(h l) (+ h (sum-list l))])) ``` - We forgot to specify the data-type `cons` in the second pattern - Racket will raise an exception notifying us that the pattern is incorrect ```scheme ex.rkt:5:5: match: syntax error in pattern in: (h l) location...: ex.rkt:5:5 ``` --- # Lists: example 2 ### Returns a list from n down to 1 ## Spec ```scheme (require rackunit) (check-equal? (list) (count-down 0)) (check-equal? (list 3 2 1) (count-down 3)) ``` -- ## Solution ```scheme #lang racket (define (count-down n) (cond [(<= n 0) (list)] [else (cons n (count-down (- n 1)))])) ``` --- # Lists: example 3 ### Point-wise pairing of two lists ## Spec ```scheme (require rackunit) (check-equal? (list (cons 3 30) (cons 2 20) (cons 1 10)) (zip (list 3 2 1) (list 30 20 10))) (check-equal? (list (cons 3 30) (cons 2 20) (cons 1 10)) (zip (list 3 2 1) (list 30 20 10 `5 4 3 2 1`))) (check-equal? (list (cons 3 30) (cons 2 20) (cons 1 10)) (zip (list 3 2 1 `90 180 270`) (list 30 20 10))) ``` --- # Lists: example 3 ### Point-wise pairing of two lists -- ## Solution .col-6[ ```scheme #lang racket (define pair list) ; Encode a pair as a list (define (zip l1 l2) ``` ] -- .row[] .col-6[ ```scheme (match* (l1 l2) [((list) _) (list)] [(_ (list)) (list)] [((cons h1 l1) (cons h2 l2)) (cons (pair h1 h2) (zip l1 l2))])) ``` ] .col-6[ - Use `match*` to pattern match two values at once ] --- class: impact # Using nested definitions --- # Build a list from 1 up to n > Our goal is to build a list from 1 up to some number. > Here is a template of our function and a test case for > us to play with. For the sake of simplicity, we will > not handle non-positive numbers. ```scheme #lang racket (define (countup-from1 x) #f) (require rackunit) (check-equal? (list 1) (countup-from1 1)) (check-equal? (list 1 2) (countup-from1 2)) (check-equal? (list 1 2 3 4 5) (countup-from1 5)) ``` > Hint: write a helper function `count` that builds > counts from `n` up to `m`. --- # Exercise 1: attempt #1 > We write a helper function `count` that builds counts from `n` up to `m`. ```scheme #lang racket (define (countup-from1 x) (count 1 x)) (define (count from to) (cond [(equal? from to) (list to)] [else (cons from (count (+ 1 from) to))])) ``` -- .space-top.center[ ## Let us refactor the code and hide function `count` ] --- # Exercise 1: attempt #2 > We move function `count` to be internal to function `countup-from1`, as it is > a helper function and therefore it is good practice to make it *private* to > `countup-from1`. ```scheme (define (countup-from1 x) ; Internally defined function, not visible from ; the outside * (define (count from to) * (cond [(equal? from to) (list to)] * [else (cons from (count (+ 1 from) to))])) ; The same call as before (count 1 x)) ``` --- # When to nest functions? Nest functions: * If they are unnecessary outside * If they are under development * If you want to hide them: **Every function in the public interface of your code is something you'll have to maintain!** --- class: full, center, middle # Intermission: # Nested definitions --- # Nested definition: local variables > Nested definitions bind a variable within the body of a function and are only visible within that function (these are local variables) ```scheme #lang racket (define (f x) (define z 3) (+ x z)) (+ 1 `z`) ; Error: z is not visible outside function f ``` --- # Nested definitions shadow other variables > Nested definitions silently shadow any already defined variable ```scheme #lang racket (define z 10) (define (f x) (define `x` 3) ; Shadows parameter (define `z` 20) ; Shadows global (+ x z)) (f 1) ; Outputs 23 ``` --- # No redefined local variables > It is an error to re-define local variables ```scheme #lang racket (define (f b) ; OK to shadow a parameter (define b (+ b 1)) (define a 1) ; Not OK to re-define local variables * ; Error: define-values: duplicate binding name (define a (+ a 1)) (+ a b)) ``` --- class: full, center, middle # Back to Exercise 1 --- # Exercise 1: attempt #2 > Notice that we have some redundancy in our code. > .alt[In function `count`, parameter `to` remains unchanged throughout execution.] ```scheme (define (countup-from1 x) ; Internally defined function, not visible from ; the outside (define (count from `to`) (cond [(equal? from to) (list to)] [else (cons from (count (+ 1 from) `to`))])) ; The same call as before (count 1 x)) ``` --- # Exercise 1: attempt #3 > We removed parameter `to` from function `count` as it > was constant throughout the execution. Variable `to` > is captured/copied when `count` is defined. ```scheme (define (countup-from1 to) ; Internally defined function, not visible from ; the outside (define (count from) (cond [(equal? from `to`) (list `to`)] [else (cons from (count (+ 1 from)))])) ; The same call as before (count 1)) ``` --- # Example 1: summary * Use a nested definition to hide a function that is only used internally. * Nested definitions can refer to variables defined outside the scope of their definitions. * The last expression of a function's body is evaluated as the function's return value --- class: impact # Measuring performance --- class: full, center, middle # Example 2 ## Maximum number from a list of integers --- # Example 2: attempt 1 > Finding the maximum element of a list. ```scheme #lang racket (define (max xs) (cond [(empty? xs) (error "max: expecting a non-empty list!")] [(empty? (rest xs)) (first xs)] ; The list only has one element (the max) [(> (first xs) (max (rest xs))) (first xs)] ; The max of the rest is smaller than 1st [else (max (rest xs))])) ; Otherwise, use the max of the rest ; A simple unit-test (require rackunit) (check-equal? 10 (max (list 1 2 10 4 0))) ``` > We use function `error` to abort the program with an exception. --- # Example 2: attempt 1 > Finding the maximum element of a list. Let us benchmark `max` with sorted list (worst-case scenario): * 20 elements: 18.43ms * 21 elements: 36.63ms * 22 elements: 75.78ms > Whenever we add an element we double the execution time. .alt[Why?] --- # Example 2: attempt 1 > Whenever we hit the else branch (because we can't find the maximum), > we re-compute the max element. ```scheme (define (max xs) (cond [(empty? xs) (error "max: expecting a non-empty list!")] [(empty? (rest xs)) (first xs)] ; The list only has one element (the max) [(> (first xs) `(max (rest xs))`) (first xs)] ; The max of the rest is smaller than 1st [else `(max (rest xs))`])) ; Otherwise, use the max of the rest ``` --- # Example 2: attempt 2 > We use a local variable to cache a duplicate computation. ```scheme (define (max xs) (cond [(empty? xs) (error "max: expecting a non-empty list!")] [(empty? (rest xs)) (first xs)] [else * (define rest-max (max (rest xs))) ; Cache the max of the rest * (cond * [(> (first xs) rest-max) (first xs)] * [else rest-max])])) ``` * Attempt #1: 20 elements in 75.78ms * Attempt #2: 1,000,000 elements in 101.15ms --- # Example 2 takeaways * Use nested definitions to cache intermediate results * Identify repeated computations and cache them in nested (local) definitions