func reverseString(s string) string {
  n := 0
  rune := make([]rune, len(s))
  for _, r := range s {
    rune[n] = r
    n++
  }
  rune = rune[0:n]
  // Reverse
  for i := 0; i < n/2; i++ {
    rune[i], rune[n-1-i] = rune[n-1-i], rune[i]
  }
  // Convert back to UTF-8.
  return string(rune)
}

func Reverse(s string) string {
  r := []rune(s)
  for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
    r[i], r[j] = r[j], r[i]
  }
  return string(r)
}

func ReverseFast(s string) string {
  size := len(s)
  buf := make([]byte, size)
  for start := 0; start < size; {
    r, n := utf8.DecodeRuneInString(s[start:])
    start += n
    utf8.EncodeRune(buf[size-start:], r)
  }
  return string(buf)
}

func ReverseClosure(s string) (result string) {
  for _, v := range s {
    defer func(r rune) { result += string(r) }(v)
  }
  return
}

func main() {
  switch 42 {
  case 42:
    fmt.Println("First case: 42!")
    fallthrough
  default:
    fmt.Println("Second case")
  }
}
// First case: 42!
// Second case

func main() {
  switch 42 {
  case 42:
    fmt.Println("First case: 42!")
  default:
    fmt.Println("Second case")
    fallthrough
  }
}
// cannot fallthrough final case in switch

func main() {
  switch 42 {
  default:
    fmt.Println("Second case")
    fallthrough
  case 42:
    fmt.Println("First case: 42!")
  }
}
// First case: 42!

func main() {
  var pi interface{} = 3.14
  switch i := pi.(type) {
  case int:
    fmt.Printf("%v", i)
    fallthrough
  default:
    fmt.Println("don't know the type")
  }
}
// ./prog.go:18:3: cannot fallthrough in type switch

func main() {
  switch 42 {
  case 42:
    fmt.Println("First case: 42!")
    if true {
      fallthrough
    }
  case 1:
    fmt.Println("First case: 1!")
  }
}
// ./prog.go:18:4: fallthrough statement out of place

func TestQuick(t *testing.T) {
    ...
}

func TestTimeConsuming(t *testing.T) {
    if testing.Short() {
        t.Skip("skipping test in short mode.")
    }
}

// +build integration

func TestTimeConsuming(t *testing.T) {
       // ...
}

func TestQuickUnit(t *testing.T) {
    ...
}

func TestIntegraion(t *testing.T) {
    ...
}

$ go test -run Integration
$ go test -run Unit

func main() {
  a := []int{1, 2, 3}
  fmt.Println(a[-1])
}
invalid slice index -1 (index must be non-negative)

func main() {
  a := []int{1, 2, 3}
  fmt.Println(a[len(a)-1])
}

a := m[-3]
// is equivalent to
a := m[len(m)-3]

a := m[len-1]

package Errors

// based on https://upspin.googlesource.com/upspin/+/master/errors/errors.go#23
type Error struct {
  // a unique string describing a method or a function e.g. getUser
  Op op
  
  // can be predefined code/or own code (http/gRPC)
  Kind kind
  
  // you can add severity
  Severity logrus.Level
  
  // You can add any application Specific Data e.g.
  ZipCode   string
  CreatedAt time.Time
}

if err != nil {
return &errors.Error{Op: “getUser”, Error: err}
}

package main

import "math"   // math.Sin
import m "math" // m.Sin
import k "math" // k.Sin

func main() {
  print(math.Pi, m.Pi, k.Pi)
}

import (
  "path"
  pathpkg "path"
)
func (ld *loader) stdVendor(parentPath, path string) string {
       // missing few lines here
        vendorPath := pathpkg.Join("cmd", "vendor", path)
        // missing few lines here

gg v 255 .

gg c case .

gg k if .