User Tools

Site Tools


cs330_f2016:rackethof

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision
Previous revision
cs330_f2016:rackethof [2016/09/06 16:24]
morse
cs330_f2016:rackethof [2021/06/30 23:42] (current)
Line 4: Line 4:
   * First-class functions   * First-class functions
   * Anonymous functions   * Anonymous functions
-  * Map+  * Map (including andmap and ormap)
   * Filter   * Filter
   * Fold   * Fold
Line 18: Line 18:
 ====Deliverables:​==== ====Deliverables:​====
  
-For this lab, you will need to reimplement the following functions from the previous lab using Racket'​s higher-order functions ''​map'',​ ''​filter'', ​and ''​foldr'':​+For this lab, you will need to reimplement the following functions from the previous lab using Racket'​s higher-order functions ''​map'' ​(including ''​andmap''​ and ''​ormap''​), ''​filter'', ​or ''​foldr''​. You may not use functions that take or return indices, such as ''​index-of''​ or ''​list-ref'':​
   * ''​convertFC''​   * ''​convertFC''​
   * ''​check-temps1''​   * ''​check-temps1''​
Line 27: Line 27:
   * ''​eliminate-larger''​   * ''​eliminate-larger''​
  
-In addition, you will need to implement the following ​functions:+You must write these using higher-order functions rather than implementing the recursion yourself. ​  
 +As with the previous lab, you may not use ''​set!''​. 
 + 
 +In addition, you will need to implement the following ​function:
   * ''​curry2''​   * ''​curry2''​
  
Line 34: Line 37:
 (define (curry2 func) ...) (define (curry2 func) ...)
 </​code>​ </​code>​
-where ''​fun''​ is a two-parameter function and the result is a curried version of that two-parameter function.+where ''​func''​ is a two-parameter function and the result is a curried version of that two-parameter ​function. 
 + 
 +You may not use any built-in curry functions to implement this. 
 + 
 +Hint: You **don'​t** need to know what the function passed in actually does. All you need to know is that it requires two parameters, and once you have those parameters you use the function.
  
 ---- ----
Line 42: Line 49:
 You again **do not** need to bulletproof the code to enforce proper inputs.  ​ You again **do not** need to bulletproof the code to enforce proper inputs.  ​
 Your code only needs to return correct values given correct inputs. Your code only needs to return correct values given correct inputs.
 +
 +You may also use other higher-order functions such as ''​andmap'',​ ''​ormap'',​ etc., but these are not required ​ These short-circuit the map-and-fold process rather than performing all of the mapping and then folding the results. ​ You will find that trying to pass the ''​and''​ and ''​or''​ operators to higher-order functions won't work because they are special forms and not just ordinary functions.
  
 ---- ----
Line 47: Line 56:
 ====Hints:​==== ====Hints:​====
  
 +  * Look at the pattern or recursion used for each problem in the previous assignment and then choose a suitable higher-order function for that.
 +  * Remember:
 +    * If you want to do something to each element of a list one-by-one and return a list of the results, use ''​map''​.
 +    * If you want to test each element of a list using a true/false predicate and get a list of those that pass the test, use ''​filter''​. ​ (If you want to see if any or all of the elements in the list pass the test, look at ''​ormap''​ and ''​andmap'',​ respectively. You can also see if any passed the test by checking whether the result of ''​filter''​ is an empty list.)
 +    * If you want to recurse through the list and at each level do something to the first thing in the list and the already-recursed-through rest of the list, use ''​foldr''​. ​ (This is quite general, and you can even use it instead of ''​map''​ or ''​filter'',​ but you might find the other two easier in many cases. ​ But some will require using ''​foldr''​.)
 +  * When using ''​foldr'',​ the trick is to figure out what to use for the folding operator. ​ Remember that when called it will receive two parameters: the first thing in the list and the ** already folded ** rest of the list. (There'​s a bit of a leap of faith here, just like recursion.) ​ Then think about what it is you want to do with those two pieces of data.  Be careful with your selection of the base for the folding as well and use what you would return for the empty list.
 +  * If your recursive implementation of some of these involved a helper function that also recursed through some list (or sublist), consider using two higher-order functions, one for each recursive function that you wrote earlier.
cs330_f2016/rackethof.1473179093.txt.gz · Last modified: 2021/06/30 23:40 (external edit)