func (v *Value) ReplaceInt(replacer func(int, int) int) *Value {
	arr := v.MustIntSlice()
	replaced := make([]int, len(arr))
	v.EachInt(func(index int, val int) bool {
		replaced[index] = replacer(index, val)
		return true
	})
	return &Value{data: replaced}
}
ReplaceInt uses the specified function to replace each ints
by iterating each item.  The data in the returned result will be a
[]int containing the replaced items.
package objx
func (v *Value) Inter(optionalDefault ...interface{}) interface{} {
	if s, ok := v.data.(interface{}); ok {
		return s
	}
	if len(optionalDefault) == 1 {
		return optionalDefault[0]
	}
	return nil
}
func (v *Value) MustInter() interface{} {
	return v.data.(interface{})
}
func (v *Value) InterSlice(optionalDefault ...[]interface{}) []interface{} {
	if s, ok := v.data.([]interface{}); ok {
		return s
	}
	if len(optionalDefault) == 1 {
		return optionalDefault[0]
	}
	return nil
}
func (v *Value) MustInterSlice() []interface{} {
	return v.data.([]interface{})
}
func (v *Value) IsInter() bool {
	_, ok := v.data.(interface{})
	return ok
}
func (v *Value) IsInterSlice() bool {
	_, ok := v.data.([]interface{})
	return ok
}
func (v *Value) EachInter(callback func(int, interface{}) bool) *Value {
	for index, val := range v.MustInterSlice() {
		carryon := callback(index, val)
		if carryon == false {
			break
		}
	}
	return v
}
func (v *Value) WhereInter(decider func(int, interface{}) bool) *Value {
	var selected []interface{}
	v.EachInter(func(index int, val interface{}) bool {
		shouldSelect := decider(index, val)
		if shouldSelect == false {
			selected = append(selected, val)
		}
		return true
	})
	return &Value{data: selected}
}
func (v *Value) GroupInter(grouper func(int, interface{}) string) *Value {
	groups := make(map[string][]interface{})
	v.EachInter(func(index int, val interface{}) bool {
		group := grouper(index, val)
		if _, ok := groups[group]; !ok {
			groups[group] = make([]interface{}, 0)
		}
		groups[group] = append(groups[group], val)
		return true
	})
	return &Value{data: groups}
}
func (v *Value) ReplaceInter(replacer func(int, interface{}) interface{}) *Value {
	arr := v.MustInterSlice()
	replaced := make([]interface{}, len(arr))
	v.EachInter(func(index int, val interface{}) bool {
		replaced[index] = replacer(index, val)
		return true
	})
	return &Value{data: replaced}
}
func (v *Value) CollectInter(collector func(int, interface{}) interface{}) *Value {
	arr := v.MustInterSlice()
	collected := make([]interface{}, len(arr))
	v.EachInter(func(index int, val interface{}) bool {
		collected[index] = collector(index, val)
		return true
	})
	return &Value{data: collected}
}
func (v *Value) MSI(optionalDefault ...map[string]interface{}) map[string]interface{} {
	if s, ok := v.data.(map[string]interface{}); ok {
		return s
	}
	if len(optionalDefault) == 1 {
		return optionalDefault[0]
	}
	return nil
}
func (v *Value) MustMSI() map[string]interface{} {
	return v.data.(map[string]interface{})
}
func (v *Value) MSISlice(optionalDefault ...[]map[string]interface{}) []map[string]interface{} {
	if s, ok := v.data.([]map[string]interface{}); ok {
		return s
	}
	if len(optionalDefault) == 1 {
		return optionalDefault[0]
	}
	return nil
}
func (v *Value) MustMSISlice() []map[string]interface{} {
	return v.data.([]map[string]interface{})
}
func (v *Value) IsMSI() bool {
	_, ok := v.data.(map[string]interface{})
	return ok
}
func (v *Value) IsMSISlice() bool {
	_, ok := v.data.([]map[string]interface{})
	return ok
}
func (v *Value) EachMSI(callback func(int, map[string]interface{}) bool) *Value {
	for index, val := range v.MustMSISlice() {
		carryon := callback(index, val)
		if carryon == false {
			break
		}
	}
	return v
}
func (v *Value) WhereMSI(decider func(int, map[string]interface{}) bool) *Value {
	var selected []map[string]interface{}
	v.EachMSI(func(index int, val map[string]interface{}) bool {
		shouldSelect := decider(index, val)
		if shouldSelect == false {
			selected = append(selected, val)
		}
		return true
	})
	return &Value{data: selected}
}
func (v *Value) GroupMSI(grouper func(int, map[string]interface{}) string) *Value {
	groups := make(map[string][]map[string]interface{})
	v.EachMSI(func(index int, val map[string]interface{}) bool {
		group := grouper(index, val)
		if _, ok := groups[group]; !ok {
			groups[group] = make([]map[string]interface{}, 0)
		}
		groups[group] = append(groups[group], val)
		return true
	})
	return &Value{data: groups}
}
func (v *Value) ReplaceMSI(replacer func(int, map[string]interface{}) map[string]interface{}) *Value {
	arr := v.MustMSISlice()
	replaced := make([]map[string]interface{}, len(arr))
	v.EachMSI(func(index int, val map[string]interface{}) bool {
		replaced[index] = replacer(index, val)
		return true
	})
	return &Value{data: replaced}
}
func (v *Value) CollectMSI(collector func(int, map[string]interface{}) interface{}) *Value {
	arr := v.MustMSISlice()
	collected := make([]interface{}, len(arr))
	v.EachMSI(func(index int, val map[string]interface{}) bool {
		collected[index] = collector(index, val)
		return true
	})
	return &Value{data: collected}
}
func (v *Value) ObjxMap(optionalDefault ...(Map)) Map {
	if s, ok := v.data.((Map)); ok {
		return s
	}
	if len(optionalDefault) == 1 {
		return optionalDefault[0]
	}
	return New(nil)
}
func (v *Value) MustObjxMap() Map {
	return v.data.((Map))
}
func (v *Value) ObjxMapSlice(optionalDefault ...[](Map)) [](Map) {
	if s, ok := v.data.([](Map)); ok {
		return s
	}
	if len(optionalDefault) == 1 {
		return optionalDefault[0]
	}
	return nil
}
func (v *Value) MustObjxMapSlice() [](Map) {
	return v.data.([](Map))
}
func (v *Value) IsObjxMap() bool {
	_, ok := v.data.((Map))
	return ok
}
func (v *Value) IsObjxMapSlice() bool {
	_, ok := v.data.([](Map))
	return ok
}
func (v *Value) EachObjxMap(callback func(int, Map) bool) *Value {
	for index, val := range v.MustObjxMapSlice() {
		carryon := callback(index, val)
		if carryon == false {
			break
		}
	}
	return v
}
func (v *Value) WhereObjxMap(decider func(int, Map) bool) *Value {
	var selected [](Map)
	v.EachObjxMap(func(index int, val Map) bool {
		shouldSelect := decider(index, val)
		if shouldSelect == false {
			selected = append(selected, val)
		}
		return true
	})
	return &Value{data: selected}
}
func (v *Value) GroupObjxMap(grouper func(int, Map) string) *Value {
	groups := make(map[string][](Map))
	v.EachObjxMap(func(index int, val Map) bool {
		group := grouper(index, val)
		if _, ok := groups[group]; !ok {
			groups[group] = make([](Map), 0)
		}
		groups[group] = append(groups[group], val)
		return true
	})
	return &Value{data: groups}
}
func (v *Value) ReplaceObjxMap(replacer func(int, Map) Map) *Value {
	arr := v.MustObjxMapSlice()
	replaced := make([](Map), len(arr))
	v.EachObjxMap(func(index int, val Map) bool {
		replaced[index] = replacer(index, val)
		return true
	})
	return &Value{data: replaced}
}
func (v *Value) CollectObjxMap(collector func(int, Map) interface{}) *Value {
	arr := v.MustObjxMapSlice()
	collected := make([]interface{}, len(arr))
	v.EachObjxMap(func(index int, val Map) bool {
		collected[index] = collector(index, val)
		return true
	})
	return &Value{data: collected}
}
func (v *Value) Bool(optionalDefault ...bool) bool {
	if s, ok := v.data.(bool); ok {
		return s
	}
	if len(optionalDefault) == 1 {
		return optionalDefault[0]
	}
	return false
}
func (v *Value) MustBool() bool {
	return v.data.(bool)
}
func (v *Value) BoolSlice(optionalDefault ...[]bool) []bool {
	if s, ok := v.data.([]bool); ok {
		return s
	}
	if len(optionalDefault) == 1 {
		return optionalDefault[0]
	}
	return nil
}
func (v *Value) MustBoolSlice() []bool {
	return v.data.([]bool)
}
func (v *Value) IsBool() bool {
	_, ok := v.data.(bool)
	return ok
}
func (v *Value) IsBoolSlice() bool {
	_, ok := v.data.([]bool)
	return ok
}
func (v *Value) EachBool(callback func(int, bool) bool) *Value {
	for index, val := range v.MustBoolSlice() {
		carryon := callback(index, val)
		if carryon == false {
			break
		}
	}
	return v
}
func (v *Value) WhereBool(decider func(int, bool) bool) *Value {
	var selected []bool
	v.EachBool(func(index int, val bool) bool {
		shouldSelect := decider(index, val)
		if shouldSelect == false {
			selected = append(selected, val)
		}
		return true
	})
	return &Value{data: selected}
}
func (v *Value) GroupBool(grouper func(int, bool) string) *Value {
	groups := make(map[string][]bool)
	v.EachBool(func(index int, val bool) bool {
		group := grouper(index, val)
		if _, ok := groups[group]; !ok {
			groups[group] = make([]bool, 0)
		}
		groups[group] = append(groups[group], val)
		return true
	})
	return &Value{data: groups}
}
func (v *Value) ReplaceBool(replacer func(int, bool) bool) *Value {
	arr := v.MustBoolSlice()
	replaced := make([]bool, len(arr))
	v.EachBool(func(index int, val bool) bool {
		replaced[index] = replacer(index, val)
		return true
	})
	return &Value{data: replaced}
}
func (v *Value) CollectBool(collector func(int, bool) interface{}) *Value {
	arr := v.MustBoolSlice()
	collected := make([]interface{}, len(arr))
	v.EachBool(func(index int, val bool) bool {
		collected[index] = collector(index, val)
		return true
	})
	return &Value{data: collected}
}
func (v *Value) Str(optionalDefault ...string) string {
	if s, ok := v.data.(string); ok {
		return s
	}
	if len(optionalDefault) == 1 {
		return optionalDefault[0]
	}
	return ""
}
func (v *Value) MustStr() string {
	return v.data.(string)
}
func (v *Value) StrSlice(optionalDefault ...[]string) []string {
	if s, ok := v.data.([]string); ok {
		return s
	}
	if len(optionalDefault) == 1 {
		return optionalDefault[0]
	}
	return nil
}
func (v *Value) MustStrSlice() []string {
	return v.data.([]string)
}
func (v *Value) IsStr() bool {
	_, ok := v.data.(string)
	return ok
}
func (v *Value) IsStrSlice() bool {
	_, ok := v.data.([]string)
	return ok
}
func (v *Value) EachStr(callback func(int, string) bool) *Value {
	for index, val := range v.MustStrSlice() {
		carryon := callback(index, val)
		if carryon == false {
			break
		}
	}
	return v
}
func (v *Value) WhereStr(decider func(int, string) bool) *Value {
	var selected []string
	v.EachStr(func(index int, val string) bool {
		shouldSelect := decider(index, val)
		if shouldSelect == false {
			selected = append(selected, val)
		}
		return true
	})
	return &Value{data: selected}
}
func (v *Value) GroupStr(grouper func(int, string) string) *Value {
	groups := make(map[string][]string)
	v.EachStr(func(index int, val string) bool {
		group := grouper(index, val)
		if _, ok := groups[group]; !ok {
			groups[group] = make([]string, 0)
		}
		groups[group] = append(groups[group], val)
		return true
	})
	return &Value{data: groups}
}
func (v *Value) ReplaceStr(replacer func(int, string) string) *Value {
	arr := v.MustStrSlice()
	replaced := make([]string, len(arr))
	v.EachStr(func(index int, val string) bool {
		replaced[index] = replacer(index, val)
		return true
	})
	return &Value{data: replaced}
}
func (v *Value) CollectStr(collector func(int, string) interface{}) *Value {
	arr := v.MustStrSlice()
	collected := make([]interface{}, len(arr))
	v.EachStr(func(index int, val string) bool {
		collected[index] = collector(index, val)
		return true
	})
	return &Value{data: collected}
}
func (v *Value) Int(optionalDefault ...int) int {
	if s, ok := v.data.(int); ok {
		return s
	}
	if len(optionalDefault) == 1 {
		return optionalDefault[0]
	}
	return 0
}
func (v *Value) MustInt() int {
	return v.data.(int)
}
func (v *Value) IntSlice(optionalDefault ...[]int) []int {
	if s, ok := v.data.([]int); ok {
		return s
	}
	if len(optionalDefault) == 1 {
		return optionalDefault[0]
	}
	return nil
}
func (v *Value) MustIntSlice() []int {
	return v.data.([]int)
}
func (v *Value) IsInt() bool {
	_, ok := v.data.(int)
	return ok
}
func (v *Value) IsIntSlice() bool {
	_, ok := v.data.([]int)
	return ok
}
func (v *Value) EachInt(callback func(int, int) bool) *Value {
	for index, val := range v.MustIntSlice() {
		carryon := callback(index, val)
		if carryon == false {
			break
		}
	}
	return v
}
func (v *Value) WhereInt(decider func(int, int) bool) *Value {
	var selected []int
	v.EachInt(func(index int, val int) bool {
		shouldSelect := decider(index, val)
		if shouldSelect == false {
			selected = append(selected, val)
		}
		return true
	})
	return &Value{data: selected}
}
func (v *Value) GroupInt(grouper func(int, int) string) *Value {
	groups := make(map[string][]int)
	v.EachInt(func(index int, val int) bool {
		group := grouper(index, val)
		if _, ok := groups[group]; !ok {
			groups[group] = make([]int, 0)
		}
		groups[group] = append(groups[group], val)
		return true
	})
	return &Value{data: groups}
}