selsl/selsl/value.go

package selsl

import "fmt"

type Members map[string][]Value

type Value interface {
	Name() string
	// Proto/type of the value.
	Type() Type
	String() string
	Members() Members
}

// A type is modeled by it's name as a string
type Type struct {
	name    string
	meta    *Type // type of the type
	members Members
}

func (t Type) String() string {
	return fmt.Sprintf(":type %s;", t.name)
}

func (t Type) Name() string {
	return t.name
}

func (t Type) Members() Members {
	return t.members
}

// Type returns the metatype of a type.
func (t Type) Type() Type {
	// turtles all the way down.
	if t.meta == nil || t.meta.meta == nil {
		return RootType
	}
	return *t.meta
}

func (t Type) Match(v Value) bool {
	t2 := v.Type()
	return t.Name() == t2.Name()
}

func NewType(name string, meta *Type, members Members) Type {
	return Type{name: name, meta: meta, members: members}
}

var RootType Type = NewType("Type", nil, nil)
var ObjectType Type = NewType("Object", &RootType, nil)
var ErrorType Type = NewType("Error", &ObjectType, nil)
var StringType Type = NewType("String", &ObjectType, nil)
var IntType Type = NewType("Int", &ObjectType, nil)
var ListType Type = NewType("List", &ObjectType, nil)
var MethodType Type = NewType("Method", &ObjectType, nil)

type Object struct {
	name    string
	typ     Type
	members Members
}

func (o Object) String() string {
	return fmt.Sprintf("%s: %s", o.typ, o.name)
}

func (o Object) Name() string {
	return o.name
}

func (o Object) Members() Members {
	return o.members
}

func (o Object) Type() Type {
	return o.typ
}

func NewObject(name string, typ Type, members Members) Object {
	return Object{name: name, typ: typ, members: members}
}

type Error struct {
	Object
	Value error
}

func (s Error) String() string {
	return fmt.Sprintf("%s", s.Value)
}

func NewError(name string, members Members, value error) Error {
	return Error{Object: NewObject(name, ErrorType, members),
		Value: value}
}

type String struct {
	Object
	Value string
}

func (s String) String() string {
	return s.Value
}

func NewString(name string, members Members, value string) String {
	return String{Object: NewObject(name, StringType, members),
		Value: value}
}

type Int struct {
	Object
	Value int64
}

func NewInt(name string, members Members, value int64) Int {
	return Int{Object: NewObject(name, IntType, members),
		Value: value}
}

func (i Int) String() string {
	return fmt.Sprintf("%d", i.Value)
}

type List struct {
	Object
	Value []Value
}

func NewList(name string, members Members, value ...Value) List {
	return List{Object: NewObject(name, ListType, members),
		Value: value}
}

func (l List) String() string {
	return fmt.Sprintf("[%v]", l.Value)
}

type Method struct {
	Object
	Signature List
	Value     func(env Value, self Value, args ...Value) List
}

func NewMethod(name string, members Members, signature List,
	value func(env Value, self Value, args ...Value) List) Method {
	return Method{Object: NewObject(name, MethodType, members),
		Signature: signature, Value: value}
}

func (m Method) String() string {
	return fmt.Sprintf("Method: %s", m.Name())
}

var _ Value = RootType
var _ Value = ObjectType
var _ Value = Error{}
var _ Value = String{}
var _ Value = Int{}
var _ Value = List{}
var _ Value = Method{}