// Package main provides possibility to see Go documentation.
package main

import "fmt"

// Version represents the version number of the package.
const Version = 1.0

// Help returns nothing, but prints the usage as side effect.
func Help() {
	fmt.Println("My main package. Created by me.")
	fmt.Printf("Version: %.1f\n", Version)
}

func main() {
	/*
		General comments start with the character sequence slash-star and stop with
		the first subsequent character sequence star-slash.
		To document a type, variable, constant, function, or even a package, write
		a regular comment directly preceding its declaration, with no intervening
		blank line.
	*/
	// Line comments start with the character sequence slash-slash and stop at
	// the end of the line.
	Help()
}

package main

import "fmt"

func main() {
	// Integer literals
	var i uint64
	i = 42
	i = 4_2
	i = 0600
	i = 0_600
	i = 0o600
	i = 0O600 // second character is capital letter 'O'
	i = 0xBadFace
	i = 0xBad_Face
	i = 0x_67_7a_2f_cc_40_c6
	i = 17014118346046923173
	i = 170_141183_460469_23173
	fmt.Println(i)

	// Floating-point literals
	var f float64
	f = 0.
	f = 72.40
	f = 072.40 // == 72.40
	f = 2.71828
	f = 1.e+0
	f = 6.67428e-11
	f = 1e6
	f = .25
	f = .12345e+5
	f = 1_5.        // == 15.0
	f = 0.15e+0_2   // == 15.0
	f = 0x1p-2      // == 0.25
	f = 0x2.p10     // == 2048.0
	f = 0x1.Fp+0    // == 1.9375
	f = 0x.8p-0     // == 0.5
	f = 0x15e - 2   // == 0x15e - 2 (integer subtraction)
	f = 0x_1FFFp-16 // == 0.1249847412109375
	fmt.Println(f)

	// Imaginary literals
	var c complex128
	c = 0i
	c = 123i   // == 123i for backward-compatibility
	c = 0o123i // == 0o123 * 1i == 83i
	c = 0xabci // == 0xabc * 1i == 2748i
	c = 0.i
	c = 2.71828i
	c = 1.e+0i
	c = 6.67428e-11i
	c = 1e6i
	c = .25i
	c = .12345e+5i
	c = 0x1p-2i // == 0x1p-2 * 1i == 0.25i
	fmt.Println(c)

	// Rune literals
	var r rune
	r = 'a'
	r = '本'
	r = '\'' // rune literal containing single quote character
	r = '\t'
	r = '\000'
	r = '\007'
	r = '\377'
	r = '\x07'
	r = '\xff'
	r = '\u12e4'
	r = '\U00101234'
	r = 'ä'
	fmt.Println(r)

	// String literals
	var s string
	s = `abc` // same as "abc"
	s = `\n
\n` // same as "\\n\n\\n"
	s = "\n"
	s = "\"" // same as `"`
	s = "Hello, world!\n"
	s = "日本語"
	s = "\u65e5本\U00008a9e"
	s = "\xff\u00FF"
	s = "日本語"                               // UTF-8 input text
	s = `日本語`                               // UTF-8 input text as raw literal
	s = "\u65e5\u672c\u8a9e"                   // the explicit Unicode code points
	s = "\U000065e5\U0000672c\U00008a9e"       // the explicit Unicode code points
	s = "\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e" // the explicit UTF-8 bytes
	fmt.Println(s)
}

package main

import "fmt"

const myName = "Gábor"

func sayHello(name string) string {
	return fmt.Sprintf("Hello, %v!", name)
}

// PrintHello prints a greeting for name.
func PrintHello(name string) {
	fmt.Println(sayHello(name))
}

func main() {
	PrintHello(myName)
}

Expression = UnaryExpr | Expression binary_op Expression .
UnaryExpr  = PrimaryExpr | unary_op UnaryExpr .

binary_op  = "||" | "&&" | rel_op | add_op | mul_op .
rel_op     = "==" | "!=" | "<" | "<=" | ">" | ">=" .
add_op     = "+" | "-" | "|" | "^" .
mul_op     = "*" | "/" | "%" | "<<" | ">>" | "&" | "&^" .

unary_op   = "+" | "-" | "!" | "^" | "*" | "&" | "<-" .

Precedence    Operator
    5             *  /  %  <<  >>  &  &^
    4             +  -  |  ^
    3             ==  !=  <  <=  >  >=
    2             &&
    1             ||

package main

import "fmt"

// [const] Constants

// Pi exported constant, one value per line.
const Pi = 3.14 // const cannot be declared using the := syntax

// More constants by one const.
const (
	truth    = false           // boolean constant
	lf       = '\n'            // rune constant
	statusOK = 200             // integer constant
	pi       = 3.1415965359    // floating-point constant
	comp     = 1.e+0i          // complex constant
	greeting = "Hello, world!" // string constant
)

const (
	a = 0
	b = 1
	c = 2
)

// The same with auto increment IOTA.
const (
	d = iota // 0
	e        // 1
	f        // 2
)

// Iota can also start from non-zero number - iota expressions can also be used
// to start iota from any number
const (
	g = iota + 10 // 10
	h             // 11
	i             // 12
)

// Size is our type for 8 bit length unsigned integers.
type Size uint8

// Enum in Golang: IOTA provides an automated way to create a enum in Golang.
const (
	small Size = iota
	medium
	large
	extraLarge
)

func main() {
	fmt.Println("truth:", truth)
	fmt.Println("lf:", lf)
	fmt.Println("statusOK:", statusOK)
	fmt.Println("pi:", pi)
	fmt.Println("comp:", comp)
	fmt.Println("greeting:", greeting)
	fmt.Println(small)
	fmt.Println(medium)
	fmt.Println(large)
	fmt.Println(extraLarge)
}

package main

import "fmt"

// [var] Variables

// Declare one by one.
var male bool

// Name is exported if it begins with a Capital Letter.
var Name string

// Declare list of variables.
var (
	age      int
	name     string
	location string
)

// [=] Declare and initialize.
var (
	age2      int    = 32
	name2     string = "Interpreted Literal"
	location2 string = `Raw String Literal`
)

// [=] Declare and initialize inferred.
var (
	age3      = 42
	name3     = "Initialized Literal"
	location3 = "File"
)

// <ARRAY>
var myArr [10]int
var sentence [2]string
var multiDimension [2][3]string

// <SLICE>
var mySlice []int // <- nil slice, mySlice == nil: true

func main() {
	// [:=] Inside a function, the := SHORT VARIABLE DECLARATION or
	// short assignment statement.
	name, location := "Its Me", "Here"
	fmt.Println("name:", name, "location:", location)
	raw := `Raw string\tliterals\n`
	fmt.Println("raw string: ", raw)
	hereDoc := `Here docs
or here strings can be
written easily by the
raw string literal.
`
	fmt.Print("here doc: ", hereDoc)
	interp := "Interpreted string\tliterals\n"
	fmt.Print("interpreted string: ", interp)
	lenRaw := len(raw)
	fmt.Printf("Length of raw string: %v\n", lenRaw)
	firstByte := raw[0] // strings can be handled as byte arrays
	fmt.Println("First byte of raw string:", firstByte)
	age := 32
	fmt.Println("Age:", age)

	// <ARRAY> initialization
	sentence[0] = "Hello"
	sentence[1] = "World"
	myArr = [10]int{75, 42, 53, 67} // <ARRAY> initialization by literal
	lenMyArr := len(myArr)          // 10
	fmt.Printf("Length of my array: %v\n", lenMyArr)
	sen := [2]string{"hello", "world!"}
	fmt.Println("String array of sentence, Println:", sen)
	// [hello world!]
	fmt.Printf("String array of sentence, Printf, %v: %s\n", "%s", sen)
	// [hello world!]
	fmt.Printf("String array of sentence, Printf, %v: %q\n", "%q", sen)
	// ["hello" "world!"]
	a := [...]string{"hello", "world!"} // [...] ellipsis:  implicit length
	fmt.Printf("String array with ellipsis, Printf, %v: %q\n", "%q", a)
	multiDimension[0][1] = "42" // reference first row and second column

	// <SLICE> initialization
	mySlice = make([]int, 50, 100)
	mySlice = new([100]int)[0:50]       // equivalent
	mySlice = []int{2, 3, 5, 7, 11, 13} // or initialization by literal
	lenMySlice := len(mySlice)          // 6
	fmt.Printf("Length of my slice: %v\n", lenMySlice)
	fmt.Println("mySlice: ", mySlice)
	// [:] The slice maker operator: array[lowerIndex:higherIndex]
	mySlice = myArr[1:3]         // [:] s[lo:hi]: slice of elements lo - hi-1
	mySlice = append(mySlice, 3) // add the number 3 to the right side
	// Slices are like pointers to named or anonym arrays.
	cities := make([]string, 3)
	cities[0] = "Santa Monica"
	cities[1] = "Venice"
	cities[2] = "Los Angeles"
	// Slices make array manipulation dynamic
	cities = append(cities, "San Diego") // add to the right side
	cities = append(cities, "San Diego", "Mountain View")
	fmt.Printf("cities: %q\n", cities)
}

var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

i := 42
f := float64(i)
u := uint(f)

i, err := strconv.Atoi("-42")
s := strconv.Itoa(-42)
b, err := strconv.ParseBool("true")
f, err := strconv.ParseFloat("3.1415", 64)
i, err := strconv.ParseInt("-42", 10, 64)
u, err := strconv.ParseUint("42", 10, 64)
s := strconv.FormatBool(true)
s := strconv.FormatFloat(3.1415, 'E', -1, 64)
s := strconv.FormatInt(-42, 16)
s := strconv.FormatUint(42, 16)
q := strconv.Quote("Hello, 世界")
q := strconv.QuoteToASCII("Hello, 世界")

t := i.(T)

t, ok := i.(T)

m := make(map[string]int) // map
m["Answer"] = 42          // map has one entry
v, ok := m["Answer"]      // reading from map similar

package main

import (
	"fmt"
	"strconv"
)

// [type]
type myFloat float64
type text []string

var (
	debug    bool = true
	runCount int
	version  float32   = 1.0
	unreal   complex64 = 1.e+1i
	lf       rune      = '\n'
	name     string    = "Gábor"
)

func main() {
	var pi myFloat = 3.14
	var greeting text = text{"Welcome", "to", "the", "Go"}
	fmt.Printf("pi: %v\n", pi)
	fmt.Printf("greeting: %q\n", greeting)

	// type casting
	a := 42
	f := float64(a)
	u := uint(f)
	fmt.Println(a, f, u)

	// type conversion
	i, err := strconv.Atoi("-42")
	fmt.Println(i, err)
	s := strconv.Itoa(-42)
	fmt.Println(s)
	b, err := strconv.ParseBool("true")
	fmt.Println(b, err)
	f, err = strconv.ParseFloat("3.1415", 64)
	fmt.Println(f, err)
	j, err := strconv.ParseInt("-42", 10, 64)
	fmt.Println(j, err)
	ui, err := strconv.ParseUint("42", 10, 64)
	fmt.Println(ui, err)
	s = strconv.FormatBool(true)
	fmt.Println(s)
	s = strconv.FormatFloat(3.1415, 'E', -1, 64)
	fmt.Println(s)
	s = strconv.FormatInt(-42, 16)
	fmt.Println(s)
	s = strconv.FormatUint(42, 16)
	fmt.Println(s)

	// type assertion
	var ifc interface{} = "hello" // static type: interface, dynamic type: string
	s = ifc.(string)
	fmt.Println(s)
	s, ok := ifc.(string)
	fmt.Println(s, ok)
	f, ok = ifc.(float64)
	fmt.Println(f, ok)
	//f = ifc.(float64) // panic!
	//fmt.Println(f)
}

package main

import "fmt"

// [struct]
var aPoint struct {
	x int
	y int
}

type point struct {
	x int
	y int
}

// User struct is like an object of attributes.
type User struct {
	ID                                  int
	Age                                 int
	Name, FirstName, LastName, Location string
}

// Player struct includes User and additional attribute
type Player struct {
	User
	GameID int
}

func main() {
	// [struct] initialization
	p := point{1, 2}
	q := &point{1, 2} // has type *point
	r := point{x: 1}  // y:0 is implicit
	s := point{}      // x:0 and y:0
	fmt.Printf("point{1, 2}: %v,\n", p)
	fmt.Printf("&point{1, 2}: %v,\n", q)
	fmt.Printf("point{x: 1}: %v,\n", r)
	fmt.Printf("point{}: %v\n", s)
	me := Player{}
	me.ID = 47
	me.Name = "Gábor"
	me.Location = "Hungary"
	fmt.Println(me)
}

package main

import "fmt"

// --- Anonymous Field in Struct ---

type Polygon struct {
	Sides int
}

func (p *Polygon) NSides() int {
	return p.Sides
}

type Triangle struct {
	Polygon // Anonymous Field
}

// ---------------------------------

func main() {
	pizza := struct {
		name string
	}{
		name: "Pizza",
	}
	fmt.Println(pizza) // prints {Pizza}

	// Using Anonymous Field of Struct to reduce unnecessary function calls.
	t := Triangle{
		Polygon{
			Sides: 3,
		},
	}
	fmt.Println(t.NSides()) // 3
}

package main

import "fmt"

//var env map[string]string

func main() {
	// [map]
	//env = make(map[string]string)
	//env["PATH"] = "/bin"
	scientists := map[string]int{
		"Nikola Tesla":        166,
		"Thomas Edison":       175,
		"Tivadar Puskás":      178,
		"James Clerk Maxwell": 191,
	}
	fmt.Printf("%#v\n", scientists)
	env := map[string]string{
		"PATH":  "/bin:/usr/bin",
		"SHELL": "/bin/bash",
		"USER":  "nobody",
	}
	key := "USER"
	elem := "gabor"
	// Insert or update an element in map m:
	env[key] = elem
	// Retrieve an element:
	elem = env[key]
	// Delete an element:
	key = "SHELL"
	delete(env, key)
	// Test that a key is present with a two-value assignment:
	elem1, ok := env[key]
	// If key is in m, ok is true. If not, ok is false and elem is the zero value
	// for the map’s element type.
	if ok == false {
		fmt.Printf("map: No key %v found in env:\n", key)
		fmt.Printf("%q\n", env)
	} else {
		fmt.Println(elem1)
	}
	fmt.Println()
}

package main

import "fmt"

// [func] function definition
// Can have more parameters.
func add(x int, y int) int {
	// [return]
	return x + y // [+]
}

// More parameters from the same type can be listed with same type.
func myMath(x, y float64) {
	fmt.Println("x + y:", x+y)           // [+] sum
	fmt.Println("x - y:", x-y)           // [-] difference
	fmt.Println("x * y:", x*y)           // [*] product
	fmt.Println("x / y:", x/y)           // [/] quotient
	fmt.Println("x % y:", int(x)%int(y)) // [%] remainder
	/*
		& 	bitwise AND                    // [&]
		| 	bitwise OR                     // [|]
		^ 	bitwise XOR                    // [^]
		&^	bit clear (AND NOT)            // [&^]
	*/
}

// Can return more values.
func sort(x, y int) (int, int) {
	if x < y {
		return x, y // [,]
	}
	return y, x
}

/*
	Multiple return values can be named and act just like variables. If the
	result parameters are named, a return statement without arguments returns the
	current values of the results.
*/
func sort2(x, y int) (first, second int) {
	if x < y {
		first, second = x, y // [,]
	} else {
		first, second = y, x
	}
	return
}

// Variadic functions have variadic parameters.
// [...] ...Type: pack operator
func variadicFunc(arg ...int) {
	for i := range arg {
		fmt.Println("Variadic func", i, arg[i])
	}
}

// <POINTER>
func inc(num *int) {
	/*
		By default Go passes arguments by value (copying the arguments), if you
		want to pass the arguments by reference, you need to pass pointers (or use
		a structure using reference values like slices and maps.
	*/
	// Dereference a pointer, use the [*] symbol.
	*num++ // [++]
}
func dec(num *int) {
	*num-- // [--]
}

// <METHOD>

// user struct is like an OBJECT of attributes.
type user struct {
	id                                  int
	age                                 int
	name, firstName, lastName, location string
}

// NewUser as user's constructor-like function.
func NewUser(id, age int, firstName, lastName, location string) *user {
	u := new(user)
	u.id = id
	u.age = age
	u.firstName = firstName
	u.lastName = lastName
	u.location = location
	return u
}

/*
	Stringer [interface] is defined by the fmt package.
	This is one of the most ubiquitous interfaces.
	A STRINGER is a type that can describe itself as a string.
*/
// Stringer interface defines String() method.
type Stringer interface {
	String() string
}

func (u *user) String() string {
	return fmt.Sprintf("--- USER ---\nname:\t\t%v\nid:\t\t%v\nage:\t\t%v\nlocation:\t%v\n------------", u.Name(), u.id, u.age, u.location)
}

// Namer [interface] contains one method definition.
// An interface type is defined by a set of methods.
type Namer interface {
	Name() string
}

// Name <METHOD> prints the user's name.
// Interfaces are satisfied implicitly.
func (u *user) Name() string {
	return fmt.Sprintf("%s %s", u.firstName, u.lastName)
}

// Greetings <METHOD> is just a function with a RECEIVER ARGUMENT.
func (u *user) Greetings() string { // (u *user): method receiver
	return fmt.Sprintf("Hi %s from %s", u.Name(), u.location)
}

// Birth returns by the birth year.
func (u *user) Birth() int {
	return 2022 - u.age // [-]
}

// <GENERIC>
// Generics will be introduced in Go v1.18.
/*
func printAnySlice[T any](s []T) {
	for _, v := range s {
		fmt.Print(v)
	}
}
*/

func main() {
	// [func] call
	fmt.Println("add(42, 13): ", add(42, 13))
	fmt.Println("mymath(12.0, 33.0): ")
	myMath(12.0, 33.0)
	a, b := sort(42, 13)
	fmt.Println("sort(42, 13): ", a, b)
	a, b = sort2(42, 13)
	fmt.Println("sort2(42, 13): ", a, b)
	fmt.Println("variadicfunc(1, 2, 3):")

	variadicFunc(1, 2, 3)
	var nums []int = []int{42, 57, 93}
	fmt.Println("variadicFunc(42, 57, 93):")
	variadicFunc(nums...) // [...] Var...: unpack operator

	age := 33
	fmt.Println("age: ", age)
	fmt.Println("inc(&age)")
	inc(&age) // get the <POINTER> of a value, use the & symbol
	fmt.Println("age: ", age)
	fmt.Println("dec(&age)")
	dec(&age) // get the <POINTER> of a value, use the & symbol
	fmt.Println("age: ", age)

	// Methods
	/*
		Instead of:
		me := &user{} //me := new(user)
		me.id = 1
		me.age = 127
		me.firstName = "Gábor"
		me.lastName = "Imolai"
		me.location = "Hungary"
	*/
	// We call "constructor".
	me := NewUser(1, 127, "Gábor", "Imolai", "Hungary")
	fmt.Println(me) // Print via Stringer.
}

package main

import "fmt"

func main() {
	// Anonymous function
	v := func() {
		fmt.Println("Inside anonymous function")
	}
	v() // call
	func() {
		fmt.Println("Anonymous function gets invoked immediately")
	}()
	func(v int) {
		fmt.Println(v)
	}(42) // Passing Arguments to an Anonymous Function
	g := func(v string) {
		fmt.Println(v)
	}
	func(v string, g func(v string)) {
		g(v)
	}("Passing Anonymous Functions as an Argument", g)
	f1 := func() func(v string) {
		f := func(v string) {
			fmt.Println(v)
		}
		return f
	}
	h := f1()
	h("Returning Anonymous Function from a Function")
}

package main

import "fmt"

// [goto]
func funGoTo() {
	fmt.Println("Before a goto.")
	goto FINISH
	fmt.Println("Unreachable code due to goto.")
FINISH: // label
	fmt.Println("After a goto.")
}

func main() {
	funGoTo()
}

package main

import "fmt"

func add(x int, y int) int {
	// [return]
	return x + y // [+]
}

// Can return more values.
func sort(x, y int) (int, int) {
	if x < y {
		return x, y // [,]
	}
	return y, x
}

/*
	Multiple return values can be named and act just like variables. If the
	result parameters are named, a return statement without arguments returns the
	current values of the results.
*/
func sort2(x, y int) (first, second int) {
	if x < y {
		first, second = x, y // [,]
	} else {
		first, second = y, x
	}
	return
}

func main() {
	fmt.Println("add(42, 13): ", add(42, 13))
	fmt.Println("mymath(12.0, 33.0): ")
	a, b := sort(42, 13)
	fmt.Println("sort(42, 13): ", a, b)
	a, b = sort2(42, 13)
	fmt.Println("sort2(42, 13): ", a, b)
}

package main

import (
	"fmt"
	"os"
)

// [defer]
/*
	Defer statement is used to execute a function call just before the
	surrounding function where the defer statement is present returns
	When a function has multiple defer calls, they are pushed on to a stack an
	executed in Last In First Out (LIFO) order.
*/
func writeToTempFile(text string) error {
	file, err := os.Open("temp.txt")
	if err != nil {
		return err
	}
	defer file.Close()

	n, err := file.WriteString(text)
	if err != nil {
		return err
	}
	fmt.Printf("Number of bytes written: %d", n)
	return nil
}

func main() {
	writeToTempFile("Some text from deferred function.")
}

package main

import (
	"fmt"
	"time"
)

// user struct is like an OBJECT of attributes.
type user struct {
	id                                  int
	age                                 int
	name, firstName, lastName, location string
}

// [interface]
// Namer [interface] contains one method definition.
// An interface type is defined by a set of methods.
type Namer interface {
	Name() string
}

// Name <METHOD> prints the user's name.
// Interfaces are satisfied implicitly.
func (u *user) Name() string {
	return fmt.Sprintf("%s %s", u.firstName, u.lastName)
}

/*
	Stringer [interface] is defined by the fmt package.
	This is one of the most ubiquitous interfaces.
	A STRINGER is a type that can describe itself as a string.
*/
// Stringer interface defines String() method.
type Stringer interface {
	String() string
}

func (u *user) String() string {
	return fmt.Sprintf("--- USER ---\nname:\t\t%v\nid:\t\t%v\nage:\t\t%v\nlocation:\t%v\n------------", u.Name(), u.id, u.age, u.location)
}

// The ERROR type is a built-in interface similar to fmt.Stringer:
type error interface {
	Error() string
}
type MyError struct {
	When time.Time
	What string
}

func (e *MyError) Error() string {
	return fmt.Sprintf("at %v, %s",
		e.When, e.What)
}
func run() error {
	return &MyError{
		time.Now(),
		"it didn't work",
	}
}

func main() {
	me := new(user)
	me.id = 1
	me.age = 127
	me.firstName = "Gábor"
	me.lastName = "Imolai"
	me.location = "Hungary"
	fmt.Println(me) // Print via Stringer.
}

package main

import "fmt"

func main() {
	// [if]
	answer := 42
	if answer == 42 { // [==]
		fmt.Println("The Answer to the Ultimate Question of Life, the Universe, and Everything...")
	}
	foo := func() interface{} {
		return nil
	}
	// Like for, the if statement can start with a short statement.
	if err := foo(); err != nil { // [!=]
		panic(err)
	}
	// Nested ifs can be avoided by chaining conditions logically.
	question := "What do you get if you multiply six by nine?"
	if question == "What do you get if you multiply six by nine?" && answer == 42 {
		fmt.Println("Don't panic!")
	}
}

package main

import "fmt"

func main() {
	// [if] [else]
	magicNum := 100
	if magicNum == 100 {
		fmt.Println("Japan")
	} else {
		fmt.Println("Canada")
	}

	// [if] [else] [if]
	if magicNum == 50 {
		fmt.Println("Germany")
	} else if magicNum == 100 {
		fmt.Println("Japan")
	} else {
		fmt.Println("Canada")
	}
}

package main

import (
	"fmt"
	"runtime"
	"time"
)

func main() {
	// [switch] [case]
	score := 7
	switch score {
	case 1, 3, 5, 7:
		fmt.Println("Terrible")
	}

	// Switch with a short statement.
	switch os := runtime.GOOS; os {
	case "linux":
		fmt.Println("Linux.")
	}

	t := time.Now()
	// Switch without a condition is the same as switch true.
	switch {
	case t.Hour() < 12:
		fmt.Println("Good morning!")
	}
}

switch v := i.(type) {
case T:
    // here v has type T
case S:
    // here v has type S
default:
    // no match; here v has the same type as i
}

package main

import "fmt"

func do(i interface{}) {
	switch v := i.(type) {
	case bool:
		fmt.Printf("Boolean: %v\n", v)
	case int:
		fmt.Printf("Twice %v is %v\n", v, v*2)
	case string:
		fmt.Printf("%q is %v bytes long\n", v, len(v))
	default:
		fmt.Printf("I don't know about type %T!\n", v)
	}
}

func main() {
	do(21)
	do("hello")
	do(true)
}

package main

import (
	"fmt"
	"runtime"
	"time"
)

func main() {
	// [switch] [case]
	score := 7
	switch score {
	case 0, 1, 3:
		fmt.Println("Terrible")
	case 4, 5:
		fmt.Println("Mediocre")
	case 6, 7:
		fmt.Println("Not bad")
	case 8, 9:
		fmt.Println("Almost perfect")
	case 10:
		fmt.Println("hmm did you cheat?")
	}

	// Switch with a short statement.
	switch os := runtime.GOOS; os {
	case "darwin":
		fmt.Println("OS X.")
	case "linux":
		fmt.Println("Linux.")
	}

	t := time.Now()
	// Switch without a condition is the same as switch true.
	switch {
	case t.Hour() < 12:
		fmt.Println("Good morning!")
	case t.Hour() < 17:
		fmt.Println("Good afternoon.")
	}
}

package main

import (
	"fmt"
	"runtime"
	"time"
)

func main() {
	// [switch] [case]
	score := 7
	switch score {
	case 0, 1, 3:
		fmt.Println("Terrible")
	case 4, 5:
		fmt.Println("Mediocre")
	case 6, 7:
		fmt.Println("Not bad")
	case 8, 9:
		fmt.Println("Almost perfect")
	case 10:
		fmt.Println("hmm did you cheat?")
	default:
		fmt.Println(score, " off the chart")
	}

	// Switch with a short statement.
	switch os := runtime.GOOS; os {
	case "darwin":
		fmt.Println("OS X.")
	case "linux":
		fmt.Println("Linux.")
	default:
		// freebsd, openbsd,
		// plan9, windows...
		fmt.Printf("%s.\n", os)
	}

	t := time.Now()
	// Switch without a condition is the same as switch true.
	switch {
	case t.Hour() < 12:
		fmt.Println("Good morning!")
	case t.Hour() < 17:
		fmt.Println("Good afternoon.")
	default:
		fmt.Println("Good evening.")
	}
}

package main

import "fmt"

func main() {
	// [fallthrough]
	n := 4
	switch n {
	case 0:
		fmt.Println("is zero")
		fallthrough
	case 1:
		fmt.Println("is <= 1")
		fallthrough
	case 2:
		fmt.Println("is <= 2")
		fallthrough
	case 3:
		fmt.Println("is <= 3")
		fallthrough
	case 4:
		fmt.Println("is <= 4")
		fallthrough
	case 5:
		fmt.Println("is <= 5")
		fallthrough
	case 6:
		fmt.Println("is <= 6")
		fallthrough
	case 7:
		fmt.Println("is <= 7")
		fallthrough
	case 8:
		fmt.Println("is <= 8")
		fallthrough
	default:
		fmt.Println("Try again!")
	}
}

package main

func main() {
	// [for]
	sum := 0
	// Traditional for loop
	for i := 0; i < 10; i++ {
		sum += i
	}
	sum = 1
	// Loop without pre/post statements
	for sum < 1000 {
		sum += sum
	}
	sum = 1
	// For loop as a while loop
	for sum < 1000 {
		sum += sum
	}
	// Infinite loop
	//for {
	// do something in a loop forever
	//}
}

package main

import "fmt"

func main() {
	// [break]
	for i := 1; i <= 5; i++ {
		// terminates the loop when i is equal to 3
		if i == 3 {
			break
		}
		fmt.Println(i)
	}
}

package main

import "fmt"

func main() {
	// [continue]
	for i := 1; i <= 5; i++ {
		// skips the iteration when i is equal to 3
		if i == 3 {
			continue
		}
		fmt.Println(i)
	}
}

package main

import "fmt"

func printList(args ...int) {
	for i, arg := range args {
		fmt.Println("Elem", i, arg)
	}
}

func main() {
	// [range]
	printList(42, 57, 63, 71)
	cities := []string{"Barcelona", "Budapest", "Belgrad", "Wien"}
	fmt.Println("cities printed in range:")
	for i, city := range cities {
		// for _, city := range cities { // skip the index
		fmt.Printf("%v) %v\n", i, city)
	}
}

$ ls ~/sdk/go1.17.6/src/math/*.go | xargs grep ^package | cut -d: -f2 | sort -u
package math
package math_test

package main

import (
	"fmt"
	"math/rand" // It is defined in the "rand" directory in the "math" directory
	// as "rand.go" and "package rand" inside.
	/*
		~$ ls ~/sdk/go1.17.6/src/math/rand/rand.go
		/home/$USER/sdk/go1.17.6/src/math/rand/rand.go
		~$ grep ^package ~/sdk/go1.17.6/src/math/rand/rand.go
		package rand
	*/
	"time"
)

func main() {
	// In Go, a name is exported if it begins with a capital letter. Like the
	// Seed, Now, Println, Intn.
	rand.Seed(time.Now().UnixNano())
	fmt.Println("Random number between 0 and 10: ", rand.Intn(10))
}

package main

// [import]
/*
	Almost everything we want to do in Go comes from some package. And to use
	those packages, we need to import them.

	**Aliased import**
	import f "fmt"

	**Blank import**
	import _ "time"    ignore the unused import

	**Dot import** [.]
	If an explicit period (.) appears instead of a name, all the package's
	exported identifiers will be declared in the current file's file block an
	can be accessed without a qualifier
	Import declaration          Local name of Sin
	import   "lib/math"         math.Sin
	import M "lib/math"         M.Sin
	import . "lib/math"         Sin
*/

//import "fmt" // import packages one by one
//import "os"

import ( // grouped import syntax
	"fmt"
	"os"
)

func main() {
	fmt.Println()
	os.Exit(0)
}

package main

import (
	"fmt"
	"time"
)

// [go]
func printNums(from, to int) {
	for i := from; i <= to; i++ {
		time.Sleep(50 * time.Millisecond)
		fmt.Print(i, " ")
	}
}

func main() {
	fmt.Println("Print nums by Goroutines.")
	go printNums(0, 5)
	go printNums(6, 10)
	// No output, because the main() does not wait, exits before the Goroutines.
	// It is a simple solution to put a wait in the main thread:
	time.Sleep(500 * time.Millisecond)

	// Anonymous Goroutine
	go func() {
		for i := 11; i < 16; i++ {
			fmt.Print(i, " ")
			time.Sleep(100 * time.Millisecond)
		}
	}()
	time.Sleep(1 * time.Second)
}

package main

import "fmt"

func printNumsCh(from, to int, ch chan bool) {
	for i := from; i <= to; i++ {
		fmt.Print(i, " ")
	}
	ch <- true // [<-]
}

func main() {
	// [chan]
	/*
		To enable communication between Goroutines, Go provides Channels. A channel
		is like a pipe, allowing you to send and receive data from Goroutines.
	*/
	fmt.Println("Print nums by Goroutines using Channels.")
	ch := make(chan bool)
	workers := 2
	go printNumsCh(0, 5, ch)
	go printNumsCh(6, 10, ch)
	// [<-]
	for i := workers; i > 0; i-- {
		<-ch // or: value := <-ch
	}
	fmt.Println()
}

package main

import "fmt"

func sumEven(from, to int, ch chan int) {
	sum := 0
	for i := from; i <= to; i++ {
		if i%2 == 0 {
			sum += i
		}
	}
	ch <- sum // [<-]
}

func sumOdd(from, to int, ch chan int) {
	sum := 0
	for i := from; i <= to; i++ {
		if i%2 != 0 {
			sum += i
		}
	}
	ch <- sum // [<-]
}

func main() {
	// [select]
	/*
		The select statement is used to wait on multiple channel operations.
		The syntax is similar to switch except that each of the case statements
		will be a channel operation.
	*/
	fmt.Println("Print even and odd sums by Goroutines using Channels.")
	even := make(chan int)
	odd := make(chan int)
	workers := 2
	go sumEven(0, 100, even)
	go sumOdd(0, 100, odd)
	for i := workers; i > 0; i-- {
		select {
		case x := <-even:
			fmt.Println("Even:", x)
		case y := <-odd:
			fmt.Println("Odd:", y)
		}
	}
}