ITEC 380 2012fall ibarland tlewis32

home—lectures—exams—hws—breeze (snow day)

lect09a
Trees in Java

Hey, please don't forget the methodology used every hw, lect: (from lect02b):

Design recipe:
1. data def'n
2. examples of data

3. write function header, signature, purpose
4. case anlaysis
5. inventory
6. natural recursion
7. fill in

Go over lect08-Ancestor-Trees-java/. Write List<String> AncTree.allNames().

Aside: the meaning(s) of null

Btw, compare this to the traditional approach to trees in CS2: in our approach we don't actually mention null, and we won't have any NullPointerExceptions. In traditional binary trees, null is used to represent data -- it represents the empty tree(Node). BUT: you can't call any methods on null (even though it makes sense to call methods on an empty tree). Even worse, the traditional type declaration makes it look like

class Node {
  String name;
  Node left;   // well, a real Node *or* null
  Node right;  // well, a real Node *or* null
  }

The problem stems from the fact that the recursive data definition has three types (Node, emptyTree, and Tree), but the traditional approach program uses one-or-two (Node, null, and …places where we need to check for null-vs.-Node). Without getting the data-definition correct (the one mathematicians use for lists and trees), we suddenly are missing a methodology, and our code no longer can mirror the data.

Note that null certainly does have its uses as a sentinel: for example, a search function might return the object found or null. (In racket, false is the idiomatic sentinel.) Since null type-checks as any type, we can still say our function returns a Node to appease the type-checker; in comments we say "this function returns a Node or null". The important thing to remember is that anybody who calls the function needs to treat the result as a union type, and do a cond or dispatch on it. In Java, the type system fails to remind us of this, and programmers easily forget.

Haskell has an interesting approach: They use the composite pattern to represent the union of null-or-something. In java-ish terms:

// A non-helpful Java implementation of Haskell's Maybe/Just/Nothing types:

abstract class Maybe<T> {}

<T> class Nothing extends Maybe<T> {}  // The "null" case.

class Just<T> extends Maybe<T> {
  T val;
  Maybe(T _val) { this.val = val; }
  }
   

Btw: Objects.html
Note that this class is created so that we have null-safe variants of common methods; they are therefore necessarily static methods.

How many ways are there, to call a function in Java?

   Java:  obj.meth(...)    [also with implicit 'this']
          Class.meth(...)
          a + b            (+ a b)
          !a               (not a)
          new int[23]      (make-vector 23 0)        or: (build-vector 23 (lambda (i) (* 3 i)))
          arr[i]           (vector-ref arr i)        Btw, compare to List.get(i)
          arr[i] = ...     (vector-set! arr i ...)   Btw, compare to List.set(i,...)

          new Widget(...)  (make-widget ...)
          super(...)       
          this(...)
          obj.f            (widget-f obj)
          obj.f = ...      (set-widget-f! obj ...)
          (String literals call string constructor?)

Although "assigning to a field" and "assigning to a variable" look virtually the same in Java, they are really very different. In racket, they have different names: set! for variables, vs. set-struct-field! for structures.

          obj.f = ...      (set-widget-f! obj ...)

          int a = 17;      (define a 17)
          a = 99;          (set! a 99)

  int a = 17;
  // some code that doesn't mention `a`
  System.out.print( a );  // MUST be 17. 

  
  Widget obj = ...
  obj.f = 17;
  // some code that doesn't mention `obj.f`, or even `obj`
  System.out.print( obj.f );  // might have been modified!

lect09c: Show grammar for N0; give examples of expressions *and* parse trees; give internal-representation data def'n, and examples Discuss what read,eval,print should do, and go over the recursive-descent parsing.

lect10a: Give an example for testing `parse` (expected result: a tree); talk about `substitute`. This led to discussions re how identifiers will be represented.

home—lectures—exams—hws—breeze (snow day)

©2012, Ian Barland, Radford University Last modified 2012.Nov.02 (Fri)

Please mail any suggestions (incl. typos, broken links) to ibarlandradford.edu