BYU CS classes

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====Objective:====

Learn how to use first-class and higher-order functions:
  * First-class functions
  * Anonymous functions
  * Map (including andmap and ormap)
  * Filter
  * Fold

----

====Preparation:====

You will again use DrRacket, which you should have downloaded and installed for the previous labs.

----

====Deliverables:====

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''
  * ''check-temps1''
  * ''check-temps''
  * ''convert''
  * ''duple''
  * ''average''
  * ''eliminate-larger''

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 ===
<code racket>
(define (curry2 func) ...)
</code>
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.

----

====Notes:====

You again **do not** need to bulletproof the code to enforce proper 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.

----

====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.
BYU CS classes

User Tools

Site Tools

Page Tools
