func GetMap(builder interface{}) map[string]interface{} {
	m := getBuilderMap(builder)
	structType := getBuilderStructType(reflect.TypeOf(builder))
	ret := make(map[string]interface{}, m.Size())
	m.ForEach(func(name string, val ps.Any) {
		list, isList := val.(ps.List)
		if isList {
			arrayType := anyArrayType
			if structType != nil {
				field, ok := (*structType).FieldByName(name)
				if ok {
					arrayType = field.Type
				}
			}
			val = listToSlice(list, arrayType).Interface()
		}
		ret[name] = val
	})
	return ret
}
GetMap returns a map[string]interface{} of the values set in the given
builder.

See notes on Get regarding returned slices.
package builder
import (
	"github.com/lann/ps"
	"go/ast"
	"reflect"
)
type Builder struct {
	builderMap ps.Map
}
var (
	EmptyBuilder      = Builder{ps.NewMap()}
	emptyBuilderValue = reflect.ValueOf(EmptyBuilder)
)
func getBuilderMap(builder interface{}) ps.Map {
	b := convert(builder, Builder{}).(Builder)
	if b.builderMap == nil {
		return ps.NewMap()
	}
	return b.builderMap
}
func Set(builder interface{}, name string, v interface{}) interface{} {
	b := Builder{getBuilderMap(builder).Set(name, v)}
	return convert(b, builder)
}
func Delete(builder interface{}, name string) interface{} {
	b := Builder{getBuilderMap(builder).Delete(name)}
	return convert(b, builder)
}
func Append(builder interface{}, name string, vs ...interface{}) interface{} {
	return Extend(builder, name, vs)
}
func Extend(builder interface{}, name string, vs interface{}) interface{} {
	if vs == nil {
		return builder
	}
	maybeList, ok := getBuilderMap(builder).Lookup(name)
	var list ps.List
	if ok {
		list, ok = maybeList.(ps.List)
	}
	if !ok {
		list = ps.NewList()
	}
	forEach(vs, func(v interface{}) {
		list = list.Cons(v)
	})
	return Set(builder, name, list)
}
func listToSlice(list ps.List, arrayType reflect.Type) reflect.Value {
	size := list.Size()
	slice := reflect.MakeSlice(arrayType, size, size)
	for i := size - 1; i >= 0; i-- {
		val := reflect.ValueOf(list.Head())
		slice.Index(i).Set(val)
		list = list.Tail()
	}
	return slice
}
var anyArrayType = reflect.TypeOf([]interface{}{})
func Get(builder interface{}, name string) (interface{}, bool) {
	val, ok := getBuilderMap(builder).Lookup(name)
	if !ok {
		return nil, false
	}
	list, isList := val.(ps.List)
	if isList {
		arrayType := anyArrayType
		if ast.IsExported(name) {
			structType := getBuilderStructType(reflect.TypeOf(builder))
			if structType != nil {
				field, ok := (*structType).FieldByName(name)
				if ok {
					arrayType = field.Type
				}
			}
		}
		val = listToSlice(list, arrayType).Interface()
	}
	return val, true
}