# Functional abstraction. What is abstraction? Eating apples. Readings: HtDP, sections Language level: Intermediate Student With Lambda

Save this PDF as:

Size: px
Start display at page:

Download "Functional abstraction. What is abstraction? Eating apples. Readings: HtDP, sections Language level: Intermediate Student With Lambda"

## Transcription

1 Functional abstraction Readings: HtDP, sections Language level: Intermediate Student With Lambda different order used in lecture section 24 material introduced much earlier sections 22, 23 not covered in lecture CS 135 Winter : Functional abstraction 1 What is abstraction? Abstraction is the process of finding similarities or common aspects, and forgetting unimportant differences. Example: writing a function. The differences in parameter values are forgotten, and the similarity is captured in the function body. We have seen many similarities between functions, and captured them in design recipes. But some similarities still elude us. CS 135 Winter : Functional abstraction 2 Eating apples (define (eat-apples lst) (cond [(empty? lst) empty] [(not (symbol=? (first lst) apple)) (cons (first lst) (eat-apples (rest lst)))] [else (eat-apples (rest lst))])) CS 135 Winter : Functional abstraction 3

2 Keeping odd numbers (define (keep-odds lst) (cond [(empty? lst) empty] [(odd? (first lst)) (cons (first lst) (keep-odds (rest lst)))] [else (keep-odds (rest lst))])) CS 135 Winter : Functional abstraction 4 Abstracting from these examples What these two functions have in common is their general structure. Where they differ is in the specific predicate used to decide whether an item is removed from the answer or not. We could write one function to do both these tasks if we could supply, as an argument to that function, the predicate to be used. The Intermediate language permits this. CS 135 Winter : Functional abstraction 5 In the Intermediate language, functions are values. In fact, they are first-class values. Functions have the same status as the other values we ve seen. They can be: 1. consumed as function arguments 2. produced as function results 3. bound to identifiers 4. put in structures and lists This is a feature that many mainstream programming languages lack but is central to functional programming languages. CS 135 Winter : Functional abstraction 6

3 More rapidly-evolving or recently-defined languages that are not primarily functional (e.g. Python, Ruby, Perl 6, C#) do implement this feature to some extent. Java and C++ provide other abstraction mechanisms that provide some of the benefits. Functions-as-values provides a clean way to think about the concepts and issues involved in abstraction. You can then worry about how to implement a high-level design in a given programming language. CS 135 Winter : Functional abstraction 7 Consuming functions (define (foo f x y) (f x y)) (foo + 2 3) 5 (foo 2 3) 6 CS 135 Winter : Functional abstraction 8 my-filter (define (my-filter pred? lst) (cond [(empty? lst) empty] [(pred? (first lst)) (cons (first lst) (my-filter pred? (rest lst)))] [else (my-filter pred? (rest lst))])) CS 135 Winter : Functional abstraction 9

4 Tracing my-filter (my-filter odd? (list 5 6 7)) (cons 5 (my-filter odd? (list 6 7))) (cons 5 (my-filter odd? (list 7))) (cons 5 (cons 7 (my-filter odd? empty))) (cons 5 (cons 7 empty)) my-filter is an abstract list function which handles the general operation of removing items from lists. CS 135 Winter : Functional abstraction 10 Using my-filter (define (keep-odds lst) (my-filter odd? lst)) (define (not-symbol-apple? item) (not (symbol=? item apple))) (define (eat-apples lst) (my-filter not-symbol-apple? lst)) The function filter, which behaves identically to our my-filter, is built into Intermediate Student and full Racket. filter and other abstract list functions provided in Racket are used to apply common patterns of structural recursion. We ll discuss how to write contracts for them shortly. CS 135 Winter : Functional abstraction 11 Advantages of functional abstraction Functional abstraction is the process of creating abstract functions such as filter. It reduces code size. It avoids cut-and-paste. Bugs can be fixed in one place instead of many. Improving one functional abstraction improves many applications. CS 135 Winter : Functional abstraction 12

5 Producing Functions We saw in lecture module 09 how local could be used to create functions during a computation, to be used in evaluating the body of the local. But now, because functions are values, the body of the local can produce such a function as a value. Though it is not apparent at first, this is enormously useful. We illustrate with a very small example. CS 135 Winter : Functional abstraction 13 (define (make-adder n) (local [(define (f m) (+ n m))] f)) What is (make-adder 3)? We can answer this question with a trace. CS 135 Winter : Functional abstraction 14 (make-adder 3) (local [(define (f m) (+ 3 m))] f) (define (f 42 m) (+ 3 m)) f 42 (make-adder 3) is the renamed function f 42, which is a function that adds 3 to its argument. We can apply this function immediately, or we can use it in another expression, or we can put it in a data structure. CS 135 Winter : Functional abstraction 15

7 Putting functions in lists Recall our code in lecture module 08 for evaluating alternate arithmetic expressions such as (+ ( 3 4) 2). ;; eval: AltAExp Num (define (eval aax) (cond [(number? aax) aax] [else (my-apply (first aax) (rest aax))])) CS 135 Winter : Functional abstraction 19 ;; my-apply: Sym AltAExpList Num (define (my-apply f aaxl) (cond [(and (empty? aaxl) (symbol=? f )) 1] [(and (empty? aaxl) (symbol=? f +)) 0] [(symbol=? f ) ( (eval (first aaxl)) (my-apply f (rest aaxl)))] [(symbol=? f +) (+ (eval (first aaxl)) (my-apply f (rest aaxl)))])) Note the similar-looking code. CS 135 Winter : Functional abstraction 20 Much of the code is concerned with translating the symbol + into the function +, and the same for and. If we want to add more functions to the evaluator, we have to write more code which is very similar to what we ve already written. We can use an association list to store the above correspondence, and use the function lookup-al we saw in lecture module 08 to look up symbols. CS 135 Winter : Functional abstraction 21

8 (define trans-table (list (list + +) (list ))) Now (lookup-al + trans-table) produces the function +. ((lookup-al + trans-table) 3 4 5) 12 CS 135 Winter : Functional abstraction 22 ;; newapply: Sym AltAExpList Num (define (newapply f aaxl) (cond [(and (empty? aaxl) (symbol=? f )) 1] [(and (empty? aaxl) (symbol=? f +)) 0] [else ((lookup-al f trans-table) (eval (first aaxl)) (newapply f (rest aaxl)))])) We can simplify this even further, because in Intermediate Student, + and allow zero arguments. (+) 0 and ( ) 1 CS 135 Winter : Functional abstraction 23 ;; newapply: Sym AltAExpList Num (define (newapply f aaxl) (local [(define op (lookup-al f trans-table))] (cond [(empty? aaxl) (op)] [else (op (eval (first aaxl)) (newapply f (rest aaxl)))]))) Now, to add a new binary function (that is also defined for 0 arguments), we need only add one line to trans-table. CS 135 Winter : Functional abstraction 24

9 Contracts and types Our contracts describe the type of data consumed by and produced by a function. Until now, the type of data was either a basic (built-in) type, a defined (struct) type, an anyof type, or a list type, such as List-of-Symbols, which we then called (listof Sym). Now we need to talk about the type of a function consumed or produced by a function. CS 135 Winter : Functional abstraction 25 We can use the contract for a function as its type. For example, the type of > is (Num Num Bool), because that s the contract of that function. We can then use type descriptions of this sort in contracts for functions which consume or produce other functions. CS 135 Winter : Functional abstraction 26 Simulating Structures We can use the ideas of producing and binding functions to simulate structures. (define (my-make-posn x y) (local [(define (symbol-to-value s) (cond [(symbol=? s x) x] [(symbol=? s y) y]))] symbol-to-value)) A trace demonstrates how this function works. CS 135 Winter : Functional abstraction 27

10 (define p1 (my-make-posn 3 4)) (define p1 (local [(define (symbol-to-value s) (cond [(symbol=? s x) 3] [(symbol=? s y) 4]))] symbol-to-value)) Notice how the parameters have been substituted into the local definition. We now rename symbol-to-value and lift it out. CS 135 Winter : Functional abstraction 28 This yields: (define (symbol-to-value 38 s) (cond [(symbol=? s x) 3] [(symbol=? s y) 4])) (define p1 symbol-to-value 38) p1 is now a function with the x and y values we supplied to my-make-posn coded in. To get out the x value, we can use (p1 x): (p1 x) 3 CS 135 Winter : Functional abstraction 29 We can define a few convenience functions to simulate posn-x and posn-y: (define (my-posn-x p) (p x)) (define (my-posn-y p) (p y)) If we apply my-make-posn again with different values, it will produce a different rewritten and lifted version of symbol-to-value, say symbol-to-value 39. We have just seen how to implement structures without using lists. CS 135 Winter : Functional abstraction 30

11 Scope revisited (define (my-make-posn x y) (local [(define (symbol-to-value s) (cond [(symbol=? s x) x] [(symbol=? s y) y]))] symbol-to-value)) Consider the use of x inside symbol-to-value. Its binding occurrence is outside the definition of symbol-to-value. CS 135 Winter : Functional abstraction 31 Our trace made it clear that the result of a particular application, say (my-make-posn 3 4), is a copy of symbol-to-value with 3 and 4 substituted for x and y, respectively. That copy can be used much later, to retrieve the value of x or y that was supplied to my-make-posn. This is possible because the copy of symbol-to-value, even though it was defined in a local definition, survives after the evaluation of the local is finished. CS 135 Winter : Functional abstraction 32 Anonymous functions (local [(define (symbol-to-value s) (cond [(symbol=? s x) x] [(symbol=? s y) y]))] symbol-to-value) The result of evaluating this expression is a function. What is its name? It is anonymous (has no name). This is sufficiently valuable that there is a special mechanism for it. CS 135 Winter : Functional abstraction 33

12 Producing anonymous functions (define (not-symbol-apple? item) (not (symbol=? item apple))) (define (eat-apples lst) (filter not-symbol-apple? lst)) This is a little unsatisfying, because not-symbol-apple? is such a small and relatively useless function. It is unlikely to be needed elsewhere. We can avoid cluttering the top level with such definitions by putting them in local expressions. CS 135 Winter : Functional abstraction 34 (define (eat-apples lst) (local [(define (not-symbol-apple? item) (not (symbol=? item apple)))] (filter not-symbol-apple? lst))) This is as far as we would go based on our experience with local. But now that we can use functions as values, the value produced by the local expression can be the function not-symbol-apple?. We can then take that value and deliver it as an argument to filter. CS 135 Winter : Functional abstraction 35 (define (eat-apples lst) (filter (local [(define (not-symbol-apple? item) (not (symbol=? item apple)))] not-symbol-apple?) lst)) But this is still unsatisfying. Why should we have to name not-symbol-apple? at all? In the expression ( (+ 2 3) 4), we didn t have to name the intermediate value 5. Racket provides a mechanism for constructing a nameless function which can then be used as an argument. CS 135 Winter : Functional abstraction 36

13 Introducing lambda (local [(define (name-used-once x1... xn) exp)] name-used-once) can also be written (lambda (x1... xn) exp) lambda can be thought of as make-function. It can be used to create a function which we can then use as a value for example, as the value of the first argument of filter. CS 135 Winter : Functional abstraction 37 We can then replace (define (eat-apples lst) (filter (local [(define (not-symbol-apple? item) (not (symbol=? item apple)))] not-symbol-apple?) lst) with the following: (define (eat-apples lst) (filter (lambda (item) (not (symbol=? item apple))) lst)) CS 135 Winter : Functional abstraction 38 lambda is available in Intermediate Student with Lambda, and discussed in section 24 of the textbook. We re jumping ahead to it because of its central importance in Racket, Lisp, and the history of computation in general. The designers of the teaching languages could have renamed it as they did with other constructs, but chose not to out of respect. The word lambda comes from the Greek letter, used as notation in the first formal model of computation. CS 135 Winter : Functional abstraction 39

14 We can use lambda to simplify our implementation of posn structures. (define (my-make-posn x y) (lambda (s) (cond [(symbol=? s x) x] [(symbol=? s y) y]))) CS 135 Winter : Functional abstraction 40 lambda also underlies the definition of functions. Until now, we have had two different types of definitions. ;; a definition of a numerical constant (define interest-rate 3/100) ;; a definition of a function to compute interest (define (interest-earned amount) ( interest-rate amount)) There is really only one kind of define, which binds a name to a value. CS 135 Winter : Functional abstraction 41 Internally, (define (interest-earned amount) ( interest-rate amount)) is translated to (define interest-earned (lambda (amount) ( interest-rate amount))) which binds the name interest-earned to the value (lambda (amount) ( interest-rate amount)). CS 135 Winter : Functional abstraction 42

15 We should change our semantics for function definition to represent this rewriting. But doing so would make traces much harder to understand. As long as the value of defined constants (now including functions) cannot be changed, we can leave their names unsubstituted in our traces for clarity. But in CS 136, when we introduce mutation, we will have to make this change. CS 135 Winter : Functional abstraction 43 Syntax and semantics of Intermediate Student with Lambda We don t have to make many changes to our earlier syntax and semantics. The first position in an application can now be an expression (computing the function to be applied). If this is the case, it must be evaluated along with the other arguments. CS 135 Winter : Functional abstraction 44 Before, the next thing after the open parenthesis in a function application had to be a defined or primitive function name. Now a function application can have two or more open parentheses in a row, as in ((make-adder 3) 4). CS 135 Winter : Functional abstraction 45

16 We need a rule for evaluating applications where the function being applied is anonymous (a lambda expression.) ((lambda (x1... xn) exp) v1... vn) exp where exp is exp with all occurrences of x1 replaced by v1, all occurrences of x2 replaced by v2, and so on. As an example: ((lambda (x y) ( (+ y 4) x)) 5 6) ( (+ 6 4) 5) CS 135 Winter : Functional abstraction 46 Here s make-adder rewritten using lambda. (define make-adder (lambda (x) (lambda (y) (+ x y)))) We see the same scope phenomenon we discussed earlier: the binding occurrence of x lies outside (lambda (y) (+ x y)). What is (make-adder 3)? CS 135 Winter : Functional abstraction 47 (make-adder 3) ((lambda (x) (lambda (y) (+ x y))) 3) (lambda (y) (+ 3 y)) This shorthand is very useful, which is why lambda is being added to mainstream programming languages. CS 135 Winter : Functional abstraction 48

17 Suppose during a computation, we want to specify some action to be performed one or more times in the future. Before knowing about lambda, we might build a data structure to hold a description of that action, and a helper function to consume that data structure and perform the action. Now, we can just describe the computation clearly using lambda. CS 135 Winter : Functional abstraction 49 Example: character translation in strings Recall that Racket provides the function string list to convert a string to a list of characters. This is the most effective way to work with strings, though typically structural recursion on these lists is not natural, and generative recursion (as discussed in module 11) is used. In the example we are about to discuss, structural recursion works. CS 135 Winter : Functional abstraction 50 We ll develop a general method of performing character translations on strings. For example, we might want to convert every a in a string to a b. The string "abracadabra" becomes "bbrbcbdbbrb". This doesn t require functional abstraction. You could have written a function that does this in lecture module 05. CS 135 Winter : Functional abstraction 51

18 ;; a b: Str Str (define (a b str) (list string (a b/loc (string list str)))) ;; a b/loc: (listof Char) (listof Char) (define (a b/loc loc) (cond [(empty? loc) empty] [(char=? (first loc) #\a) (cons #\b (a b/loc (rest loc)))] [else (cons (first loc) (a b/loc (rest loc)))])) CS 135 Winter : Functional abstraction 52 Functional abstraction is useful in generalizing this example. Here, we went through a string applying a predicate ( equals a? ) to each character, and applied an action ( make it b ) to characters that satisfied the predicate. A translation is a pair (a list of length two) consisting of a predicate and an action. We might want to apply several translations to a string. CS 135 Winter : Functional abstraction 53 We can describe the translation in our example like this: (list (lambda (c) (char=? #\a c)) (lambda (c) #\b)) Since these are likely to be common sorts of functions, we can write helper functions to create them. (define (is-char? c1) (lambda (c2) (char=? c1 c2))) (define (always c1) (lambda (c2) c1)) (list (is-char? #\a) (always #\b)) CS 135 Winter : Functional abstraction 54

19 Our translate function will consume a list of translations and a string to be translated. For each character c in the string, it will create a result character by applying the action of the first translation on the list whose predicate is satisfied by c. If no predicate is satisfied by c, the result character is c. CS 135 Winter : Functional abstraction 55 An example of its use: suppose we have a string s, and we want a version of it where all letters are capitalized, and all numbers are redacted by replacing them with asterisks. (define s "Testing ") (translate (list (list char-alphabetic? char-upcase) (list char-numeric? (always #\ ))) s) "TESTING - -." char-alphabetic?, char-upcase, and char-numeric? are primitive functions in the teaching languages. CS 135 Winter : Functional abstraction 56 (define (translate lot str) (list string (trans-loc lot (string list str)))) (define (trans-loc lot loc) (cond [(empty? loc) empty] [else (cons (trans-char lot (first loc)) (trans-loc lot (rest loc)))])) (define (trans-char lot c) (cond [(empty? lot) c] [((first (first lot)) c) ((second (first lot)) c)] [else (trans-char (rest lot) c)])) What is the contract for trans-loc? CS 135 Winter : Functional abstraction 57

20 Contracts for abstract list functions filter consumes a function and a list, and produces a list. We might be tempted to conclude that its contract is (Any Bool) (listof Any) (listof Any). But this is not specific enough. The application (filter odd? (list a b c)) does not violate the above contract, but will clearly cause an error. There is a relationship among the two arguments to filter and the result of filter that we need to capture in the contract. CS 135 Winter : Functional abstraction 58 Parametric types An application (filter pred? lst), can work on any type of list, but the predicate provided should consume elements of that type of list. In other words, we have a dependency between the type of the predicate (which is the contract of the predicate) and the type of list. To express this, we use a type variable, such as X, and use it in different places to indicate where the same type is needed. CS 135 Winter : Functional abstraction 59 The contract for filter filter consumes a predicate with contract X Bool, where X is the base type of the list that it also consumes. It produces a list of the same type it consumes. The contract for filter is thus: ;; filter: (X Bool) (listof X) (listof X) Here X stands for the unknown data type of the list. We say filter is polymorphic or generic; it works on many different types of data. CS 135 Winter : Functional abstraction 60

21 The contract for filter has three occurrences of a type variable X. Since a type variable is used to indicate a relationship, it needs to be used at least twice in any given contract. A type variable used only once can probably be replaced with Any. We will soon see examples where more than one type variable is needed in a contract. CS 135 Winter : Functional abstraction 61 Understanding contracts Many of the difficulties one encounters in using abstract list functions can be overcome by careful attention to contracts. For example, the contract for the function provided as an argument to filter says that it consumes one argument and produces a Boolean value. This means we must take care to never use filter with an argument that is a function that consumes two variables, or that produces a number. CS 135 Winter : Functional abstraction 62 Abstracting from examples Here are two early list functions we wrote. (define (negate-list lst) (cond [(empty? lst) empty] [else (cons ( (first lst)) (negate-list (rest lst)))])) (define (compute-taxes lst) (cond [(empty? lst) empty] [else (cons (sr tr (first lst)) (compute-taxes (rest lst)))])) CS 135 Winter : Functional abstraction 63

22 We look for a difference that can t be explained by renaming (it being what is applied to the first item of a list) and make that a parameter. (define (my-map f lst) (cond [(empty? lst) empty] [else (cons (f (first lst)) (my-map f (rest lst)))])) CS 135 Winter : Functional abstraction 64 Tracing my-map (my-map sqr (list 3 6 5)) (cons 9 (my-map sqr (list 6 5))) (cons 9 (cons 36 (my-map sqr (list 5)))) (cons 9 (cons 36 (cons 25 (my-map sqr empty)))) (cons 9 (cons 36 (cons 25 empty))) my-map performs the general operation of transforming a list element-by-element into another list of the same length. CS 135 Winter : Functional abstraction 65 The application (my-map f (list x1 x2... xn)) has the same effect as evaluating (list (f x1) (f x2)... (f xn)). We can use my-map to give short definitions of a number of functions we have written to consume lists: (define (negate-list lst) (my-map lst)) (define (compute-taxes lst) (my-map sr tr lst)) How can we use my-map to rewrite trans-loc? CS 135 Winter : Functional abstraction 66

23 The contract for my-map my-map consumes a function and a list, and produces a list. How can we be more precise about its contract, using parametric type variables? CS 135 Winter : Functional abstraction 67 Built-in abstract list functions Intermediate Student also provides map as a built-in function, as well as many other abstract list functions. There is a useful table on page 313 of the text (Figure 57 in section 21.2). The abstract list functions map and filter allow us to quickly describe functions to do something to all elements of a list, and to pick out selected elements of a list, respectively. CS 135 Winter : Functional abstraction 68 Building an abstract list function The functions we have worked with so far consume and produce lists. What about abstracting from functions such as count-symbols and sum-of-numbers, which consume lists and produce values? Let s look at these, find common aspects, and then try to generalize from the template. CS 135 Winter : Functional abstraction 69

24 (define (sum-of-numbers lst) (cond [(empty? lst) 0] [else (+ (first lst) (sum-of-numbers (rest lst)))])) (define (prod-of-numbers lst) (cond [(empty? lst) 1] [else ( (first lst) (prod-of-numbers (rest lst)))])) (define (count-symbols lst) (cond [(empty? lst) 0] [else (+ 1 (count-symbols (rest lst)))])) CS 135 Winter : Functional abstraction 70 Note that each of these examples has a base case which is a value to be returned when the argument list is empty. Each example is applying some function to combine (first lst) and the result of a recursive function application with argument (rest lst). This continues to be true when we look at the list template and generalize from that. CS 135 Winter : Functional abstraction 71 (define (list-template lst) (cond [(empty? lst)... ] [else (... (first lst)... (list-template (rest lst))... )])) We replace the first ellipsis by a base value. We replace the rest of the ellipses by some function which combines (first lst) and the result of a recursive function application on (rest lst). This suggests passing the base value and the combining function as parameters to an abstract list function. CS 135 Winter : Functional abstraction 72

25 The abstract list function foldr (define (my-foldr combine base lst) (cond [(empty? lst) base] [else (combine (first lst) (my-foldr combine base (rest lst)))])) foldr is also a built-in function in Intermediate Student With Lambda. CS 135 Winter : Functional abstraction 73 Tracing my-foldr (my-foldr f 0 (list 3 6 5)) (f 3 (my-foldr f 0 (list 6 5))) (f 3 (f 6 (my-foldr f 0 (list 5))) (f 3 (f 6 (f 5 (my-foldr f 0 empty))) (f 3 (f 6 (f 5 0)))... Intuitively, the effect of the application (foldr f b (list x1 x2... xn)) is to compute the value of the expression (f x1 (f x2 (... (f xn b)... ))). CS 135 Winter : Functional abstraction 74 foldr is short for fold right. The reason for the name is that it can be viewed as folding a list using the provided combine function, starting from the right-hand end of the list. foldr can be used to implement map, filter, and other abstract list functions. CS 135 Winter : Functional abstraction 75

26 The contract for foldr foldr consumes three arguments: a function which combines the first list item with the result of reducing the rest of the list; a base value; a list on which to operate. What is the contract for foldr? CS 135 Winter : Functional abstraction 76 Using foldr (define (sum-of-numbers lst) (foldr + 0 lst)) If lst is (list x1 x2... xn), then by our intuitive explanation of foldr, the expression (foldr + 0 lst) reduces to (+ x1 (+ x2 (+... (+ xn 0)... ))) Thus foldr does all the work of the template for processing lists, in the case of sum-of-numbers. CS 135 Winter : Functional abstraction 77 The function provided to foldr consumes two parameters: one is an element on the list which is an argument to foldr, and one is the result of reducing the rest of the list. Sometimes one of those arguments should be ignored, as in the case of using foldr to compute count-symbols. CS 135 Winter : Functional abstraction 78

27 The important thing about the first argument to the function provided to foldr is that it contributes 1 to the count; its actual value is irrelevant. Thus the function provided to foldr in this case can ignore the value of the first parameter, and just add 1 to the reduction of the rest of the list. CS 135 Winter : Functional abstraction 79 (define (count-symbols lst) (foldr (lambda (x y) (add1 y)) 0 lst)) The function provided to foldr, namely (lambda (x y) (add1 y)), ignores its first argument. Its second argument represents the reduction of the rest of the list (in this case the length of the rest of the list, to which 1 must be added). CS 135 Winter : Functional abstraction 80 Using foldr to produce lists So far, the functions we have been providing to foldr have produced numerical results, but they can also produce cons expressions. foldr is an abstraction of structural recursion on lists, so we should be able to use it to implement negate-list from module 05. We need to define a function (lambda (x y)... ) where x is the first element of the list and y is the result of the recursive function application. negate-list takes this element, negates it, and conses it onto the result of the recursive function application. CS 135 Winter : Functional abstraction 81

28 The function we need is (lambda (x y) (cons ( x) y)) Thus we can give a nonrecursive version of negate-list (that is, foldr does all the recursion). (define (negate-list lst) (foldr (lambda (x y) (cons ( x) y)) empty lst)) Because we generalized negate-list to map, we should be able to use foldr to define map. CS 135 Winter : Functional abstraction 82 Let s look at the code for my-map. (define (my-map f lst) (cond [(empty? lst) empty] [else (cons (f (first lst)) (my-map f (rest lst)))])) Clearly empty is the base value, and the function provided to foldr is something involving cons and f. CS 135 Winter : Functional abstraction 83 In particular, the function provided to foldr must apply f to its first argument, then cons the result onto its second argument (the reduced rest of the list). (define (my-map f lst) (foldr (lambda (x y) (cons (f x) y)) empty lst)) We can also implement my-filter using foldr. CS 135 Winter : Functional abstraction 84

29 Imperative languages, which tend to provide inadequate support for recursion, usually provide looping constructs such as while and for to perform repetitive actions on data. Abstract list functions cover many of the common uses of such looping constructs. Our implementation of these functions is not difficult to understand, and we can write more if needed, but the set of looping constructs in a conventional language is fixed. CS 135 Winter : Functional abstraction 85 Anything that can be done with the list template can be done using foldr, without explicit recursion (unless it ends the recursion early, like insert). Does that mean that the list template is obsolete? No. Experienced Racket programmers still use the list template, for reasons of readability and maintainability. Abstract list functions should be used judiciously, to replace relatively simple uses of recursion. CS 135 Winter : Functional abstraction 86 Higher-order functions Functions that consume or produce functions like filter, map, and foldr are sometimes called higher-order functions. Another example is the built-in build-list. This consumes a natural number n and a function f, and produces the list (list (f 0) (f 1)... (f (sub1 n))) (build-list 4 add1) (list ). Clearly build-list abstracts the count up pattern, and it is easy to write our own version. CS 135 Winter : Functional abstraction 87

30 (define (my-build-list n f) (local [(define (list-from i) (cond [(>= i n) empty] [else (cons (f i) (list-from (add1 i)))]))] (list-from 0))) CS 135 Winter : Functional abstraction 88 We can now simplify mult-table even further. (define (mult-table nr nc) (build-list nr (lambda (i) (build-list nc (lambda (j) ( i j)))))) CS 135 Winter : Functional abstraction 89 Goals of this module You should understand the idea of functions as first-class values: how they can be supplied as arguments, produced as values using lambda, bound to identifiers, and placed in lists. You should be familiar with the built-in list functions provided by Racket, understand how they abstract common recursive patterns, and be able to use them to write code. CS 135 Winter : Functional abstraction 90

31 You should be able to write your own abstract list functions that implement other recursive patterns. You should understand how to do step-by-step evaluation of programs written in the Intermediate language that make use of functions as values. CS 135 Winter : Functional abstraction 91

### Functional abstraction

Functional abstraction Readings: HtDP, sections 19-24. Language level: Intermediate Student With Lambda different order used in lecture section 24 material introduced much earlier sections 22, 23 not covered

### Module 8: Local and functional abstraction

Module 8: Local and functional abstraction Readings: HtDP, Intermezzo 3 (Section 18); Sections 19-23. We will cover material on functional abstraction in a somewhat different order than the text. We will

### Local definitions and lexical scope

Local definitions and lexical scope Readings: HtDP, Intermezzo 3 (Section 18). Language level: Intermediate Student CS 135 Winter 2018 09: Local definitions and lexical scope 1 Local definitions The functions

### Local definitions and lexical scope. Local definitions. Motivating local definitions. s(s a)(s b)(s c), where s = (a + b + c)/2.

Local definitions and lexical scope Readings: HtDP, Intermezzo 3 (Section 18). Language level: Intermediate Student CS 135 Winter 2018 09: Local definitions and lexical scope 1 Local definitions The functions

### Lists. Readings: HtDP, sections 9 and 10. Avoid 10.3 (uses draw.ss). CS 135 Winter : Lists 1

Lists Readings: HtDP, sections 9 and 10. Avoid 10.3 (uses draw.ss). CS 135 Winter 2018 05: Lists 1 Introducing lists Structures are useful for representing a fixed amount of data. But there are many circumstances

### CS115 - Module 9 - filter, map, and friends

Fall 2017 Reminder: if you have not already, ensure you: Read How to Design Programs, Intermezzo 3 (Section 18); Sections 19-23. Abstraction abstraction, n. 3a.... The process of isolating properties or

### Module 5: Lists. Readings: HtDP, Sections 9, 10.

Module 5: Lists Readings: HtDP, Sections 9, 10. Lists are the main tool used in Racket to work with unbounded data. As with conditional expressions and structures, the data definition for lists leads naturally

### Working with recursion

Working with recursion Readings: HtDP, sections 11, 12, 13 (Intermezzo 2). We can extend the idea of a self-referential definition to defining the natural numbers, which leads to the use of recursion in

### Working with recursion. From definition to template. Readings: HtDP, sections 11, 12, 13 (Intermezzo 2).

Working with recursion Readings: HtDP, sections 11, 12, 13 (Intermezzo 2). We can extend the idea of a self-referential definition to defining the natural numbers, which leads to the use of recursion in

### Summer 2017 Discussion 10: July 25, Introduction. 2 Primitives and Define

CS 6A Scheme Summer 207 Discussion 0: July 25, 207 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

### Module 10: General trees

Module 10: General trees Readings: HtDP, Sections 15 and 16 CS 115 Winter 2019 10: General trees 1 General trees Binary trees can be used for a large variety of application areas. One limitation is the

### Trees. Readings: HtDP, sections 14, 15, 16.

Trees Readings: HtDP, sections 14, 15, 16. We will cover the ideas in the text using different examples and different terminology. The readings are still important as an additional source of examples.

### The design recipe. Readings: HtDP, sections 1-5. (ordering of topics is different in lectures, different examples will be used)

The design recipe Readings: HtDP, sections 1-5 (ordering of topics is different in lectures, different examples will be used) Survival and Style Guides CS 135 Winter 2018 02: The design recipe 1 Programs

### CS115 - Module 10 - General Trees

Fall 2017 Reminder: if you have not already, ensure you: Read How to Design Programs, Sections 15 and 16. Arithmetic Expressions Recall with binary trees we could represent an expression containing binary

### Trees. Binary arithmetic expressions. Visualizing binary arithmetic expressions. ((2 6) + (5 2))/(5 3) can be defined in terms of two smaller

Trees Readings: HtDP, sections 14, 15, 16. We will cover the ideas in the text using different examples and different terminology. The readings are still important as an additional source of examples.

### The syntax and semantics of Beginning Student

The syntax and semantics of Beginning Student Readings: HtDP, Intermezzo 1 (Section 8). We are covering the ideas of section 8, but not the parts of it dealing with section 6/7 material (which will come

### The syntax and semantics of Beginning Student

The syntax and semantics of Beginning Student Readings: HtDP, Intermezzo 1 (Section 8). We are covering the ideas of section 8, but not the parts of it dealing with section 6/7 material (which will come

### CS2500 Exam 2 Fall 2011

CS2500 Exam 2 Fall 2011 Name: Student Id (last 4 digits): Section (morning, honors or afternoon): Write down the answers in the space provided. You may use the usual primitives and expression forms, including

### Generative and accumulative recursion. What is generative recursion? Example revisited: GCD. Readings: Sections 25, 26, 27, 30, 31

Generative and accumulative recursion Readings: Sections 25, 26, 27, 30, 31 Some subsections not explicitly covered in lecture Section 27.2 technique applied to strings CS 135 Fall 2017 11: Generative

### Module 3: New types of data

Module 3: New types of data Readings: Sections 4 and 5 of HtDP. A Racket program applies functions to values to compute new values. These new values may in turn be supplied as arguments to other functions.

### CS 135 Fall 2018 Final Exam Review. CS 135 Fall 2018 Final Exam Review 1

CS 135 Fall 2018 Final Exam Review CS 135 Fall 2018 Final Exam Review 1 Final Exam Information The final exam will be held on Saturday, December 15 th 9:00AM - 11:30AM in the PAC Check your exam seating

### SCHEME 8. 1 Introduction. 2 Primitives COMPUTER SCIENCE 61A. March 23, 2017

SCHEME 8 COMPUTER SCIENCE 61A March 2, 2017 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

### Local defini1ons. Func1on mul1ples- of

Local defini1ons The func1ons and special forms we ve seen so far can be arbitrarily nested except define and check- expect. So far, defini.ons have to be made at the top level, outside any expression.

### Trees. Example: Binary expression trees. Example: Evolution trees. Readings: HtDP, sections 14, 15, 16.

Trees Readings: HtDP, sections 14, 15, 16. We will cover the ideas in the text using different examples and different terminology. The readings are still important as an additional source of examples.

### Intro. Scheme Basics. scm> 5 5. scm>

Intro Let s take some time to talk about LISP. It stands for LISt Processing a way of coding using only lists! It sounds pretty radical, and it is. There are lots of cool things to know about LISP; if

### 6.001 Notes: Section 6.1

6.001 Notes: Section 6.1 Slide 6.1.1 When we first starting talking about Scheme expressions, you may recall we said that (almost) every Scheme expression had three components, a syntax (legal ways of

### Module 10: Imperative Programming, Modularization, and The Future

Module 10: Imperative Programming, Modularization, and The Future If you have not already, make sure you Read How to Design Programs Sections 18. 1 CS 115 Module 10: Imperative Programming, Modularization,

### Introduction to Typed Racket. The plan: Racket Crash Course Typed Racket and PL Racket Differences with the text Some PL Racket Examples

Introduction to Typed Racket The plan: Racket Crash Course Typed Racket and PL Racket Differences with the text Some PL Racket Examples Getting started Find a machine with DrRacket installed (e.g. the

### Fall 2017 Discussion 7: October 25, 2017 Solutions. 1 Introduction. 2 Primitives

CS 6A Scheme Fall 207 Discussion 7: October 25, 207 Solutions Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write

### Module 8: Binary trees

Module 8: Binary trees Readings: HtDP, Section 14 We will cover the ideas in the text using different examples and different terminology. The readings are still important as an additional source of examples.

### Repetition Through Recursion

Fundamentals of Computer Science I (CS151.02 2007S) Repetition Through Recursion Summary: In many algorithms, you want to do things again and again and again. For example, you might want to do something

### CSE 413 Languages & Implementation. Hal Perkins Winter 2019 Structs, Implementing Languages (credits: Dan Grossman, CSE 341)

CSE 413 Languages & Implementation Hal Perkins Winter 2019 Structs, Implementing Languages (credits: Dan Grossman, CSE 341) 1 Goals Representing programs as data Racket structs as a better way to represent

### Functional Programming. Pure Functional Programming

Functional Programming Pure Functional Programming Computation is largely performed by applying functions to values. The value of an expression depends only on the values of its sub-expressions (if any).

### CSCC24 Functional Programming Scheme Part 2

CSCC24 Functional Programming Scheme Part 2 Carolyn MacLeod 1 winter 2012 1 Based on slides from Anya Tafliovich, and with many thanks to Gerald Penn and Prabhakar Ragde. 1 The Spirit of Lisp-like Languages

### Module 9: Trees. If you have not already, make sure you. Read How to Design Programs Sections 14, 15, CS 115 Module 9: Trees

Module 9: Trees If you have not already, make sure you Read How to Design Programs Sections 14, 15, 16. 1 CS 115 Module 9: Trees Mathematical Expressions We are going to discuss how to represent mathematical

### (Provisional) Lecture 08: List recursion and recursive diagrams 10:00 AM, Sep 22, 2017

Integrated Introduction to Computer Science Hughes (Provisional) Lecture 08: List recursion and recursive diagrams 10:00 AM, Sep 22, 2017 Contents 1 Announcements 1 2 Evaluation Correction 1 3 Lists 2

### Module 9: Binary trees

Module 9: Binary trees Readings: HtDP, Section 14 We will cover the ideas in the text using different examples and different terminology. The readings are still important as an additional source of examples.

### Environments

Environments PLAI Chapter 6 Evaluating using substitutions is very inefficient To work around this, we want to use a cache of substitutions. We begin evaluating with no cached substitutions, then collect

### Types of recursion. Readings: none. In this module: a glimpse of non-structural recursion. CS 135 Winter : Types of recursion 1

Types of recursion Readings: none. In this module: a glimpse of non-structural recursion CS 135 Winter 2018 07: Types of recursion 1 Structural vs. general recursion All of the recursion we have done to

### CS61A Discussion Notes: Week 11: The Metacircular Evaluator By Greg Krimer, with slight modifications by Phoebus Chen (using notes from Todd Segal)

CS61A Discussion Notes: Week 11: The Metacircular Evaluator By Greg Krimer, with slight modifications by Phoebus Chen (using notes from Todd Segal) What is the Metacircular Evaluator? It is the best part

### SCHEME 7. 1 Introduction. 2 Primitives COMPUTER SCIENCE 61A. October 29, 2015

SCHEME 7 COMPUTER SCIENCE 61A October 29, 2015 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

### SCHEME AND CALCULATOR 5b

SCHEME AND CALCULATOR 5b COMPUTER SCIENCE 6A July 25, 203 In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

### Welcome to CS 115 (Winter 2019)

Welcome to CS 115 (Winter 2019) Web page (the main information source): http://www.student.cs.uwaterloo.ca/ cs115/ Course Personnel: Contact information and office hours for all staff: instructors, ISAs

### CSE413: Programming Languages and Implementation Racket structs Implementing languages with interpreters Implementing closures

CSE413: Programming Languages and Implementation Racket structs Implementing languages with interpreters Implementing closures Dan Grossman Fall 2014 Hi! I m not Hal J I love this stuff and have taught

### Outline. Data Definitions and Templates Syntax and Semantics Defensive Programming

Outline Data Definitions and Templates Syntax and Semantics Defensive Programming 1 Data Definitions Question 1: Are both of the following data definitions ok? ; A w-grade is either ; - num ; - posn ;

### Spring 2018 Discussion 7: March 21, Introduction. 2 Primitives

CS 61A Scheme Spring 2018 Discussion 7: March 21, 2018 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme

### Spring 2018 Discussion 7: March 21, Introduction. 2 Primitives

CS 61A Scheme Spring 2018 Discussion 7: March 21, 2018 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme

### 6.001 Notes: Section 15.1

6.001 Notes: Section 15.1 Slide 15.1.1 Our goal over the next few lectures is to build an interpreter, which in a very basic sense is the ultimate in programming, since doing so will allow us to define

### Documentation for LISP in BASIC

Documentation for LISP in BASIC The software and the documentation are both Copyright 2008 Arthur Nunes-Harwitt LISP in BASIC is a LISP interpreter for a Scheme-like dialect of LISP, which happens to have

### Functions that return lists

342 Chapter 23 Functions that return lists If you did exercises 22.5.15 or 22.5.16, you ve already written some functions that return lists, but only in a very simple way: adding one new element to the

### Types of recursion. Structural vs. general recursion. Pure structural recursion. Readings: none. In this module: learn to use accumulative recursion

Types of recursion Readings: none. In this module: learn to use accumulative recursion learn to recognize generative recursion CS 135 Fall 2018 07: Types of recursion 1 Structural vs. general recursion

### Fall 2018 Discussion 8: October 24, 2018 Solutions. 1 Introduction. 2 Primitives

CS 6A Scheme Fall 208 Discussion 8: October 24, 208 Solutions Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write

### CS115 - Module 4 - Compound data: structures

Fall 2017 Reminder: if you have not already, ensure you: Read How to Design Programs, sections 6-7, omitting 6.2, 6.6, 6.7, and 7.4. Compound data It often comes up that we wish to join several pieces

### 6.001 Notes: Section 4.1

6.001 Notes: Section 4.1 Slide 4.1.1 In this lecture, we are going to take a careful look at the kinds of procedures we can build. We will first go back to look very carefully at the substitution model,

### Assignment: 7. Due: Language level: Allowed recursion:

Assignment: 7 Due: Language level: Allowed recursion: CS 135 Winter 2018 Graham, Nijjar Tuesday, March 13th, 2018 9:00pm Beginning Student with List Abbreviations Pure Structural and Structural Recursion

### CS 342 Lecture 7 Syntax Abstraction By: Hridesh Rajan

CS 342 Lecture 7 Syntax Abstraction By: Hridesh Rajan 1 Reading SICP, page 11-19, Section 1.1.6 Little Schemer, Chapter 2 2 The Idea of Syntax Abstraction Problem. Often programming tasks are repetitive,

### CSE341: Programming Languages Lecture 17 Implementing Languages Including Closures. Dan Grossman Autumn 2018

CSE341: Programming Languages Lecture 17 Implementing Languages Including Closures Dan Grossman Autumn 2018 Typical workflow concrete syntax (string) "(fn x => x + x) 4" Parsing Possible errors / warnings

### Functional Programming. Big Picture. Design of Programming Languages

Functional Programming Big Picture What we ve learned so far: Imperative Programming Languages Variables, binding, scoping, reference environment, etc What s next: Functional Programming Languages Semantics

### Wellesley College CS251 Programming Languages Spring, 2000 FINAL EXAM REVIEW PROBLEM SOLUTIONS

Wellesley College CS251 Programming Languages Spring, 2000 FINAL EXAM REVIEW PROBLEM SOLUTIONS This document contains solutions to the problems on the final exam review problems posted earlier except for

### Style and Submission Guide

Style and Submission Guide 1 Assignment Style Guidelines The code you submit for assignments, as with all code you write, can be made more readable and useful by paying attention to style. This includes

### Welcome to CS 115 (Winter 2018)

Welcome to CS 115 (Winter 2018) Web page (the main information source): http://www.student.cs.uwaterloo.ca/ cs115/ Course Personnel: Contact information and office hours for all staff: instructors, ISAs

### CS 135 Winter 2018 Tutorial 8: Mutual recursion, nested lists, and local. CS 135 Winter 2018 Tutorial 8: Mutual recursion, nested lists, and local 1

CS 135 Winter 2018 Tutorial 8: Mutual recursion, nested lists, and local CS 135 Winter 2018 Tutorial 8: Mutual recursion, nested lists, and local 1 Goals of this tutorial You should be able to... write

### Homework 6: Higher-Order Procedures Due: 11:59 PM, Oct 16, 2018

Integrated Introduction to Computer Science Klein Homework 6: Higher-Order Procedures Due: 11:59 PM, Oct 16, 2018 Contents 1 Fun with map (Practice) 2 2 Unfold (Practice) 3 3 Map2 3 4 Fold 4 5 All You

### Module 4: Compound data: structures

Module 4: Compound data: structures Readings: Sections 6 and 7 of HtDP. Sections 6.2, 6.6, 6.7, 7.4, and 10.3 are optional readings; they use the obsolete draw.ss teachpack. The teachpacks image.ss and

### CS115 - Module 8 - Binary trees

Fall 2017 Reminder: if you have not already, ensure you: Read How to Design Programs, Section 14. Binary arithmetic expressions Operators such as +,,, and take two arguments, so we call them binary operators.

### Comp 311: Sample Midterm Examination

Comp 311: Sample Midterm Examination October 29, 2007 Name: Id #: Instructions 1. The examination is closed book. If you forget the name for a Scheme operation, make up a name for it and write a brief

### How to Design Programs

How to Design Programs How to (in Racket): represent data variants trees and lists write functions that process the data See also http://www.htdp.org/ 1 Running Example: GUIs Pick a fruit: Apple Banana

### Typed Scheme: Scheme with Static Types

Typed Scheme: Scheme with Static Types Version 4.1.1 Sam Tobin-Hochstadt October 5, 2008 Typed Scheme is a Scheme-like language, with a type system that supports common Scheme programming idioms. Explicit

### Functional Programming

Functional Programming CS331 Chapter 14 Functional Programming Original functional language is LISP LISt Processing The list is the fundamental data structure Developed by John McCarthy in the 60 s Used

### Scheme as implemented by Racket

Scheme as implemented by Racket (Simple view:) Racket is a version of Scheme. (Full view:) Racket is a platform for implementing and using many languages, and Scheme is one of those that come out of the

### Module 4: Compound data: structures

Module 4: Compound data: structures Readings: Sections 6 and 7 of HtDP. Sections 6.2, 6.6, 6.7, 7.4, and 10.3 are optional reading; they use the obsolete draw.ss teachpack. The teachpacks image.ss and

### CS 115 Lecture Notes Winter 2019

CS 115 Lecture Notes Winter 2019 Collin Roberts January 8, 2019 Contents 1 Lecture 01 6 1.1 Administrivia........................... 6 1.2 Introduction to CS 115 - Course Website and Slides 1-9.... 6 1.3

### The Typed Racket Guide

The Typed Racket Guide Version 5.3.6 Sam Tobin-Hochstadt and Vincent St-Amour August 9, 2013 Typed Racket is a family of languages, each of which enforce

### CS 135 Winter 2018 Tutorial 7: Accumulative Recursion and Binary Trees. CS 135 Winter 2018 Tutorial 7: Accumulative Recursion and Binary Trees 1

CS 135 Winter 2018 Tutorial 7: Accumulative Recursion and Binary Trees CS 135 Winter 2018 Tutorial 7: Accumulative Recursion and Binary Trees 1 Goals of this tutorial You should be able to... understand

### CS 314 Principles of Programming Languages

CS 314 Principles of Programming Languages Lecture 18: Functional Programming Zheng (Eddy) Zhang Rutgers University April 9, 2018 Review: Defining Scheme Functions (define ( lambda (

### Announcements. The current topic: Scheme. Review: BST functions. Review: Representing trees in Scheme. Reminder: Lab 2 is due on Monday at 10:30 am.

The current topic: Scheme! Introduction! Object-oriented programming: Python Functional programming: Scheme! Introduction! Numeric operators, REPL, quotes, functions, conditionals! Function examples, helper

### Use recursion to write a function that duplicates the following function: (def (f L) (map (lambda (x) (+ (sqr x) x)) L))

Write a function (multiply-each L n). It consumes a (listof Num) and a Num, and returns the list containing all the values in L, each multiplied by n. (multiply-each (list 2 3 5) 4) => (list 8 12 20) Write

### SCHEME The Scheme Interpreter. 2 Primitives COMPUTER SCIENCE 61A. October 29th, 2012

SCHEME COMPUTER SCIENCE 6A October 29th, 202 In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs, we will eventually

### Concepts of programming languages

Concepts of programming languages Lecture 7 Wouter Swierstra 1 Last time Relating evaluation and types How to handle variable binding in embedded languages? 2 DSLs: approaches A stand-alone DSL typically

### 6.184 Lecture 4. Interpretation. Tweaked by Ben Vandiver Compiled by Mike Phillips Original material by Eric Grimson

6.184 Lecture 4 Interpretation Tweaked by Ben Vandiver Compiled by Mike Phillips Original material by Eric Grimson 1 Interpretation Parts of an interpreter Arithmetic calculator

### Loops in Scheme, II. (early slides assume map/filter)

Loops in Scheme, II (early slides assume map/filter) c. Kathi Fisler, 2001 Recap: filter and map filter and map are Scheme s loops filter : (α! boolean) list[α]! list[α] extract list of elts that satisfy

### Homework 6: Higher-Order Procedures Due: 10:00 PM, Oct 17, 2017

Integrated Introduction to Computer Science Hughes Homework 6: Higher-Order Procedures Due: 10:00 PM, Oct 17, 2017 Contents 1 Fun with map (Practice) 2 2 Unfold (Practice) 3 3 Map2 3 4 Fold 4 5 All You

### Func+on applica+ons (calls, invoca+ons)

Func%ons in Racket Racket Functions: most important building block in Racket (and 25) Functions/procedures/methods/subroutines abstract over computations Like Java methods, Python functions have arguments

### A Brief Introduction to Scheme (I)

A Brief Introduction to Scheme (I) Philip W. L. Fong pwlfong@cs.uregina.ca Department of Computer Science University of Regina Regina, Saskatchewan, Canada Scheme Scheme I p.1/44 Scheme: Feature Set A

### CSU211 Exam 2 Fall 2007

CSU211 Exam 2 Fall 2007 Name: Student Id (last 4 digits): Instructor s Name: Write down the answers in the space provided. You may use the usual primitives and expression forms, including those suggested

### Lambda the Ultimate. Corky Cartwright Vivek Sarkar Department of Computer Science Rice University

Lambda the Ultimate Corky Cartwright Vivek Sarkar Department of Computer Science Rice University 1 Function filter2: variant of filter1 function from last lecture ;; filter2 : test lon -> lon ;; to construct

### For this chapter, switch languages in DrRacket to Advanced Student Language.

Chapter 30 Mutation For this chapter, switch languages in DrRacket to Advanced Student Language. 30.1 Remembering changes Suppose you wanted to keep track of a grocery shopping list. You could easily define

### Graphs. Directed graphs. Readings: Section 28

Graphs Readings: Section 28 CS 135 Winter 2018 12: Graphs 1 Directed graphs A directed graph consists of a collection of vertices (also called nodes) together with a collection of edges. An edge is an

### Functions & First Class Function Values

Functions & First Class Function Values PLAI 1st ed Chapter 4, PLAI 2ed Chapter 5 The concept of a function is itself very close to substitution, and to our with form. Consider the following morph 1 {

### Racket Style Guide Fall 2017

CS17 Integrated Introduction to Computer Science Hughes Racket Style Guide Fall 2017 Contents 1 Introduction 1 2 Naming 1 3 Formatting 1 4 Equality 3 5 Conditionals 4 5.1 Prefer Cond to If......................................

### CSC 533: Programming Languages. Spring 2015

CSC 533: Programming Languages Spring 2015 Functional programming LISP & Scheme S-expressions: atoms, lists functional expressions, evaluation, define primitive functions: arithmetic, predicate, symbolic,

### LECTURE 16. Functional Programming

LECTURE 16 Functional Programming WHAT IS FUNCTIONAL PROGRAMMING? Functional programming defines the outputs of a program as a mathematical function of the inputs. Functional programming is a declarative

### Organization of Programming Languages CS3200/5200N. Lecture 11

Organization of Programming Languages CS3200/5200N Razvan C. Bunescu School of Electrical Engineering and Computer Science bunescu@ohio.edu Functional vs. Imperative The design of the imperative languages

### 11/6/17. Functional programming. FP Foundations, Scheme (2) LISP Data Types. LISP Data Types. LISP Data Types. Scheme. LISP: John McCarthy 1958 MIT

Functional programming FP Foundations, Scheme (2 In Text: Chapter 15 LISP: John McCarthy 1958 MIT List Processing => Symbolic Manipulation First functional programming language Every version after the

### Project 5 - The Meta-Circular Evaluator

MASSACHVSETTS INSTITVTE OF TECHNOLOGY Department of Electrical Engineering and Computer Science 6.001 Structure and Interpretation of Computer Programs Spring Semester, 2005 Project 5 - The Meta-Circular

### Introduction to Functional Programming in Racket. CS 550 Programming Languages Jeremy Johnson

Introduction to Functional Programming in Racket CS 550 Programming Languages Jeremy Johnson 1 Objective To introduce functional programming in racket Programs are functions and their semantics involve

### Scheme. Functional Programming. Lambda Calculus. CSC 4101: Programming Languages 1. Textbook, Sections , 13.7

Scheme Textbook, Sections 13.1 13.3, 13.7 1 Functional Programming Based on mathematical functions Take argument, return value Only function call, no assignment Functions are first-class values E.g., functions

### Racket. CSE341: Programming Languages Lecture 14 Introduction to Racket. Getting started. Racket vs. Scheme. Example.

Racket Next 2+ weeks will use the Racket language (not ML) and the DrRacket programming environment (not emacs) Installation / basic usage instructions on course website CSE34: Programming Languages Lecture