- Concepts of Programming Languages

Strict and Nonstrict Evaluation

Instructor:

Learning Objectives

How much of an expression should be evaluated when computing a result?

• Perform expression evaluation
• Perform function calls and function argument evaluation

Strict and Nonstrict Operators

• A strict construct evaluates all of its operands before it runs

Conditional Expression

Conditional expression if e1 then e2 else e3

• Evaluate e1; if true then evaluate e2, else evaluate e3

for i <- 0 to 10 do
  print(i)
  if i % 2 == 0
  then println(": even")
  else println(": odd")
end for

Conditionals in C

• Conditional statement: executes return 1 or return n*..., never both

int fact (int n) {
  if (n <= 1) {
    return 1;
  } else {
    return n * fact (n - 1);
  }
}

int fact (int n) {
  return (n <= 1) ? 1 : n * fact (n - 1);
}

What Happens?

• Function calls are strict

def f(b: Boolean, t: Unit, f: Unit) : Unit =
  if b then t else f
for i <- 0 to 10 do
  print(i)
  f(i % 2 == 0,
    println(": even"),
    println(": odd"))
end for

• Both "even" and "odd" are printed every time f is invoked

What Happens?

• Thunks: pass-by-name for explicit nonstrict evaluation of function arguments

def f(b: Boolean, t: => Unit, f: => Unit) : Unit =
  if b then t else f
for i <- 0 to 10 do
  print(i)
  f(i % 2 == 0,
    println(": even"),
    println(": odd"))
end for

• "even" and "odd" are printed again alternating

Call-By-Value: Scala

def f(x: Double) : Double =
  val x1 = x
  val x2 = x
  x1 - x2
end f
println("f= " + f (Math.random())) // prints 0 (difference of same random Double)

Call-By-Value: Scala

• Scala allows functions as parameters (no argument: delayed value = thunk)

def g(x: () => Double) : Double =
  val x1 = x()
  val x2 = x()
  x1 - x2
end g
// print difference of 2 random doubles
println ("g= " + g (() => Math.random()))

interface java.util.function.Supplier<T> { T get(); }
class GetRnd implements Supplier<Double> {
  public Double get() { return Math.random(); }
}
class Client {
  public static double g(Supplier<Double> t) {
    double x1 = t.get();
    double x2 = t.get();
    return x1-x2;
  }
}
// print difference of 2 random doubles
System.out.println ("g= " + g (new GetRnd()));
// functional notation without explicit class GetRnd
System.out.println ("g= " + g (() -> Math.random()));

Call-By-Name: Scala

• Scala has a special syntax for using thunks as parameters
• Call-by-name parameters are non-strict

Thunks in Scala

def h(x: => Double) : Double =
  // discouraged use of thunks
  val x1 = x
  val x2 = x
  x1 - x2
end h
// prints difference of 2 random doubles
println ("h= " + h (Math.random()))

Call-By-Name: Scala

• Curried call-by-name functions create new control constructs

  def myWhile (cond: => Boolean) (body: => Unit) : Unit =
    if (cond)
      body
      myWhile (cond) (body)
  end myWhile
  

• Use (brackets {} or parentheses () are required)

  var i = 3
  myWhile (i > 0) {
    println ("i= " + i)
    i = i - 1
  }
  

Summary