第七章-示例说明(重要)

package seven 

import (
	"fmt"
	"math"
	"testing"
	"strings"
)

type Expr interface {
	// 根据给定的环境变量返回表达式的值
	Eval(env Env) float64
	Check(vars map[Var]bool) error
}
type Var string
type literal float64

type unary struct {
	op   rune
	x, y Expr
}
type binary struct {
	op   rune
	x, y Expr
}
type call struct {
	fn   string
	args []Expr
}

type Env map[Var]float64

func (v Var) Eval(env Env) float64 {
	return env[v]
}

func (l literal) Eval(_ Env) float64 {
	return float64(l)
}

func (u unary) Eval(env Env) float64 {
	switch u.op {
	case '+':
		return +u.x.Eval(env)
	case '-':
		return -u.x.Eval(env)
	}
	panic(fmt.Sprintf("unsupported unary operator: %q", u.op))
}

func (b binary) Eval(env Env) float64 {
	switch b.op {
	case '+':
		return b.y.Eval(env) + b.x.Eval(env)
	case '-':
		return b.y.Eval(env) - b.x.Eval(env)
	case '*':
		return b.y.Eval(env) * b.x.Eval(env)
	case '/':
		return b.y.Eval(env) / b.x.Eval(env)
	}
	panic(fmt.Sprintf("unsupported unary operator: %q", b.op))
}

func (c call) Eval(env Env) float64 {
	switch c.fn {
	case "pow":
		return math.Pow(c.args[0].Eval(env), c.args[1].Eval(env))
	case "sin":
		return math.Sin(c.args[0].Eval(env))
	case "sqrt":
		return math.Sqrt(c.args[0].Eval(env))
	}
	panic(fmt.Sprintf("unsupported unary operator: %s", c.fn))
}

func (v Var) Check(vars map[Var]bool) error {
	vars[v] = true
	return nil
}

func (literal) Check(vars map[Var]bool) error {
	return nil
}
func (u unary) Check(vars map[Var]bool) error {
	if !strings.ContainsRune("+-", u.op) {
		return fmt.Errorf("unexpect unary op %q", u.op)
	}
	return u.x.Check(vars)
}

func (b binary) Check(vars map[Var]bool) error {
	if !strings.ContainsRune("+-*/", b.op) {
		return fmt.Errorf("unexpect binary op %q", b.op)
	}
	if err := b.x.Check(vars); err != nil {
		return err
	}
	return b.y.Check(vars)
}

var numParams = map[string]int{"pow": 2, "sin": 1, "sqrt": 1}

func (c call) Check(vars map[Var]bool) error {
	arity, ok := numParams[c.fn]
	if !ok {
		return fmt.Errorf("unknow function %q", c.fn)
	}
	if len(c.args) != arity {
		return fmt.Errorf("call to %s has %d args, want %d", c.fn, len(c.args), arity)
	}

	for _, arg := range c.args {
		if err := arg.Check(vars); err != nil {
			return err
		}
	}
	return nil
}

//测试函数
func TestEval(t *testing.T) {
	tests := []struct {
		expr string
		env  Env
		want string
	}{
		{"sqrt(A/pi)", Env{"A": 87616, "pi": math.Pi}, "167"},
		{"pow(x,3)+pow(y,3)", Env{"x": 12, "y": 1}, "1729"},
		{"pow(x,3)+pow(y,3)", Env{"x": 9, "y": 10}, "1729"},
		{"5/9*(F-32)", Env{"F": -40}, "-40"},
		{"5/9*(F-32)", Env{"F": -40}, "0"},
		{"5/9*(F-32)", Env{"F": -40}, "100"},
	}
	var prevExpr string
	for _, test := range tests {
		if test.expr != prevExpr {
			fmt.Print("\n%s\n", test.expr)
			prevExpr = test.expr
		}
		expr, err := Parse(test.expr)
		if err != nil {
			t.Error(err)
			continue
		}
		got := fmt.Sprintf("%.6g", expr.Eval(test.env))
		fmt.Printf("\t%v => %s\n", test.env, got)
		if got != test.want {
			t.Errorf("%s.Eval() in %v =%q ,want %q\n", test.expr, test.env, got, test.want)

		}
	}
}

var  w io.Writer
w = os.Stdout
f :=w.(*os.File) //success 检查成功
c :=w.(*bytes.Buffer) //panic 异常  
cs,ok :=w.(*bytes.Buffer) //正常执行，OK返回false

//常用态
if f,ok :=w.(*os.File); ok{
  //具体事项
}

package os
func IsExits(err error) bool
func IsNotExits(err error) bool
func IsPermission(err error) bool
~~~ 
os包中定义了一个PathError 类型来描述在文件路径操作中涉及到的失败并且定义了一个LinkError的变量来描述设计到两个文件路径的操作，像Symlink和Rename.
PathError的实体内容:

大多数调用方都不知道PathError并且通过调用错误本身的Error方法来统一处理所有的错误。尽管PathError的Error方法简单地把这些字段连起来生成错误信息，一般的调用：

* * * *
####基于类型断言询问行为

* * * *
####类型开关
引言：*switch 语句可以简化ifelse  type switch (类型开关) 可以简化类型断言的 if-else链*
**使用关键字面量type来简化类型判断**