trackler 1.0.0 → 1.0.0.1

data/tracks/go/exercises/robot-simulator/defs.go

@@ -4,10 +4,10 @@ import "fmt"
 
 // definitions used in step 1
 
-var (
+var Step1Robot struct {
 	X, Y   int
-	Facing Dir
-)
+	Dir
+}
 
 type Dir int
 
@@ -19,14 +19,14 @@ type Command byte // valid values are 'R', 'L', 'A'
 type RU int
 type Pos struct{ Easting, Northing RU }
 type Rect struct{ Min, Max Pos }
-type DirAt struct {
+type Step2Robot struct {
 	Dir
 	Pos
 }
 
 // additional definition used in step 3
 
-type Place struct {
+type Step3Robot struct {
 	Name string
-	DirAt
+	Step2Robot
 }

data/tracks/go/exercises/robot-simulator/example.go

@@ -3,7 +3,7 @@ package robot
 import "fmt"
 
 // ======= Step 1
-
+const testVersion = 3
 const (
 	N Dir = iota
 	E
@@ -15,13 +15,13 @@ func (d Dir) String() string {
 	return "NESW"[d : d+1]
 }
 
-func Right() { Facing = (Facing + 1) % 4 }
-func Left()  { Facing = (Facing + 3) % 4 }
+func Right() { Step1Robot.Dir = (Step1Robot.Dir + 1) % 4 }
+func Left()  { Step1Robot.Dir = (Step1Robot.Dir + 3) % 4 }
 func Advance() {
-	if Facing&1 == 1 {
-		X += 1 - int(Facing&2)
+	if Step1Robot.Dir&1 == 1 {
+		Step1Robot.X += 1 - int(Step1Robot.Dir&2)
 	} else {
-		Y += 1 - int(Facing&2)
+		Step1Robot.Y += 1 - int(Step1Robot.Dir&2)
 	}
 }
 
@@ -29,33 +29,33 @@ func Advance() {
 
 type Action byte
 
-func Robot(cmd chan Command, act chan Action) {
+func StartRobot(cmd chan Command, act chan Action) {
 	for c := range cmd {
 		act <- Action(c)
 	}
 	close(act)
 }
 
-func Room(extent Rect, place DirAt, act chan Action, report chan DirAt) {
+func Room(extent Rect, robot Step2Robot, act chan Action, report chan Step2Robot) {
 	for a := range act {
 		switch a {
 		case 'R':
-			place.Dir = (place.Dir + 1) % 4
+			robot.Dir = (robot.Dir + 1) % 4
 		case 'L':
-			place.Dir = (place.Dir + 3) % 4
+			robot.Dir = (robot.Dir + 3) % 4
 		case 'A':
-			np := place.Pos
-			if place.Dir&1 == 1 {
-				np.Easting += 1 - RU(place.Dir&2)
+			np := robot.Pos
+			if robot.Dir&1 == 1 {
+				np.Easting += 1 - RU(robot.Dir&2)
 			} else {
-				np.Northing += 1 - RU(place.Dir&2)
+				np.Northing += 1 - RU(robot.Dir&2)
 			}
 			if in(np, extent) {
-				place.Pos = np
+				robot.Pos = np
 			}
 		}
 	}
-	report <- place
+	report <- robot
 }
 
 func in(p Pos, ext Rect) bool {
@@ -72,14 +72,14 @@ type Action3 struct {
 
 const beep = 7 // robots beep to communicate that they are done
 
-func Robot3(name, script string, act chan Action3, log chan string) {
+func StartRobot3(name, script string, act chan Action3, log chan string) {
 	for i := 0; i < len(script); i++ {
 		act <- Action3{name, script[i]}
 	}
 	act <- Action3{name, beep}
 }
 
-func Room3(extent Rect, robots []Place, act chan Action3, rep chan []Place, log chan string) {
+func Room3(extent Rect, robots []Step3Robot, act chan Action3, rep chan []Step3Robot, log chan string) {
 	// The function has multiple returns.  No matter what, rep <- is how we
 	// communicate to the test program that the room is terminating.
 	defer func() { rep <- robots }()
@@ -96,15 +96,15 @@ func Room3(extent Rect, robots []Place, act chan Action3, rep chan []Place, log
 		}
 		nx[r.Name] = x
 
-		if !in(r.DirAt.Pos, extent) {
+		if !in(r.Step2Robot.Pos, extent) {
 			log <- "Robot placed outside room"
 			return
 		}
-		if _, ok := px[r.DirAt.Pos]; ok {
+		if _, ok := px[r.Step2Robot.Pos]; ok {
 			log <- "Position occupied"
 			return
 		}
-		px[r.DirAt.Pos] = x
+		px[r.Step2Robot.Pos] = x
 	}
 	done := 0
 	for a := range act {
@@ -113,7 +113,7 @@ func Room3(extent Rect, robots []Place, act chan Action3, rep chan []Place, log
 			log <- "Action by unknown robot"
 			return
 		}
-		da := &robots[x].DirAt
+		da := &robots[x].Step2Robot
 		switch a.action {
 		case 'R':
 			da.Dir = (da.Dir + 1) % 4

data/tracks/go/exercises/robot-simulator/robot_simulator_step2_test.go

@@ -12,7 +12,7 @@ import "testing"
 // Step 2 introduces a "room."  It seems a small addition, but we'll make
 // big changes to clarify the rolls of "room", "robot", and "test program"
 // and begin to clarify the physics of the simulation.  You will define Room
-// and Robot as functions which the test program "brings into existance" by
+// and Robot as functions which the test program "brings into existence" by
 // launching them as goroutines.  Information moves between test program,
 // robot, and room over Go channels.
 //
@@ -21,12 +21,12 @@ import "testing"
 // coordinate space of the room, the location of the robot and the walls,
 // and ensure for example that the robot doesn't walk through walls.
 // We want Robot to be an agent that performs actions, but we want Room to
-// maintain a coherrent truth.
+// maintain a coherent truth.
 //
 // Step 2 API:
 //
-// Robot(chan Command, chan Action)
-// Room(extent Rect, place DirAt, act chan Action, rep chan DirAt)
+// StartRobot(chan Command, chan Action)
+// Room(extent Rect, robot Step2Robot, act chan Action, rep chan Step2Robot)
 //
 // You get to define Action; see defs.go for other definitions.
 //
@@ -41,27 +41,27 @@ import "testing"
 
 var test2 = []struct {
 	Command
-	DirAt
+	Step2Robot
 }{
-	0:  {' ', DirAt{N, Pos{1, 1}}}, // no command, this is the start DirAt
-	1:  {'A', DirAt{N, Pos{1, 2}}},
-	2:  {'R', DirAt{E, Pos{1, 2}}},
-	3:  {'A', DirAt{E, Pos{2, 2}}},
-	4:  {'L', DirAt{N, Pos{2, 2}}},
-	5:  {'L', DirAt{W, Pos{2, 2}}},
-	6:  {'L', DirAt{S, Pos{2, 2}}},
-	7:  {'A', DirAt{S, Pos{2, 1}}},
-	8:  {'R', DirAt{W, Pos{2, 1}}},
-	9:  {'A', DirAt{W, Pos{1, 1}}},
-	10: {'A', DirAt{W, Pos{1, 1}}}, // bump W wall
-	11: {'L', DirAt{S, Pos{1, 1}}},
-	12: {'A', DirAt{S, Pos{1, 1}}}, // bump S wall
-	13: {'L', DirAt{E, Pos{1, 1}}},
-	14: {'A', DirAt{E, Pos{2, 1}}},
-	15: {'A', DirAt{E, Pos{2, 1}}}, // bump E wall
-	16: {'L', DirAt{N, Pos{2, 1}}},
-	17: {'A', DirAt{N, Pos{2, 2}}},
-	18: {'A', DirAt{N, Pos{2, 2}}}, // bump N wall
+	0:  {' ', Step2Robot{N, Pos{1, 1}}}, // no command, this is the start DirAt
+	1:  {'A', Step2Robot{N, Pos{1, 2}}},
+	2:  {'R', Step2Robot{E, Pos{1, 2}}},
+	3:  {'A', Step2Robot{E, Pos{2, 2}}},
+	4:  {'L', Step2Robot{N, Pos{2, 2}}},
+	5:  {'L', Step2Robot{W, Pos{2, 2}}},
+	6:  {'L', Step2Robot{S, Pos{2, 2}}},
+	7:  {'A', Step2Robot{S, Pos{2, 1}}},
+	8:  {'R', Step2Robot{W, Pos{2, 1}}},
+	9:  {'A', Step2Robot{W, Pos{1, 1}}},
+	10: {'A', Step2Robot{W, Pos{1, 1}}}, // bump W wall
+	11: {'L', Step2Robot{S, Pos{1, 1}}},
+	12: {'A', Step2Robot{S, Pos{1, 1}}}, // bump S wall
+	13: {'L', Step2Robot{E, Pos{1, 1}}},
+	14: {'A', Step2Robot{E, Pos{2, 1}}},
+	15: {'A', Step2Robot{E, Pos{2, 1}}}, // bump E wall
+	16: {'L', Step2Robot{N, Pos{2, 1}}},
+	17: {'A', Step2Robot{N, Pos{2, 2}}},
+	18: {'A', Step2Robot{N, Pos{2, 2}}}, // bump N wall
 }
 
 func TestStep2(t *testing.T) {
@@ -69,16 +69,16 @@ func TestStep2(t *testing.T) {
 	for i := 1; i <= len(test2); i++ {
 		cmd := make(chan Command)
 		act := make(chan Action)
-		rep := make(chan DirAt)
-		go Robot(cmd, act)
-		go Room(Rect{Pos{1, 1}, Pos{2, 2}}, test2[0].DirAt, act, rep)
+		rep := make(chan Step2Robot)
+		go StartRobot(cmd, act)
+		go Room(Rect{Pos{1, 1}, Pos{2, 2}}, test2[0].Step2Robot, act, rep)
 		for j := 1; j < i; j++ {
 			cmd <- test2[j].Command
 		}
 		close(cmd)
 		da := <-rep
 		last := i - 1
-		want := test2[last].DirAt
+		want := test2[last].Step2Robot
 		if da.Pos != want.Pos {
 			t.Fatalf("Command #%d, Pos = %v, want %v", last, da.Pos, want.Pos)
 		}

data/tracks/go/exercises/robot-simulator/robot_simulator_step3_test.go

@@ -12,14 +12,13 @@ import "testing"
 //
 // Step 3 API:
 //
-//    Robot3(name, script string, action chan Action3, log chan string)
-//    Room3(extent Rect, robots []Place,
-//       action chan Action3, report chan []Place, log chan string)
+//    StartRobot3(name, script string, action chan Action3, log chan string)
+//    Room3(extent Rect, robots []Step3Robot, action chan Action3, report chan []Step3Robot, log chan string)
 //
 // Again, you define Action3.
 //
-// For the final position report sent from Room3, you can return the same slice
-// recieved from the robots channel, just with updated positions and directions.
+// For the final position report sent from StartRobot3, you can return the same slice
+// received from the robots channel, just with updated positions and directions.
 //
 // Messages must be sent on the log channel for
 // *  A robot without a name
@@ -33,29 +32,29 @@ import "testing"
 
 var testOneRobot = []struct {
 	cmd byte
-	DirAt
+	Step2Robot
 	nMsg int
 }{
 	// (test2 data with message counts added)
-	{' ', DirAt{N, Pos{1, 1}}, 0},
-	{'A', DirAt{N, Pos{1, 2}}, 0},
-	{'R', DirAt{E, Pos{1, 2}}, 0},
-	{'A', DirAt{E, Pos{2, 2}}, 0},
-	{'L', DirAt{N, Pos{2, 2}}, 0},
-	{'L', DirAt{W, Pos{2, 2}}, 0},
-	{'L', DirAt{S, Pos{2, 2}}, 0},
-	{'A', DirAt{S, Pos{2, 1}}, 0},
-	{'R', DirAt{W, Pos{2, 1}}, 0},
-	{'A', DirAt{W, Pos{1, 1}}, 0},
-	{'A', DirAt{W, Pos{1, 1}}, 1}, // bump W wall
-	{'L', DirAt{S, Pos{1, 1}}, 1},
-	{'A', DirAt{S, Pos{1, 1}}, 2}, // bump S wall
-	{'L', DirAt{E, Pos{1, 1}}, 2},
-	{'A', DirAt{E, Pos{2, 1}}, 2},
-	{'A', DirAt{E, Pos{2, 1}}, 3}, // bump E wall
-	{'L', DirAt{N, Pos{2, 1}}, 3},
-	{'A', DirAt{N, Pos{2, 2}}, 3},
-	{'A', DirAt{N, Pos{2, 2}}, 4}, // bump N wall
+	{' ', Step2Robot{N, Pos{1, 1}}, 0},
+	{'A', Step2Robot{N, Pos{1, 2}}, 0},
+	{'R', Step2Robot{E, Pos{1, 2}}, 0},
+	{'A', Step2Robot{E, Pos{2, 2}}, 0},
+	{'L', Step2Robot{N, Pos{2, 2}}, 0},
+	{'L', Step2Robot{W, Pos{2, 2}}, 0},
+	{'L', Step2Robot{S, Pos{2, 2}}, 0},
+	{'A', Step2Robot{S, Pos{2, 1}}, 0},
+	{'R', Step2Robot{W, Pos{2, 1}}, 0},
+	{'A', Step2Robot{W, Pos{1, 1}}, 0},
+	{'A', Step2Robot{W, Pos{1, 1}}, 1}, // bump W wall
+	{'L', Step2Robot{S, Pos{1, 1}}, 1},
+	{'A', Step2Robot{S, Pos{1, 1}}, 2}, // bump S wall
+	{'L', Step2Robot{E, Pos{1, 1}}, 2},
+	{'A', Step2Robot{E, Pos{2, 1}}, 2},
+	{'A', Step2Robot{E, Pos{2, 1}}, 3}, // bump E wall
+	{'L', Step2Robot{N, Pos{2, 1}}, 3},
+	{'A', Step2Robot{N, Pos{2, 2}}, 3},
+	{'A', Step2Robot{N, Pos{2, 2}}, 4}, // bump N wall
 }
 
 func logMon(log chan string, nMsg chan int, t *testing.T) {
@@ -74,17 +73,17 @@ func TestOneStep3(t *testing.T) {
 		nMsg := make(chan int)
 		go logMon(log, nMsg, t)
 		act := make(chan Action3)
-		rep := make(chan []Place)
+		rep := make(chan []Step3Robot)
 		go Room3(
 			Rect{Pos{1, 1}, Pos{2, 2}},
-			[]Place{{"Robbie", testOneRobot[0].DirAt}},
+			[]Step3Robot{{"Robbie", testOneRobot[0].Step2Robot}},
 			act, rep, log)
 		scr := ""
 		for j := 1; j < i; j++ {
 			scr += string(testOneRobot[j].cmd)
 		}
 		t.Logf("Script %q", scr)
-		go Robot3("Robbie", scr, act, log)
+		go StartRobot3("Robbie", scr, act, log)
 		pls := <-rep
 		lastTest := testOneRobot[i-1]
 		if len(pls) != 1 {
@@ -95,8 +94,8 @@ func TestOneStep3(t *testing.T) {
 			t.Fatalf(`Got report for robot %q, want report for "Robbie".`,
 				pl.Name)
 		}
-		da := pl.DirAt
-		want := lastTest.DirAt
+		da := pl.Step2Robot
+		want := lastTest.Step2Robot
 		if da.Pos != want.Pos {
 			t.Fatalf("Script %q, Pos = %v, want %v", scr, da.Pos, want.Pos)
 		}
@@ -115,12 +114,12 @@ func TestNoName(t *testing.T) {
 	nMsg := make(chan int)
 	go logMon(log, nMsg, t)
 	act := make(chan Action3)
-	rep := make(chan []Place)
+	rep := make(chan []Step3Robot)
 	go Room3(
 		Rect{Pos{1, 1}, Pos{1, 1}},
-		[]Place{{"", DirAt{N, Pos{1, 1}}}},
+		[]Step3Robot{{"", Step2Robot{N, Pos{1, 1}}}},
 		act, rep, log)
-	go Robot3("", "", act, log)
+	go StartRobot3("", "", act, log)
 	<-rep
 	close(log)
 	if n := <-nMsg; n != 1 {
@@ -133,16 +132,16 @@ func TestSameName(t *testing.T) {
 	nMsg := make(chan int)
 	go logMon(log, nMsg, t)
 	act := make(chan Action3)
-	rep := make(chan []Place)
+	rep := make(chan []Step3Robot)
 	go Room3(
 		Rect{Pos{1, 1}, Pos{2, 1}},
-		[]Place{
-			{"Daryl", DirAt{N, Pos{1, 1}}},
-			{"Daryl", DirAt{N, Pos{2, 1}}},
+		[]Step3Robot{
+			{"Daryl", Step2Robot{N, Pos{1, 1}}},
+			{"Daryl", Step2Robot{N, Pos{2, 1}}},
 		},
 		act, rep, log)
-	go Robot3("Daryl", "", act, log)
-	go Robot3("Daryl", "", act, log)
+	go StartRobot3("Daryl", "", act, log)
+	go StartRobot3("Daryl", "", act, log)
 	<-rep
 	close(log)
 	if n := <-nMsg; n != 1 {
@@ -155,16 +154,16 @@ func TestSamePosition(t *testing.T) {
 	nMsg := make(chan int)
 	go logMon(log, nMsg, t)
 	act := make(chan Action3)
-	rep := make(chan []Place)
+	rep := make(chan []Step3Robot)
 	go Room3(
 		Rect{Pos{1, 1}, Pos{100, 100}},
-		[]Place{
-			{"Matter", DirAt{N, Pos{23, 47}}},
-			{"Antimatter", DirAt{N, Pos{23, 47}}},
+		[]Step3Robot{
+			{"Matter", Step2Robot{N, Pos{23, 47}}},
+			{"Antimatter", Step2Robot{N, Pos{23, 47}}},
 		},
 		act, rep, log)
-	go Robot3("Matter", "", act, log)
-	go Robot3("Animatter", "", act, log)
+	go StartRobot3("Matter", "", act, log)
+	go StartRobot3("Antimatter", "", act, log)
 	<-rep
 	close(log)
 	if n := <-nMsg; n != 1 {
@@ -177,12 +176,12 @@ func TestOutsideRoom(t *testing.T) {
 	nMsg := make(chan int)
 	go logMon(log, nMsg, t)
 	act := make(chan Action3)
-	rep := make(chan []Place)
+	rep := make(chan []Step3Robot)
 	go Room3(
 		Rect{Pos{1, 1}, Pos{1, 1}},
-		[]Place{{"Elvis", DirAt{N, Pos{2, 3}}}},
+		[]Step3Robot{{"Elvis", Step2Robot{N, Pos{2, 3}}}},
 		act, rep, log)
-	go Robot3("Elvis", "", act, log)
+	go StartRobot3("Elvis", "", act, log)
 	<-rep
 	close(log)
 	if n := <-nMsg; n != 1 {
@@ -195,12 +194,12 @@ func TestBadCommand(t *testing.T) {
 	nMsg := make(chan int)
 	go logMon(log, nMsg, t)
 	act := make(chan Action3)
-	rep := make(chan []Place)
+	rep := make(chan []Step3Robot)
 	go Room3(
 		Rect{Pos{0, 0}, Pos{0, 99}},
-		[]Place{{"Vgr", DirAt{N, Pos{0, 99}}}},
+		[]Step3Robot{{"Vgr", Step2Robot{N, Pos{0, 99}}}},
 		act, rep, log)
-	go Robot3("Vgr", "RET", act, log)
+	go StartRobot3("Vgr", "RET", act, log)
 	<-rep
 	close(log)
 	if n := <-nMsg; n != 1 {
@@ -213,12 +212,12 @@ func TestBadRobot(t *testing.T) {
 	nMsg := make(chan int)
 	go logMon(log, nMsg, t)
 	act := make(chan Action3)
-	rep := make(chan []Place)
+	rep := make(chan []Step3Robot)
 	go Room3(
 		Rect{Pos{0, 0}, Pos{0, 0}},
-		[]Place{{"Data", DirAt{N, Pos{0, 0}}}},
+		[]Step3Robot{{"Data", Step2Robot{N, Pos{0, 0}}}},
 		act, rep, log)
-	go Robot3("Lore", "A", act, log)
+	go StartRobot3("Lore", "A", act, log)
 	<-rep
 	close(log)
 	if n := <-nMsg; n != 1 {
@@ -231,16 +230,16 @@ func TestThree(t *testing.T) { // no bumping
 	nMsg := make(chan int)
 	go logMon(log, nMsg, t)
 	act := make(chan Action3)
-	go Robot3("clutz", "LAAARALA", act, log)
-	go Robot3("sphero", "RRAAAAALA", act, log)
-	go Robot3("roomba", "LAAARRRALLLL", act, log)
-	rep := make(chan []Place)
+	go StartRobot3("clutz", "LAAARALA", act, log)
+	go StartRobot3("sphero", "RRAAAAALA", act, log)
+	go StartRobot3("roomba", "LAAARRRALLLL", act, log)
+	rep := make(chan []Step3Robot)
 	go Room3(
 		Rect{Pos{-10, -10}, Pos{15, 10}},
-		[]Place{
-			{"clutz", DirAt{N, Pos{0, 0}}},
-			{"sphero", DirAt{E, Pos{2, -7}}},
-			{"roomba", DirAt{S, Pos{8, 4}}},
+		[]Step3Robot{
+			{"clutz", Step2Robot{N, Pos{0, 0}}},
+			{"sphero", Step2Robot{E, Pos{2, -7}}},
+			{"roomba", Step2Robot{S, Pos{8, 4}}},
 		},
 		act, rep, log)
 	pls := <-rep
@@ -248,22 +247,22 @@ func TestThree(t *testing.T) { // no bumping
 		t.Fatalf("Got report on %d robots, want 3.", len(pls))
 	}
 exp:
-	for _, exp := range []Place{
-		{"clutz", DirAt{W, Pos{-4, 1}}},
-		{"sphero", DirAt{S, Pos{-3, -8}}},
-		{"roomba", DirAt{N, Pos{11, 5}}},
+	for _, exp := range []Step3Robot{
+		{"clutz", Step2Robot{W, Pos{-4, 1}}},
+		{"sphero", Step2Robot{S, Pos{-3, -8}}},
+		{"roomba", Step2Robot{N, Pos{11, 5}}},
 	} {
 		for _, pl := range pls {
 			if pl.Name != exp.Name {
 				continue
 			}
-			if pl.DirAt.Pos != exp.DirAt.Pos {
+			if pl.Step2Robot.Pos != exp.Step2Robot.Pos {
 				t.Fatalf("%s at %v, want %v",
-					pl.Name, pl.DirAt.Pos, exp.DirAt.Pos)
+					pl.Name, pl.Step2Robot.Pos, exp.Step2Robot.Pos)
 			}
-			if pl.DirAt.Dir != exp.DirAt.Dir {
+			if pl.Step2Robot.Dir != exp.Step2Robot.Dir {
 				t.Fatalf("%s facing %v, want %v",
-					pl.Name, pl.DirAt.Dir, exp.DirAt.Dir)
+					pl.Name, pl.Step2Robot.Dir, exp.Step2Robot.Dir)
 			}
 			continue exp
 		}
@@ -276,14 +275,14 @@ func TestBattle(t *testing.T) {
 	nMsg := make(chan int)
 	go logMon(log, nMsg, t)
 	act := make(chan Action3)
-	go Robot3("Toro", "AAAAAAA", act, log)
-	go Robot3("Phere", "AAAAAAA", act, log)
-	rep := make(chan []Place)
+	go StartRobot3("Toro", "AAAAAAA", act, log)
+	go StartRobot3("Phere", "AAAAAAA", act, log)
+	rep := make(chan []Step3Robot)
 	go Room3(
 		Rect{Pos{1, 1}, Pos{9, 9}},
-		[]Place{
-			{"Toro", DirAt{E, Pos{1, 5}}},
-			{"Phere", DirAt{W, Pos{9, 5}}},
+		[]Step3Robot{
+			{"Toro", Step2Robot{E, Pos{1, 5}}},
+			{"Phere", Step2Robot{W, Pos{9, 5}}},
 		},
 		act, rep, log)
 	<-rep