Ejemplo n.º 1
0
func ParsexSignChecker(parser px.Parser) ArgsSignChecker {
	return func(args ...interface{}) error {
		st := px.NewStateInMemory(args)
		_, err := parser(st)
		return err
	}
}
Ejemplo n.º 2
0
// NewStringState 构造一个新的基于字符串的 state
func NewStringState(data string) *px.StateInMemory {
	buf := make([]interface{}, len(data))
	for idx, r := range data {
		buf[idx] = r
	}
	return px.NewStateInMemory(buf)
}
Ejemplo n.º 3
0
Archivo: let.go Proyecto: zy02636/gisp
func LetFunc(env Env, args ...interface{}) (Lisp, error) {
	st := px.NewStateInMemory(args)
	_, err := TypeAs(LIST)(st)
	if err != nil {
		return nil, ParsexSignErrorf("Let Args Error: except args list but error: %v", err)
	}

	local := map[string]Var{}
	vars := args[0].(List)
	for _, v := range vars {
		declares := v.(List)
		varb := declares[0].(Atom)
		slot := VarSlot(varb.Type)
		value, err := Eval(env, (declares[1]))
		if err != nil {
			return nil, err
		}
		slot.Set(value)
		local[varb.Name] = slot
	}
	meta := map[string]interface{}{
		"local": local,
	}
	let := Let{meta, args}
	return let, nil
}
Ejemplo n.º 4
0
// OrExpr 是  or 表达式
func OrExpr(x, y px.Parser) LispExpr {
	return func(env Env, args ...interface{}) (Lisp, error) {
		data, err := Evals(env, args...)
		if err != nil {
			return nil, err
		}
		st := px.NewStateInMemory(data)
		rex, err := x(st)
		if err != nil {
			return nil, err
		}
		if b, ok := rex.(bool); ok {
			if b {
				return Q(true), nil
			}
			st.SeekTo(0)
			rex, err = y(st)
			if err != nil {
				return nil, err
			}
			return Q(rex), nil
		}
		return nil, ParsexSignErrorf("Unknow howto combine %v or %v for %v", x, y, data)
	}
}
Ejemplo n.º 5
0
func TestAddx0(t *testing.T) {
	var data = []interface{}{0, 1, 2, 3, 4, 5, 6}
	st := px.NewStateInMemory(data)
	s, err := addx(st)
	if err != nil {
		t.Fatalf("except error is nil but %v", err)
	}
	if s.(Int) != 21 {
		t.Fatalf("except sum 0~6 is 21 but got %v", s)
	}
}
Ejemplo n.º 6
0
Archivo: args.go Proyecto: gale320/gisp
// GetArgs 方法为将传入的 args 的 gisp 值从指定环境中解析出来,然后传入 parser 。
func GetArgs(env Env, parser px.Parser, args []interface{}) ([]interface{}, error) {
	ret, err := Evals(env, args...)
	if err != nil {
		return nil, err
	}
	st := px.NewStateInMemory(ret)
	_, err = parser(st)
	if err != nil {
		return nil, fmt.Errorf("Args Type Sign Check got error:%v", err)
	}
	return ret, nil
}
Ejemplo n.º 7
0
// LambdaExpr 生成一个封装后的 Lambda 表达式
func LambdaExpr(env Env, args ...interface{}) (Tasker, error) {
	st := px.NewStateInMemory(args)
	_, err := TypeAs(LIST)(st)
	if err != nil {
		return nil, ParsexSignErrorf("Lambda Args Error: except args list but error: %v", err)
	}
	lptr, err := DeclareLambda(env, args[0].(List), args[1:]...)
	if err != nil {
		return nil, fmt.Errorf("Lambda Args Error: except lambda tasker but error: %v", err)
	}
	return Q(lptr).Eval, nil
}
Ejemplo n.º 8
0
// MatchArgsSign 校验参数是否匹配
func (lambda Lambda) MatchArgsSign(env Env, args ...interface{}) (interface{}, error) {
	params := make([]interface{}, len(args))
	for idx, arg := range args {
		param, err := Eval(env, arg)
		if err != nil {
			return nil, err
		}
		params[idx] = param
	}
	pxs := lambda.Meta["parameter parsexs"].([]px.Parser)
	st := px.NewStateInMemory(params)
	return px.UnionAll(pxs...)(st)
}
Ejemplo n.º 9
0
// ExtExpr 带扩展环境
func ExtExpr(extExpr func(env Env) px.Parser) LispExpr {
	return func(env Env, args ...interface{}) (Lisp, error) {
		data, err := Evals(env, args...)
		if err != nil {
			return nil, err
		}
		st := px.NewStateInMemory(data)
		ret, err := extExpr(env)(st)
		if err != nil {
			return nil, err
		}
		return Q(ret), nil
	}
}
Ejemplo n.º 10
0
func (mrm mrMul) Task(env Env, args ...interface{}) (Lisp, error) {
	params, err := Evals(env, args...)
	if err != nil {
		return nil, err
	}
	st := px.NewStateInMemory(params)
	data, err := mrm.argsParser(st)
	if err != nil {
		return nil, err
	}
	return TaskBox{func(env Env) (interface{}, error) {
		vals := data.([]interface{})
		m := vals[0].(money)
		for _, r := range vals[1].([]interface{}) {
			m = m.Mul(r.(Float))
		}
		return m, nil
	}}, nil
}
Ejemplo n.º 11
0
// ParsexReverseExpr 是倒排运算
func ParsexReverseExpr(pxExpr px.Parser) LispExpr {
	return func(env Env, args ...interface{}) (Lisp, error) {
		data, err := Evals(env, args...)
		if err != nil {
			return nil, err
		}
		l := len(data)
		last := l - 1
		datax := make([]interface{}, l)
		for idx, item := range data {
			datax[last-idx] = item
		}
		st := px.NewStateInMemory(data)
		x, err := pxExpr(st)
		if err != nil {
			return nil, err
		}
		return Q(x), nil
	}
}
Ejemplo n.º 12
0
// Axiom 是基本的 LISP 公理实现,尽可能贴近原始的 LISP 公理描述,但是部分实现对实际的 golang
// 环境做了妥协
var Axiom = Toolkit{
	Meta: map[string]interface{}{
		"name":     "axiom",
		"category": "package",
	},
	Content: map[string]interface{}{
		"quote": LispExpr(func(env Env, args ...interface{}) (Lisp, error) {
			if len(args) != 1 {
				return nil, fmt.Errorf("Quote Args Error: except only one arg but %v", args)
			}
			return Q(Q(args[0])), nil
		}),
		"var": LispExpr(func(env Env, args ...interface{}) (Lisp, error) {
			st := px.NewStateInMemory(args)
			_, err := px.Binds_(TypeAs(ATOM), px.Either(px.Try(px.Eof),
				px.Bind_(px.AnyOne, px.Eof)))(st)
			if err != nil {
				return nil, err
			}
			first := args[0].(Atom)
			slot := VarSlot(first.Type)
			if len(args) == 1 {
				err := env.Defvar(first.Name, slot)
				return Q(nil), err
			}
			val, err := Eval(env, args[1])
			slot.Set(val)
			err = env.Defvar(first.Name, slot)
			return Q(val), err
Ejemplo n.º 13
0
		"category": "package",
	},
	Content: map[string]interface{}{
		"state": func(env Env, args ...interface{}) (Lisp, error) {
			if len(args) != 1 {
				return nil, ParsexSignErrorf("Parsex Arg Error:except args has 1 arg.")
			}
			param, err := Eval(env, args[0])
			if err != nil {
				return nil, err
			}
			switch data := param.(type) {
			case string:
				return Q(NewStringState(data)), nil
			case List:
				return Q(px.NewStateInMemory(data)), nil
			default:
				return nil, fmt.Errorf("Parsex Error: Except create a state from a string or List but %v", data)
			}
		},
		"s2str": func(env Env, args ...interface{}) (Lisp, error) {
			if len(args) != 1 {
				return nil, ParsexSignErrorf("Slice to string Arg Error:except args has 1 arg.")
			}
			param, err := Eval(env, args[0])
			if err != nil {
				return nil, err
			}
			var (
				slice []interface{}
				ok    bool