Александр Павлюк

type User struct {
    Name string
    Email string
    // все нужные поля далее
}

func CreateUser(r.Context(), user)

1. Вы создаете небуферизированный канал done.
   
2. Функции, пытающиеся записать в канал done блокируются, пока канал не будет прочитан.
   

type BigStruct struct {
    field1 int
    filed2 string
    field3 uint
    field4 []byte
    ...
    field50 string
}

s := BigStruct{}
// заполняем поля
Report(s)

s := BigStruct{}
// заполняем поля
Report(&s) // тут добавился & - берём адрес структуры, а не саму структуру

// создаём переменную s сразу с типом указатель на BigStruct
s := &BigStruct{}
// заполняем поля
Report(s) // поскольку s уже является указателем - & тут не нужен

var i *int
    i = new(int)
    *i = 10 // пишем значение

    fmt.Printf("i: %v\n", i)
    fmt.Printf("*i: %v\n", *i)

i: 0xc0000160d8 (это адрес памяти, где лежит значение переменной i)
*i: 10 (а это её значение)

Наверное, надо задать кодировку?

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup

    num := make(chan int, 1000) // 1000 - размер буффера канала

    wg.Add(1)
    go func() {
        for i := 0; i < 1000; i++ {
            num <- i
            fmt.Printf("write to channel: %d\n", i)
            // задержка нужна только на время теста
            time.Sleep(100 * time.Microsecond)
        }
        close(num)
        wg.Done()
    }()

    wg.Add(1)
    go func() {
        for {
            val, ok := <-num
            if !ok {
                break
            }
            fmt.Printf("goroutine 1 got: %d\n", val)
        }
        wg.Done()
    }()

    wg.Add(1)
    go func() {
        for {
            val, ok := <-num
            if !ok {
                break
            }
            fmt.Printf("goroutine 2 got: %d\n", val)
        }
        wg.Done()
    }()

    wg.Wait()
}

package main

import (
  "fmt"
  "time"
)

var c = make(chan int, 3)
var data = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

func main() {
  fmt.Println("Hello, playground")
  go save()
  go read()
  time.Sleep(3 * time.Second)
}

func save() {
  for _, val := range data {
    c <- val
  }
}

func read() {
  for {
    val := <-c
    fmt.Println("read:", val)
  }
}

package main

import (
	"fmt"
	"time"
)

var c = make(chan *int)
var data = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

func main() {
	fmt.Println("Hello, playground")
	go save()
	go read()
	time.Sleep(3 * time.Second)
}

func save() {
	for _, val := range data {
	        v := val
		c <- &v
	}
}

func read() {
	for {
		val := <-c
		fmt.Println("read:", *val)
	}
}

package main

import (
	"fmt"
	"time"


var c = make(chan *int, 5)
var data = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

func main() {
	fmt.Println("Hello, playground")
	go save()
	go read()
	time.Sleep(3 * time.Second)
}

func save() {
	for i := range data {
		c <- &data[i]
	}
}

func read() {
	for {
		val := <-c
		fmt.Println("read:", *val)
	}
}

package main

import (
	"fmt"
	"time"
)

var c = make(chan *int, 5)
var data = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

func main() {
	fmt.Println("Hello, playground")
	go save()
	go read()
	time.Sleep(3 * time.Second)
}

func save() {
	for _, val := range data {
		c <- &val
		fmt.Printf("write: %v\n", &val)
	}
}

func read() {
	for {
		val := <-c
		fmt.Println("read:", *val)
	}
}

Hello, playground
write: 0xc000094000
write: 0xc000094000
write: 0xc000094000
write: 0xc000094000
write: 0xc000094000
write: 0xc000094000
...

func save() {
	for _, val := range data {
		v := val
		c <- &v
		fmt.Printf("write: %v\n", &v)
	}
}

Hello, playground
write: 0xc000094000
write: 0xc000094010
write: 0xc000094018
write: 0xc000094020
write: 0xc000094028
write: 0xc000094030

package config

import (
	"encoding/json"
	"fmt"
	"os"
)

type Cfg struct {
	// Fields
}

var (
	cfg *Cfg
)

func Config() *Cfg {
	return cfg
}

func LoadConfig() error {
	f, err := os.Open("./config/config.json")
	if err != nil {
		return fmt.Errorf("can't open config file: %w", err)
	}
	defer f.Close()

	dec := json.NewDecoder(f)
	var c *Cfg
	if err := dec.Decode(c); err != nil {
		return fmt.Errorf("can't decode config file: %w", err)
	}

	if err := validate(c); err != nil {
		return fmt.Errorf("can't validate config file: %w", err)
	}
	
	cfg = c

	return nil
}

func validate(cfg *Cfg) error {
	// Logic
	return nil
}