[Go] Airport Robot

Author: sanderploegsma

go/airport-robot/HELP.md

@@ -0,0 +1,41 @@
+# Help
+
+## Running the tests
+
+To run the tests run the command `go test` from within the exercise directory.
+
+If the test suite contains benchmarks, you can run these with the `--bench` and `--benchmem`
+flags:
+
+    go test -v --bench . --benchmem
+
+Keep in mind that each reviewer will run benchmarks on a different machine, with
+different specs, so the results from these benchmark tests may vary.
+
+## Submitting your solution
+
+You can submit your solution using the `exercism submit airport_robot.go` command.
+This command will upload your solution to the Exercism website and print the solution page's URL.
+
+It's possible to submit an incomplete solution which allows you to:
+
+- See how others have completed the exercise
+- Request help from a mentor
+
+## Need to get help?
+
+If you'd like help solving the exercise, check the following pages:
+
+- The [Go track's documentation](https://exercism.org/docs/tracks/go)
+- The [Go track's programming category on the forum](https://forum.exercism.org/c/programming/go)
+- [Exercism's programming category on the forum](https://forum.exercism.org/c/programming/5)
+- The [Frequently Asked Questions](https://exercism.org/docs/using/faqs)
+
+Should those resources not suffice, you could submit your (incomplete) solution to request mentoring.
+
+To get help if you're having trouble, you can use one of the following resources:
+
+- [How to Write Go Code](https://golang.org/doc/code.html)
+- [Effective Go](https://golang.org/doc/effective_go.html)
+- [Go Resources](http://golang.org/help)
+- [StackOverflow](http://stackoverflow.com/questions/tagged/go)

go/airport-robot/HINTS.md

@@ -0,0 +1,29 @@
+# Hints
+
+## General
+
+- Maybe have a look at [Interfaces in the Tour of Go][interfaces-tour-of-go] to see more examples if you struggle with the exercise.
+
+## 1. Create the abstract greeting functionality
+
+- Look back at `Counter` example the introduction to find out how to define an interface.
+- Revisit the [functions concepts][concept-functions] to recap how to write function signatures in Go.
+- The abstract `Greeter` type can be used in a function signature the same way as a normal concrete type like `string`.
+- To implement `SayHello`, call the methods on the argument of type `Greeter`.
+  Then use string formatting or string concatenation to construct the final result.
+
+## 2. Implement Italian
+
+- Revisit the [structs concept][concept-structs] to see how to define a struct type.
+- To solve the task, the struct does not need any fields at all.
+- Once you defined the struct, you want to add the methods `LanguageName` and `Greet` to it.
+  Revisit the [methods concept][concept-methods] to find out how to add a method for a type.
+
+## 3. Implement Portuguese
+
+- See hints for task 2.
+
+[interfaces-tour-of-go]: https://go.dev/tour/methods/9
+[concept-functions]: /tracks/go/concepts/functions
+[concept-structs]: /tracks/go/concepts/structs
+[concept-methods]: /tracks/go/concepts/methods

go/airport-robot/README.md

@@ -0,0 +1,133 @@
+# Airport Robot
+
+Welcome to Airport Robot on Exercism's Go Track.
+If you need help running the tests or submitting your code, check out `HELP.md`.
+If you get stuck on the exercise, check out `HINTS.md`, but try and solve it without using those first :)
+
+## Introduction
+
+## Interface as a set of methods
+
+In its simplest form, an **interface type** is a set of method signatures.
+Here is an example of an interface definition that includes two methods `Add` and `Value`:
+
+```go
+type Counter interface {
+    Add(increment int)
+    Value() int
+}
+```
+
+The parameter names like `increment` can be omitted from the interface definition but they often increase readability.
+
+Interface names in Go do not contain the word `Interface` or `I`.
+Instead, they often end with `er`, e.g. `Reader`, `Stringer`.
+
+## Implementing an interface
+
+Any type that defines the methods of the interface automatically implicitly "implements" the interface.
+There is no `implements` keyword in Go.
+
+The following type implements the `Counter` interface we saw above.
+
+```go
+type Stats struct {
+    value int
+    // ...
+}
+
+func (s Stats) Add(v int) {
+    s.value += v
+}
+
+func (s Stats) Value() int {
+    return s.value
+}
+
+func (s Stats) SomeOtherMethod() {
+    // The type can have additional methods not mentioned in the interface.
+}
+```
+
+For implementing the interface, it does not matter whether the method has a value or pointer receiver.
+(Revisit the [methods concepts][concept-methods] if you are unsure about those.)
+
+> A value of interface type can hold any value that implements those methods. [^1]
+
+That means `Stats` can now be used in all the places that expect the `Counter` interface.
+
+```go
+func SetUpAnalytics(counter Counter) {
+    // ...
+}
+
+stats := Stats{}
+SetUpAnalytics(stats)
+// works because Stats implements Counter
+```
+
+Because interfaces are implemented implicitly, a type can easily implement multiple interfaces.
+It only needs to have all the necessary methods defined.
+
+## Empty interface
+
+There is one very special interface type in Go, the **empty interface** type that contains zero methods.
+The empty interface is written like this: `interface{}`.
+In Go 1.18 or higher, `any` can be used as well. It was defined as an alias.
+
+Since the empty interface has no methods, every type implements it implicitly.
+This is helpful for defining a function that can generically accept any value.
+In that case, the function parameter uses the empty interface type.
+
+[concept-methods]: /tracks/go/concepts/methods
+
+## Instructions
+
+The new airport in Berlin hired developers for their robots lab and you are starting your job there.
+They have clunky, somewhat humanoid-looking robots that they are trying to use to improve customer service.
+
+Your first task on the job is to write a program so that the robot can greet people in their native language after they scanned their passports at the self-check-in counter.
+
+The robot is proud of its abilities so it will always say which language it can speak first and then greet the person.
+For example, if someone scans a German passport the robot would say:
+
+```txt
+I can speak German: Hallo Dietrich!
+```
+
+## 1. Create the abstract greeting functionality
+
+You will not write the code for the different languages yourself so you need to structure your code for the robot so that other developers can easily add more languages later.
+
+As a first step, define an interface `Greeter` with two methods.
+
+- `LanguageName` which returns the name of the language (a `string`) that the robot is supposed to greet the visitor in.
+- `Greet` which accepts a visitor's name (a `string`) and returns a `string` with the greeting message in a specific language.
+
+Next, implement a function `SayHello` that accepts the name of the visitor and anything that implements the `Greeter` interface as arguments and returns the desired greeting string.
+For example, imagine a German `Greeter` implementation for which `LanguageName` returns `"German"` and `Greet` returns `"Hallo {name}!"`:
+
+```go
+SayHello("Dietrich", germanGreeter)
+// => "I can speak German: Hallo Dietrich!"
+```
+
+## 2. Implement Italian
+
+Now your job is to make the robot work for people that scan Italian passports.
+
+For that, create a struct `Italian` and implement the two methods that are needed for the struct to fulfill the `Greeter` interface you set up in task 1.
+You can greet someone in Italian with `"Ciao {name}!"`.
+
+## 3. Implement Portuguese
+
+Before you call it a day, you are also supposed to finish the functionality to greet people in Portuguese.
+
+For that, create a struct `Portuguese` and implement the two methods that are needed for the struct to fulfill the `Greeter` interface here as well.
+You can greet someone in Portuguese with `"Olá {name}!"`.
+
+## Source
+
+### Created by
+
+- @junedev

go/airport-robot/airport_robot.go

@@ -0,0 +1,32 @@
+package airportrobot
+
+import "fmt"
+
+type Greeter interface {
+	LanguageName() string
+	Greet(name string) string
+}
+
+func SayHello(name string, greeter Greeter) string {
+	return greeter.Greet(name)
+}
+
+type Italian struct {}
+
+func (i Italian) LanguageName() string {
+	return "Italian"
+}
+
+func (i Italian) Greet(name string) string {
+	return fmt.Sprintf("I can speak %s: Ciao %s!", i.LanguageName(), name)
+}
+
+type Portuguese struct {}
+
+func (i Portuguese) LanguageName() string {
+	return "Portuguese"
+}
+
+func (i Portuguese) Greet(name string) string {
+	return fmt.Sprintf("I can speak %s: Olá %s!", i.LanguageName(), name)
+}

go/airport-robot/airport_robot_test.go

@@ -0,0 +1,59 @@
+package airportrobot
+
+import "testing"
+
+// testRunnerTaskID=2
+func TestSayHello_Italien(t *testing.T) {
+	tests := []struct {
+		testName string
+		name     string
+		want     string
+	}{
+		{
+			testName: "name without spaces",
+			name:     "Flora",
+			want:     "I can speak Italian: Ciao Flora!",
+		},
+		{
+			testName: "full name",
+			name:     "Tomaso Giulio Micheli",
+			want:     "I can speak Italian: Ciao Tomaso Giulio Micheli!",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.testName, func(t *testing.T) {
+			if got := SayHello(tt.name, Italian{}); got != tt.want {
+				t.Errorf("SayHello(%q, \"Italian{}\") = %q, want %q", tt.name, got, tt.want)
+			}
+		})
+	}
+}
+
+// testRunnerTaskID=3
+func TestSayHello_Portuguese(t *testing.T) {
+	tests := []struct {
+		testName string
+		name     string
+		want     string
+	}{
+		{
+			testName: "name without spaces",
+			name:     "Fabrício",
+			want:     "I can speak Portuguese: Olá Fabrício!",
+		},
+		{
+			testName: "full name",
+			name:     "Manuela Alberto",
+			want:     "I can speak Portuguese: Olá Manuela Alberto!",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.testName, func(t *testing.T) {
+			if got := SayHello(tt.name, Portuguese{}); got != tt.want {
+				t.Errorf("SayHello(%q, \"Portuguese{}\") = %q, want %q", tt.name, got, tt.want)
+			}
+		})
+	}
+}

go/airport-robot/go.mod

@@ -0,0 +1,3 @@
+module airportrobot
+
+go 1.18

go/go.work

@@ -2,6 +2,7 @@ go 1.19
 
 use (
 	./accumulate
+	./airport-robot
 	./annalyns-infiltration
 	./bird-watcher
 	./blackjack