brew install asdf

if command -v asdf &> /dev/null; then
  . /opt/homebrew/opt/asdf/libexec/asdf.sh
fi

asdf plugin add golang

# Устанавливаем нужную нам версию
asdf install golang 1.20.2

# Делаем ее глобальной для системы
asdf global golang 1.20.2

package main

import "fmt"

func main() {
  fmt.Println("Hello, World") // Hello, World
}

// Первый способ
var hello_world string = "Hello, World!"

// Второй способ (shorthand syntax)
hi := "Hi!"

hello := "Hello!" // Not OK
func main() {
  hi := "Hi!" // OK
}

import "fmt"

var hello string = "Hello!" // OK!

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

var hello_world = "Hello, World!" // type: string

const PI float32 = 3.14

// Минимально возможный знаковый тип
var smallest int8 = -8

// Минимально возможный беззнаковый тип
var smallest_unsigned uint8 = 8

// Аналог int8 (алиас к int8)
var smallest_analogue byte = 32

// 16-битный тип числа
var small int16 =

// 16-битный беззнаковый тип
var small_unsigned f uint16 = 5

// 32-битный тип числа
var medium g int32 = -6

// 32-битный беззнаковый тип
var medium_unsigned j uint32 = 8

// Алиас к int32
var medium_analogue h rune = -7

// 64-битный тип числа
var large k int64 = -9

// 64-битный беззнаковый тип
var large_unsigned l uint64 = 10

// Платформозависимый тип
var platform m int = 102

// Платформозависимый беззнаковый тип
var platform_unsigned n uint = 105

var float_medium float32 = -1.23232;
var float_large float64 = 2.323409230;

var complex_medium complex64 = 1+5i
var complex_large complex128 = 4+i

var b1 bool = true
var b2 bool = false

var s string = "Hello, World!\n"

package main

import "fmt"

var amount_of_people = 255

func main() {

  // Условие
  // Если количество людей четное - то условие выполнится
  if amount_of_people % 2 == 0 {
    fmt.Println("Amount of people is even!")
  } else {
    fmt.Println("Amount of people isn't even!")
  }
}

// Amount of people isn't even!

package main

import "fmt"

func main() {
  if amount_of_people := 255; amount_of_people % 2 == 0 {
    fmt.Println("Amount of people is even!")
  } else {
    fmt.Println("Amount of people isn't even!")
  }
}

package main
import "fmt"

func main() {
  // Вечный цикл
  for {
    fmt.Println("Hello!")
  }
}

package main
import "fmt"

func main() {
  // Цикл с внешним операндом
  var i = 0;
  for i < 10 {
    fmt.Println(i) // Циклично: 0 1 2 3 4 5 6 7 8 9
    i += 1
  }
}

package main
import "fmt"

func main() {
  // Цикл с внешним операндом, который инициализирован перед условием цикла
  for i := 0; i < 10; {
    fmt.Println(i) // Циклично: 0 1 2 3 4 5 6 7 8 9
    i += 1
  }
}

package main

import "fmt"

func main() {
    // Стандартный цикл for
    for i := 0; i < 10; i += 1 {
        fmt.Println(i) // Циклично: 0 1 2 3 4 5 6 7 8 9
    }
}

package main

import "fmt"

var amount_of_people = 255

func main() {

  switch amount_of_people {
    case 0: fmt.Println("There's no people")
    case 100: fmt.Println("There's a hundred")
    case 200: fmt.Println("There's a 2 hundred")
    default: fmt.Println("Unknown Number")
  }
}

package main

import "fmt"
var amount_of_people = 255

func main() {

  switch {
    case amount_of_people < 0: fmt.Println("There's no people")
    case amount_of_people <= 100: fmt.Println("There's a hundred or less people")
    case amount_of_people <= 200: fmt.Println("There's a two hundred or less people")
    case amount_of_people == 255: fmt.Println("There's exactly 255 people")
    default: fmt.Println("Unknown number!")
  }
}

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Now()
    switch {
    case t.Hour() < 12:
        fmt.Println("Good morning!")
    case t.Hour() < 17: // Метод t.Hour() здесь не выполнится, если switch прервался на кейсе t.Hour() < 12
        fmt.Println("Good afternoon.")
    default:
        fmt.Println("Good evening.")
    }
}

package main

import "fmt"

func main() {
  var arr [2]string = [2]string {"Hello", "World"}
  fmt.Println(arr) // [Hello World]
}

package main

import "fmt"

func main() {
  var arr [2]int32
  fmt.Println(arr[1]) // 0
}

package main

import "fmt"

func main() {
  arr := [...]string {"Hello", "World"}
  fmt.Println(arr) // [Hello World]
}

package main

import "fmt"

func main() {
  arr := [...]int {1,2,3,4,5}

  for index, value := range arr {
    fmt.Println("Index: ", index, "\nValue: ", value, "\n")
  }
}

// Output:
/*
  Index: 0
  Value: 1

  Index: 1
  Value: 2

  Index: 2
  Value: 3

  Index: 3
  Value: 4

  Index: 4
  Value: 5
*/

package main

import "fmt"

func main() {
  arr := [...]int {1,2,3,4,5}

  for _, value := range arr {
    fmt.Println("Value: ", value)
  }
}

// Output:
/*
  Value: 1
  Value: 2
  Value: 3
  Value: 4
  Value: 5
*/

    Slice from 0th element to 3rd (not inclusive)

                  ┌─────────────────┐              ┌─────────────────┐
                  │0:3              │              │0                │
                  │*pointer to array│              │                 │
                  │                 ├─────────────►│      127        │
                  │                 │              │                 │
                  │                 │              │                 │
                  └───────────┬─────┘              ├─────────────────┤
                              │                    │1                │
                              │                    │                 │
                              │                    │      355        │
                              │                    │                 │
                              │                    │                 │
                              │                    ├─────────────────┤
                              │                    │2                │
                              │                    │                 │
                              │                    │      899        │
                              └───────────────────►│                 │
                                                   │                 │
                                                   ├─────────────────┤
                                                   │3                │
                                                   │                 │
                                                   │      417        │
                                                   │                 │
                                                   │                 │
                                                   └─────────────────┘

package main

import "fmt"

func main() {
  var x = [10]int {};
  var y = x[0:1]
  var z = x[0:1]
  fmt.Println("First Output: ", x, y, z) // [0 0 0 0 0 0 0 0 0 0] [0] [0]

  // Прямое изменение
  x[0] = 1
  fmt.Println("Second Output:", x, y, z) // [1 0 0 0 0 0 0 0 0 0] [1] [1]

  // Изменение через ссылку
  y[0] = 2
  fmt.Println("Third Output: ", x, y, z) // [2 0 0 0 0 0 0 0 0 0] [2] [2]
}

/*
  First Output:  [0 0 0 0 0 0 0 0 0 0] [0] [0]
  Second Output: [1 0 0 0 0 0 0 0 0 0] [1] [1]
  Third Output:  [2 0 0 0 0 0 0 0 0 0] [2] [2]
*/

type Slice struct {
  first_element: Pointer,
  length: int,
  capacity: int,
}

package main

import "fmt"

func main() {

  // В данном случае слайс создает массив под капотом, нам не нужно ничего указывать
  arr := []string{"Hello", "World"}
  fmt.Println(arr) // [ Hello World ]

  // В данном случае массив не выделяется (то есть слайс ссылается на nil - нулеовой указатель)
  empty := []string {}

  // Мы можем добавить элемент к пустому слайсу и тогда Go автоматически выделит нам память под новый слайс
  empty = append(empty, "Hello!")
  fmt.Println(empty) // [ Hello! ]
}

package main

import "fmt"

func main() {
  // Выделяем память под новый массив с помощью make
  var slice = make([]string, 4)
  fmt.Println(slice) // [ "" "" "" "" ]
  slice[0] = "Hello"
  slice[1] = ","
  slice[2] = " "
  slice[3] = "World"
  fmt.Println(slice) // [ "Hello" "," " " "World" ]

  // Копируем слайс в другой слайс
  copied_slice := make([]string, len(slice) + 1)
  copy(copied_slice, slice)
  fmt.Println(copied_slice) // [ "Hello" "," " " "World" ]

  // Дополняем слайс
  copied_slice = append(copied_slice, "!")
  fmt.Println(copied_slice) // [ "Hello" "," " " "World" "!" ]
}

package main

import "fmt"

func main() {
  arr := make([]int, 2)
  fmt.Println(arr) // [ 0 0 ]
}

package main

import "fmt"

func main() {
  arr := []int{}
  fmt.Println(arr) // [ ]
}

package main

import "fmt"

func main() {
  var arr []int
  fmt.Println(arr) // [ ]

  arr[0] = 0; // ERROR
}

panic: runtime error: index out of range [0] with length 0

goroutine 1 [running]:
main.main()
    /tmp/sandbox4123608687/prog.go:9 +0x65

package main
import "fmt"

func main() {
  // Инициализация с помощью метода пустышки
  empty_hashmap := map[string]int{}

  // Инициализация с помощью make
  make_hashmap := make(map[string]int)

  fmt.Println(empty_hashmap, make_hashmap) // map[] map[]
}

package main
import "fmt"

func main() {
  // Инициализация с помощью метода пустышки
  empty_hashmap := map[string]int{
    "Daniil": 20,
  }
  empty_hashmap["Slava"] = 21

  // Инициализация с помощью make
  make_hashmap := make(map[string]int)
  make_hashmap["Daniil"] = 20

  fmt.Println(empty_hashmap, make_hashmap) // map[Daniil:20 Slava:21] map[Daniil:20]
}

package main
import "fmt"

func main() {
  ages := map[string]int {
    "Daniil": 20,
  }

  fmt.Println(ages) // map[ Daniil:20 ]

  delete(ages, "Daniil")

  fmt.Println(ages) // map[]
}

package main
import "fmt"

func main() {
  ages := map[string]int {
    "Daniil": 20,
  }

  fmt.Println(ages["Lena"]) // 0
}

package main
import "fmt"

func main() {
  ages := map[string]int {
    "Daniil": 20,
  }

  if age, is_exist := ages["Lena"]; is_exist {
    fmt.Println(ages["Lena"])
  } else {
    fmt.Println("No value")
  }
}

// Output: No value

func pretty_output(title string, description string) {
  fmt.Println("Title: ", title)
  fmt.Println("Description: ", description)
}

package main
import "fmt"

func pretty_output(title, description string) { // В данном случае и title, и description будут с типом string
  fmt.Println("Title: ", title)
  fmt.Println("Description: ", description)
}

package main

func sum(a, b int) int {
  return a + b
}

package main
import "fmt"

func divideWithReminder(a int, b int) (int, int) {
  var divide int = a / b
  var reminder int = a % b
  return divide, reminder
}

func main() {
  d, r := divideWithReminder(11, 5)
  fmt.Println(d, r) // 2 1
}

package main
import "fmt"

func divideWithReminder(a int, b int) (divide int, reminder int) {
  divide = a / b
  reminder = a % b
  return
}

func main() {
  d, r := divideWithReminder(11, 5)
  fmt.Println(d, r) // 2 1
}

package main
import "fmt"

func divideWithReminder(a int, b int) (divide, reminder int) {
  divide = a / b
  reminder = a % b
  return
}

func main() {
  d, r := divideWithReminder(11, 5)
  fmt.Println(d, r) // 2 1
}

func arguments(args ...string) {
  for _, v := range args {
    fmt.Println(v)
  }
}

func main() {
  arguments("Hello", "World", "!")
}

// Output:

/*
Hello
World
!
*/

func main() {
  modifier := 5

  add := func(x, y int) int {
    return x + y + modifier
  }

  fmt.Println(add(1,1)) // 7
}

package main

import "fmt"

func generate_add(modifier int) func(a int, b int) int {
  // Объявляем новую функцию внутри другой функции (замыкание)
  add_callback := func(a, b int) int {
    return a + b + modifier
  }

  // Возвращаем внутренний коллбэк
  return add_callback
}


func main() {
    var add = generate_add(10)
    fmt.Println(add(5, 7)) // 22
}

package main
import "fmt"

func main() {
  for i, _ := range make([]int, 9) {
    defer fmt.Println(i + 1)
  }
}

// Output:
/*
9
8
7
6
5
4
3
2
1
*/

f, _ := os.Open(filename)
defer f.Close() // Закроет файл в конце выполнения функции

package main

import "fmt"

func main() {

  defer func() {
    str := recover()
    fmt.Println(str)
  }()

  panic("PANIC")
}

package main
import "fmt"

func main() {
  arr := [...]int {1, 2, 3}
  change_last_element(arr)
  fmt.Println(arr) // [ 1 2 3 ]
}

func change_last_element(arr [3]int) {

  // Изменяет данные в копии массива
  arr[2] = 2
}

package main
import "fmt"

func main() {
  arr := [...]int {1, 2, 3}
  fmt.Printf("Address of array = %v: %p\n", arr, &arr) // Address of array = [1 2 3]: 0xc00001a018
}

package main
import "fmt"

func main() {
  // Мы создаем массив данных, мы можем получить ссылку на адрес памяти с помощью &arr
  arr := [...]int {1, 2, 3}

  // Мы создаем указатель, обратите внимание на тип
  // Он всегда будет следующего синтакисиса: *<исходный тип данных>
  var pointer_to_arr *[3]int = &arr

  // Теперь мы можем использовать pointer_to_arr чтобы с помощью обращения по памяти
  // посмотреть что лежит внутри переданного адреса:
  fmt.Println(*pointer_to_arr) // [ 1 2 3 ]
}

package main
import "fmt"

func main() {
  arr := [...]int {1, 2, 3}
  pointer_arr := &arr
  change_last_element(pointer_arr)
  fmt.Println(arr) // [ 1 2 2 ]
}

func change_last_element(arr *[3]int) {

  // Изменяет данные в переданном массиве через указатель
  arr[2] = 2
}

package main
import "fmt"

func main() {
  arr := [...]int {1, 2, 3}
  change_last_element(&arr)
  fmt.Println(arr) // [ 1 2 2 ]
}

func change_last_element(arr *[3]int) {

  // Изменяет данные в переданном массиве через указатель
  arr[2] = 2
}

package main
import "fmt"

type Rectangle struct {
  width: uint
  height: uint
}

func main() {
  var first_rectangle Rectangle
}

package main
import "fmt"

type Rectangle struct {
  width: uint
  height: uint
}

func main() {
  first_rectangle := Rectangle {
    width: 20,
    height: 30
  }
}

package main
import "fmt"

type Rectangle struct {
  width: uint
  height: uint
}

func main() {
  first_rectangle := Rectangle {
    20, // width
    30 // height
  }
}

package main
import "fmt"

type Rectangle struct {
  width: uint
  height: uint
}

func main() {
  first_rectangle := make(Rectangle)
  first_rectangle.width = 20
  fmt.Println(first_rectangle)
}

// Output:
/*
  Rectangle {
  width: 20,
  height: 0
  }
*/

type HexColor struct {
  r, g, b uint8
}

package main
import "fmt"

type Rectangle struct {
  width: uint
  height: uint
}

func area(rect Rectangle) {
  return rect.width * rect.height
}

func main() {
  first_rectangle := Rectangle {
    20, // width
    30 // height
  }

  fmt.Println(area(first_rectangle)) // 600
}

type Rectangle struct {
  width: uint
  height: uint
}

func (rect *Rectangle) area() uint {
  return rect.width * rect.height
}

package main
import "fmt"

type Human struct {
  Name string
}

func (h *Human) talk(replic string) {
  fmt.Println(h.Name, ": ", replic)
}

type Developer struct {
  Human
  Main_language string
}

func main() {
  d := new(Developer)
  d.Name = "Hannah"

  fmt.Println(d)
  d.talk("Hi!")
}

type Developer struct {
  Human
}

package main
import "fmt"

type Person struct {
  name string
}

func main() {
  person1 := new(Person)
  person2 := &Person{}

  fmt.Printf("Person1 type: %T\n", person1) // Person1 type: *main.Person
  fmt.Printf("Person2 type: %T", person2)   // Person2 type: *main.Person
}

package main
import "fmt"

type Person struct {
  Name string
  Age int
}

func main() {
  p := Person{}
  fmt.Println(p.Age) // 0
}

package main
import "fmt"

type Person struct {
  Name *string
  Age *int
}

func main() {
  var name string = "Daniil"
  p := Person{
    Name: &name
  }
  fmt.Println(p) // {0xc000014270 <nil>}
  fmt.Println(p.Age) // <nil>
}

type Shape interface {
  area() int
}

type Shape interface {
  area() int
}

type Multiplier struct {
  Shape_with_area Shape
}

type Shape interface {
  area() int
}

func some_calculation(s Shape) {
  // ...
}

package main

import "fmt"

func f(n int) {
  for i := 0; i < 10; i++ {
    fmt.Println(n, ":", i)
  }
}

func main() {
  go f(0)
  var input string
  fmt.Scanln(&input)
}

/*
0 : 0
0 : 1
0 : 2
0 : 3
0 : 4
0 : 5
0 : 6
0 : 7
0 : 8
0 : 9
<пользовательский ввод>
*/

0 : 0
0 : 1

0 : 0
0 : 1
0 : 2
0 : 3
0 : 4

0 : 0

0 : 0

0 : 0
0 : 1
0 : 2
0 : 3
0 : 4
0 : 5
0 : 6
0 : 7
0 : 8

package main

import (
  "fmt"
  "time"
)

func pinger(c chan string) {
  for i := 0; ; i++ {
    c <- "ping"
  }
}

func printer(c chan string) {
  for {
    msg := <- c
    fmt.Println(msg)
    time.Sleep(time.Second * 1)
  }
}

func main() {
  var c chan string = make(chan string)

  go pinger(c)
  go printer(c)

  var input string
  fmt.Scanln(&input)
}

/*
  Будет выводить "ping" каждую секунду
*/

var c chan string = make(chan string)

c <- "ping"

var a string = <- c
// или
fmt.Println(<- c)

package main

import (
  "fmt"
  "time"
)

func pinger(c chan string) {
  for i := 0; ; i++ {
    c <- "ping"
  }
}

func postping(c chan string) {
  for i := 0; ; i++ {
    c <- "postping"
  }
}

func printer(c chan string) {
  for {
    msg := <- c
    fmt.Println(msg)
    time.Sleep(time.Second * 1)
  }
}

func main() {
  var c chan string = make(chan string)

  go pinger(c)
  go postping(c)
  go printer(c)

  var input string
  fmt.Scanln(&input)
}

/*

  Порядок вывода будет следующим:
  Вывелся "ping"
  ** Прошла секунда **
  Вывелся "postping"
  ** Прошла секунда **

  НО НИКАК НЕ СЛЕДУЮЩИМ:
  Вывелся "ping"
  Вывелся "postping"
  ** Прошла секунда **
  Вывелся "ping"
  Вывелся "postping"
  ** Прошла секунда **

  ...
*/