API: Attr type for HasAttrs implementations

[emcfarlane]

Types that implement HasAttrs need a way to map strings to values or methods that implement Callable. The simple way to do this is with a switch:

starlark-go/starlark/bench_test.go

Lines 83 to 96 in 5411bad

	func (benchmark) AttrNames() []string { return []string{"n", "restart", "start", "stop"} }
	func (b benchmark) Attr(name string) (starlark.Value, error) {
	switch name {
	case "n":
	return starlark.MakeInt(b.b.N), nil
	case "restart":
	return benchmarkRestart.BindReceiver(b), nil
	case "start":
	return benchmarkStart.BindReceiver(b), nil
	case "stop":
	return benchmarkStop.BindReceiver(b), nil
	}
	return nil, nil
	}

The main issue with switch cases is the need to ensure all switch cases are covered by AttrNames() and vice versa.

If Attrs just link to methods the implementation can create a map of *Builtins, like how the internal types map to methods:

starlark-go/starlark/library.go

Lines 142 to 144 in 5411bad

	setMethods = map[string]*Builtin{
	"union": NewBuiltin("union", set_union),
	}

This creates a value to a mapping of type:

starlark-go/starlark/value.go

Line 720 in 5411bad

fn func(thread *Thread, fn *Builtin, args Tuple, kwargs []Tuple) (Value, error)

starlark-go/starlark/library.go

Lines 2171 to 2184 in 5411bad

	// https://github.com/google/starlark-go/blob/master/doc/spec.md#set·union.
	func set_union(_ *Thread, b *Builtin, args Tuple, kwargs []Tuple) (Value, error) {
	var iterable Iterable
	if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0, &iterable); err != nil {
	return nil, err
	}
	iter := iterable.Iterate()
	defer iter.Done()
	union, err := b.Receiver().(*Set).Union(iter)
	if err != nil {
	return nil, nameErr(b, err)
	}
	return union, nil
	}

Maybe a new attribute type could be added to better support builtin methods and values? It would also be able to support golang native methods by handling the type casting withing the map functions.

type Attr func(v Value) Value

type Attrs map[string]Attr

// Keys returns a new sorted slice of d's keys.
func (d Attrs) Keys() []string {
	names := make([]string, 0, len(d))
	for name := range d {
		names = append(names, name)
	}
	sort.Strings(names)
	return names
}

func (d Attrs) Attr(name) (Value, error) {
	if a := d[name]; a != nil {
		return a(d), nil
	}
	return nil, nil // no such method
}

// A new type Method would need to be added to support the new function signature.
type Method struct {
    recv Value
    name string
    fn func(*Thread, string, Tuple, []Tuple) (Value, error)
}

The method signature would be changed, dropping the *Builtin arg and replacing it with fnname string like the first arg in the unpack functions. Could avoid the type casting by implementing custom Attr funcs like func(s *Set) Value but then would need to implement custom Attr() and AttrNames() methods.

As an example Set attrs could then be implemented like:

var setAttrs = Attrs{
   "union": func(v Value) Value { return NewMethod(v, "union", v.(*Set).union) },
}

 func (s *Set) union(_ *Thread, fnname string, args Tuple, kwargs []Tuple) (Value, error) { 
 	var iterable Iterable 
 	if err := UnpackPositionalArgs(fnname, args, kwargs, 0, &iterable); err != nil { 
 		return nil, err 
 	} 
 	iter := iterable.Iterate() 
 	defer iter.Done() 
 	union, err := s.Union(iter) 
 	if err != nil { 
 		return nil, nameErr(b, err) 
 	} 
 	return union, nil 
 } 

[adonovan]

The API exposed by the starlark package is definitely oriented around the needs of an efficient interpreter implementation, rather than convenience of the application that embeds the interpreter. However, it should be possible to define convenience helpers (e.g. using reflection) outside the repository, as the https://github.com/starlight-go/starlight project does, for example. I suggest you start by experimenting with a helper function that meets your needs in your application's repository.