Adds initial selection of sample programs

Joe the bos, lists, binary trees.

Author: apblack

binaryTrees/binaryTree.grace

@@ -0,0 +1,157 @@
+def ConcurrentModification = ProgrammingError.refine "ConcurrentModification "
+
+method empty {
+    withAll []
+}
+
+class withAll(pairs:Collection) {
+    // answers a new mutable binary tree containing pairs, a which must be
+    // a collection of key-value bindings.
+
+    class nodeContaining(key', data')withChildren(left', right') is confidential {
+        var key is readable := key'
+        var data is public := data'
+        var left is public := left'
+        var right is public := right'
+        method isEmpty { false }
+        method asString { "Node({key}, {data}, {left}, {right})" }
+        method copy { 
+            nodeContaining(key, data) withChildren(left.copy, right.copy)
+        }
+        method height { 1 + max(left.height, right.height) }
+        method do(block1) {
+            left.do(block1)
+            block1.apply(key::data)
+            right.do(block1)
+        }
+    }
+
+    def emptyTree = object {
+        method isEmpty { true }
+        method asString { "emptyTree" }
+        method copy { emptyTree }
+        method height { 0 }
+        method do(block1) { }
+    }
+    
+    method nodeContaining(key, data) is confidential {
+        nodeContaining(key, data) withChildren(emptyTree, emptyTree)
+    }
+
+    var root := emptyTree
+    var size is readable := 0
+    var eventCount := 0
+    
+    addAll(pairs)
+    
+    method height { root.height }   // TODO: should this be confidential?
+
+    method at(key) put(data) {
+        addNode(nodeContaining(key, data))
+    }
+
+    method addNode(newNode) is confidential {
+        eventCount := eventCount + 1
+        def addNode' = { newNode', currentNode -> 
+            if (newNode'.isEmpty) then {
+                currentNode
+            } elseif (currentNode.isEmpty) then {
+                size := size + 1
+                newNode'
+            } elseif (newNode'.key < currentNode.key) then {
+                currentNode.left := addNode'.apply(newNode', currentNode.left)
+                currentNode
+            } elseif (newNode'.key > currentNode.key) then {
+                currentNode.right := addNode'.apply(newNode', currentNode.right)
+                currentNode
+            } else {
+                currentNode.data := newNode'.data
+                currentNode
+            }
+        }
+
+        root := addNode'.apply(newNode, root)
+    }
+
+    method addAll(newPairs) {
+        newPairs.do { each -> at(each.key) put(each.value) }
+    }
+
+    method remove(key) {
+        eventCount := eventCount + 1
+        var removedNode := emptyTree
+        var rightBranch := emptyTree
+
+        def remove' = { key', parentNode, currentNode -> 
+            if (currentNode.isEmpty) then {
+                NoSuchObject.raise "Can't remove key {key} because it is not present"
+            } elseif (key' < currentNode.key) then {
+                currentNode.left := remove'.apply(key', currentNode, currentNode.left)
+                currentNode
+            } elseif (key' > currentNode.key) then {
+                currentNode.right := remove'.apply(key', currentNode, currentNode.right)
+                currentNode
+            } else {
+                size := size - 1
+                removedNode := currentNode
+                rightBranch := currentNode.right
+                currentNode.left
+            }
+        }
+
+        root := remove'.apply(key, emptyTree, root)
+        addNode(rightBranch)
+        if (!rightBranch.isEmpty) then { size := size - 1 } 
+        removedNode.key::removedNode.data
+    }
+    method at(key) {
+        def at' = { key', currentNode -> 
+            if (currentNode.isEmpty) then {
+                NoSuchObject.raise
+            } elseif (key' < currentNode.key) then {
+                at'.apply(key', currentNode.left)
+            } elseif (key' > currentNode.key) then {
+                at'.apply(key', currentNode.right)
+            } else {
+                return currentNode.data
+            }
+        }
+        at'.apply(key, root)
+    }
+    method isEmpty { root.isEmpty }
+    method asString { root.asString }
+    method copy {
+        def newTree = outer.with
+        newTree.addNode(root.copy) 
+        newTree
+    }
+    method do(block1) {
+        root.do(block1)
+    }
+    class iterator<T> {
+        def zipper is readable = list []
+        def savedEventCount = eventCount
+        addLeftmostPath(root)
+        method addLeftmostPath(start) is confidential {
+            var n := start
+            while { n.isEmpty.not } do {
+                zipper.addLast(n) 
+                n := n.left
+            }
+        }
+        method hasNext { zipper.isEmpty.not }
+        method next {
+            if (savedEventCount != eventCount) then {
+                ConcurrentModification.raise "the tree has changed!"
+            }
+            if (!hasNext) then {
+                IteratorExhausted.raise "on Tree" 
+            } 
+            def current = zipper.removeLast
+            addLeftmostPath(current.right)
+            current.key::current.data
+        }
+    }
+}
+
+

binaryTrees/binaryTreeTest.grace

@@ -0,0 +1,138 @@
+import "gUnit" as gU
+import "binaryTree" as tree
+import "unicode" as u
+
+def binaryTreeTest = object {
+    class forMethod(m) {
+        inherits gU.testCaseNamed(m)
+
+        method tournamentTree(grow, lo, hi) {
+            if (lo <= hi) then {
+                def k = ((lo + hi) / 2).truncated
+                def d = u.create("a".ord - 1 + k)
+                grow.at(k) put (d)
+                tournamentTree(grow, lo, k-1)
+                tournamentTree(grow, k+1, hi)
+            }
+        }
+
+        method testTournamentTreeDo {
+            def tt = tree.empty
+            tournamentTree(tt, 1, 26)
+            def l = list []
+            tt.do { each -> l.add(each.value) }
+            assert (l) shouldBe ((1..26).map {n -> u.create("a".ord - 1 + n)})
+        }
+
+        method testIsEmptyOfEmptyTree {
+            assert (tree.empty.isEmpty) shouldBe (true)
+        }
+        method testIssizeEmptyTree {
+            assert (tree.empty.size) shouldBe (0)
+        }
+        method testIsEmptyOfNonEmptyTree {
+            assert (tree.withAll ["a"::1].isEmpty) shouldBe (false)
+        }
+        method testSizeOfNonEmptyTree {
+            assert (tree.withAll ["a"::1].size) shouldBe (1)
+        }
+        method testSizeAfterRemoval {
+            def t = tree.withAll [1::"a"]
+            assert (t.remove(1)) shouldBe (1::"a")
+            assert (t.size) shouldBe (0)
+        }
+        method testAddToEmptyTree {
+            def t = tree.empty
+            t.at(1)put(1)
+            assert (t.isEmpty) shouldBe (false)
+        }
+        method testAtWithOneNode {
+            def t = tree.withAll ["a"::1]
+            assert (t.at("a")) shouldBe (1)
+        }
+        method testAtWithALeftNode {
+            def t = tree.withAll ["b"::1, "a"::2]
+            assert (t.at("a")) shouldBe (2)
+            assert (t.at("b")) shouldBe (1)
+        }
+        method testAtWithARightNode {
+            def t = tree.withAll ["a"::1, "c"::2]
+            assert (t.at("a")) shouldBe (1)
+            assert (t.at("c")) shouldBe (2)
+        }
+        method testRemoveFromEmtpyTree {
+            def t = tree.empty
+            assert { t.remove(1) } shouldRaise (NoSuchObject)
+        }
+        method testRemoveNodeWithNoChildrenFromTree {
+            def t = tree.withAll [1::2]
+            t.remove(1)
+            assert (t.isEmpty) shouldBe (true)
+        }
+        method testRemoveNodeWithRightChildFromTree {
+            def t = tree.withAll [1::"a", 2::"b"]
+            t.remove(1)
+            assert (t.isEmpty) shouldBe (false)
+            assert (t.at(2)) shouldBe ("b")
+        }
+        method testRemoveNodeWithLeftChildFromTree {
+            def t = tree.withAll [2::"b", 1::"a"]
+            t.remove(2)
+            assert (t.isEmpty) shouldBe (false)
+            assert (t.at(1)) shouldBe ("a")
+        }
+        method testRemoveNodeWithBothChildrenFromTree {
+            def t = tree.withAll [2::"b", 1::"a", 3::"c"]
+            t.remove(2)
+            assert (t.isEmpty) shouldBe (false)
+            assert (t.at(1)) shouldBe ("a")
+            assert (t.at(3)) shouldBe ("c")
+        }
+        method testRemoveInnerNodeFromTree {
+            def t = tree.withAll [4::"d", 2::"b", 1::"a", 3::"c"]
+            t.remove(2)
+            assert (t.isEmpty) shouldBe (false)
+            assert (t.at(1)) shouldBe ("a")
+            assert (t.at(3)) shouldBe ("c")
+            assert (t.at(4)) shouldBe ("d")
+        }
+        method testIteratorTT {
+            def tt = tree.empty
+            tournamentTree(tt, 1, 26)
+            def ks = list []
+            def vs = list []
+            def iter = tt.iterator
+            while { iter.hasNext } do { 
+                def each = iter.next
+                ks.add(each.key)
+                vs.add(each.value)
+            }
+            assert (ks) shouldBe ((1..26))
+            assert (vs) shouldBe ((1..26).map {n -> u.create("a".ord - 1 + n)})
+        }
+        method testIterator {
+            def t = tree.withAll [4::"d", 2::"b", 1::"a", 3::"c"]
+            def r = list []
+            def iter = t.iterator
+            while {iter.hasNext} do {
+                r.addLast(iter.next)
+            }
+            def desired = list [1::"a", 2::"b", 3::"c", 4::"d"]
+            assert (r) shouldBe (desired)
+        }
+        method testConcurrentModification {
+            def t = tree.withAll [4::"d", 2::"b", 1::"a", 3::"c"]
+            def r = list []
+            def iter = t.iterator
+            assert {
+                while {iter.hasNext} do {
+                    def n = iter.next
+                    r.addLast(n)
+                    t.at(n.key + 10) put(n.value)
+                }
+            } shouldRaise (tree.ConcurrentModification)
+        }
+    }
+}
+
+gU.testSuite.fromTestMethodsIn(binaryTreeTest).runAndPrintResults

binaryTrees/exploreTree.grace

@@ -0,0 +1,30 @@
+import "unicode" as u
+import "binaryTree" as bt
+
+def t = bt.empty
+
+(1..26).do { each -> 
+    def data = u.create("a".ord - 1 + each)
+    t.at(each) put(data)
+}
+
+for(t) do { each -> print(each) }
+
+print "height of t is {t.height}."
+
+def tt = bt.empty
+
+method tournamentTree(grow, lo, hi) {
+    if (lo <= hi) then {
+        def k = ((lo + hi) / 2).truncated
+        def d = u.create("a".ord - 1 + k)
+        grow.at(k) put (d)
+        tournamentTree(grow, lo, k-1)
+        tournamentTree(grow, k+1, hi)
+    }
+}
+
+tournamentTree(tt, 1, 26)
+for(tt) do { each -> print(each) }
+print "height of tt is {tt.height}."
+

joeTheBox/box.grace

@@ -0,0 +1,71 @@
+//
+// Steve Willoughby
+// Spring 2016
+//
+import "objectdraw" as od
+import "math" as math
+method named(name) {
+  object {
+    var origin is readable := 0@0
+    var heading is public := 0
+    var extent is public := defaultExtent
+    def noRect = object { 
+        inherits Singleton.new
+        def asString is readable = "noRect"
+        method moveTo { }
+        method visible:=(_) { }
+    }
+    var myRect := noRect
+    
+    method defaultExtent {
+        20@20
+    }
+    
+    method turnBy(degrees) {
+        heading := (heading + degrees) %  360 
+    }    
+    
+    method face(degrees) {
+        heading := degrees
+    }
+    method faceEast {
+        // Set heading to 0 degrees explicitly
+        face(0)
+    }
+    
+    method showOn(canvas) {
+        if (myRect == noRect) then {
+            myRect := od.framedRectAt(origin) size(extent) on (canvas)
+        }
+        myRect.visible := true
+    }
+    
+    method hide {
+        myRect.visible := false
+    }
+    
+    method moveTo(location:Point) {
+        origin := location
+        if (myRect ≠ noRect) then {myRect.moveTo(origin)}
+    }
+    
+    method moveBy(increment:Point) {
+        moveTo(origin + increment)
+    }
+    
+    method moveDistance(distance:Number) {
+        // Move in the current heading some distance
+        moveBy(((heading*π/180).cos*distance)@((heading*π/180.0).sin*distance))
+    }
+    
+    method growBy(increment:Point) {
+        extent := extent + increment
+        myRect.setSize(extent)
+    }
+    
+    method asString {
+        "a box named {name}"
+    }
+  }
+}
+