package main

import (
 "fmt"
 "time"
)

func main() {
 ch := make(chan int)
 done := make(chan struct{})

 go func() {
  defer close(done)
  for i := 0; i < 3; i++ {
   ch <- i
   time.Sleep(100 * time.Millisecond)
  }
  close(ch)
 }()

 go func() {
  for {
   select {
   case v, ok := <-ch:
    if !ok {
     fmt.Println("channel closed")
     return
    }
    fmt.Println("received:", v)
   default:
    fmt.Println("default case")
    time.Sleep(50 * time.Millisecond)
   }
  }
 }()

 <-done
 time.Sleep(500 * time.Millisecond)
}

package main

import (
 "fmt"
 "time"
)

type Speaker interface {
 Speak() string
}

type Person struct {
 name string
}

func (p Person) Speak() string {
 return "Hi, I'm " + p.name
}

func main() {
 var s Speaker
 p := Person{name: "Alice"}
 s = p

 p.name = "Bob"

 fmt.Println(s.Speak()) // (1)

 func() {
  s := p // shadowing: s — это теперь Person, а не Speaker
  fmt.Println(s.Speak()) // (2)
 }()
 go func(p Person) {
  time.Sleep(10 * time.Millisecond)
  fmt.Println(p.Speak()) // (3)
 }(p)

 p.name = "Charlie"

 time.Sleep(20 * time.Millisecond)
}

package main

import "fmt"

func main() {
 values := []int{10, 20, 30}
 funcs := []func(){}

 for v := range values {
  funcs = append(funcs, func() {
   fmt.Println(v)
  })
 }

 for _, f := range funcs {
  f()
 }
}

1
2

2
2

20
30

0
0

package main

import (
    "fmt"
)

func change(val *int) {
    defer fmt.Println("defer:", *val)
    *val = 20
    fmt.Println("changed:", *val)
}

func main() {
    num := 10
    change(&num)
    fmt.Println("main:", num)
}

defer: 20
main: 20

defer: 10
main: 20

changed: 20
main: 20

defer: 20
main: 20