Consider the following piece of code.

  val x = 1
  val y = 2
  def p() = x + y
  def q(p: Int => Int) = p(x * y)
  def f = {
    val x = 2
    q(p + _)
  }
  def g(q: Int => Int) = {
    val y = 3
    def p() = x - y
    q(f)
  }
  print(g(_ + 2))

Determine the output of the code using static scoping and dynamic scoping.

If the following programs type-check according to the rules given in the course, give the corresponding type derivation tree, otherwise give a partial tree that shows where it doesn't work

a)

  var x:Int
  var y:Int
  if (1 > 42) x
  else y
  x = y

b)

  var x: Int
  var y: Int
  if (0 > 0) {
    if (3 > 4) {x = y}
    else {y = x}
  }
  else
    if (4 > 3) {x = x}
    else {y = y}

c)

 class C {
  def f(x: Int): Int = 1+f(x)  
}
 

Write down the type derivation tree for the following example. Does the program type check?

class Fun {
  val u :Boolean
  var a :Boolean 
  def f(y: Boolean): Boolean = {
    a = y
    if (u == y) {
      var u: Int = 0
      a = f(u < 0)
      return u < 0
    } else 
      return u > 0 
  }
}