func MapInt8Int64Err(f func(int8) (int64, error), list []int8) ([]int64, error) {
	if f == nil {
		return []int64{}, nil
	}
	newList := make([]int64, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
MapInt8Int64Err takes two inputs -
1. Function 2. List. Then It returns a new list after applying the function on each item of the list and error
package fp
func MapIntInt64Err(f func(int) (int64, error), list []int) ([]int64, error) {
	if f == nil {
		return []int64{}, nil
	}
	newList := make([]int64, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapIntInt32Err(f func(int) (int32, error), list []int) ([]int32, error) {
	if f == nil {
		return []int32{}, nil
	}
	newList := make([]int32, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapIntInt16Err(f func(int) (int16, error), list []int) ([]int16, error) {
	if f == nil {
		return []int16{}, nil
	}
	newList := make([]int16, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapIntInt8Err(f func(int) (int8, error), list []int) ([]int8, error) {
	if f == nil {
		return []int8{}, nil
	}
	newList := make([]int8, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapIntUintErr(f func(int) (uint, error), list []int) ([]uint, error) {
	if f == nil {
		return []uint{}, nil
	}
	newList := make([]uint, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapIntUint64Err(f func(int) (uint64, error), list []int) ([]uint64, error) {
	if f == nil {
		return []uint64{}, nil
	}
	newList := make([]uint64, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapIntUint32Err(f func(int) (uint32, error), list []int) ([]uint32, error) {
	if f == nil {
		return []uint32{}, nil
	}
	newList := make([]uint32, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapIntUint16Err(f func(int) (uint16, error), list []int) ([]uint16, error) {
	if f == nil {
		return []uint16{}, nil
	}
	newList := make([]uint16, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapIntUint8Err(f func(int) (uint8, error), list []int) ([]uint8, error) {
	if f == nil {
		return []uint8{}, nil
	}
	newList := make([]uint8, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapIntStrErr(f func(int) (string, error), list []int) ([]string, error) {
	if f == nil {
		return []string{}, nil
	}
	newList := make([]string, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapIntBoolErr(f func(int) (bool, error), list []int) ([]bool, error) {
	if f == nil {
		return []bool{}, nil
	}
	newList := make([]bool, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapIntFloat32Err(f func(int) (float32, error), list []int) ([]float32, error) {
	if f == nil {
		return []float32{}, nil
	}
	newList := make([]float32, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapIntFloat64Err(f func(int) (float64, error), list []int) ([]float64, error) {
	if f == nil {
		return []float64{}, nil
	}
	newList := make([]float64, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt64IntErr(f func(int64) (int, error), list []int64) ([]int, error) {
	if f == nil {
		return []int{}, nil
	}
	newList := make([]int, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt64Int32Err(f func(int64) (int32, error), list []int64) ([]int32, error) {
	if f == nil {
		return []int32{}, nil
	}
	newList := make([]int32, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt64Int16Err(f func(int64) (int16, error), list []int64) ([]int16, error) {
	if f == nil {
		return []int16{}, nil
	}
	newList := make([]int16, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt64Int8Err(f func(int64) (int8, error), list []int64) ([]int8, error) {
	if f == nil {
		return []int8{}, nil
	}
	newList := make([]int8, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt64UintErr(f func(int64) (uint, error), list []int64) ([]uint, error) {
	if f == nil {
		return []uint{}, nil
	}
	newList := make([]uint, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt64Uint64Err(f func(int64) (uint64, error), list []int64) ([]uint64, error) {
	if f == nil {
		return []uint64{}, nil
	}
	newList := make([]uint64, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt64Uint32Err(f func(int64) (uint32, error), list []int64) ([]uint32, error) {
	if f == nil {
		return []uint32{}, nil
	}
	newList := make([]uint32, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt64Uint16Err(f func(int64) (uint16, error), list []int64) ([]uint16, error) {
	if f == nil {
		return []uint16{}, nil
	}
	newList := make([]uint16, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt64Uint8Err(f func(int64) (uint8, error), list []int64) ([]uint8, error) {
	if f == nil {
		return []uint8{}, nil
	}
	newList := make([]uint8, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt64StrErr(f func(int64) (string, error), list []int64) ([]string, error) {
	if f == nil {
		return []string{}, nil
	}
	newList := make([]string, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt64BoolErr(f func(int64) (bool, error), list []int64) ([]bool, error) {
	if f == nil {
		return []bool{}, nil
	}
	newList := make([]bool, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt64Float32Err(f func(int64) (float32, error), list []int64) ([]float32, error) {
	if f == nil {
		return []float32{}, nil
	}
	newList := make([]float32, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt64Float64Err(f func(int64) (float64, error), list []int64) ([]float64, error) {
	if f == nil {
		return []float64{}, nil
	}
	newList := make([]float64, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt32IntErr(f func(int32) (int, error), list []int32) ([]int, error) {
	if f == nil {
		return []int{}, nil
	}
	newList := make([]int, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt32Int64Err(f func(int32) (int64, error), list []int32) ([]int64, error) {
	if f == nil {
		return []int64{}, nil
	}
	newList := make([]int64, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt32Int16Err(f func(int32) (int16, error), list []int32) ([]int16, error) {
	if f == nil {
		return []int16{}, nil
	}
	newList := make([]int16, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt32Int8Err(f func(int32) (int8, error), list []int32) ([]int8, error) {
	if f == nil {
		return []int8{}, nil
	}
	newList := make([]int8, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt32UintErr(f func(int32) (uint, error), list []int32) ([]uint, error) {
	if f == nil {
		return []uint{}, nil
	}
	newList := make([]uint, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt32Uint64Err(f func(int32) (uint64, error), list []int32) ([]uint64, error) {
	if f == nil {
		return []uint64{}, nil
	}
	newList := make([]uint64, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt32Uint32Err(f func(int32) (uint32, error), list []int32) ([]uint32, error) {
	if f == nil {
		return []uint32{}, nil
	}
	newList := make([]uint32, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt32Uint16Err(f func(int32) (uint16, error), list []int32) ([]uint16, error) {
	if f == nil {
		return []uint16{}, nil
	}
	newList := make([]uint16, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt32Uint8Err(f func(int32) (uint8, error), list []int32) ([]uint8, error) {
	if f == nil {
		return []uint8{}, nil
	}
	newList := make([]uint8, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt32StrErr(f func(int32) (string, error), list []int32) ([]string, error) {
	if f == nil {
		return []string{}, nil
	}
	newList := make([]string, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt32BoolErr(f func(int32) (bool, error), list []int32) ([]bool, error) {
	if f == nil {
		return []bool{}, nil
	}
	newList := make([]bool, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt32Float32Err(f func(int32) (float32, error), list []int32) ([]float32, error) {
	if f == nil {
		return []float32{}, nil
	}
	newList := make([]float32, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt32Float64Err(f func(int32) (float64, error), list []int32) ([]float64, error) {
	if f == nil {
		return []float64{}, nil
	}
	newList := make([]float64, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt16IntErr(f func(int16) (int, error), list []int16) ([]int, error) {
	if f == nil {
		return []int{}, nil
	}
	newList := make([]int, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt16Int64Err(f func(int16) (int64, error), list []int16) ([]int64, error) {
	if f == nil {
		return []int64{}, nil
	}
	newList := make([]int64, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt16Int32Err(f func(int16) (int32, error), list []int16) ([]int32, error) {
	if f == nil {
		return []int32{}, nil
	}
	newList := make([]int32, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt16Int8Err(f func(int16) (int8, error), list []int16) ([]int8, error) {
	if f == nil {
		return []int8{}, nil
	}
	newList := make([]int8, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt16UintErr(f func(int16) (uint, error), list []int16) ([]uint, error) {
	if f == nil {
		return []uint{}, nil
	}
	newList := make([]uint, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt16Uint64Err(f func(int16) (uint64, error), list []int16) ([]uint64, error) {
	if f == nil {
		return []uint64{}, nil
	}
	newList := make([]uint64, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt16Uint32Err(f func(int16) (uint32, error), list []int16) ([]uint32, error) {
	if f == nil {
		return []uint32{}, nil
	}
	newList := make([]uint32, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt16Uint16Err(f func(int16) (uint16, error), list []int16) ([]uint16, error) {
	if f == nil {
		return []uint16{}, nil
	}
	newList := make([]uint16, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt16Uint8Err(f func(int16) (uint8, error), list []int16) ([]uint8, error) {
	if f == nil {
		return []uint8{}, nil
	}
	newList := make([]uint8, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt16StrErr(f func(int16) (string, error), list []int16) ([]string, error) {
	if f == nil {
		return []string{}, nil
	}
	newList := make([]string, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt16BoolErr(f func(int16) (bool, error), list []int16) ([]bool, error) {
	if f == nil {
		return []bool{}, nil
	}
	newList := make([]bool, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt16Float32Err(f func(int16) (float32, error), list []int16) ([]float32, error) {
	if f == nil {
		return []float32{}, nil
	}
	newList := make([]float32, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt16Float64Err(f func(int16) (float64, error), list []int16) ([]float64, error) {
	if f == nil {
		return []float64{}, nil
	}
	newList := make([]float64, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}
func MapInt8IntErr(f func(int8) (int, error), list []int8) ([]int, error) {
	if f == nil {
		return []int{}, nil
	}
	newList := make([]int, len(list))
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		newList[i] = r
	}
	return newList, nil
}