Type check

value.go

@@ -0,0 +1,48 @@
+package main
+
+import "fmt"
+
+var (
+	zero IntValue  = 0
+	True BoolValue = true
+	Frue BoolValue = false
+)
+
+type Value interface {
+	Expression
+	HasValue()
+}
+
+type IntValue int
+
+func (i *IntValue) HasValue()                               {}
+func (i *IntValue) Step() (Expression, error)               { return i, nil }
+func (i *IntValue) Substitute(Id, Expression)               {}
+func (i *IntValue) TypeCheck(TypeEnvironment) (Type, error) { return &PrimInteger, nil }
+func (i *IntValue) String() string                          { return fmt.Sprint(*i) }
+
+type FloatValue float32
+
+func (f *FloatValue) HasValue()                               {}
+func (f *FloatValue) Step() (Expression, error)               { return f, nil }
+func (f *FloatValue) Substitute(Id, Expression)               {}
+func (f *FloatValue) TypeCheck(TypeEnvironment) (Type, error) { return &PrimFloat, nil }
+func (f *FloatValue) String() string                          { return fmt.Sprint(*f) }
+
+type BoolValue bool
+
+func (b *BoolValue) HasValue()                               {}
+func (b *BoolValue) Step() (Expression, error)               { return b, nil }
+func (b *BoolValue) Substitute(Id, Expression)               {}
+func (b *BoolValue) TypeCheck(TypeEnvironment) (Type, error) { return &PrimBoolean, nil }
+func (b BoolValue) String() string                           { return fmt.Sprint(bool(b)) }
+
+type Quoted struct{ expr Expression }
+
+func (q *Quoted) HasValue()                 {}
+func (q *Quoted) Step() (Expression, error) { return q, nil }
+func (q *Quoted) Substitute(Id, Expression) {}
+func (q Quoted) String() string             { return fmt.Sprintf("'%v", q.expr) }
+func (q *Quoted) TypeCheck(env TypeEnvironment) (Type, error) {
+	return &QuotedType{&PrimVoid}, nil
+}