// The built-in error interface is a regular interface for handling errors. 
// where nil means no errors. 
type error interface { 
    Error() string 
}

func main() {
    conent, err := openFile()
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(string(conent))
    }
}

package main
import (
    "fmt"
    "strconv"
)
func main() {
	var input string
	fmt.Print("Type some number: ")
	fmt.Scanln(&input)
	number, err := strconv.Atoi(input)
	if err == nil {
		fmt.Println(number, "is number")
	} else {
		fmt.Println(input, "is not number")
		fmt.Println(err.Error())
	}
}

func validate(input string) (bool, error) {
	if strings.TrimSpace(input) == "" {
		return false, fmt.Errorf("%s can't be empty", input)
		//return false, errors.New("cannot be empty")
	}
	return true, nil
}
func main() {
	var name string
	fmt.Print("Type your name: \n")
	fmt.Scanln(&name)
	if valid, err := validate(name); valid {
		fmt.Println("hello", name)
	} else {
		fmt.Println(err.Error())
	}
}

import "github.com/pkg/errors"
internal := errors.New("internal error")
// 給error增加其他上下文信息
wrapped := errors.Wrap(internal, "wrapper")
// 獲得原始錯誤信息
unwrapped := errors.Cause(wrapped)

import "errors"
internal := errors.New("internal error")
// add additional context to an error
wrapped := fmt.Errorf("wrapper: %w", internal)
// get original error
unwrapped := errors.Unwrap(wrapped)

import (
	"fmt"
	"github.com/pkg/errors"
	"strings"
)
func validate(input string) (bool, error) {
	if strings.TrimSpace(input) == "" {
		err := errors.New("can't be empty")
		return false, errors.Wrap(err, "input error")
	}
	return true, nil
}
func main() {
	var name string
	fmt.Print("Type your name: \n")
	fmt.Scanln(&name)
	if valid, err := validate(name); valid {
		fmt.Println("hello", name)
	} else {
		fmt.Println(errors.Unwrap(err))
	}
}

func panic( interface{} )

package main
import  "fmt"
func main() {
    fmt.Println("start Go program")
    panic(" built in panic keyword gives error msg")  // panic keyword
    fmt.Println("End Go program")
    }

package main
import (
 "fmt"
)
func main() {
    a,b := 1,0   // variable a & b are declared and initialized
    result := a/b        // division operation
    fmt.Println(result)
}

package main
import "fmt"
func main() {
    names := []string{  //slice data type
        "Learn eTutorials",     // index 0
        "Golang",  //index 1
        "panic tutorial", //index 2
    }
    //fmt.Println(names[0]) commented
    //fmt.Println(names[2]) commented
    fmt.Println(names[4]) //panic: runtime error: index out of range [4] with length 3
}

func Name(firstName *string, lastName *string) {
	defer fmt.Println("Name function deferred call")
	if firstName == nil {
		panic("runtime error: first name cannot be nil")
	}
	if lastName == nil {
		panic("runtime error: last name cannot be nil")
	}
	fmt.Printf("%s %s\n", *firstName, *lastName)
	fmt.Println("return from Name")
}
func main() {
	defer fmt.Println("main() deffered call")
	firstName := "Elon"
	Name(&firstName, nil)
	fmt.Println("return from main")
}

func main() {
	fmt.Println("lets learn about recover() in golang")
	Panicfunc()
	fmt.Println("learned all about recover() ")
}
func Panicfunc() {
	defer Panicrecover()
	fmt.Println("instruction just before panicking situation")
	panic("Panicfunc  resume  execution")
	fmt.Println("instruction after panic does not execute")
}
func Panicrecover() {
	if err := recover(); err != nil {
		fmt.Printf("Recovered from panic: %v \n", err)
	}
}