Evaluation Strategy

Table of Contents

• Evaluation Strategy
• Table of Contents
• Call By Value
• Call By Reference
• Call By Result
• Call By Value-Result
• Call By Name
• Call By Need

Call By Value

Copies the arguments into the callee.

Pros:

• Immutability via copying.

Cons:

• If values are large, slow copying.
• If we try to pass by address, leads to unreliable code.

Call By Reference

Passes arguments as references into callee.

Pros:

• Large objects do not need to be copied.

Cons:

• Cause trouble with shared variables because now all objects have state. Especially bad with heap variables.

Call By Result

Passes arguments into the function, with 1 of them being a reference to the result that the function fills in.

Pros:

• Useful if want multiple return values(i.e. answer, error codes, etc)

Cons:

• Caller needs to do extra work, API complicates.

Call By Value-Result

Same as call by result, but that parameter that will contain the value, will also be used as a variable before the answer is filled in.

Pros:

• Saving space, maybe?

Cons:

• Really complicates the strategy

Call By Name

Calls by name sends the full expression as variables into the function.

For something like:

void f(... a, ... b){
    ...
}

f(x+1, x)

We are legitimately sending an lvalue expression(x+1) that is not yet evaluated, and an rvalue expression(x) that is also not yet evaluated(we don’t know its address) into f.

To get the value out, we kind of treat them as lambdas, and a will give us an lvalue and b will give us an rvalue address. We will be updating whatever x we were using, as if it was passed by reference.

Pros:

• Delays evaluation, so control flow can optimize evaluation scheme.

Cons:

• Really inefficient to write in real life.

Call By Need

The same as call by name, but memoizes the results of the computation. a and b are bounded to the results after their first evaluation.

However, this gives different side-effects:

void f(by-need int a, by-need int b){
    b = a; // 'i = i+1' -> gives us &i = 4.
    // a -> 4
    // b -> &i
    b = a; // Already cached: &i = 4.
}

void g(){
    int i = 3;
    f(i+1, i);
    return i;
}

Pros:

• Caches, so it is much faster than call-by-name
• Doesn’t crash when the crashing parameter isn’t evaluated.

Cons:

• Still hard to implement.