Class 21: Type checking declarations

Held Friday, October 21, 1998

Notes

• Nathaniel Borenstein will be visiting campus the first two weeks of the second half of this semester.
  • As part of his visit, he is giving the convocation speech on October 29th. Typically, students are invited to a post-convocation lunch. If you are interested in attending that lunch, please let Mr. Adelberg know before you depart for break.
  • A very rough draft of his schedule is available online.
• Reminder: exams are due at the beginning of class today unless you've already made other arrangements.
• Have a wonderful break. Come back refreshed and ready to discuss lots of topics in depth.

Type Checking and Declarations

• Note that declarations are somewhat different than expressions, in that while most expressions require only an analysis of type, declarations can also modify the environment.
  • Expressions can also modify the environment (e.g., let expressions).
  • Are there others beside let?
• Some declarations are easy to type check, as they just involve updating the table (and perhaps type-checking an initializer).
• For example, to type check a variable declaration, you need to check the type of the initializer and, if there's an explicit type, confirm that the two are the same. Then you update the environment.
• Nonrecursive function and type declarations are similarly simple.

Recursive declarations

• Recursive declarations (such as those for types or functions) can be more complicated.
• Appel suggests entering the ``headers'' of the definitions first, and then processing the bodies.
• In types, you can also use named types to handle the indirection.
• Here's a rough example for translating sequences of functions

  for each function in the sequence
    add the function ``header'' (name, parameter types, return type)
      to the environment
  end for each
  for each function in the sequence
    begin a new environment
    add all of the parameters to the environment
    type-check the body of the function
    end the new environment
  end for each
  

A note on function types

• It seems that we can determine the type of many things ``automatically''. Tiger takes advantage of this in permitting programmers to elide the type of variables (since that type can be determined from the type of the initializer).
• Why don't we do the same with functions? That is, why must functions have explicit return types (other than the decision that ``no return type'' = ``procedure'').
• It turns out to be difficult to determine the types of recursive functions. Consider how we might determine a type for

  function f(i:int) = f(i+1)
  

• Observe that the code on p. 99 of the green book is therefore incorrect.

History

• Created Friday, October 16, 1998, almost completely from the outline of the previous class. (Notice a trend?)
• On Sunday, October 25, 1998, moved the section on "run time" to the subsequent outline.