title: CS450 layout: true author: Tiago Cogumbreiro lecture: 08 abstract: foldl, looping last-to-first; tail-recursion 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, full # {{title}} ## Structure of Higher Level Languages ### Lecture {{lecture}}: {{abstract}} ### {{author}} --- class: impact # Looping from last-to-first --- class: full, center, middle # Reversing a list --- # Exercise: write copy in terms of foldr .col-6[ ### Using our recursion pattern ```scheme (define (copy l) (match `l` ; (list 1 2 3) [(list) `(list)`] [(list h l ...) ; h = 1 ; l = (list 2 3) (define result (copy l)) ; result = (list 2 3) `(cons h result)` ; output = (list 1 2 3) ] )) ``` ] -- .col-6[ ### Using foldr ```scheme (define (copy-foldr l) (foldr ; step (lambda (h result) `(cons h result)` ) ; base-case `(list)` ; list we are iterating over `l` ) ) ``` ] --- # Reversing a list ## Aka copy in reverse .col-6[ ```scheme (define (reverse-copy l) (`foldr` ; step (lambda (h result) (cons h result) ) ; base-case (list) ; list we are iterating over l ) ) ``` ] .col-6[ - The difference between `foldr` and `foldl` is the traversal order - Copying is traversing last-to-first (since `cons` adds to the l-h-s) - Reversing is traversing first-to-last (first becomes last with `cons`) ] --- # Reversing ## Adding to the right-hand-side ```scheme (define (cons-right x l) ... ) ; x = 4 ; l = (list 1 2 3) ; output = (list 1 2 3 4) ``` --- # Reversing ## Adding to the right-hand-side .col-6[ ```scheme (define (cons-right x l) ; x = 4 ; l = (list 1 2 3) (match l [(list) (list x)] [(list h l ...) ; h = 1 ; l = (list 2 3) (define result (cons-right x l)) ; result = (list 2 3 4) (cons h result) ; output = (list 1 2 3 4) ] )) ``` ] .col-6[ ```scheme (define (reverse-slow l) (match l ; (list 1 2 3) [(list) (list)] [(list h l ...) ; h = 1 ; l = (list 2 3) (define result (reverse-slow l)) ; result = (list 3 2) (cons-right h result) ] ) ) ``` ] --- # Reversing ## Adding to the right-hand-side - The problem with `cons-right` is that it needs to traverse the whole list - Reversing effectively traverses the list $`\sum_{i \le n} i = \frac{(n - 1)n}{2}`$ times, thus makes a linear-time operation into quadratic! - <b>Can you implement `cons-right` and `reverse-slow` with either foldl or with foldr?</b> --- # Reversing a list Implement function `(reverse l)` that reverses a list. ### Spec ```scheme (check-equal? (list 4 3 2 1) (reverse (list 1 2 3 4))) ``` -- .col-6[ ### Solution .small[ ```scheme (define (reverse l) (define (rev accum l) (match l [(list) accum] [(list h l ...) (rev (cons h accum) l)])) (rev l (list))) ``` ] ] .col-6[ - We use a parameter `accum` as a "loop variable", that is, a variable that we update at each iteration. - The idea behind `rev` is that recursing can be thought of as "calling" the next iteration of the loop where we update the loop variables (ie, `accum` and `l` with their new respective values) ] --- class: full, center, middle # Joining strings in Racket --- # Joining strings in Python ```python >>> " + ".join(["x", "y", "z"]) "x + y + z" >>> " + ".join([]) "" >>> " + ".join(["x"]) "x" ``` --- # Joining strings in Racket ```scheme (require rackunit) (check-equal? (join ", " '("x" "y" "z")) "x, y, z") (check-equal? (join ", " '()) "") (check-equal? (join ", " '("x")) "x") ``` --- # Joining strings in Racket <div class="col-6" markdown> * **Separator as a suffix:**<br/> -- "x, y, z, " -- * **Separator as a suffix, but not on last:**<br/> -- "x, y, " + "z"<br/> .alt[How do you check the last?] -- * **Separator as a prefix:**<br/> -- ", x, y, z" -- * **Separator as a prefix, but not on first:**<br/> -- "x" + ", y, z" <br/> </div> --- # Separator as suffix .col-6.small[ ```scheme (define (join-suffix sep l) (match l [(list) ""] [(list x) x] [(list h l ...) (string-append h sep (join-suffix sep l)) ] ) ) ``` ] .col-6[ - We can use pattern `(list x)` to identify the *last element* - When we reach the last-element, we do not add a suffix - Otherwise, (third pattern) we suffix the element with the separator. - **Insight:** recursion+pattern matching lets us easily mention the last $k$ elements. - A problem of this solution is that it is less trivial to adapt it to `fold`s. ] --- # Separator as a prefix .col-6[ ```scheme (define (join-prefix sep l) (match l [(list) ""] [(list h l ...) (define (join-iter l) (match l [(list) ""] [(list h l ...) ; h = "b" ; l = (list "c") (string-append sep h (join-iter l)) ; output = ", b, c" ] ) ) (string-append h (join-iter l))])) ``` ] .col-6[ - If the list is empty, there is no separator to handle. - If the list is non-empty, we handle the first element differently, the rest of the list is handled recursively. - Recursively, traverse last-to-first, so add the separator as a prefix, in-order - **Try implementing `join-iter` with foldr!** ] --- # Separator as prefix <div class="col-6" markdown> ```scheme (define (join sep l) (define (join-iter accum l) (match l [(list) accum] [(list h l ...) (join-iter (string-append accum sep h) l)])) (match l [(list) ""] [(list h l ...) (join-iter h l)])) ``` </div> .col-6[ - This solution uses a parameter `accum` to build the list, rather than handling the result of recursion - This solution is more complicated, but faster (next lecture) ] --- # Imperative versus functional <div markdown class="col-6"> ```py def join(sep, l): if l == []: return "" accum = l[0] l = l[1:] for x in l: accum = accum + sep + x return accum >>> l = ["x", "y", "z"] >>> join(", ", l) 'x, y, z' ``` </div> <div markdown class="col-6"> ```scheme (define (join sep l) (define (join-iter accum l) (match l [(list) accum] [(list h l ...) (join-iter (string-append accum sep h) l)])) (match l [(list) ""] [(list h l ...) (join-iter h l)])) ``` </div> --- # Another pattern arises .col-6.small[ ```scheme ; Example 1 (define (reverse l) * (define (rev accum l) * (match l * [(list) accum] * [(list h l ...) (rev (cons h accum) l)])) (rev l (list))) ; Example 2 (define (join sep l) * (define (join-iter accum l) * (match l * [(list) accum] * [(list h l ...) * (join-iter * (string-append accum sep h) * l)])) (match l [(list) ""] [(list h l ...) (join-iter h l)])) ``` ] .col-6[ ### A generalized recursion pattern for lists ```scheme (define (rec base-case l) (match l [(list) base-case] [(list h l ...) (rec (step h accum) l)])) ``` #### For instance, ```scheme (cons h accum) ``` #### maps to ```scheme (step h accum) ``` ] --- # Implementing this recursion pattern .col-6[ ### Recursive pattern for lists ```scheme (define (rec base-case l) (match l [(list) base-case] [(list h l ...) (rec (step h accum) l)])) ``` ] .col-6[ ### Fold left reduction ```scheme (define (foldl step base-case l) (match l [(list) base-case] [(list h l ...) (foldl (step h accum) l)])) ``` ] --- # Implementing join with foldl <div class="col-5 small" markdown> ### Before ```scheme (define (join sep l) (define (join-iter accum l) (match l [(list) accum] [(list h l ...) (join-iter (string-append accum sep h) l)])) (match l [(list) ""] [(list h l ...) (join-iter h l)])) ``` </div> -- <div class="col-6" markdown> ### After ```scheme (define (join sep l) (match l [(list) ""] [(list h l ...) * (define (step elem accum) * (string-append accum sep elem)) * (foldl step h l)])) ``` .small[ .alt[Python version suggested by Dakai Tzou:] ```py from functools import reduce def join(l, sep): if l == []: return l def step(elem, accum): return elem + sep + accum return reduce(step, l[1:], l[0]) ``` ] </div> --- # Implementing reverse with foldl .col-7[ ### Original ```scheme (define (reverse l) (define (rev accum l) (match l [(list) accum] [(list h l ...) (rev (cons h accum) l)])) (rev l (list))) ``` ] -- .col-5[ ### Solution ```scheme (define (reverse l) (define (on-elem elem accum) (cons elem accum)) (foldl on-elem (list) l)) ``` or ```scheme (define (reverse l) (foldl cons (list) l)) ``` ] --- # Exercise > Write a function `(to-string l)` that takes a list of numbers > and renders them as `[n1, n2, ...]`. Example, `(list-to-string '(1 2 3))` > should output `[1, 2, 3]`. Function `number->string` converts a number > into a string -- ```scheme (define (to-string l) (string-append "[" (join ", " (map number->string l)) "]")) ``` 1. convert a list of string to a list of numbers (so that `join` can use the list) 2. convert a list of numbers into `1, 2, 3` 3. Surround the string with brackets.