package main

import (
    "context"
    "errors"
    "fmt"
    "time"
)

func main() {
    ctx, cancle := context.WithTimeout(context.Background(), time.Second*5)
    defer cancle()
    fmt.Println("<<<<<<<<<<<<<<<<", T2(ctx))

}

func T(ctx context.Context) []int {
    c := make(chan int)
    go func() {
        for i := 0; i < 10; i++ {
            c <- i
            time.Sleep(1 * time.Second)
        }
        close(c)
    }()
    result := make([]int, 0)
    for {
        var (
            ok bool
            x  int
        )
        select {
        case x, ok = <-c:
            fmt.Println(">>>>>>>>>>>", x)
            result = append(result, x)
        case <-ctx.Done():
            fmt.Println(">>>>>>>>>timeout")
        }
        if !ok {
            break
        }
    }
    return result
}

func T2(ctx context.Context) []int {
    c := make(chan error)
    result := make([]int, 0)
    go func() {
        defer close(c)

        for i := 0; i < 10; i++ {
            result = append(result, i)
            c <- errors.New("hahahah")
            time.Sleep(1 * time.Second)
        }
    }()
    for {
        select {
        case x, ok := <-c:
            fmt.Println(">>>>>>>", x)
            if !ok {
                return result
            }
        case <-ctx.Done():
            fmt.Println(">>>>>>>>>timeout")
            return result
        }
    }
}

func T3() []int {
    c := make(chan error)
    result := make([]int, 0)
    go func() {
        defer close(c)

        for i := 0; i < 10; i++ {
            result = append(result, i)
            c <- errors.New("hahahah")
            time.Sleep(1 * time.Second)
        }
    }()
    for {
        select {
        case x, ok := <-c:
            fmt.Println(">>>>>>>", x)
            if !ok {
                return result
            }
        case <-time.After(time.Second * 5):
            fmt.Println(">>>>>>>>>timeout")
            return result
        }
    }
}

func T4() []int {
    c := make(chan error)
    result := make([]int, 0)
    go func() {
        defer close(c)
        for i := 0; i < 10; i++ {
            result = append(result, i)
            c <- errors.New("hahahah")
            time.Sleep(6 * time.Second)
        }
    }()
    for {
        select {
        case x, ok := <-c:
            fmt.Println(">>>>>>>", x)
            if !ok {
                return result
            }
        case <-time.After(time.Second * 5):
            fmt.Println(">>>>>>>>>timeout")
            return result
        }
    }
}

func T5() []int {
    c := make(chan error)
    result := make([]int, 0)
    go func() {
        defer close(c)
        for i := 0; i < 10; i++ {
            result = append(result, i)
            c <- errors.New("hahahah")
            time.Sleep(6 * time.Second)
        }
    }()
    for timeOut := time.After(time.Second * 20); ; {
        select {
        case x, ok := <-c:
            fmt.Println(">>>>>>>", x)
            if !ok {
                return result
            }
        case <-timeOut:
            fmt.Println(">>>>>>>>>timeout")
            return result
        }
    }
}

# package main

import "fmt"

func main() {
    origin := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    s := func(i int) func() {
        return func() {
            fmt.Println(">>>>>>>>>>>>>", i)
        }
    }(origin[9])

    origin[9] = 10
    s() // output: >>>>>>>>>>>>> 9
    origin = append([]int{-1}, origin...)
    s() // output: >>>>>>>>>>>>> 9
    s2 := func(i *int) func() {
        return func() {
            fmt.Println(">>>>>>>>>>>>>>", *i)
        }
    }(&(origin[9]))
    s2() // output: >>>>>>>>>>>>> 8
    origin[9] = 9
    s2() // output: >>>>>>>>>>>>> 9
}

package main

import (
    "fmt"
    "sort"
    "strings"
)

func main() {
    god := []string{"g", "o", "d"}
    sort.SliceStable(god, func(i, j int) bool { return i > j })
    fmt.Printf("god is %s", strings.Join(god,""))
}

output is : god is dog