func (mmap MarshalMap) Float(key string) (float64, error) {
	val, exists := mmap.Value(key)
	if !exists {
		return 0, fmt.Errorf(`"%s" is not set`, key)
	}
	if floatVal, isNumber := treflect.Float64(val); isNumber {
		return floatVal, nil
	}
	return 0, fmt.Errorf(`"%s" is expected to be a signed number type`, key)
}
Float returns a value at key that is expected to be a float64 or compatible
float value.
package tcontainer
import (
	"fmt"
	"reflect"
	"strconv"
	"strings"
	"time"
	"github.com/trivago/tgo/treflect"
)
type MarshalMap map[string]interface{}
const (
	MarshalMapSeparator = '/'
	MarshalMapArrayBegin = '['
	MarshalMapArrayEnd = ']'
)
func NewMarshalMap() MarshalMap {
	return make(map[string]interface{})
}
func TryConvertToMarshalMap(value interface{}, formatKey func(string) string) interface{} {
	valueMeta := reflect.ValueOf(value)
	switch valueMeta.Kind() {
	default:
		return value
	case reflect.Array, reflect.Slice:
		arrayLen := valueMeta.Len()
		converted := make([]interface{}, arrayLen)
		for i := 0; i < arrayLen; i++ {
			converted[i] = TryConvertToMarshalMap(valueMeta.Index(i).Interface(), formatKey)
		}
		return converted
	case reflect.Map:
		converted := NewMarshalMap()
		keys := valueMeta.MapKeys()
		for _, keyMeta := range keys {
			strKey, isString := keyMeta.Interface().(string)
			if !isString {
				continue
			}
			if formatKey != nil {
				strKey = formatKey(strKey)
			}
			val := valueMeta.MapIndex(keyMeta).Interface()
			converted[strKey] = TryConvertToMarshalMap(val, formatKey)
		}
		return converted  
	}
}
func ConvertToMarshalMap(value interface{}, formatKey func(string) string) (MarshalMap, error) {
	converted := TryConvertToMarshalMap(value, formatKey)
	if result, isMap := converted.(MarshalMap); isMap {
		return result, nil
	}
	return nil, fmt.Errorf("Root value cannot be converted to MarshalMap")
}
func (mmap MarshalMap) Clone() MarshalMap {
	clone := cloneMap(reflect.ValueOf(mmap))
	return clone.Interface().(MarshalMap)
}
func cloneMap(mapValue reflect.Value) reflect.Value {
	clone := reflect.MakeMap(mapValue.Type())
	keys := mapValue.MapKeys()
	for _, k := range keys {
		v := mapValue.MapIndex(k)
		switch k.Kind() {
		default:
			clone.SetMapIndex(k, v)
		case reflect.Array, reflect.Slice:
			if v.Type().Elem().Kind() == reflect.Map {
				sliceCopy := reflect.MakeSlice(v.Type(), v.Len(), v.Len())
				for i := 0; i < v.Len(); i++ {
					element := v.Index(i)
					sliceCopy.Index(i).Set(cloneMap(element))
				}
			} else {
				sliceCopy := reflect.MakeSlice(v.Type(), 0, v.Len())
				reflect.Copy(sliceCopy, v)
				clone.SetMapIndex(k, sliceCopy)
			}
		case reflect.Map:
			vClone := cloneMap(v)
			clone.SetMapIndex(k, vClone)
		}
	}
	return clone
}
func (mmap MarshalMap) Bool(key string) (bool, error) {
	val, exists := mmap.Value(key)
	if !exists {
		return false, fmt.Errorf(`"%s" is not set`, key)
	}
	boolValue, isBool := val.(bool)
	if !isBool {
		return false, fmt.Errorf(`"%s" is expected to be a boolean`, key)
	}
	return boolValue, nil
}
func (mmap MarshalMap) Uint(key string) (uint64, error) {
	val, exists := mmap.Value(key)
	if !exists {
		return 0, fmt.Errorf(`"%s" is not set`, key)
	}
	if intVal, isNumber := treflect.Uint64(val); isNumber {
		return intVal, nil
	}
	return 0, fmt.Errorf(`"%s" is expected to be an unsigned number type`, key)
}
func (mmap MarshalMap) Int(key string) (int64, error) {
	val, exists := mmap.Value(key)
	if !exists {
		return 0, fmt.Errorf(`"%s" is not set`, key)
	}
	if intVal, isNumber := treflect.Int64(val); isNumber {
		return intVal, nil
	}
	return 0, fmt.Errorf(`"%s" is expected to be a signed number type`, key)
}