func FilterMapInt32Uint32Err(fFilter func(int32) (bool, error), fMap func(int32) (uint32, error), list []int32) ([]uint32, error) {
	if fFilter == nil || fMap == nil {
		return []uint32{}, nil
	}
	var newList []uint32
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
FilterMapInt32Uint32Err filters given list, then apply function(2nd argument) on each item in the list and returns a new list, error
Takes 3 inputs
1. Function: takes one input type - int32 and returns (bool, error).
2. Function: takes int32 as argument and returns (uint32, error)
3. List of type int32

Returns:
New List of type uint32, error
Empty list if all there parameters are nil or either of parameter is nil
package fp
func FilterMapIntInt64Err(fFilter func(int) (bool, error), fMap func(int) (int64, error), list []int) ([]int64, error) {
	if fFilter == nil || fMap == nil {
		return []int64{}, nil
	}
	var newList []int64
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntInt32Err(fFilter func(int) (bool, error), fMap func(int) (int32, error), list []int) ([]int32, error) {
	if fFilter == nil || fMap == nil {
		return []int32{}, nil
	}
	var newList []int32
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntInt16Err(fFilter func(int) (bool, error), fMap func(int) (int16, error), list []int) ([]int16, error) {
	if fFilter == nil || fMap == nil {
		return []int16{}, nil
	}
	var newList []int16
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntInt8Err(fFilter func(int) (bool, error), fMap func(int) (int8, error), list []int) ([]int8, error) {
	if fFilter == nil || fMap == nil {
		return []int8{}, nil
	}
	var newList []int8
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntUintErr(fFilter func(int) (bool, error), fMap func(int) (uint, error), list []int) ([]uint, error) {
	if fFilter == nil || fMap == nil {
		return []uint{}, nil
	}
	var newList []uint
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntUint64Err(fFilter func(int) (bool, error), fMap func(int) (uint64, error), list []int) ([]uint64, error) {
	if fFilter == nil || fMap == nil {
		return []uint64{}, nil
	}
	var newList []uint64
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntUint32Err(fFilter func(int) (bool, error), fMap func(int) (uint32, error), list []int) ([]uint32, error) {
	if fFilter == nil || fMap == nil {
		return []uint32{}, nil
	}
	var newList []uint32
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntUint16Err(fFilter func(int) (bool, error), fMap func(int) (uint16, error), list []int) ([]uint16, error) {
	if fFilter == nil || fMap == nil {
		return []uint16{}, nil
	}
	var newList []uint16
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntUint8Err(fFilter func(int) (bool, error), fMap func(int) (uint8, error), list []int) ([]uint8, error) {
	if fFilter == nil || fMap == nil {
		return []uint8{}, nil
	}
	var newList []uint8
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntStrErr(fFilter func(int) (bool, error), fMap func(int) (string, error), list []int) ([]string, error) {
	if fFilter == nil || fMap == nil {
		return []string{}, nil
	}
	var newList []string
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntBoolErr(fFilter func(int) (bool, error), fMap func(int) (bool, error), list []int) ([]bool, error) {
	if fFilter == nil || fMap == nil {
		return []bool{}, nil
	}
	var newList []bool
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntFloat32Err(fFilter func(int) (bool, error), fMap func(int) (float32, error), list []int) ([]float32, error) {
	if fFilter == nil || fMap == nil {
		return []float32{}, nil
	}
	var newList []float32
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntFloat64Err(fFilter func(int) (bool, error), fMap func(int) (float64, error), list []int) ([]float64, error) {
	if fFilter == nil || fMap == nil {
		return []float64{}, nil
	}
	var newList []float64
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64IntErr(fFilter func(int64) (bool, error), fMap func(int64) (int, error), list []int64) ([]int, error) {
	if fFilter == nil || fMap == nil {
		return []int{}, nil
	}
	var newList []int
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64Int32Err(fFilter func(int64) (bool, error), fMap func(int64) (int32, error), list []int64) ([]int32, error) {
	if fFilter == nil || fMap == nil {
		return []int32{}, nil
	}
	var newList []int32
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64Int16Err(fFilter func(int64) (bool, error), fMap func(int64) (int16, error), list []int64) ([]int16, error) {
	if fFilter == nil || fMap == nil {
		return []int16{}, nil
	}
	var newList []int16
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64Int8Err(fFilter func(int64) (bool, error), fMap func(int64) (int8, error), list []int64) ([]int8, error) {
	if fFilter == nil || fMap == nil {
		return []int8{}, nil
	}
	var newList []int8
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64UintErr(fFilter func(int64) (bool, error), fMap func(int64) (uint, error), list []int64) ([]uint, error) {
	if fFilter == nil || fMap == nil {
		return []uint{}, nil
	}
	var newList []uint
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64Uint64Err(fFilter func(int64) (bool, error), fMap func(int64) (uint64, error), list []int64) ([]uint64, error) {
	if fFilter == nil || fMap == nil {
		return []uint64{}, nil
	}
	var newList []uint64
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64Uint32Err(fFilter func(int64) (bool, error), fMap func(int64) (uint32, error), list []int64) ([]uint32, error) {
	if fFilter == nil || fMap == nil {
		return []uint32{}, nil
	}
	var newList []uint32
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64Uint16Err(fFilter func(int64) (bool, error), fMap func(int64) (uint16, error), list []int64) ([]uint16, error) {
	if fFilter == nil || fMap == nil {
		return []uint16{}, nil
	}
	var newList []uint16
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64Uint8Err(fFilter func(int64) (bool, error), fMap func(int64) (uint8, error), list []int64) ([]uint8, error) {
	if fFilter == nil || fMap == nil {
		return []uint8{}, nil
	}
	var newList []uint8
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64StrErr(fFilter func(int64) (bool, error), fMap func(int64) (string, error), list []int64) ([]string, error) {
	if fFilter == nil || fMap == nil {
		return []string{}, nil
	}
	var newList []string
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64BoolErr(fFilter func(int64) (bool, error), fMap func(int64) (bool, error), list []int64) ([]bool, error) {
	if fFilter == nil || fMap == nil {
		return []bool{}, nil
	}
	var newList []bool
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64Float32Err(fFilter func(int64) (bool, error), fMap func(int64) (float32, error), list []int64) ([]float32, error) {
	if fFilter == nil || fMap == nil {
		return []float32{}, nil
	}
	var newList []float32
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64Float64Err(fFilter func(int64) (bool, error), fMap func(int64) (float64, error), list []int64) ([]float64, error) {
	if fFilter == nil || fMap == nil {
		return []float64{}, nil
	}
	var newList []float64
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt32IntErr(fFilter func(int32) (bool, error), fMap func(int32) (int, error), list []int32) ([]int, error) {
	if fFilter == nil || fMap == nil {
		return []int{}, nil
	}
	var newList []int
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt32Int64Err(fFilter func(int32) (bool, error), fMap func(int32) (int64, error), list []int32) ([]int64, error) {
	if fFilter == nil || fMap == nil {
		return []int64{}, nil
	}
	var newList []int64
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt32Int16Err(fFilter func(int32) (bool, error), fMap func(int32) (int16, error), list []int32) ([]int16, error) {
	if fFilter == nil || fMap == nil {
		return []int16{}, nil
	}
	var newList []int16
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt32Int8Err(fFilter func(int32) (bool, error), fMap func(int32) (int8, error), list []int32) ([]int8, error) {
	if fFilter == nil || fMap == nil {
		return []int8{}, nil
	}
	var newList []int8
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt32UintErr(fFilter func(int32) (bool, error), fMap func(int32) (uint, error), list []int32) ([]uint, error) {
	if fFilter == nil || fMap == nil {
		return []uint{}, nil
	}
	var newList []uint
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt32Uint64Err(fFilter func(int32) (bool, error), fMap func(int32) (uint64, error), list []int32) ([]uint64, error) {
	if fFilter == nil || fMap == nil {
		return []uint64{}, nil
	}
	var newList []uint64
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}