Programming-Idioms.org

fmt.Println("Hello World")

for i := 0; i < 10; i++ {
	fmt.Println("Hello")
}

fmt.Println(strings.Repeat("Hello\n", 10))

for range 10 {
	fmt.Println("Hello")
}

func finish(name string) {
  fmt.Println("My job here is done. Good bye " + name)
}

finish := func(name string) {
	fmt.Println("My job here is done. Good bye " + name)
}

func square(x int) int {
  return x*x
}

type Point struct {
    x, y float64
}

for _, x := range items {
    doSomething(x)
}

for i, x := range items {
    fmt.Printf("Item %d = %v \n", i, x)
}

x := map[string]int {"one": 1, "two": 2}

type BinTree struct {
	Label       valueType
	Left, Right *BinTree
}

type BinTree[L any] struct {
	Label       L
	Left, Right *BinTree[L]
}

for i := range x {
	j := rand.Intn(i + 1)
	x[i], x[j] = x[j], x[i]
}

y := make([]T, len(x))
perm := rand.Perm(len(x))
for i, v := range perm {
	y[v] = x[i]
}

rand.Shuffle(len(x), func(i, j int) {
	x[i], x[j] = x[j], x[i]
})

for i := len(x) - 1; i > 0; i-- {
	j := rand.Intn(i + 1)
	x[i], x[j] = x[j], x[i]
}

func shuffle[T any](x []T) {
	rand.Shuffle(len(x), func(i, j int) {
		x[i], x[j] = x[j], x[i]
	})
}

x[rand.Intn(len(x))]

func pickT(x []T) T {
	return x[rand.Intn(len(x))]
}

func pick[T any](x []T) T {
	return x[rand.Intn(len(x))]
}

func Contains(list []T, x T) bool {
	for _, item := range list {
		if item == x {
			return true
		}
	}
	return false
}

slices.Contains(list, x)

for k, x := range mymap {
  fmt.Println("Key =", k, ", Value =", x)
}

func pick(a, b  float64)  float64 {
	return a + (rand.Float64() * (b-a))
}

func pick(a,b int) int {
	return a + rand.Intn(b-a+1)
}

func pick(a, b int) int {
	return a + rand.IntN(b-a+1)
}

func (bt *BinTree) Dfs(f func(*BinTree)) {
	if bt == nil {
		return
	}
	bt.Left.Dfs(f)
	f(bt)
	bt.Right.Dfs(f)
}

func (bt *BinTree[L]) Dfs(f func(*BinTree[L])) {
	if bt == nil {
		return
	}
	bt.Left.Dfs(f)
	f(bt)
	bt.Right.Dfs(f)
}

type Tree struct {
	Key keyType
	Deco valueType
	Children []*Tree
}

type Tree[L any] struct {
	Label    L
	Children []*Tree[L]
}

func (t *Tree) Dfs(f func(*Tree)) {
	if t == nil {
		return
	}
	f(t)
	for _, child := range t.Children {
		child.Dfs(f)
	}
}

func (t *Tree[L]) Dfs(f func(*Tree[L])) {
	if t == nil {
		return
	}
	f(t)
	for _, child := range t.Children {
		child.Dfs(f)
	}
}

for i, j := 0, len(x)-1; i < j; i, j = i+1, j-1 {
	x[i], x[j] = x[j], x[i]
}

func reverse[T any](x []T) {
	for i, j := 0, len(x)-1; i < j; i, j = i+1, j-1 {
		x[i], x[j] = x[j], x[i]
	}
}

slices.Reverse(x)

func search(m [][]int, x int) (bool, int, int) {
	for i := range m {
		for j, v := range m[i] {
			if v == x {
				return true, i, j
			}
		}
	}
	return false, 0, 0
}

a, b = b, a

i, err  := strconv.Atoi(s) 

i, err := strconv.ParseInt(s, 10, 0)

s := fmt.Sprintf("%.2f", x)

s := "ネコ"

go func() {
	v := <-ch
	fmt.Printf("Hello, %v\n", v)
}()

ch <- "Alan"

const m, n = 3, 4
var x [m][n]float64

func make2D(m, n int) [][]float64 {
	buf := make([]float64, m*n)

	x := make([][]float64, m)
	for i := range x {
		x[i] = buf[:n:n]
		buf = buf[n:]
	}
	return x
}

func make2D[T any](m, n int) [][]T {
	buf := make([]T, m*n)

	x := make([][]T, m)
	for i := range x {
		x[i] = buf[:n:n]
		buf = buf[n:]
	}
	return x
}

const m, n, p = 2, 2, 3
var x [m][n][p]float64

func make3D(m, n, p int) [][][]float64 {
	buf := make([]float64, m*n*p)

	x := make([][][]float64, m)
	for i := range x {
		x[i] = make([][]float64, n)
		for j := range x[i] {
			x[i][j] = buf[:p:p]
			buf = buf[p:]
		}
	}
	return x
}

func make3D[T any](m, n, p int) [][][]T {
	buf := make([]T, m*n*p)

	x := make([][][]T, m)
	for i := range x {
		x[i] = make([][]T, n)
		for j := range x[i] {
			x[i][j] = buf[:p:p]
			buf = buf[p:]
		}
	}
	return x
}

type ItemPSorter []Item
func (s ItemPSorter) Len() int{ return len(s) }
func (s ItemPSorter) Less(i,j int) bool{ return s[i].p<s[j].p }
func (s ItemPSorter) Swap(i,j int) { s[i],s[j] = s[j],s[i] }

func sortItems(items []Item){
	sorter := ItemPSorter(items)
	sort.Sort(sorter)
}

less := func(i, j int) bool {
	return items[i].p < items[j].p
}
sort.Slice(items, less)

compare := func(a, b Item) int {
	return cmp.Compare(a.p, b.p)
}
slices.SortFunc(items, compare)

items = append(items[:i], items[i+1:]...)

copy(items[i:], items[i+1:])
items[len(items)-1] = nil
items = items[:len(items)-1]

items = slices.Delete(items, i, i+1)

for i := range 1_000 {
	go f(i)
}

func f(i int) int {
  if i == 0 {
    return 1
  }
  return i * f(i-1)
}

func exp(x, n int) int {
	switch {
	case n == 0:
		return 1
	case n == 1:
		return x
	case n%2 == 0:
		return exp(x*x, n/2)
	default:
		return x * exp(x*x, (n-1)/2)
	}
}

var lock sync.Mutex

lock.Lock()
x = f(x)
lock.Unlock()

x := make(map[T]bool)

x := make(map[T]struct{})

func compose(f func(A) B, g func(B) C) func(A) C {
	return func(x A) C {
		return g(f(x))
	}
}

func composeIntFuncs(f func(int) int, g func(int) int) func(int) int {
	return func(x int) int {
		return g(f(x))
	}
}

func compose[T, U, V any](f func(T) U, g func(U) V) func(T) V {
	return func(x T) V {
		return g(f(x))
	}
}

type PayFactory func(Company, *Employee, *Employee) Payroll

type CustomPayFactory func(*Employee) Payroll

func CurryPayFactory(pf PayFactory,company Company, boss *Employee) CustomPayFactory {
	return func(e *Employee) Payroll {
		return pf(company, boss, e)
	}
}

t := string([]rune(s)[i:j])

ok := strings.Contains(s, word)

type Vertex struct{
	Id int
	Label string
	Neighbours map[*Vertex]bool
}

type Graph []*Vertex

type Graph[L any] []*Vertex[L]

type Vertex[L any] struct {
	Label      L
	Neighbours map[*Vertex[L]]bool
}

runes := []rune(s)
for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
   runes[i], runes[j] = runes[j], runes[i]
}
t := string(runes)

func reverse(s string) string {
	if len(s) <= 1 {
		return s
	}
	var b strings.Builder
	b.Grow(len(s))
	for len(s) > 0 {
		r, l := utf8.DecodeLastRuneInString(s)
		s = s[:len(s)-l]
		b.WriteRune(r)
	}
	return b.String()
}

runes := []rune(s)
slices.Reverse(runes)
t := string(runes)

mainloop:
	for _, v := range a {
		for _, w := range b {
			if v == w {
				continue mainloop
			}
		}
		fmt.Println(v)
	}

mainloop:
	for i, line := range m {
		for _, v := range line {
			if v < 0 {
				fmt.Println(v)
				break mainloop
			}
		}
	}

s = append(s, 0)
copy(s[i+1:], s[i:])
s[i] = x

s = slices.Insert(s, i, x)

time.Sleep(5 * time.Second)

t := s
r := []rune(s)
if len(r) > 5 {
	t = string(r[:5])
}

i := 0
count := 0
for i = range s {
	if count >= 5 {
		break
	}
	count++
}
t := s
if count >= 5 {
	t = s[:i]
}

t := s
r := []rune(s)
if len(r) > 5 {
	t = string(r[len(r)-5:])
}

i := len(s)
for j := 0; i > 0 && j < 5; j++ {
	_, size := utf8.DecodeLastRuneInString(s[0:i])
	i -= size
}
t := s[i:]

s := `Huey
Dewey
Louie`

chunks := strings.Split(s, " ")

chunks := strings.Fields(s)

for {
	// Do something
}

_, ok := m[k]

func containsValue(m map[K]T, v T) bool {
	for _, x := range m {
		if x == v {
			return true
		}
	}
	return false
}

func containsValue[M ~map[K]V, K, V comparable](m M, v V) bool {
	for _, x := range m {
		if x == v {
			return true
		}
	}
	return false
}

y := strings.Join(x, ", ")

s := 0
for _, v := range x {
	s += v
}

s := strconv.Itoa(i)

s := strconv.FormatInt(i, 10)

s := fmt.Sprintf("%d", i)

var wg sync.WaitGroup
wg.Add(1_000)
for i := range 1_000 {
	go func() {
		f(i)
		wg.Done()
	}()
}
wg.Wait()

y := make([]T, 0, len(x))
for _, v := range x{
	if p(v){
		y = append(y, v)
	}
}

n := 0
for _, v := range x {
	if p(v) {
		n++
	}
}
y := make([]T, 0, n)
for _, v := range x {
	if p(v) {
		y = append(y, v)
	}
}

func filter[S ~[]T, T any](x S, p func(T) bool) S {
	var y S
	for _, v := range x {
		if p(v) {
			y = append(y, v)
		}
	}
	return y
}

del := func(t *T) bool { return !p(t) }

y := slices.DeleteFunc(slices.Clone(x), del)

b, err := os.ReadFile(f)
if err != nil {
	// Handle error...
}
lines := string(b)

fmt.Fprintln(os.Stderr, x, "is negative")

x := os.Args[1]

d := time.Now()

i := strings.Index(x, y)

x2 := strings.Replace(x, y, z, -1)

x2 := strings.ReplaceAll(x, y, z)

x := new(big.Int)
x.Exp(big.NewInt(3), big.NewInt(247), nil)

s := fmt.Sprintf("%.1f%%", 100.0*x)

nb := big.NewInt(int64(n))
var z big.Int
z.Exp(x, nb, nil)

z := new(big.Int)
z.Binomial(n, k)

var x *big.Int = new(big.Int)

x := make([]bool, n)

x := make([]uint64, (n+63)/64)

r := rand.New(rand.NewSource(s))

r := rand.New(rand.NewPCG(s, s))

r := rand.New(rand.NewSource(time.Now().UnixNano()))

func main() {
    fmt.Println(strings.Join(os.Args[1:], " "))
}

type ParentFactory func(string) Parent

var fact ParentFactory = func(str string) Parent {
	return Parent{
		name: str,
	}
}

x.GCD(nil, nil, a, b)

gcd.GCD(nil, nil, a, b)
x.Div(a, gcd).Mul(x, b)

s := strconv.FormatInt(x, 2)

s := fmt.Sprintf("%b", x)

x := 3i - 2
x *= 1i

for{
   someThing()
   someOtherThing()
   if !c {
     break
   }
}

for done := false; !done; {
	someThing()
	someOtherThing()
	done = !c()
}

y := float64(x)

y := int(x)

y := int(math.Floor(x + 0.5))

x := strings.Count(s, t)

r := regexp.MustCompile("htt+p")

func PopCountUInt64(i uint64) (c int) {
	i -= (i >> 1) & 0x5555555555555555
	i = (i>>2)&0x3333333333333333 + i&0x3333333333333333
	i += i >> 4
	i &= 0x0f0f0f0f0f0f0f0f
	i *= 0x0101010101010101
	return int(i >> 56)
}

func PopCountUInt32(i uint32) (n int) {
	i -= (i >> 1) & 0x55555555
	i = (i>>2)&0x33333333 + i&0x33333333
	i += i >> 4
	i &= 0x0f0f0f0f
	i *= 0x01010101
	return int(i >> 24)
}

c := bits.OnesCount(i)

func addingWillOverflow(x int, y int) bool {
	if x > 0 {
		return y > math.MaxInt-x
	}
	return y < math.MinInt-x
}

func multiplyWillOverflow(x, y uint64) bool {
   if x <= 1 || y <= 1 {
     return false
   }
   d := x * y
   return d/y != x
}

os.Exit(0)

buf := make([]byte, 1_000_000)

return nil, fmt.Errorf("invalid value for x: %v", x)

type Foo struct {
	x int
}

func (f *Foo) X() int {
	return f.x
}

buffer, err := os.ReadFile("data.json")
if err != nil {
	return err
}
err = json.Unmarshal(buffer, &x)
if err != nil {
	return err
}

r, err := os.Open(filename)
if err != nil {
	return err
}
decoder := json.NewDecoder(r)
err = decoder.Decode(&x)
if err != nil {
	return err
}

buffer, err := json.MarshalIndent(x, "", "  ")
if err != nil {
	return err
}
err = os.WriteFile("data.json", buffer, 0644)

func control(f func()) {
	f()
}

fmt.Println(reflect.TypeOf(x))

fmt.Printf("%T", x)

info, err := os.Stat(path)
if err != nil {
	return err
}
x := info.Size()

b := strings.HasPrefix(s, prefix)

b := strings.HasSuffix(s, suffix)

d := time.Unix(ts, 0)

x := d.Format("2006-01-02")

type ItemCSorter []Item
func (s ItemCSorter) Len() int           { return len(s) }
func (s ItemCSorter) Less(i, j int) bool { return c(s[i], s[j]) }
func (s ItemCSorter) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

func sortItems(items []Item) {
	sorter := ItemCSorter(items)
	sort.Sort(sorter)
}

type ItemsSorter struct {
	items []Item
	c     func(x, y Item) bool
}

func (s ItemsSorter) Len() int           { return len(s.items) }
func (s ItemsSorter) Less(i, j int) bool { return s.c(s.items[i], s.items[j]) }
func (s ItemsSorter) Swap(i, j int)      { s.items[i], s.items[j] = s.items[j], s.items[i] }

func sortItems(items []Item, c func(x, y Item) bool) {
	sorter := ItemsSorter{
		items,
		c,
	}
	sort.Sort(sorter)
}

sort.Slice(items, func(i, j int) bool {
	return c(items[i], items[j])
})

slices.SortFunc(items, c)

res, err := http.Get(u)
if err != nil {
	return err
}
buffer, err := io.ReadAll(res.Body)
res.Body.Close()
if err != nil {
	return err
}
s := string(buffer)

out, err := os.Create("result.txt")
if err != nil {
	return err
}
defer out.Close()

resp, err := http.Get(u)
if err != nil {
	return err
}
defer func() {
	io.Copy(io.Discard, resp.Body)
	resp.Body.Close()
}()
if resp.StatusCode != 200 {
	return fmt.Errorf("Status: %v", resp.Status)
}

_, err = io.Copy(out, resp.Body)
if err != nil {
	return err
}

buffer, err := os.ReadFile("data.xml")
if err != nil {
	return err
}
err = xml.Unmarshal(buffer, &x)
if err != nil {
	return err
}

buffer, err := xml.MarshalIndent(x, "", "  ")
if err != nil {
	return err
}
err = os.WriteFile("data.xml", buffer, 0644)

path := os.Args[0]
s = filepath.Base(path)

path, err := os.Executable()
if err != nil {
  panic(err)
}
s = filepath.Base(path)

dir, err := os.Getwd()

programPath := os.Args[0]
absolutePath, err := filepath.Abs(programPath)
if err != nil {
	return err
}
dir := filepath.Dir(absolutePath)

var t T
tType := reflect.TypeOf(t)
n := tType.Size()

blank := strings.TrimSpace(s) == ""

err := exec.Command("x", "a", "b").Run()

keys := make([]string, 0, len(mymap))
for k := range mymap {
	keys = append(keys, k)
}
sort.Strings(keys)

for _, k := range keys {
	x := mymap[k]
	fmt.Println("Key =", k, ", Value =", x)
}

keys := maps.Keys(mymap)
slices.Sort(keys)

for _, k := range keys {
	x := mymap[k]
	fmt.Println("Key =", k, ", Value =", x)
}

keys := maps.Keys(mymap)
slices.SortFunc(keys, compare)

for _, k := range keys {
	x := mymap[k]
	fmt.Println("Key =", k, ", Value =", x)
}

type entry struct {
	key   string
	value int
}

type entries []entry
func (list entries) Len() int { return len(list) }
func (list entries) Less(i, j int) bool { return list[i].value < list[j].value }
func (list entries) Swap(i, j int) { list[i], list[j] = list[j], list[i] }

entries := make(entries, 0, len(mymap))
for k, x := range mymap {
	entries = append(entries, entry{key: k, values: x})
}
sort.Sort(entries)

for _, e := range entries {
	fmt.Println("Key =", e.key, ", Value =", e.value)
}

type entry struct {
	key   string
	value int
}

entries := make([]entry, 0, len(mymap))
for k, x := range mymap {
	entries = append(entries, entry{key: k, value: x})
}
sort.Slice(entries, func(i, j int) bool {
	return entries[i].value < entries[j].value
})

for _, e := range entries {
	fmt.Println("Key =", e.key, ", Value =", e.value)
}

b := reflect.DeepEqual(x, y)

b := d1.Before(d2)

s2 := strings.Replace(s1, w, "", -1)

s2 := strings.ReplaceAll(s1, w, "")

n := len(x)

y := make(map[T]struct{}, len(x))
for _, v := range x {
	y[v] = struct{}{}
}

func sliceToSet[T comparable](x []T) map[T]struct{} {
	y := make(map[T]struct{}, len(x))
	for _, v := range x {
		y[v] = struct{}{}
	}
	return y
}

y := make(map[T]struct{}, len(x))
for _, v := range x {
	y[v] = struct{}{}
}
x2 := make([]T, 0, len(y))
for _, v := range x {
	if _, ok := y[v]; ok {
		x2 = append(x2, v)
		delete(y, v)
	}
}
x = x2

seen := make(map[T]bool)
j := 0
for _, v := range x {
	if !seen[v] {
		x[j] = v
		j++
		seen[v] = true
	}
}
x = x[:j]

seen := make(map[T]bool)
j := 0
for _, v := range x {
	if !seen[v] {
		x[j] = v
		j++
		seen[v] = true
	}
}
for i := j; i < len(x); i++ {
	x[i] = nil
}
x = x[:j]

func deduplicate[S ~[]T, T comparable](x S) S {
	seen := make(map[T]bool)
	j := 0
	for _, v := range x {
		if !seen[v] {
			x[j] = v
			j++
			seen[v] = true
		}
	}
	var zero T
	for i := j; i < len(x); i++ {
		// Avoid memory leak
		x[i] = zero
	}
	return x[:j]
}

slices.Sort(x)
x = slices.Compact(x)

_, err := fmt.Scan(&n)

_, err := fmt.Scanf("%d", &n)

ServerAddr,err := net.ResolveUDPAddr("udp",p)
if err != nil {
	return err
}
ServerConn, err := net.ListenUDP("udp", ServerAddr)
if err != nil {
	return err
}
defer ServerConn.Close()
n,addr,err := ServerConn.ReadFromUDP(b[:1024])
if err != nil {
	return err
}
if n<1024 {
	return fmt.Errorf("Only %d bytes could be read.", n)
}

type Suit int

const (
  Spades Suit = iota
  Hearts
  Diamonds
  Clubs
)

if !isConsistent() {
	panic("State consistency violated")
}

func binarySearch(a []T, x T) int {
	imin, imax := 0, len(a)-1
	for imin <= imax {
		imid := imin + (imax-imin) / 2
		switch {
		case a[imid] == x:
			return imid
		case a[imid] < x:
			imin = imid + 1
		default:
			imax = imid - 1
		}
	}
	return -1
}

func binarySearch(a []int, x int) int {
	i := sort.SearchInts(a, x)
	if i < len(a) && a[i] == x {
		return i
	}
	return -1
}

func binarySearch(a []T, x T) int {
	f := func(i int) bool { return a[i] >= x }
	i := sort.Search(len(a), f)
	if i < len(a) && a[i] == x {
		return i
	}
	return -1
}