{% include_relative test_{{ include.example }}.go.escaped %}$ go run test_{{include.example}}.go
{% include_relative test_{{ include.example }}.expected.escaped %}{{ page.question }}
{{ content }} ================================================ FILE: bin/server ================================================ #!/usr/bin/env bash set -eou pipefail bundle exec jekyll serve -H 0.0.0.0 -wDP "$PORT" -l --livereload-port "$LRPORT" -t ================================================ FILE: bin/tests ================================================ #!/usr/bin/env bash TEST_OUTPUT=/tmp/test_output.$$ print_success() { echo -n .; } print_failure() { echo -n x; } print_pending() { echo -n p; } print_output() { echo; cat $TEST_OUTPUT/*; } run_test() { diff <( go run "$1" 2>&1) "$2" > /dev/null; } record_failure() { { echo "Failed: $1" echo " To reset, run:" echo " rm $2" diff -yW200 <( go run "$1" 2>&1) "$2" echo "------------------------" echo } >> "$TEST_OUTPUT/${1//\//_}.out" } generate_expected() { echo echo "$2 not found - generating it..." go run "$1" > "$2" } generate_escaped() { sed 's/&(?!amp;)/\&/g; s//\>/g; s/"/\"/g; s/'"'"'/\'/g' < "$1" > "$1.escaped" } process_file() { file=$1 expected=${file/.go/.expected} if [ -s "$file" ]; then if [ -f "$expected" ]; then if run_test "$file" "$expected"; then print_success else record_failure "$file" "$expected" print_failure fi else generate_expected "$file" "$expected" fi else print_pending fi generate_escaped "$expected" generate_escaped "$file" } main() { mkdir $TEST_OUTPUT touch $TEST_OUTPUT/cat_on_empty_dir_hangs if [[ "$#" -gt 0 ]]; then shopt -s nullglob files=( "$@" ) else readarray -t files < <(find chapters -name "test*.go") fi echo "Running tests for ${files[*]}" for file in "${files[@]}"; do process_file "$file" & done wait print_output rm -rf $TEST_OUTPUT } main "$@" ================================================ FILE: chapters/arrays/reverse/index.md ================================================ --- title: Reversing an Array question: How do I reverse an array? --- Reversing an array is fairly straightforward in Go, due to multiple return values. Simply loop through the first half of the array, swapping each element in turn with its mirror counterpart: {%include example.html example="simple"%} There's an even more terse implementation which makes use of the `,` operator inside the Go for loop: {%include example.html example="terse"%} Note that both of these `reverse` functions take slices, which are passed by value. This is good for performance, but means we're actually modifying the passed in array, leading to unexpected results. In other words, the `reverse` method could be written like such: {%include example.html example="alternate"%} Now `reverse` doesn't return another reference to the slice, which makes it much more clear that it's modifying the slice in-place. If we want to return a modified copy of the slice, we must do so manually: {%include example.html example="copy"%} As you can see in the output above, the original array is untouched. Since we're not modifying the array in-place, we can also simplify our algorithm buy doing a more straight-forward element copy: {%include example.html example="copy_simple"%} ================================================ FILE: chapters/arrays/reverse/test_alternate.expected ================================================ [5 4 3 2 1] ================================================ FILE: chapters/arrays/reverse/test_alternate.expected.escaped ================================================ [5 4 3 2 1] ================================================ FILE: chapters/arrays/reverse/test_alternate.go ================================================ package main import "fmt" func reverse(numbers []int) { for i, j := 0, len(numbers)-1; i < j; i, j = i+1, j-1 { numbers[i], numbers[j] = numbers[j], numbers[i] } } func main() { array := []int{1, 2, 3, 4, 5} reverse(array) fmt.Printf("%v\n", array) } ================================================ FILE: chapters/arrays/reverse/test_alternate.go.escaped ================================================ package main import "fmt" func reverse(numbers []int) { for i, j := 0, len(numbers)-1; i < j; i, j = i+1, j-1 { numbers[i], numbers[j] = numbers[j], numbers[i] } } func main() { array := []int{1, 2, 3, 4, 5} reverse(array) fmt.Printf("%v\n", array) } ================================================ FILE: chapters/arrays/reverse/test_copy.expected ================================================ [5 4 3 2 1] [1 2 3 4 5] ================================================ FILE: chapters/arrays/reverse/test_copy.expected.escaped ================================================ [5 4 3 2 1] [1 2 3 4 5] ================================================ FILE: chapters/arrays/reverse/test_copy.go ================================================ package main import "fmt" func reverse(numbers []int) []int { newNumbers := make([]int, len(numbers)) for i, j := 0, len(numbers)-1; i <= j; i, j = i+1, j-1 { newNumbers[i], newNumbers[j] = numbers[j], numbers[i] } return newNumbers } func main() { array := []int{1, 2, 3, 4, 5} fmt.Printf("%v\n", reverse(array)) fmt.Printf("%v\n", array) } ================================================ FILE: chapters/arrays/reverse/test_copy.go.escaped ================================================ package main import "fmt" func reverse(numbers []int) []int { newNumbers := make([]int, len(numbers)) for i, j := 0, len(numbers)-1; i <= j; i, j = i+1, j-1 { newNumbers[i], newNumbers[j] = numbers[j], numbers[i] } return newNumbers } func main() { array := []int{1, 2, 3, 4, 5} fmt.Printf("%v\n", reverse(array)) fmt.Printf("%v\n", array) } ================================================ FILE: chapters/arrays/reverse/test_copy_simple.expected ================================================ [5 4 3 2 1] [1 2 3 4 5] ================================================ FILE: chapters/arrays/reverse/test_copy_simple.expected.escaped ================================================ [5 4 3 2 1] [1 2 3 4 5] ================================================ FILE: chapters/arrays/reverse/test_copy_simple.go ================================================ package main import "fmt" func reverse(numbers []int) []int { newNumbers := make([]int, 0, len(numbers)) for i := len(numbers)-1; i >= 0; i-- { newNumbers = append(newNumbers, numbers[i]) } return newNumbers } func main() { array := []int{1, 2, 3, 4, 5} fmt.Printf("%v\n", reverse(array)) fmt.Printf("%v\n", array) } ================================================ FILE: chapters/arrays/reverse/test_copy_simple.go.escaped ================================================ package main import "fmt" func reverse(numbers []int) []int { newNumbers := make([]int, 0, len(numbers)) for i := len(numbers)-1; i >= 0; i-- { newNumbers = append(newNumbers, numbers[i]) } return newNumbers } func main() { array := []int{1, 2, 3, 4, 5} fmt.Printf("%v\n", reverse(array)) fmt.Printf("%v\n", array) } ================================================ FILE: chapters/arrays/reverse/test_simple.expected ================================================ [5 4 3 2 1] [4 3 2 1] ================================================ FILE: chapters/arrays/reverse/test_simple.expected.escaped ================================================ [5 4 3 2 1] [4 3 2 1] ================================================ FILE: chapters/arrays/reverse/test_simple.go ================================================ package main import "fmt" func reverse(numbers []int) []int { for i := 0; i < len(numbers)/2; i++ { j := len(numbers) - i - 1 numbers[i], numbers[j] = numbers[j], numbers[i] } return numbers } func main() { fmt.Printf("%v\n", reverse([]int{1, 2, 3, 4, 5})) fmt.Printf("%v\n", reverse([]int{1, 2, 3, 4})) } ================================================ FILE: chapters/arrays/reverse/test_simple.go.escaped ================================================ package main import "fmt" func reverse(numbers []int) []int { for i := 0; i < len(numbers)/2; i++ { j := len(numbers) - i - 1 numbers[i], numbers[j] = numbers[j], numbers[i] } return numbers } func main() { fmt.Printf("%v\n", reverse([]int{1, 2, 3, 4, 5})) fmt.Printf("%v\n", reverse([]int{1, 2, 3, 4})) } ================================================ FILE: chapters/arrays/reverse/test_terse.expected ================================================ [5 4 3 2 1] [4 3 2 1] ================================================ FILE: chapters/arrays/reverse/test_terse.expected.escaped ================================================ [5 4 3 2 1] [4 3 2 1] ================================================ FILE: chapters/arrays/reverse/test_terse.go ================================================ package main import "fmt" func reverse(numbers []int) []int { for i, j := 0, len(numbers)-1; i < j; i, j = i+1, j-1 { numbers[i], numbers[j] = numbers[j], numbers[i] } return numbers } func main() { fmt.Printf("%v\n", reverse([]int{1, 2, 3, 4, 5})) fmt.Printf("%v\n", reverse([]int{1, 2, 3, 4})) } ================================================ FILE: chapters/arrays/reverse/test_terse.go.escaped ================================================ package main import "fmt" func reverse(numbers []int) []int { for i, j := 0, len(numbers)-1; i < j; i, j = i+1, j-1 { numbers[i], numbers[j] = numbers[j], numbers[i] } return numbers } func main() { fmt.Printf("%v\n", reverse([]int{1, 2, 3, 4, 5})) fmt.Printf("%v\n", reverse([]int{1, 2, 3, 4})) } ================================================ FILE: chapters/files/read-write/index.md ================================================ --- title: Reading and Writing to Files question: How do I read from and write to a file? --- http://stackoverflow.com/questions/1821811/how-to-read-write-from-to-file http://stackoverflow.com/a/16615559/2620448 ================================================ FILE: chapters/maps/presence/index.md ================================================ --- title: Testing for the Presence of a Key in a Map question: How do I determine if a map contains a given key? --- http://stackoverflow.com/questions/2050391/how-to-check-if-a-map-contains-a-key-in-go ================================================ FILE: chapters/numbers/enums/index.md ================================================ --- title: Representing Enums question: How do I represent enumerated constants in Go? --- http://stackoverflow.com/questions/14426366/what-is-an-idiomatic-way-of-representing-enums-in-golang http://stackoverflow.com/a/1721367 ================================================ FILE: chapters/numbers/string_to_num/index.md ================================================ --- title: Converting a string to number question: How do I convert a string to number if possible in Go? --- Go comes with a core package called `strconv` which makes this task very easy. You can convert a string to an integer and specify a base as well. You also have the flexibility to define the size of bits into which the number should fit into. {% include example.html example="string_to_int" %} The `strconv` package also contains functions such as `ParseUint` and `ParseFloat` which convert a string to unsigned integer and floating point numbers respectively. {% include example.html example="string_to_float" %} ================================================ FILE: chapters/numbers/string_to_num/test_string_to_float.expected ================================================ float64 123.123000 ================================================ FILE: chapters/numbers/string_to_num/test_string_to_float.expected.escaped ================================================ float64 123.123000 ================================================ FILE: chapters/numbers/string_to_num/test_string_to_float.go ================================================ package main import ( "fmt" "os" "strconv" ) func main() { str := "123.123" /* The first argument to ParseInt is the string to be converted. The second argument is the number of bits to which the number should fit. */ i, err := strconv.ParseFloat(str, 64) if err != nil { fmt.Println(err) os.Exit(1) } fmt.Printf("%T %f\n", i, i) } ================================================ FILE: chapters/numbers/string_to_num/test_string_to_float.go.escaped ================================================ package main import ( "fmt" "os" "strconv" ) func main() { str := "123.123" /* The first argument to ParseInt is the string to be converted. The second argument is the number of bits to which the number should fit. */ i, err := strconv.ParseFloat(str, 64) if err != nil { fmt.Println(err) os.Exit(1) } fmt.Printf("%T %f\n", i, i) } ================================================ FILE: chapters/numbers/string_to_num/test_string_to_int.expected ================================================ int64 123 strconv.ParseInt: parsing "invalidString123": invalid syntax ================================================ FILE: chapters/numbers/string_to_num/test_string_to_int.expected.escaped ================================================ int64 123 strconv.ParseInt: parsing "invalidString123": invalid syntax ================================================ FILE: chapters/numbers/string_to_num/test_string_to_int.go ================================================ package main import ( "fmt" "strconv" ) func handleError(err error) { if err != nil { fmt.Println(err) } } func main() { str := "123" /* The first argument to ParseInt is the string to be converted. The second argument is the base to which the number is to be converted. The third argument is the number of bits to which the number should fit. */ i, err := strconv.ParseInt(str, 10, 64) handleError(err) fmt.Printf("%T %d\n", i, i) str = "invalidString123" _, err = strconv.ParseInt(str, 10, 64) handleError(err) } ================================================ FILE: chapters/numbers/string_to_num/test_string_to_int.go.escaped ================================================ package main import ( "fmt" "strconv" ) func handleError(err error) { if err != nil { fmt.Println(err) } } func main() { str := "123" /* The first argument to ParseInt is the string to be converted. The second argument is the base to which the number is to be converted. The third argument is the number of bits to which the number should fit. */ i, err := strconv.ParseInt(str, 10, 64) handleError(err) fmt.Printf("%T %d\n", i, i) str = "invalidString123" _, err = strconv.ParseInt(str, 10, 64) handleError(err) } ================================================ FILE: chapters/running/cross-compiling/index.md ================================================ --- title: Cross Compiling question: How do I compile a binary designed to run on a different platform than my local host? --- Since Go is a statically compiled language, it's well designed for producing tiny, pre-compiled tools. This is great for Unix administrators or DevOps engineers, as they can send their tools with them when they work on remote systems. However, many developers use OS X or Windows on their local machine, and another OS like Linux on others. How do you use one system to compile binaries that will work on the other? This is called cross-compiling, and it's pretty simple with Go. ### Pre 1.5 Before 1.5, cross compilation was an arduous process, requiring [massive scripts](http://dave.cheney.net/2013/07/09/an-introduction-to-cross-compilation-with-go-1-1) to build separate go compilers for each supported platform. ### Post 1.5 Things have been much better since v1.5 of Go was released. Go now [comes with support for all architectures built in](http://dave.cheney.net/2015/03/03/cross-compilation-just-got-a-whole-lot-better-in-go-1-5). That means cross compiling is as simple as setting the right `$GOOS` and `$GOARCH` environment variables before building. Consider the below example program, which simply prints the OS and Architecture it's compiled for. While the output will always be the same as the platform it's being executed on, it's really a compile-time value - not something determined at runtime. ``` package main import "fmt" import "runtime" func main() { fmt.Printf("OS: %s\nArchitecture: %s\n", runtime.GOOS, runtime.GOARCH) } ``` Now, let's compile this program for an Apple MacBook. To do so, we simply set two environment variables: `$GOOS`, which is the target operating system, and `$GOARCH`, which is the target processor. Then we run `go build` as normal: ``` $ GOOS=darwin GOARCH=386 go build test.go ``` Note that the `test` executable that comes out the other end only runs on OS X, and cannot be run on Linux or Windows. On the other hand, if we wanted to compile for Microsoft Windows, we'd simply set `GOOS=windows` and `GOARCH=386`. When we run the resulting binary on the right platform, we see: ``` $ ./test OS: windows Architecture: 386 ``` This is another example of Go's strengths as a language for building easily distributed tools. It's almost trivial to modify your build process to produce binaries for every major platform your users may run. This is used, for example, to enable the Cloud Foundry team to distribute [Linux, Windows, and OS X CLI tools](https://github.com/cloudfoundry/cli). ================================================ FILE: chapters/running/one-off/index.md ================================================ --- title: Running a one-off File question: What's the easiest way to run a single Go file? --- First steps are often both fundamental and overlooked. Go's unusual packaging and compilation process can be daunting and confusing to a new developer. Unlike most compiled languages, Go actually comes with a very easy way of running a single file. Simply execute the program with `go run filename.go`: {% include example.html example="hello_world" %} This allows Go to act as though it were a more dynamic language, and is useful for development and exploration. However, Go's compiler is so incredibly fast, that it's possible to use this technique in a production setting: ``` $ time go run empty.go real 0m0.103s user 0m0.058s sys 0m0.033s ``` Throughout this book, you'll see many Go programs. Each one is available as a separate file in this book, and each example includes the `go run` command required to run the file along side the full output. ================================================ FILE: chapters/running/one-off/test_empty.expected ================================================ ================================================ FILE: chapters/running/one-off/test_empty.expected.escaped ================================================ ================================================ FILE: chapters/running/one-off/test_empty.go ================================================ package main func main() { } ================================================ FILE: chapters/running/one-off/test_empty.go.escaped ================================================ package main func main() { } ================================================ FILE: chapters/running/one-off/test_hello_world.expected ================================================ Hello World! ================================================ FILE: chapters/running/one-off/test_hello_world.expected.escaped ================================================ Hello World! ================================================ FILE: chapters/running/one-off/test_hello_world.go ================================================ package main import "fmt" func main() { fmt.Println("Hello World!") } ================================================ FILE: chapters/running/one-off/test_hello_world.go.escaped ================================================ package main import "fmt" func main() { fmt.Println("Hello World!") } ================================================ FILE: chapters/running/shebang/bash.go ================================================ //usr/bin/env go run $0 $@; exit package main func main() { println("hello") } ================================================ FILE: chapters/running/shebang/fail.go ================================================ #!/usr/bin/env go run package main func main() { println("hello") } ================================================ FILE: chapters/running/shebang/gorun.go ================================================ #!/usr/bin/env gorun package main func main() { println("hello") } ================================================ FILE: chapters/running/shebang/index.md ================================================ --- title: Running a file via a shebang line question: How can I add a shebang line to the top of my Go file in order to run it directly, as though it were an interpreted script? --- ### "Shebang??" In order to make it possible to execute scripts as though they were first class executables, UNIX systems will looks for what we refer to as a shebang line at the top of the file. The origin of the name is murky. Some think it came from sharp-bang or hash-bang -- contractions of `#` ("sharp") and `!` ("bang"). Others think the "SH" is in reference to the first UNIX shell, named "sh". In any case, if a UNIX system sees that the first line of an executable begins with `#!`, then it will execute the file using whatever command is specified in the rest of the line. For example, if there's a file named `/path/to/bar` that looks like: ``` #!/bin/foo ... ``` Then, when run, the kernel will execute `/bin/foo /path/to/bar`. This is great for interpreted languages like Ruby and Python which allow `#` as an innocuous comment. A clever gopher might attempt to create a file named `/path/to/example` that looks like such: ``` golang #!/usr/local/bin/go run package main import "fmt" func main() { fmt.Println("Hello!") } ``` And expect to run it and see "hello" in their terminal. However, Go does not allow `#` as a comment, which causes this to fail with a syntax error: ``` $ ./fail.go fail.go:1:1: illegal character U+0023 '#' ``` In order for this to work, the Go spec would have to be modified to accept `#` as a comment on the first line of the file. However, the Go authors are highly opinionated. When (repeatedly) asked for this feature, [Rob Pike has said](https://groups.google.com/d/msg/golang-nuts/iGHWoUQFHjg/_dbLKomrPmUJ): > I have never said it cannot be done. I have always said it should not be done, and I have explained why. > > "Useful" is not an argument for a feature. All features are useful; otherwise they would not be features. The issue is whether the feature justifies its cost. That is a judgement call, and my judgement is, no. Running compilers and linkers, doing megabytes of I/O, and creating temporary binary files is not a justifiable expense for running a small program. For large programs, the amortization is even more in favor of not doing this. > > I am firmly against adding a feature to Go that encourages abuse of resources. > > If you want the feature, use gorun or an equivalent wrapper program. That's what it's for. I think believe [sic] gorun is a mistake, but I'm not stopping you from installing it and using it as you see fit. ### gorun What's this gorun that has Rob up in arms? The Ubuntu Linux distribution produced the [gorun utility](https://wiki.ubuntu.com/gorun) to solve the shebang issue. As listed in the homepage, gorun will: * write files under a safe directory in `$TMPDIR` (or `/tmp`), so that the actual script location isn't touched (may be read-only) * avoid races between parallel executions of the same file * automatically clean up old compiled files that remain unused for some time (without races) * replace the process rather than using a child * pass arguments to the compiled application properly * handle well `GOROOT`, `GOROOT_FINAL` and the location of the toolchain Importantly, gorun will also strip the shebang line from the executed file before running it via `go run`. Because gorun is a separate tool, and not included in the Go distribution, it must first be installed via `go get launchpad.net/gorun`. Once it's installed, you can make use of it quite simply: ``` #!/usr/bin/gorun package main func main() { println("Hello world!") } ``` This file is now executable on the command line (after setting the execution bit via `chmod +x`, of course). However, it's also technically invalid Go. This means you can't compile the same code via `go build` that you would run with gorun. As we said earlier, this solution also requires that your users install gorun, making it less portable than ideal. As of March 1st, 2015, [gorun does not compile on OS X](https://bugs.launchpad.net/gorun/+bug/1176275), but it looks like this will be resolved, soon. {:.warning} ### Mimic the shebang via Bash In UNIX systems, the shebang line is handled by the family of `exec` functions inside the fundamental libc. The `exec` functions use what's referred to as magic numbers in the first bits of a file to determine what kind of executable it is. The characters `#!` are simply hard coded as a magic number that corresponds to being run as a script. But we can make clever use of the fact that `//` is both a comment in Go, *and* interpreted as a valid part of a file path in Bash, in order to trick Bash into running the file for us instead of `exec`. This isn't technically a shebang line, but serves the same purpose quite nicely. The resulting file looks like such: ``` //usr/bin/go run $0 $@; exit $? package main func main() { println("Hello world!") } ``` This file is *both* a valid Bash script and valid Go source code. When Bash runs this file, it executes `/usr/bin/go run $0 $@`, and then immediately exits. If the file were named "/path/to/foo.go", and we ran it like `./foo.go bar baz`, then Bash would execute `/usr/bin/go run ./foo.go "bar" "baz"`. At this point, the file is parsed by `go run`, which ignores the first line as a comment, and dutifully compiles and executes the rest of the file. This trick doesn't require a separately installed command, and is relatively portable. However, all is not roses: * The file must end in `.go`, since `go run` will happily ignore it otherwise. * This only works when executed via a shell. It won't work if executed directly by other programs. ### Trade-offs Sadly, unless Rob changes his mind and modifies the Go spec, there is no one-size-fits-all solution in sight. Both of the recipes above have their drawbacks, and choosing which one to use is entirely about your specific needs and tastes. ================================================ FILE: chapters/strings/accessing/index.md ================================================ --- title: Accessing Substrings question: How do I access parts of a given string? --- Go allows you to access parts of a string via the normal indexing primitives you're accustomed to using with arrays and slices. In particular, it allows you to access `mystring[n:m]`. Either `n` or `m` can be omitted, which implies from the beginning or to the end, respectively. There's also the primitive `len(s)`, which gives you the number of characters in the string. Here are some examples: {% include example.html example="index" %} Accessing strings by character, word or token are covered in the [Processing a String One Word or Character at a Time](/chapters/strings/processing) recipe. ================================================ FILE: chapters/strings/accessing/test_index.expected ================================================ Hello Hello ello World World ello Worl ================================================ FILE: chapters/strings/accessing/test_index.expected.escaped ================================================ Hello Hello ello World World ello Worl ================================================ FILE: chapters/strings/accessing/test_index.go ================================================ package main import "fmt" func main() { s := "Hello World" fmt.Println(s[:5]) // the first 5 characters fmt.Println(s[:len(s)-6]) // the same, but counting back from the end fmt.Println(s[1:]) // all except the first character fmt.Println(s[len(s)-5:]) // the last 5 characters fmt.Println(s[1 : len(s)-1]) // all except the first and last } ================================================ FILE: chapters/strings/accessing/test_index.go.escaped ================================================ package main import "fmt" func main() { s := "Hello World" fmt.Println(s[:5]) // the first 5 characters fmt.Println(s[:len(s)-6]) // the same, but counting back from the end fmt.Println(s[1:]) // all except the first character fmt.Println(s[len(s)-5:]) // the last 5 characters fmt.Println(s[1 : len(s)-1]) // all except the first and last } ================================================ FILE: chapters/strings/concatenation/index.md ================================================ --- title: Concatenating Strings question: How do I combine strings? --- http://stackoverflow.com/questions/1760757/how-to-efficiently-concatenate-strings-in-go http://srcode.org/2014/08/23/string-concatenation-in-golang/ ================================================ FILE: chapters/strings/detecting/index.md ================================================ --- title: Detecting a Substring question: How do I determine if a string contains another string or pattern? --- Go prides itself on being a low level language with a rich set of functionality included by default via the standard packages. The `strings` package is a great example of this. ### Detecting Substrings * `strings.Contains` * `strings.ContainsAny` * `strings.HasPrefix` * `strings.HasSuffix` {% include example.html example="substrings" %} ### Detecting Patterns {% include example.html example="regexp" %} ### Finding Matched Strings {% include example.html example="returned_regexp" %} ### Detecting Patterns that Include Special Characters {% include example.html example="safe_regexp" %} ### Precompiling Regular Expressions * `regexp.Compile` * `regexp.MustCompile` {% include example.html example="precompiled_regexp" %} ================================================ FILE: chapters/strings/detecting/test_precompiled_regexp.expected ================================================ ================================================ FILE: chapters/strings/detecting/test_precompiled_regexp.expected.escaped ================================================ ================================================ FILE: chapters/strings/detecting/test_precompiled_regexp.go ================================================ package main import "fmt" func main() { fmt.Println("unimplemented") } ================================================ FILE: chapters/strings/detecting/test_precompiled_regexp.go.escaped ================================================ package main import "fmt" func main() { fmt.Println("unimplemented") } ================================================ FILE: chapters/strings/detecting/test_regexp.expected ================================================ Matched: true Error: