func MapInt8Uint32PtrErr(f func(*int8) (*uint32, error), list []*int8) ([]*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
}
MapInt8Uint32PtrErr takes two inputs -
1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error
package fp
func MapIntInt64PtrErr(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 MapIntInt32PtrErr(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 MapIntInt16PtrErr(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 MapIntInt8PtrErr(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 MapIntUintPtrErr(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 MapIntUint64PtrErr(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 MapIntUint32PtrErr(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 MapIntUint16PtrErr(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 MapIntUint8PtrErr(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 MapIntStrPtrErr(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 MapIntBoolPtrErr(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 MapIntFloat32PtrErr(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 MapIntFloat64PtrErr(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 MapInt64IntPtrErr(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 MapInt64Int32PtrErr(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 MapInt64Int16PtrErr(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 MapInt64Int8PtrErr(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 MapInt64UintPtrErr(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 MapInt64Uint64PtrErr(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 MapInt64Uint32PtrErr(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 MapInt64Uint16PtrErr(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 MapInt64Uint8PtrErr(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 MapInt64StrPtrErr(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 MapInt64BoolPtrErr(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 MapInt64Float32PtrErr(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 MapInt64Float64PtrErr(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 MapInt32IntPtrErr(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 MapInt32Int64PtrErr(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 MapInt32Int16PtrErr(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 MapInt32Int8PtrErr(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 MapInt32UintPtrErr(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 MapInt32Uint64PtrErr(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 MapInt32Uint32PtrErr(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 MapInt32Uint16PtrErr(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 MapInt32Uint8PtrErr(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 MapInt32StrPtrErr(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 MapInt32BoolPtrErr(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 MapInt32Float32PtrErr(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 MapInt32Float64PtrErr(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 MapInt16IntPtrErr(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 MapInt16Int64PtrErr(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 MapInt16Int32PtrErr(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 MapInt16Int8PtrErr(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 MapInt16UintPtrErr(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 MapInt16Uint64PtrErr(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 MapInt16Uint32PtrErr(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 MapInt16Uint16PtrErr(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 MapInt16Uint8PtrErr(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 MapInt16StrPtrErr(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 MapInt16BoolPtrErr(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 MapInt16Float32PtrErr(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 MapInt16Float64PtrErr(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 MapInt8IntPtrErr(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
}
func MapInt8Int64PtrErr(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
}
func MapInt8Int32PtrErr(f func(*int8) (*int32, error), list []*int8) ([]*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 MapInt8Int16PtrErr(f func(*int8) (*int16, error), list []*int8) ([]*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 MapInt8UintPtrErr(f func(*int8) (*uint, error), list []*int8) ([]*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 MapInt8Uint64PtrErr(f func(*int8) (*uint64, error), list []*int8) ([]*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
}