func do(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("Double %v is %v\n", v, v*2)
    case string:
        fmt.Printf("%q is %v bytes long\n", v, len(v))
    default:
        fmt.Printf("I don't know type %T!\n", v)
    }
}

func main() {
    do(21)
    do("hello")
    do(true)
}

Double 21 is 42
"hello" is 5 bytes long
I don't know type bool!

type Stack struct {
    items []int
}

func (s *Stack) Push(item int) {
    s.items = append(s.items, item)
}

func (s *Stack) Pop() int {
    if len(s.items) == 0 {
        panic("Stack is empty!")
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item
}

func (s *Stack) Peek() int {
    if len(s.items) == 0 {
        panic("Stack is empty!")
    }
    return s.items[len(s.items)-1]
}

func (s *Stack) IsEmpty() bool {
    return len(s.items) == 0
}

func (s *Stack) Size() int {
    return len(s.items)
}

a := 5
b := 3

a = a + b // a становится 8
b = a - b // b становится 5 
a = a - b // a становится 3

a := 5 // 0101 в двоичной системе
b := 3 // 0011 в двоичной системе

a = a ^ b // a становится 6 (0110)
b = a ^ b // b становится 5 (0101)
a = a ^ b // a становится 3 (0011)

func main() {
    fmt.Println(swap())
}

func swap() []int {
    a, b := 15, 10
    b, a = a, b
    return []int{a, b}
}

package randc

/*
#include <stdlib.h>
*/
import "C"

func Random() int {
  return int(C.random()) // C.long -> Go int
}

func Seed(i uint) {
  C.srandom(C.uint(i)) // Go uint -> C unsigned int
}