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
}
FilterMapIntUint16Err 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 - int and returns (bool, error).
2. Function: takes int as argument and returns (uint16, error)
3. List of type int

Returns:
New List of type uint16, 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
}