// Decleration
var m map[string]int // A declared map is `nil` until initialized. 
/*
- `string` → key type  
- `int` → value type  
*/


// Initialization
m := make(map[string]int)  // using make

m := map[string]int{  // using map literal 
	"apple": 10,  
	"banana": 20,  
}  


// Adding & Updating values
m["apple"] = 30  
m["orange"] = 15    
// If the key exists → value is updated.  
// If the key does not exist → a new entry is created.  


// Accessing values
value := m["apple"]
value, exists := m["apple"] // if value doesn't exist value=zero value & exists=false


// Deleting from map
delete(m, "apple")


// Iterate over map
for key, value := range m {  
	fmt.Println(key, value)  
}  


// Length of map - count of key value pairs exising
len(m)

// Decleration
var p *int
// `p` → pointer variable  
// `*int` → pointer to an integer


x := 10  
p := &x  
// `x` → value  
// `&x` → memory address of `x`  
// `p` now stores the address of `x`  


// Dereferencing a pointer
x := 10  
p := &x  
fmt.Println(*p) // 10


// Modifying value using pointer
x := 10  
p := &x
*p = 20 // x = 20 now 


// Passing pointer to a function (pass by value, the catch is value is a pointer to a variable.)
func update(n *int) {  
	*n = 50  
}  
x := 10  
update(&x) // x updated to 50


// Creating a pointer using new
p := new(int) // Default value is 0 for int


// Pointer to a struct (go automatically dereferences struct pointer)
type Person struct {  
	name string  
	age int  
}
p := &Person{name: "John", age: 25}  
// Access using p.name & p.age, no need for (*p).name

func (receiver Type) MethodName(parameters) returnType {  
// method body  
}


type Rectangle struct {  
	width int  
	height int  
}
func (r Rectangle) Area() int {  
	return r.width * r.height  
}
rect := Rectangle{width: 10, height: 5}  
area := rect.Area()

func (r Rectangle) Area() int {  // Value reciever, The method receives a **copy of the value**.
	return r.width * r.height  
}

func (r *Rectangle) Scale(factor int) {  // Pointer reciever, recieves a pointer to the type
	r.width = r.width * factor  
	r.height = r.height * factor  
}

// Declaring a interface
type Shape interface {  
	Area() float64  
}
type Shape2 interface {  
	Area() float64  
	Perimeter() float64  
}
// Any type that defines `Area() float64` satisfies `Shape`.

// Implementing a interface
type Rectangle struct {  
	width float64  
	height float64  
}
func (r Rectangle) Area() float64 {  
	return r.width * r.height  
}

// Using an Interface
func PrintArea(s Shape) {  
	fmt.Println(s.Area())  
}  
  
rect := Rectangle{10, 5}  
PrintArea(rect)

var v interface{}  
v = 10  
v = "hello"

// Type assertions
var v interface{}  
v = 10
v := i.(int)
v, ok := i.(int)

// Type Switches, Switch for type assertions
switch v := i.(type) {  
	case int:  
		fmt.Println("int", v)  
	case string:  
		fmt.Println("string", v)  
	default:  
		fmt.Println("unknown type")  
}

type error interface {
	Error() string
}

// usage
func DoSomething() (int, error) { 
	// ... 
}

// create a new error object
var ErrNotFound = errors.New("resource was not found")
// nil for no error

// Create custom error
type MyCustomError struct {
  message string
  details string
}
func (e *MyCustomError) Error() string {
  return fmt.Sprintf("%s, details: %s", e.message, e.details)
}
func someFunction() error {
  // ...
  return &MyCustomError{
    message: "...",
    details: "...",
  }
}

rand.Int() // Any Int number
rand.Intn(10) // Any Int number between 0 and 10(exclusive)
rand.Float64() // any float64 number
  
rand.Perm(5) // slice of n elements with range [0, n)
  
nums := []int{1,2,3,4,5}  // Shuffle the existing list
rand.Shuffle(len(nums), func(i, j int) {  
  nums[i], nums[j] = nums[j], nums[i]  
})  
nums

import "regexp"

matched, _ := regexp.MatchString("go", "golang")
fmt.Println(matched) // true

re := regexp.MustCompile("[a-z]+")
fmt.Println(re.MatchString("hello123")) // true
fmt.Println(re.FindString("abc123xyz")) // abc
fmt.Println(re.FindAllString("abc123xyz456", -1)) // [abc xyz]
fmt.Println(re.ReplaceAllString("abc123xyz", "#")) // #123#
fmt.Println(re.Split("a,b,c", -1)) // [ , , ]

re = regexp.MustCompile(`[a-z]+\d*`)
b = re.MatchString("[a12]")       // => true
b = re.MatchString("12abc34(ef)") // => true
b = re.MatchString(" abc!")       // => true
b = re.MatchString("123 456")     // => false

type Stringer interface {
    String() string
}