Try / Go in Y minutes

// Single line comment
/* Multi-
 line comment */

// +build prod, dev, test

package main

import (
	"fmt"       // A package in the Go standard library.
	"io/ioutil" // Implements some I/O utility functions.
	m "math"    // Math library with local alias m.
	"net/http"  // Yes, a web server!
	"os"        // OS functions like working with the file system
	"strconv"   // String conversions.
)

// Running this code snippet is expected to fail,
// because the imported packages are not used.

func main() {
	// Println outputs a line to stdout.
	// It comes from the package fmt.
	fmt.Println("Hello world!")

	// Call another function within package main.
	beyondHello()
}

func beyondHello() {
	fmt.Println("Hello main!")
}

func noparams() {
	fmt.Println("Look ma! No parameters!")
}

var x int    // Variable declaration.
x = 3        // Variable assignment.
y := 4+3i    // "Short" declaration
fmt.Println("x:", x, ", y:", y)
fmt.Printf("Type of y: %T\n", y)

func learnMultiple(x, y int) (sum, prod int) {
	return x + y, x * y // Return two values.
}

func main() {
	a, b := learnMultiple(3,4)
	fmt.Println(a, b)
}

str := "Learn Go!" // string type.

s2 := `A "raw" string literal
can include line breaks.` // Same string type.

// Non-ASCII literal. Go source is UTF-8.
g := 'Σ' // rune type, an alias for int32, holds a unicode code point.

f := 3.14159 // float64, an IEEE-754 64-bit floating point number.
c := 3 + 4i  // complex128, represented internally with two float64's.

// var syntax with initializers.
var u uint = 7 // Unsigned, but implementation dependent size as with int.
var pi float32 = 22. / 7

// Conversion syntax with a short declaration.
n := byte('\n') // byte is an alias for uint8.

fmt.Printf("str: %s\ns2: %s\ng: %s\nf: %f\nc: %f\nu: %d\npi: %f\nn: %v\n",
	str, s2, g, f, c, u, pi, n)

a, b := 1024, 2048
p, q := &a, &b      // Declares p, q to be type pointer to int.
fmt.Println(p, q)   // This prints the addresses of p and q.
fmt.Println(*p, *q) // * follows (or dereferences) a pointer.
                    // This prints two ints.

var a4 [4]int // An array of 4 ints, initialized to all 0.
a5 := [...]int{3, 1, 5, 10, 100} // An array initialized from an array literal.
// The ellipsis says that the size is determined from the literal.
fmt.Printf("a4: %v\na5: %v\n", a4, a5)

var a4 [4]int   // An array of 4 ints, initialized to all 0.
a4_cpy := a4    // a4_cpy is a copy of a4, two separate instances.
a4_cpy[0] = 25  // Only a4_cpy is changed, a4 stays the same.
fmt.Println(a4_cpy[0] == a4[0]) // false

s3 := []int{4, 5, 9}    // Compare to a5. No ellipsis used here.
s4 := make([]int, 4)    // Allocates slice of 4 ints, initialized to all 0.
var d2 [][]float64      // Declaration only, nothing allocated here.
bs := []byte("a slice") // Type conversion syntax.
fmt.Printf("s3: %v\ns4: %v\nd2: %v\nbs: %v\n", s3, s4, d2, bs)

s3 := []int{4, 5, 9}
s3_cpy := s3    // Both variables point to the same instance.
s3_cpy[0] = 0   // Which means both are updated.
fmt.Println(s3_cpy[0] == s3[0]) // true

s := []int{1, 2, 3}		// Result is a slice of length 3.
fmt.Println(s)
s = append(s, 4, 5, 6)	// Added 3 elements. Slice now has length of 6.
fmt.Println(s)          // Updated slice is now [1 2 3 4 5 6]

s := []int{1, 2, 3, 4, 5, 6}
s = append(s, []int{7, 8, 9}...) // The ellipsis unpacks the slice
fmt.Println(s) // Updated slice is now [1 2 3 4 5 6 7 8 9]

m := map[string]int{"three": 3, "four": 4}
m["one"] = 1
fmt.Printf("m: %v\nm[\"one\"]: %d", m, m["one"])

// Try replacing the blank identifier _ with a variable name.
var _ = "This variable is not used"

package main

import (
	"os"
	"fmt"
)

func main() {
	file, _ := os.Create("output.txt")
	fmt.Fprint(file, "This is how you write to a file, by the way")
	file.Close()
}

func query(filter string) (string, string, string) { ... }

func query(filter string) (first, last, email string) { ... }

func namedReturn() (a, b int) {
	a = 1   // note the simple assignment; no short declaration := required
	        // b is initialized with the zero value, 0 in this case.
	return  // bad practice; don't do this.
}

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

func memoryAllocations() (p, q *int) {
	// Named return values p and q have type pointer to int.
	p = new(int) // Built-in function new allocates memory.

    // The allocated int slice is initialized to 0, p is no longer nil.
	s := make([]int, 20) // Allocate 20 ints as a single block of memory.
	s[3] = 7             // Assign one of them.
	r := -2              // Declare another local variable.
	return &s[3], &r     // & takes the address of an object.
}

func main() {
	a, b := memoryAllocations()
	fmt.Printf("*a: %d, *b: %d\n", *a, *b)
}

if true {
	fmt.Println("told ya")
}

a := 1
if a > 0 {
	fmt.Println("yep")
} else {
	fmt.Println("nope")
}

// You can put an assignment statement before the condition.
// In this case, the variable lives ONLY within the scope of the `if``
// statement.

if y := expensiveComputation(); y > 0 {
	fmt.Println("positive!")
}
// y is not defined outside the if block.
// fmt.Println(y) // Uncomment this line to see the error

x := 42.0
switch x {
case 0:
	fmt.Println("not 42")
case 1, 2: // Can have multiple matches on one case
	fmt.Println("still not 42")
case 42:
	fmt.Println("Yay! 42!")
	// no fallthrough to subsequent case blocks.
case 43:
	fmt.Println("This case is never reached.")
default:
	fmt.Println("The default case is optional.")
}

var data any    // data is an empty interface
data = "data"   // now data holds a string
switch c := data.(type) { // c
case string:
	fmt.Printf("%s is a string", c)
case int64:
	fmt.Printf("%d is an int64\n", c)
default:
	fmt.Printf("data's type is %T, its value is %v", c, c)
}

x := 42
for x := 0; x < 3; x++ { // ++ is the increment operator
	fmt.Println("iteration", x)
}
fmt.Println("Not the loop's x: ", x)

// infinite loops and the break statement
x := 0
for { // an unrestricted loop
	fmt.Print(x, ",")
	if x >= 3 {
		break  // exit the loop
	}
	x++
}

fmt.Println()

x = 0
for x <= 5 { // a while loop
	x++
	if x % 2 == 0 { // modulo operator
		continue // skip the rest of this iteration
	}
	fmt.Print(x, ",")
}

for index, value := range "Hello" {
	fmt.Printf("index=%d, value=%c\n", index, value)
}
fmt.Println()

for key, value := range map[string]int{"one": 1, "two": 2, "three": 3} {
	// for each pair in the map, print key and value
	fmt.Printf("key=%s, value=%d\n", key, value)
}
fmt.Println()

// If you only need the value, assign the key to the blank identifier
for _, name := range []string{"Bob", "Bill", "Joe"} {
	fmt.Printf("Hello, %s\n", name)
}

func cleanupWithoutDefer() (err error) { // err is declared here
	var a, b string
	_, err = fmt.Sscan("one", &a, &b) // too many arguments for the input
    if err != nil {
        goto fail
    }
    // more error-producing code
    if err != nil {
        goto fail
    }
    // ...
    return nil

    fail:
        fmt.Printf("Got %s, cleaning up\n", err)
		// clean up
        return err
}

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

	goto printx // ERROR: goto jumps over declaration
	x := "I am skipped"
printx:
	fmt.Println(x)

x := 99999
xBig := func() bool {  // xBig is a variable of type func() bool
    return x > 10000   // References x declared outside the closure
}
fmt.Println("xBig:", xBig()) // true
x = 1.3e3                    // This makes x == 1300
fmt.Println("xBig:", xBig()) // false now.

fmt.Printf("Add and double two numbers: %d", // %d expects an integer
    func(a, b int) int {
        return (a + b) * 2
    }(10, 2)) // Called with args 10 and 2

func main() {
	// Next two are equivalent, with second being more practical
	fmt.Println(sentenceFactory("summer")("It's", "time!"))

	d := sentenceFactory("summer")
	fmt.Println(d("A beautiful", "day!"))
	fmt.Println(d("A lazy", "afternoon!"))
}

func sentenceFactory(mystring string) func(before, after string) string {
	return func(before, after string) string {
		return fmt.Sprintf("%s %s %s", before, mystring, after) // new string
	}
}

func learnDefer() (err error) {
	defer func() {
		fmt.Println("deferred statements execute in reverse (LIFO) order.")
	}()  // Note the parens! The deferred func must be called here.
	defer fmt.Println("\nThis line is being printed first because")
	fmt.Println("This is normal code.")
	return nil
}

func main() {
	_ = learnDefer()  // always make ignoring an error an explicit operation
}

// Define Stringer as an interface type with one method, String.
type Stringer interface {
	String() string
}

// Define pair as a struct with two fields, ints named x and y.
type pair struct {
	x, y int
}

// Define a method on type pair. Pair now implements Stringer
// because Pair has defined all the methods in the interface.
func (p pair) String() string { // p is called the "receiver"
	// Sprintf is another public function in package fmt.
	// Dot syntax references fields of p.
	return fmt.Sprintf("(%d, %d)", p.x, p.y)
}

func main() {
	// Brace syntax is a "struct literal". It evaluates to an initialized
	// struct. The := syntax declares and initializes p to this struct.
	p := pair{3, 4}
	fmt.Println(p.String()) // Call String method of p, of type pair.
	var i Stringer          // Declare i of interface type Stringer.
	i = p                   // Valid because pair implements Stringer
	// Call String method of i, of type Stringer. Output same as above.
	fmt.Println(i.String())

	// Functions in the fmt package call the String method to ask an object
	// for a printable representation of itself.
	fmt.Println(p) // Output same as above. Println calls String method.
	fmt.Println(i) // Output same as above.

}

func CountOccurrences[T comparable](slice []T, element T) int {
    count := 0
    for _, value := range slice {
        if value == element {
            count++
        }
    }
    return count
}

func main() {
	numbers := []int{1, 2, 3, 2, 4, 2, 5}
	count := CountOccurrences(numbers, 2)  //
	fmt.Printf("Found %d occurrences of 2 in %v\n", count, numbers)

	words := []string{"go", "is", "awesome!", "go", "go!"}
	count = CountOccurrences(words, "go")
	fmt.Printf("Found %d occurrences of 'go' in %v\n", count, words)
}

[T comparable]

[T int|string]

func learnVariadicParams(myStrings ...string) {
	// Iterate each value of the variadic.
	for i, param := range myStrings {
		fmt.Printf("(%d) %s ", i, param)
	}
	fmt.Println()
}

func main() {
	learnVariadicParams("great", "learning", "here!")

	// Expand a slice into a list of parameters by appending an ellipsis
	s := []string{"codapi", "is", "awesome!"}
	learnVariadicParams(s...)
}

func divideBy(a, b int) (int, error) {  // always put an error last
	// Create a new error
	if b == 0 {
		// errors is a package from the standard library
		return 0, errors.New("divideBy: division by zero is undefined")
	}
	return a/b, nil // nil means no error
}

func calculate() (int, error) {
	// If you cannot handle an error, pass it on with annotations
	res, err := divideBy(10, 0)
	if err != nil {
		// The fmt package has an Errorf function for creating error messages
        // %w is a special verb for wrapping errors
		return 0, fmt.Errorf("calculate: %w", err)
	}
	return res, nil
}

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

m := map[int]string{3: "three", 4: "four"}

if x, ok := m[1]; ok { // key 1 is not in the map.
	fmt.Println("1:", x)
}

if x, ok := m[3]; ok { // key 3 is in the map
	fmt.Println("3:", x)
}

// A function with an endless loop.
func surfing() {
	for {
		fmt.Print(".")
	}
}

// Start any function as a goroutine by prepending "go".
func main() {
	go surfing()
	time.Sleep(time.Millisecond)
}

// A process does not wait for running goroutines
// to finish. When main() exits, all goroutines are stopped
// immediately.

// Create a channel with integer elements.
ch := make(chan int) // this channel has zero size.

// The syntax "chan<-" tells the func that this channel
// is for sending only.
go func(send chan<- int) {
	for i := 0; i < 10; i++ {
		send <- i
		fmt.Println("sent", i)
	}
	// by closing the channel, we tell the receiver
	// that there is nothing left to wait for
	close(send)
}(ch) // don't forget to call the goroutine here

// Now that the sender runs concurrently, we can start
// receiving values from the channel.
// The range loop exits when the channel is closed.
for n := range ch {
	fmt.Println("received", n)
}

ch := make(chan int)

c1 := make(chan string)
c2 := make(chan string)

// send some values to c1 with a delay
go func() {
	for i := 0; i < 3; i++ {
		c1 <- fmt.Sprintf("one %d", i)
		time.Sleep(10 * time.Millisecond)
	}
	close(c1)
}()

// send some values to c2 with a delay
go func() {
	for i := 0; i < 2; i++ {
		c2 <- fmt.Sprintf("two %d", i)
		time.Sleep(15 * time.Millisecond)
	}
	close(c2)
}()

for {
	// select takes no expressions. The cases block
    // until one of the channels becomes available.
	select {
	// The comma,ok idiom allows checking if a channel
	// is open or closed.
	case msg1, ok := <-c1:
		if !ok {
			c1 = nil
		} else {
			fmt.Println("Received from c1:", msg1)
		}
	case msg2, ok := <-c2:
		if !ok {
			c2 = nil
		} else {
			fmt.Println("Received from c2:", msg2)
		}
	default:
		if c1 == nil && c2 == nil {
			return
		}
	}
}

// A handler function responds to an HTTP request.
func handler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "You tried Go in Y minutes!")
}

func main() {
	// Wire the base path to the handler func
	http.HandleFunc("/", handler)

	// Start a web server
	go func() {
		err := http.ListenAndServe(":8181", nil)
		if err != nil {
			fmt.Println("ListenAndServe: ", err)
		}
	}()

	// send a request
	resp, err := http.Get("http://localhost:8181/")
	if err != nil {
		log.Fatal("Error sending request: ", err)
	}
	// The response body is an `io.Reader` stream that must be
	// closed after reading.
	defer resp.Body.Close()

	// Read and print the response.
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Fatal("Error reading response body: ", err)
	}

	// `body` is a byte slice. string() turns it into a string.
	fmt.Println("The web server says:", string(body))
}