gisp

var Axiom = Environment{
	Meta: map[string]interface{}{
		"name":     "axiom",
		"category": "environment",
	},
	Content: map[string]function{
		"quote": func(env Env) element {
			return func(args ...interface{}) (interface{}, error) {
				return Quote{args[0]}, nil
			}
		},
		"var": func(env Env) element {
			return func(args ...interface{}) (interface{}, error) {
				value, err := eval(env, args[1])
				if err != nil {
					return nil, err
				}
				err = env.Define((args[0].(Atom)).Name, value)
				return nil, err
			}
		},
		"set": func(env Env) element {
			return func(args ...interface{}) (interface{}, error) {
				value, err := eval(env, args[1])
				if err != nil {
					return nil, err
				}
				err = env.SetVar((args[0].(Atom)).Name, value)
				if err == nil {
					return nil, err
				} else {
					return value, nil
				}
			}
		},
		"equal": func(env Env) element {
			return func(args ...interface{}) (interface{}, error) {
				x, err := eval(env, args[0])
				if err != nil {
					return nil, err
				}
				y, err := eval(env, args[1])
				if err != nil {
					return nil, err
				}
				return reflect.DeepEqual(x, y), nil
			}
		},
		"cond": func(env Env) element {
			return func(args ...interface{}) (interface{}, error) {
				cases := args[0].([]interface{})
				l := len(args)
				var els interface{}
				if l > 1 {
					els = args[1]
				} else {
					els = nil
				}

				for _, b := range cases {
					branch := b.([]interface{})
					cond := branch[0].(List)
					result, err := eval(env, cond)
					if err != nil {
						return nil, err
					}
					if ok := result.(bool); ok {
						return eval(env, branch[1])
					}
				}

				if els != nil {
					return eval(env, els)
				} else {
					return nil, nil
				}
			}
		},
		"car": func(env Env) element {
			return func(args ...interface{}) (interface{}, error) {

				lisp, err := eval(env, args[0])
				if err != nil {
					return nil, err
				}
				return (lisp.(List))[0], nil
			}
		},
		"cdr": func(env Env) element {
			return func(args ...interface{}) (interface{}, error) {

				lisp, err := eval(env, args[0])
				if err != nil {
					return nil, err
				}
				return (lisp.(List))[1:], nil
			}
		},

		"atom": func(env Env) element {
			return func(args ...interface{}) (interface{}, error) {
				arg := args[0]
				if l, ok := arg.(List); ok {
					return len(l) == 0, nil
				} else {
					return true, nil
				}
			}
		},

		"concat": func(env Env) element {
			return func(args ...interface{}) (interface{}, error) {
				return List(args), nil
			}
		},
	},
}

var BoolParser = Bind(Choice(String("true"), String("false")), func(input interface{}) Parser {
	return func(st ParseState) (interface{}, error) {
		switch input.(string) {
		case "true":
			return true, nil
		case "false":
			return false, nil
		default:
			return nil, fmt.Errorf("Unexpect bool token %v", input)
		}
	}
})

var EscapeChar = Bind_(Rune('\\'), func(st ParseState) (interface{}, error) {
	r, err := OneOf("nrt\"\\")(st)
	if err == nil {
		ru := r.(rune)
		switch ru {
		case 'r':
			return '\r', nil
		case 'n':
			return '\n', nil

		case '\'':
			return '\'', nil
		case '"':
			return '"', nil
		case '\\':
			return '\\', nil
		case 't':
			return '\t', nil
		default:
			return nil, st.Trap("Unknown escape sequence \\%c", r)
		}
	} else {
		return nil, err
	}
})

var NilParser = Bind_(String("nil"), Return(nil))

var RuneParser = Bind(
	Between(Rune('\''), Rune('\''),
		Either(Try(EscapeChar), NoneOf("'"))),
	ReturnString)

var StringParser = Bind(
	Between(Rune('"'), Rune('"'),
		Many(Either(Try(EscapeChar), NoneOf("\"")))),
	ReturnString)