[an error occurred while processing this directive]

<center><h2>Class 21 Notes</h2></center>

<div class=reading>
<center>
<a href="../slides/class21-2x3.pdf">Lecture Slides, Suitable For Printing</a> 
</center> 
</div> 

<h3>Lazy Data</h3>

How does lazy evaluation enable infinite data structures?
<p><Br><p><Br><p><Br><p><Br><p><Br>

<pre>
(define ints-from
    (lambda (n)
       (cons n (ints-from (+ n 1)))))
</pre>

<pre>
(define fibo-gen (lambda (a b)
     (cons a (fibo-gen ____  __________))))

(define fibos (fibo-gen 0 1))

(define get-nth (lambda (lst n)
   (if (= n 0) (car lst) (get-nth (cdr lst) (- n 1)))))

(define fibo (lambda (n) (get-nth _______ n)))
</pre>

<pre>
(define merge-lists
   (lambda (lst1 lst2 proc)
      (if (null? lst1) null
           (if (null? lst2) null
               (cons (proc (car lst1) (car lst2))
                      (merge-lists (cdr lst1) (cdr lst2) proc))))))

(define fibos
   (cons 0 (cons 1 (merge-lists ___________  ______________ +))))
</pre>


<h3>Types</h3>

When is it a good idea to give up expressiveness?
<p><Br><p><br><p><br><p>

What is the difference between manifest and latent types?
<p><Br><p><br><p><br><p>

What is the difference between static and dynamic type checking?
<p><Br><p><br><p><br><p>

What does increasing the strictness of a language's type checking do?
<p><Br><p><br><p><br><p>

What are the advantages and disadvantages of static type checking?
<p><Br><p><br><p><br><p>

<h4>Type Language</h4>

<em>CType</em> ::= <em>CPrimitiveType </em><br>
<em>CType</em> ::= <em>CProcedureType </em><br>
<em>CType</em> ::= <em>CProductType</em><br>
<p>
<em>CPrimitiveType</em> ::= <b>Number</b> | <b>Boolean</b><br>
<em>CProcedureType</em> ::= <b>(</b> <em>CProductType</em> <b>-&gt;</b> <em>Type</em><b>)</b><br>
<em>CProductType</em> ::= <b>(</b> <em>CTypeList</em> <b>)</b><br>
<em>CTypeList</em> ::= <em>CType</em> <em>CTypeList</em><br>
<em>CTypeList</em> ::= 
<p>
<p>
What is the type of:
<ul>
<li> <tt>zero?</tt>
<p><br>
<li> <tt>(lambda (x:Number) (+ x x))</tt>
<p><br>
<li> <pre>
(lambda (f:((Number) -> Number) g:((Number) -> Number))
      (lambda (x:Number)
         (f (g x)))))
</pre>
</li>
</pre>

<h4>StaticCharme</h4>

<pre>
class CPrimitiveType(CType): 
   def __init__(self, s): 
       self._name = s 
   def __str__(self): 
       return self._name 
   def isPrimitiveType(self): 
       return True 
   def matches(self, other): 
      return other.isPrimitiveType() \
             and ________________________
</pre>

<pre>
class CProcedureType(CType): 
   def __init__(self, args, rettype): 
      self._args = args 
      self._rettype = rettype 
   def __str__(self): 
      return "(" + str(self._args) + " -> " \
                 + str(self._rettype) + ")" 
   def isProcedureType(self): return True 
   def getReturnType(self): return self._rettype 
   def getParameters(self): return self._args 
   def matches(self, other): 

      return ________________________________

         and ___________________________________________

         and ___________________________________________
</pre>

<pre>
def typecheck(expr, env): 
   if isPrimitive(expr): 
      return typePrimitive(expr) 
   elif isConditional(expr): 
      return typeConditional(expr, env) 
   elif isLambda(expr): 
      return typeLambda(expr, env) 
   elif isDefinition(expr): 
      typeDefinition(expr, env) 
   elif isName(expr): 
      return typeName(expr, env) 
   elif isApplication(expr): 
      return typeApplication(expr, env) 
   else: evalError ("Unknown expression: " + str(expr)) 
</pre>

<pre>
class Environment:
    # Store a [type, value] pair for each variable.
    ...    
    def addVariable(self, name, typ, value):
        self._frame[name] = (typ, value)
    def lookupPlace(self, name):
        if self._frame.has_key(name): return self._frame[name]
        elif (self._parent): return self._parent.lookupPlace(name)
        else: return None
    def lookupVariableType(self, name):
        place = _____________________

        if place: return ______________
        else: return CErrorType("Name not found")
    def lookupVariable(self, name):
        return self.lookupPlace(name)[1]
      ...
</pre>

<pre>
def typeDefinition(expr, env):
    assert isDefinition(expr)
    if len(expr) != 5:
        evalError ("Bad definition: %s" % str(expr))
    name = expr[1]
    if isinstance(name, str):
        if expr[2] != ':':
            evalError ("Definition missing type: %s" % str(expr))        
        typ = CType.fromParsed(expr[3])

        etyp = __________________________
        if not typ.matches(etyp):
            evalError("Mistyped definition: ..." % (name, typ, etyp))
    elif isinstance(name, list):
        evalError ("Procedure definition syntax not implemented")
    else: evalError ("Bad definition: %s" % str(expr))
</pre>

<pre>
def typeLambda(expr, env): # error checking code removed
    newenv = Environment(env)
    params = expr[1]
    paramnames = []
    paramtypes = []
    for i in range(0, len(params) / 3):
        name = params[i*3]
        typ = CType.fromParsed(params[(i*3)+2])
        paramnames.append(name)
        paramtypes.append(typ)

        newenv._________________________________

    resulttype = ___________(expr[2], newenv)
    return CProcedureType(CProductType(paramtypes), resulttype)
</pre>


[an error occurred while processing this directive]