From bf3a1be50e548f4350d79bdfbb6353950c2a414a Mon Sep 17 00:00:00 2001
From: Mark Wooding <mdw@distorted.org.uk>
Date: Sat, 6 Apr 2013 18:22:11 +0100
Subject: [PATCH] go-fringe.go: Remove all of the `;' statement terminators.

---
 go-fringe.go | 88 ++++++++++++++++++++++++++++++------------------------------
 1 file changed, 44 insertions(+), 44 deletions(-)

diff --git a/go-fringe.go b/go-fringe.go
index d79760e..44aa438 100644
--- a/go-fringe.go
+++ b/go-fringe.go
@@ -6,19 +6,19 @@
 package main
 
 import (
-	"fmt";
-	"io";
-	"os";
+	"fmt"
+	"io"
+	"os"
 )
 
 ///--------------------------------------------------------------------------
 /// Utilities.
 
-var prog = os.Args[0];
+var prog = os.Args[0]
 
 func bail(msg string) {
-	fmt.Fprintf(os.Stderr, "%s: %s\n", prog, msg);
-	os.Exit(1);
+	fmt.Fprintf(os.Stderr, "%s: %s\n", prog, msg)
+	os.Exit(1)
 }
 
 ///--------------------------------------------------------------------------
@@ -33,39 +33,39 @@ type any interface {}
 
 type Iterable interface {
 	// Simply put the items to the channel CH one at a time.
-	Iterate(ch chan<- any);
+	Iterate(ch chan<- any)
 }
 
 // An iterator.
-type Iterator <-chan any;
+type Iterator <-chan any
 
 // Returns an iterator for a given iterable thing.
 func MakeIterator(it Iterable) Iterator {
-	ch := make(chan any);
+	ch := make(chan any)
 	go func () {
-		it.Iterate(ch);
-		close(ch);
-	} ();
-	return ch;
+		it.Iterate(ch)
+		close(ch)
+	} ()
+	return ch
 }
 
 // Returns the next item from an iterator IT.  If there is indeed an item
 // available, return it and true; otherwise return nil and false.
 func (it Iterator) Next() (any, bool) {
-	item, anyp := <-it;
-	return item, anyp;
+	item, anyp := <-it
+	return item, anyp
 }
 
 // Answer whether the iterators return the same items in the same order.
 // Equality is determined using `=='.  Maybe we'll do better some day.
 func SameIterators(ia, ib Iterator) bool {
 	for {
-		a, any_a := ia.Next();
-		b, any_b := ib.Next();
+		a, any_a := ia.Next()
+		b, any_b := ib.Next()
 		if !any_a { return !any_b }
 		if a != b { break }
 	}
-	return false;
+	return false
 }
 
 ///--------------------------------------------------------------------------
@@ -73,17 +73,17 @@ func SameIterators(ia, ib Iterator) bool {
 
 // Just a simple binary tree.
 type Node struct {
-	data byte;
-	left, right *Node;
+	data byte
+	left, right *Node
 }
 
 // Iteration is easy.  Note that recursion is fine here: this is just a
 // simple function.
 func (n *Node) Iterate(ch chan<- any) {
 	if n == nil { return }
-	n.left.Iterate(ch);
-	ch <- n.data;
-	n.right.Iterate(ch);
+	n.left.Iterate(ch)
+	ch <- n.data
+	n.right.Iterate(ch)
 }
 
 // Parse a tree from a textual description.  The syntax is simple:
@@ -93,23 +93,23 @@ func (n *Node) Iterate(ch chan<- any) {
 // where the ambiguity is resolved by declaring that a `(' is a tree if we're
 // expecting a tree.
 func ParseTree(s string) *Node {
-	var parse func(int) (*Node, int);
-	n := len(s);
-	i := 0;
+	var parse func(int) (*Node, int)
+	n := len(s)
+	i := 0
 	parse = func(i int) (*Node, int) {
 		if i < n && s[i] == '(' {
-			left, i := parse(i + 1);
+			left, i := parse(i + 1)
 			if i >= n { bail("no data") }
-			data := s[i];
-			right, i := parse(i + 1);
+			data := s[i]
+			right, i := parse(i + 1)
 			if i >= n || s[i] != ')' { bail("missing )") }
-			return &Node { data, left, right }, i + 1;
+			return &Node { data, left, right }, i + 1
 		}
-		return nil, i;
-	};
-	t, i := parse(0);
+		return nil, i
+	}
+	t, i := parse(0)
 	if i < n { bail("trailing junk") }
-	return t;
+	return t
 }
 
 ///--------------------------------------------------------------------------
@@ -118,24 +118,24 @@ func ParseTree(s string) *Node {
 func main() {
 	switch len(os.Args) {
 	case 2:
-		t := ParseTree(os.Args[1]);
-		i := MakeIterator(t);
+		t := ParseTree(os.Args[1])
+		i := MakeIterator(t)
 		for {
-			item, winp := i.Next();
+			item, winp := i.Next()
 			if !winp { break }
-			fmt.Printf("%c", item);
+			fmt.Printf("%c", item)
 		}
-		fmt.Printf("\n");
+		fmt.Printf("\n")
 	case 3:
-		ia := MakeIterator(ParseTree(os.Args[1]));
-		ib := MakeIterator(ParseTree(os.Args[2]));
+		ia := MakeIterator(ParseTree(os.Args[1]))
+		ib := MakeIterator(ParseTree(os.Args[2]))
 		if SameIterators(ia, ib) {
-			io.WriteString(os.Stdout, "match\n");
+			io.WriteString(os.Stdout, "match\n")
 		} else {
-			io.WriteString(os.Stdout, "no match\n");
+			io.WriteString(os.Stdout, "no match\n")
 		}
 	default:
-		bail("bad args");
+		bail("bad args")
 	}
 }
 
-- 
2.11.0