func FilterFloat32Err(f func(float32) (bool, error), list []float32) ([]float32, error) {
	if f == nil {
		return []float32{}, nil
	}
	var newList []float32
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}
FilterFloat32Err takes two arguments
1. Function: takes 1 argument of type float32 and returns (bool, error)
2. slice of type []float32

Returns:
new filtered list and error
package fp
func FilterIntErr(f func(int) (bool, error), list []int) ([]int, error) {
	if f == nil {
		return []int{}, nil
	}
	var newList []int
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}
func FilterInt64Err(f func(int64) (bool, error), list []int64) ([]int64, error) {
	if f == nil {
		return []int64{}, nil
	}
	var newList []int64
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}
func FilterInt32Err(f func(int32) (bool, error), list []int32) ([]int32, error) {
	if f == nil {
		return []int32{}, nil
	}
	var newList []int32
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}
func FilterInt16Err(f func(int16) (bool, error), list []int16) ([]int16, error) {
	if f == nil {
		return []int16{}, nil
	}
	var newList []int16
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}
func FilterInt8Err(f func(int8) (bool, error), list []int8) ([]int8, error) {
	if f == nil {
		return []int8{}, nil
	}
	var newList []int8
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}
func FilterUintErr(f func(uint) (bool, error), list []uint) ([]uint, error) {
	if f == nil {
		return []uint{}, nil
	}
	var newList []uint
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}
func FilterUint64Err(f func(uint64) (bool, error), list []uint64) ([]uint64, error) {
	if f == nil {
		return []uint64{}, nil
	}
	var newList []uint64
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}
func FilterUint32Err(f func(uint32) (bool, error), list []uint32) ([]uint32, error) {
	if f == nil {
		return []uint32{}, nil
	}
	var newList []uint32
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}
func FilterUint16Err(f func(uint16) (bool, error), list []uint16) ([]uint16, error) {
	if f == nil {
		return []uint16{}, nil
	}
	var newList []uint16
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}
func FilterUint8Err(f func(uint8) (bool, error), list []uint8) ([]uint8, error) {
	if f == nil {
		return []uint8{}, nil
	}
	var newList []uint8
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}
func FilterStrErr(f func(string) (bool, error), list []string) ([]string, error) {
	if f == nil {
		return []string{}, nil
	}
	var newList []string
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}
func FilterBoolErr(f func(bool) (bool, error), list []bool) ([]bool, error) {
	if f == nil {
		return []bool{}, nil
	}
	var newList []bool
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}