title: CS450 layout: true author: Tiago Cogumbreiro lecture: 6 abstract: Functions as data-structures, currying 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 # Functions as data-structures ## Exercises --- # Exercise 1 ## What is the output of this program? ```scheme (define x 10) (define (f x) (+ x 20)) (f 30) ``` -- **Output:** 50 Because, parameter `x` shadows the outermost definition. --- # Exercise 2 ## What is the output of this program? ```scheme (define x 10) (define f (lambda (x) (+ x 20))) (f 30) ``` -- **Output:** 50 The code above is **equivalent** to the code below: ``` (define (f x) (+ x 20)) ``` --- # Exercise 3 ## What is the output of this program? ```scheme (define (factory k) (lambda () k)) (factory 10) ``` -- **Output:** `#<procedure>` Although if Racket displayed code, we would get: `(lambda () 10)` ```scheme ((factory 10)) ; Outputs: 10 ``` --- # Exercise 3 ## Step-by-step evaluation ```scheme (factory 10) = ( (lambda (k) (lambda () k)) 10) = ; ^^^^^^^^^^^^^^^^^^^^^^^^^^\______ the value *bound* to factory (lambda () 10) ``` .space-top[ ### Why is factory replaced by a lambda? ] <div markdown class="col-6"> ### User input ```scheme (define (factory k) (lambda () k)) ``` </div> <div markdown class="col-6"> ### Internal representation ```scheme (define factory (lambda (k) (lambda () k))) ``` </div> --- # Exercise 3 ### Looking at function application more closely ```scheme ( (lambda (k) ; <- parameter k (lambda () k)) ; <- body of function 10 ; <- argument ) ; Remove outer lambda and replace each parameter by argument ; (lambda () k) <- body of function ; \___ replace parameter k by argument 10 (lambda () 10) ; <- return value ``` --- class: impact # The abstract syntactic tree (AST) ## Exercises --- # Exercise ## Q1: What is the output of this program? ```scheme (define (f x y) (lambda (b) (cond [b x] [else y]))) (define g (f 1 2)) g ``` -- **Output:** `(lambda (b) (cond [b 1] [else 2]))` .space-top[ ## Q2: How do I call `g` to obtain `1`? ] -- **Solution:** `(g #t)` --- # Implementing a pair with functions alone If we can capture one parameter, then we can also capture two parameter. .alt[**Let us implement a pair-data structure with only functions!**] **[source: SICP 2.1.3](https://sarabander.github.io/sicp/html/2_002e1.xhtml#g_t2_002e1_002e3)** ```scheme (define (pair l r) (lambda (op) ; <- we use a parameter to choose which stored data to return (match op ; if the operation is 'left then return l ['left l] ; if the operation is 'right then return r ['right r]))) ; We now define our accessors (define (pair-left p) (p 'left)) ; `Returns the first element of the pair` (define (pair-right p) (p 'right)) ; `Returns the second element of the pair` (define p (pair 10 20)) ; Same as: `(define (p op) (match op ['left 10] ['right 20])))` (pair-left p) ; `Returns 10` because (pair-left p) -> (p 'left) -> 10 (pair-right p) ; `Returns 20` because (pair-right p) -> (p 'right) -> 20 ``` --- class: impact # Recursion exercise --- # String concatenation ```scheme (define (string-concat l) 'todo) (check-equal? (string-concat (list "Hello" ", " "world" "!")) "Hello, world!") ``` --- # String concatenation (solution) ```scheme (define (string-concat l) (match l [(list) ""] [(cons h l) (string-append h (string-concat l))] )) (check-equal? (string-concat (list "Hello" ", " "world" "!")) "Hello, world!") ``` --- class: impact # Functions as values --- # What is functional programming > Functional programming has different meanings to different people * Avoid mutation * **Using functions as values** * A programming style that encourages recursion and recursive data structures * A programming model that uses *lazy* evaluation (discussed later) --- # First-class functions * **Functions are values:** can be passed as arguments, stored in data structures, bound to variables, ... * **Functions for extension points:** A powerful way to factor out a common functionality --- class: impact # Functions as parameters --- # Functions as parameters ## Monotonic increasing function (for one input) > Function `monotonic?` takes a function `f` as a parameter and a value > `x`, and then checks if `f` increases monotonically for a given `x`. <div class="col-7" markdown=1> ### Example ```scheme #lang racket (define (double n) (* 2 n)) (define (monotonic? f x) (>= (f x) x)) ;; Tests (require rackunit) (check-true (monotonic? double 3)) (check-false (monotonic? (lambda (x) (- x 1)) 3)) ``` </div> <div class="col-5" markdown=1> ### How do we evaluate? ```scheme (monotonic? double 3) ``` -- ```scheme = (>= (`double` 3) 3) = (>= (`(lambda (n) (* 2 n) 3)` 3) = (>= `(* 2 3)` 3) = (>= 6 3) = #t ``` </div> --- # Functions as parameters ## Recursively apply a function n-times > Function `apply-n` takes a function `f` as parameter, a number of times `n`, and some argument `x`, and then recursively calls `(f (f (... (f x))))` an `n`-number of times. ```scheme #lang racket (define (apply-n f n x) (cond [(<= n 0) x] [else (apply-n f (- n 1) (f x))])) ;; Tests (require rackunit) (define double (lambda (x) (* 2 x))) (check-equal? (* 2 (* 2 (* 2 1))) (apply-n double 3 1)) (check-equal? (+ 3 (+ 3 (+ 3 1))) (apply-n (lambda (x) (+ 3 x)) 3 1)) ``` --- # Example `apply-n` ### Let us unfold the following... ```scheme (apply-n double 3 1) ; (<= 3 0) = #f ``` -- ```scheme = (apply-n double (- 3 1) (double 1)) = (apply-n double 2 2) ; (<= 2 0) = #f = (apply-n double (- 2 1) (double 2)) = (apply-n double 1 4) ; (<= 1 0) = #f = (apply-n double (- 1 1) (double 4)) = (apply-n double 0 8) ; (<= 0 0) = #t = 8 ``` --- class: impact # Functions as data-structures --- # Functions as data-structures The following is a function that returns a constant value (returns 3 always): ```scheme (define three:2 (lambda () 3)) (three:2) ; <- We need to call the function to obtain its contents ; Note that we are passing 0 parameters. ``` .space-top[ ## Note the difference... ] The following is a variable binding (not a function!): ```scheme (define three:1 3) ``` .space-top[ Variable `three:1` *evaluates* to the number `3`. ] --- # A factory of constant-return functions We can generalize the procedure by creating a function that returns a new function declaration that returns a given parameter `n `. ```scheme (define (factory n) (lambda () n)) ; <-- calling 'factory' `creates a new function dynamically` ; each new function captures the given 'n', ; which changes according to how it was called (define three:4 (factory 3)) ; <- same as: `(define three:4 (lambda () 3))` (three:4) ; `Returns: 3` (define four:1 (factory 4)) ; <- same as: `(define four:1 (lambda () 4))` (four:1) ; `Returns 4` ``` --- class: impact # Functions in data structures --- # Functions stored in data structures ## "Freeze" one parameter of a function > In this example, a `frozen` data-structure stores a binary-function and the > first argument. Function `apply1` takes a frozen data structure and the second > argument, and applies the stored function to the two arguments. ```scheme (struct frozen (func arg1) #:transparent) (define (apply1 fr arg) `(define func (frozen-func fr))` ; Bind a function to a local variable (define arg1 (frozen-arg1 fr)) `(func arg1 arg)`) ; Call a function bound to a local variable (define frozen-double (frozen `*` 2)) ; Store function '*' in a data structure (define (double x) (apply1 frozen-double x)) (check-equal? (* 2 3) (double 3)) ``` --- # Unfolding `(double 3)` ```scheme (double 3) = (apply1 frozen-double 3) = (apply1 (frozen * 2) 3) = (define fr (frozen * 2)) ((frozen-func fr) (frozen-arg1 fr) 3) = (* 2 3) = 6 ``` --- # Functions stored in data structures ## Apply a list of functions to a value ```scheme #lang racket (define (double n) (* 2 n)) ; A list with two functions: ; * doubles a number ; * increments a number (define p `(list double (lambda (x) (+ x 1)))`) ; Applies each function to a value (define (pipeline funcs value) (match funcs [(list) value] [(cons f funcs) (pipeline funcs (`f` value))])) ; Run the pipeline (check-equal? (+ 1 (double 3)) (pipeline p 3)) ``` --- class:impact # Creating functions dynamically --- # Returning functions > Functions in Racket automatically capture the value of any variable > referred in its body. .col-5[ ### Example ```scheme #lang racket (define (frozen-* `arg1`) (define (get-arg2 arg2) (* `arg1` arg2)) ; Returns a new function ; every time you call frozen-* `get-arg2`) (require rackunit) (define double (frozen-* 2)) (check-equal? (* 2 3) (double 3)) ``` ] .col-7[ ### Evaluating `(frozen-* 2)` ```scheme (frozen-* 2) = (define (get-arg2 arg2) (* 2 arg2)) get-arg2 = (lambda (arg2) (* 2 arg)) ``` ### Evaluating `(double 3)` ```scheme (double 3) = ((frozen-* 2) 3) = ((lambda (arg2) (* 2 arg2)) 3) = (* 2 3) = 6 ``` ] --- class: impact # Currying functions --- # Revisiting "freeze" function .col-6[ ### Freezing binary-function ```scheme (struct frozen (func arg1) #:transparent) (define (apply1 fr arg) (define func (frozen-func fr)) (define arg1 (frozen-arg1 fr)) (func arg1 arg)) (define frozen-double (frozen * 2)) (define (double x) (apply1 frozen-double x)) (check-equal? (* 2 3) (double 3)) ``` ] .col-6[ ### Attempt #1 ```scheme (define (freeze f arg1) (define (get-arg2 arg2) (f arg1 arg2)) get-arg2) (define double (freeze * 2)) (check-equal? (* 2 3) (double 3)) ``` ] .row[] > Our `freeze` function is more general than `freeze-*` and simpler than > `frozen-double`. We abstain from using a data-structure and use Racket's > variable capture capabilities. --- # Generalizing "frozen" binary functions .col-6[ ### Attempt #2 ```scheme (define (freeze f) (define (expect-1 arg1) (define (expect-2 arg2) (f arg1 arg2)) expect-2) expect-1) (define frozen-* (freeze *)) (define double (frozen-* 2)) (check-equal? (* 2 3) (double 3)) ``` ] .col-6[ ### Evaluation ```scheme (define frozen-* (freeze *)) = (define frozen-* (define (expect-1 arg1) (define (expect-2 arg2) (`*` arg1 arg2)) expect-2) expect-1) (define double (frozen-* 2)) = (define double (define (expect-2 arg2) (* `2` arg2)) expect-2) (double 3) = (* 2 `3`) ``` ] --- # Currying functions **Currying** is the general technique of "freezing" functions with multiple parameters. It provides a way of delaying (and caching) the passage of multiple arguments by means of new functions. > A curried function $`\mathrm{curry}_{f,n,a}(x)`$ is a unary function annotated > with an uncurried function $`f`$ arguments $`a`$ and a number of expected arguments $`n`$ that > can be recursively defined as: ```math \mathrm{curry}_{f,n+1,[a_1,\dots,a_n]}(x) = \mathrm{curry}_{f,n,[a_1,\dots,a_n,x]} \\ \ \mathrm{curry}_{f,0,[a_1,\dots,a_n]}(x) = f(a_1, \dots, a_n, x) ``` ```scheme #lang racket (define frozen-* (curry *)) (define double (frozen-* 2)) (require rackunit) (check-equal? (* 2 3) (double 3)) ``` --- # Haskell Curry ## Did you know? .col-6[ * In some programming languages functions are curried by default. Examples include Haskell and ML. * The term currying is named after Haskell Curry, a notable logician who developed combinatory logic and the Curry-Howard correspondence (practical applications include proof assistants). *Haskell was born in Millis, MA (1 hour drive from UMB).* ] .col-6.center[ <img src="data:image/jpeg;base64,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" height="256px" /> .row[] [Source: public domain](http://www-history.mcs.st-andrews.ac.uk/PictDisplay/Curry.html) ] --- # Uncurried functions > All arguments must be provided at call-time, otherwise error. ### Python example ```python def add(l, r): return l + y add(10) *# Traceback (most recent call last): *# File "<stdin>", line 1, in <module> *# TypeError: add() missing 1 required positional argument: 'r' ``` --- # Curried functions > If we provide one argument to a 2-parameters function, the result > is a 1-parameter function that expects the second argument. ### Haskell example ```haskell -- Define addition add x y = x + y -- Define adding 10 to some number add10 = add 10 -- 10 + 30 add10 30 -- 40 ``` --- # Currying in Racket Function `curry` **converts** an uncurried function into a curried function. ```scheme #lang racket *(define curried-add (curry +)) (define add10 (curried-add 10)) (require rackunit) (check-equal? (+ 10 30) (add10 30)) ``` --- # Currying functions **Currying** is the general technique of "freezing" functions with multiple parameters. It provides a way of delaying (and caching) the passage of multiple arguments by means of new functions. > A curried function $`\mathrm{curry}_{f,n,a}(x)`$ is a unary function annotated > with an uncurried function $`f`$ arguments $`a`$ and a number of expected arguments $`n`$ that > can be recursively defined as: ```math \mathrm{curry}_{f,n+1,[a_1,\dots,a_n]}(x) = \mathrm{curry}_{f,n,[a_1,\dots,a_n,x]} \\ \ \mathrm{curry}_{f,0,[a_1,\dots,a_n]}(x) = f(a_1, \dots, a_n, x) ``` --- # Exercise ## What is the output of this program? <div class="col-6" markdown> ### Program ```scheme (define curried-add (lambda (arg1) (lambda (arg2) (+ arg1 arg2)))) (define a (curried-add 10)) (define b (curried-add 20)) a b (a 30) (b 40) ``` </div> -- <div class="col-6" markdown> ### Output ```scheme (lambda (arg2) (+ 10 arg2)) (lambda (arg2) (+ 20 arg2)) 40 60 ``` </div>