func RemoveFromInterfaces(set []interface{}, a interface{}) []interface{} {
	for i, s := range set {
		if s == a {
			return append(set[:i], set[i+1:]...)
		}
	}
	return set
}
RemoveFromInterfaces removes the first element from the interface{} set.
package goutil
import "strconv"
func StringsToBools(a []string) ([]bool, error) {
	r := make([]bool, len(a))
	for k, v := range a {
		i, err := strconv.ParseBool(v)
		if err != nil {
			return nil, err
		}
		r[k] = i
	}
	return r, nil
}
func StringsToFloat32s(a []string) ([]float32, error) {
	r := make([]float32, len(a))
	for k, v := range a {
		i, err := strconv.ParseFloat(v, 32)
		if err != nil {
			return nil, err
		}
		r[k] = float32(i)
	}
	return r, nil
}
func StringsToFloat64s(a []string) ([]float64, error) {
	r := make([]float64, len(a))
	for k, v := range a {
		i, err := strconv.ParseFloat(v, 64)
		if err != nil {
			return nil, err
		}
		r[k] = i
	}
	return r, nil
}
func StringsToInts(a []string) ([]int, error) {
	r := make([]int, len(a))
	for k, v := range a {
		i, err := strconv.Atoi(v)
		if err != nil {
			return nil, err
		}
		r[k] = i
	}
	return r, nil
}
func StringsToInt64s(a []string) ([]int64, error) {
	r := make([]int64, len(a))
	for k, v := range a {
		i, err := strconv.ParseInt(v, 10, 64)
		if err != nil {
			return nil, err
		}
		r[k] = i
	}
	return r, nil
}
func StringsToInt32s(a []string) ([]int32, error) {
	r := make([]int32, len(a))
	for k, v := range a {
		i, err := strconv.ParseInt(v, 10, 32)
		if err != nil {
			return nil, err
		}
		r[k] = int32(i)
	}
	return r, nil
}
func StringsToInt16s(a []string) ([]int16, error) {
	r := make([]int16, len(a))
	for k, v := range a {
		i, err := strconv.ParseInt(v, 10, 16)
		if err != nil {
			return nil, err
		}
		r[k] = int16(i)
	}
	return r, nil
}
func StringsToInt8s(a []string) ([]int8, error) {
	r := make([]int8, len(a))
	for k, v := range a {
		i, err := strconv.ParseInt(v, 10, 8)
		if err != nil {
			return nil, err
		}
		r[k] = int8(i)
	}
	return r, nil
}
func StringsToUint8s(a []string) ([]uint8, error) {
	r := make([]uint8, len(a))
	for k, v := range a {
		i, err := strconv.ParseUint(v, 10, 8)
		if err != nil {
			return nil, err
		}
		r[k] = uint8(i)
	}
	return r, nil
}
func StringsToUint16s(a []string) ([]uint16, error) {
	r := make([]uint16, len(a))
	for k, v := range a {
		i, err := strconv.ParseUint(v, 10, 16)
		if err != nil {
			return nil, err
		}
		r[k] = uint16(i)
	}
	return r, nil
}
func StringsToUint32s(a []string) ([]uint32, error) {
	r := make([]uint32, len(a))
	for k, v := range a {
		i, err := strconv.ParseUint(v, 10, 32)
		if err != nil {
			return nil, err
		}
		r[k] = uint32(i)
	}
	return r, nil
}
func StringsToUint64s(a []string) ([]uint64, error) {
	r := make([]uint64, len(a))
	for k, v := range a {
		i, err := strconv.ParseUint(v, 10, 64)
		if err != nil {
			return nil, err
		}
		r[k] = uint64(i)
	}
	return r, nil
}
func StringsToUints(a []string) ([]uint, error) {
	r := make([]uint, len(a))
	for k, v := range a {
		i, err := strconv.ParseUint(v, 10, 64)
		if err != nil {
			return nil, err
		}
		r[k] = uint(i)
	}
	return r, nil
}
func StringsConvert(a []string, fn func(string) (string, error)) ([]string, error) {
	ret := make([]string, len(a))
	for i, s := range a {
		r, err := fn(s)
		if err != nil {
			return nil, err
		}
		ret[i] = r
	}
	return ret, nil
}
func StringsConvertMap(a []string, fn func(string) (string, error)) (map[string]string, error) {
	ret := make(map[string]string, len(a))
	for _, s := range a {
		r, err := fn(s)
		if err != nil {
			return nil, err
		}
		ret[s] = r
	}
	return ret, nil
}
func IntersectStrings(set1, set2 []string) []string {
	var intersect []string
	var long, short = set1, set2
	if len(set1) < len(set2) {
		long, short = set2, set1
	}
	buf := make([]string, len(short))
	copy(buf, short)
	short = buf
	for _, m := range long {
		if len(short) == 0 {
			break
		}
		for j, n := range short {
			if m == n {
				intersect = append(intersect, n)
				short = short[:j+copy(short[j:], short[j+1:])]
				break
			}
		}
	}
	return intersect
}
func StringsDistinct(a []string) (set []string) {
	m := make(map[string]bool, len(a))
	set = make([]string, 0, len(a))
	for _, s := range a {
		if m[s] {
			continue
		}
		set = append(set, s)
		m[s] = true
	}
	return set
}
func SetToStrings(set []string, a string) []string {
	for _, s := range set {
		if s == a {
			return set
		}
	}
	return append(set, a)
}
func RemoveFromStrings(set []string, a string) []string {
	for i, s := range set {
		if s == a {
			return append(set[:i], set[i+1:]...)
		}
	}
	return set
}
func RemoveAllFromStrings(set []string, a string) []string {
	length := len(set)
	for {
		set = RemoveFromStrings(set, a)
		if length == len(set) {
			return set
		}
		length = len(set)
	}
}
func IntsDistinct(a []int) (set []int) {
	m := make(map[int]bool, len(a))
	set = make([]int, 0, len(a))
	for _, s := range a {
		if m[s] {
			continue
		}
		set = append(set, s)
		m[s] = true
	}
	return set
}
func SetToInts(set []int, a int) []int {
	for _, s := range set {
		if s == a {
			return set
		}
	}
	return append(set, a)
}
func RemoveFromInts(set []int, a int) []int {
	for i, s := range set {
		if s == a {
			return append(set[:i], set[i+1:]...)
		}
	}
	return set
}
func RemoveAllFromInts(set []int, a int) []int {
	length := len(set)
	for {
		set = RemoveFromInts(set, a)
		if length == len(set) {
			return set
		}
		length = len(set)
	}
}
func Int32sDistinct(a []int32) (set []int32) {
	m := make(map[int32]bool, len(a))
	set = make([]int32, 0, len(a))
	for _, s := range a {
		if m[s] {
			continue
		}
		set = append(set, s)
		m[s] = true
	}
	return set
}
func SetToInt32s(set []int32, a int32) []int32 {
	for _, s := range set {
		if s == a {
			return set
		}
	}
	return append(set, a)
}
func RemoveFromInt32s(set []int32, a int32) []int32 {
	for i, s := range set {
		if s == a {
			return append(set[:i], set[i+1:]...)
		}
	}
	return set
}
func RemoveAllFromInt32s(set []int32, a int32) []int32 {
	length := len(set)
	for {
		set = RemoveFromInt32s(set, a)
		if length == len(set) {
			return set
		}
		length = len(set)
	}
}
func Int64sDistinct(a []int64) (set []int64) {
	m := make(map[int64]bool, len(a))
	set = make([]int64, 0, len(a))
	for _, s := range a {
		if m[s] {
			continue
		}
		set = append(set, s)
		m[s] = true
	}
	return set
}
func SetToInt64s(set []int64, a int64) []int64 {
	for _, s := range set {
		if s == a {
			return set
		}
	}
	return append(set, a)
}
func RemoveFromInt64s(set []int64, a int64) []int64 {
	for i, s := range set {
		if s == a {
			return append(set[:i], set[i+1:]...)
		}
	}
	return set
}
func RemoveAllFromInt64s(set []int64, a int64) []int64 {
	length := len(set)
	for {
		set = RemoveFromInt64s(set, a)
		if length == len(set) {
			return set
		}
		length = len(set)
	}
}
func InterfacesDistinct(a []interface{}) (set []interface{}) {
	m := make(map[interface{}]bool, len(a))
	set = make([]interface{}, 0, len(a))
	for _, s := range a {
		if m[s] {
			continue
		}
		set = append(set, s)
		m[s] = true
	}
	return set
}
func SetToInterfaces(set []interface{}, a interface{}) []interface{} {
	for _, s := range set {
		if s == a {
			return set
		}
	}
	return append(set, a)
}