Nested dicts as input?

[chasehensel]

I am really enjoying using this. I've been trying to get parsing of nested maps to work, but somehow the inner dicts loose their "mapness" and as a result can't be index.

Think input like:

x = {args : {"a" : {
"b" : "c"
}
}}

as input to the env. x is a starlark.StringDict, and accessing x works fine inside of starlark.

args is a perfectly valid command.
args["a"] also works, but args["a"]["b"] throws a runtime exception of:

Error: unhandled index operation starlight_interface<map[string]interface {}>[string]

Curious if you ever solved this?

In general, I've been playing around with some additional wrappers on top of FromValue and ToValue in order to make them work recursively -- the use case is getting json in and out of starlark. My from value recursion works really well, but I'm struggling with ToValue and figured I'd try and start a conversation

[chasehensel]

I solved it with the following. Wondering why you don't have a recursive form of ToValue and FromValue in starlight already? Would be happy to add in a pull request

func recursiveToValue(input interface{}) (out starlark.Value, err error) {
	if err != nil {
		return nil, err
	}
	switch input.(type) {
	//Do I need other map types?
	case map[string]interface{}:
		dict := starlark.Dict{}
		for k, v := range input.(map[string]interface{}) {
			key, err := convert.ToValue(k)
			if err != nil {
				return nil, err
			}
			val, err := recursiveToValue(v)
			if err != nil {
				return nil, err
			}
			dict.SetKey(key, val)
		}
		return &dict, nil
	case []interface{}:
		l := input.([]interface{})
		out := make([]starlark.Value, 0, len(l))
		for i := 0; i < len(l); i++ {
			val, err := recursiveToValue(out[i])
			if err != nil {
				return nil, err
			}
			out[i] = val
		}
		return starlark.NewList(out), nil
	default:
		return convert.ToValue(input)
	}
}

[johnha]

thanks for the code! There is a bug in the 'out' array initialisation. Corrected:

// ToValue will convert an internal go value to starlark value.  It operates differently from the starlark/starlight convert.ToValue
//	in that it is recursive.
func ToValue(input interface{}) (out starlark.Value, err error) {
	if err != nil {
		return nil, err
	}
	switch input.(type) {
	case map[string]interface{}:
		dict := starlark.Dict{}
		for k, v := range input.(map[string]interface{}) {
			key, err := convert.ToValue(k)
			if err != nil {
				return nil, err
			}
			val, err := ToValue(v)
			if err != nil {
				return nil, err
			}
			dict.SetKey(key, val)
		}
		return &dict, nil
	case []interface{}:
		l := input.([]interface{})
		out := make([]starlark.Value, len(l))
		for i := 0; i < len(l); i++ {
			val, err := ToValue(l[i])
			if err != nil {
				return nil, err
			}
			out[i] = val
		}
		return starlark.NewList(out), nil
	default:
		return convert.ToValue(input)
	}
}

[johnha]

and just to clarify for anyone using this routine: Note that internally go does not have the tuple type. If you are serialising to/from JSON then tuples are represented as json arrays and therefore we cannot differentiate between list and tuple types (json conversion in this respect is lossy). Conversions through this function will assume a list type.