Experience report on a large Python-to-Go translation(gitlab.com)

   [1,2,3,4,5,6,7,8,9].filter {$0 % 2 == 0}.map {$0 * 2}.reduce(0, +)

   ["550", "a", "6", "b", "42", "99", "100"].compactMap{Int($0)}.filter {$0 < 100}

    sink = transform3(transform2(transform1(source)))

    sink = transform3(transform2(transform1(source)?)?)?

   ints[42] = struct{}{} // insert
   delete(ints, 42) // delete 
   for i := range ints { ... } // iterate
   if _, ok := ints[42]; ok { ... } // exists?

   type IntOrString struct { i int; s string; iok, sok bool }
   func (i IntOrString) String() (string, error) { if i.sok { return i.s, nil } else { return "", errors.New("is not a string") }}
   func NewInt(x int) IntOrString { return IntOrString{i: x, iok: true} }
   ...

   switch x := foo.(type) {
   case int:
      return x + 1
   case string:
      i, err := strconv.Atoi(x)
      return i + 1
   }

   if x, ok := foo.(interface { IntValue() int }); ok { return x.IntValue() }

   type Point struct { X, Y float64 }

   func EuclideanDistance(a, b Point) float64 { ... }

   EuclideanDistance(Point{X: 1, Y: 2}, Point{3, 4})

   func fooToInterface(foos []foo) []interface{} {
       var result []interface{}
       for _, f := range foos {
           result = append(result, f)
       }
       return result
   }

     func f(x int, y int, c string) 

     type funcOptions struct {
          x, y int
          c    string
     }
     func f(o funcOptions) {} 
 
     f(funcOptions{x:3, y:-1, c: "hello"})