Class summary: Function Evaluation and Practice

Copyright (c) 2017 Kathi Fisler

1 Warm-Up: Ticket Prices

2 How Functions Evaluate

We have talked about how expressions evaluate: from the innermost-expression out, with definitions extending the dictionary. But what happens when we add our own functions? How do programs with functions evaluate? We’ll work this first with a small function, then revisit on the ticket-price function.

2.1 Information Tracked During Evaluation

As a reminder, Pyret tracks two pieces of information at all times:

• The dictionary of known names

• (While evaluating) the current (sub) expression being evaluated.

As we look at how functions affect evaluation, our goal is to be clear on how each of defining and using functions affects these two pieces of information.

2.2 Substitute Arguments into Function Bodies

Assume that we have the following definition, and want to evaluate the expression 5 + cube(2).

Evaluation still goes inside out (and left-to-right), but when we get to call to a user-defined function, we substitute the argument into the body of the function, then continue evaluating. Here’s what the evaluation looks like step-by-step:

In the 2nd line, we replaced the call to cube{2} with the body of cube, but with each use of n replaced with the argument 2. Once the substitution occurs, evaluation continues using the same "inside-out" rule that we had before.

2.3 Handling Expressions as Arguments

What if we had the program cube(3 + 1). Would the first three steps look like:

or

or

The first sequence is correct. By the inside-out rule, Pyret will evaluate the argument (3+1) before it substitutes in the body of the function.

3 Evaluating Functions and If-Expressions

Combining functions and if-expressions doesn’t introduce anything new, but it does reinforce the rules we’ve already learned.

4 How Functions Affect the Dictionary

We have talked about how definitions impact the dictionary of known names within Pyret. How do functions affect the dictionary? Consider the following definitions window contents:

Running this program adds two names to the dictionary: outside and colored-square. The fun construct creates dictionary entries, just as = does.

5 Defining Versus Calling Functions

Does a red square get created when we run the definitions window from the previous section? No. All the fun construct does is augment the dictionary with a new operator.

We only get a red square when we use or call the function. For example, if we type

in the Interactions window, Pyret evaluates the expression with the following sequence:

It is essential to understand that defining and calling functions are two separate actions. Defining a function augments the dictionary, but the function body does not get evaluated when a function is defined. Calling a function evaluates its body.

A function gets defined only once, but it may be called many times, which means its body may be evaluated many times. To see this, consider the following sequence:

The distinction between defining and calling functions is a common stumbling block when people learn programming. Keep the dictionary in mind: we define functions in order to name computations that we’ll use multiple times. Naming is separate from using.

6 More Functions Practice

Here are several problems with which to practice both defining and evaluating functions. Make sure to use the Design Recipe while designing each one, thinking about a good set of examples.

Note that we also write examples for helper functions such as tip. Why? Two reasons: (1) we still want examples to confirm that the function is working properly, and (2) if we get the wrong answer from pizza-cost and have not checked tip, we won’t know which function contains the error.