fp

package
v1.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 15, 2023 License: Apache-2.0 Imports: 3 Imported by: 7

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func DedupeBool 

func DedupeBool(list []bool) []bool

DedupeBool Returns a new list removing consecutive duplicates in list.

func DedupeBoolPtr 

func DedupeBoolPtr(list []*bool) []*bool

DedupeBoolPtr Returns a new list removing consecutive duplicates in list.

func DedupeFloat32 

func DedupeFloat32(list []float32) []float32

DedupeFloat32 Returns a new list removing consecutive duplicates in list.

func DedupeFloat32Ptr 

func DedupeFloat32Ptr(list []*float32) []*float32

DedupeFloat32Ptr Returns a new list removing consecutive duplicates in list.

func DedupeFloat64 

func DedupeFloat64(list []float64) []float64

DedupeFloat64 Returns a new list removing consecutive duplicates in list.

func DedupeFloat64Ptr 

func DedupeFloat64Ptr(list []*float64) []*float64

DedupeFloat64Ptr Returns a new list removing consecutive duplicates in list.

func DedupeInt 

func DedupeInt(list []int) []int

DedupeInt Returns a new list removing consecutive duplicates in list.

func DedupeInt16 

func DedupeInt16(list []int16) []int16

DedupeInt16 Returns a new list removing consecutive duplicates in list.

func DedupeInt16Ptr 

func DedupeInt16Ptr(list []*int16) []*int16

DedupeInt16Ptr Returns a new list removing consecutive duplicates in list.

func DedupeInt32 

func DedupeInt32(list []int32) []int32

DedupeInt32 Returns a new list removing consecutive duplicates in list.

func DedupeInt32Ptr 

func DedupeInt32Ptr(list []*int32) []*int32

DedupeInt32Ptr Returns a new list removing consecutive duplicates in list.

func DedupeInt64 

func DedupeInt64(list []int64) []int64

DedupeInt64 Returns a new list removing consecutive duplicates in list.

func DedupeInt64Ptr 

func DedupeInt64Ptr(list []*int64) []*int64

DedupeInt64Ptr Returns a new list removing consecutive duplicates in list.

func DedupeInt8 

func DedupeInt8(list []int8) []int8

DedupeInt8 Returns a new list removing consecutive duplicates in list.

func DedupeInt8Ptr 

func DedupeInt8Ptr(list []*int8) []*int8

DedupeInt8Ptr Returns a new list removing consecutive duplicates in list.

func DedupeIntPtr 

func DedupeIntPtr(list []*int) []*int

DedupeIntPtr Returns a new list removing consecutive duplicates in list.

func DedupeStr 

func DedupeStr(list []string) []string

DedupeStr Returns a new list removing consecutive duplicates in list.

func DedupeStrPtr 

func DedupeStrPtr(list []*string) []*string

DedupeStrPtr Returns a new list removing consecutive duplicates in list.

func DedupeUint 

func DedupeUint(list []uint) []uint

DedupeUint Returns a new list removing consecutive duplicates in list.

func DedupeUint16 

func DedupeUint16(list []uint16) []uint16

DedupeUint16 Returns a new list removing consecutive duplicates in list.

func DedupeUint16Ptr 

func DedupeUint16Ptr(list []*uint16) []*uint16

DedupeUint16Ptr Returns a new list removing consecutive duplicates in list.

func DedupeUint32 

func DedupeUint32(list []uint32) []uint32

DedupeUint32 Returns a new list removing consecutive duplicates in list.

func DedupeUint32Ptr 

func DedupeUint32Ptr(list []*uint32) []*uint32

DedupeUint32Ptr Returns a new list removing consecutive duplicates in list.

func DedupeUint64 

func DedupeUint64(list []uint64) []uint64

DedupeUint64 Returns a new list removing consecutive duplicates in list.

func DedupeUint64Ptr 

func DedupeUint64Ptr(list []*uint64) []*uint64

DedupeUint64Ptr Returns a new list removing consecutive duplicates in list.

func DedupeUint8 

func DedupeUint8(list []uint8) []uint8

DedupeUint8 Returns a new list removing consecutive duplicates in list.

func DedupeUint8Ptr 

func DedupeUint8Ptr(list []*uint8) []*uint8

DedupeUint8Ptr Returns a new list removing consecutive duplicates in list.

func DedupeUintPtr 

func DedupeUintPtr(list []*uint) []*uint

DedupeUintPtr Returns a new list removing consecutive duplicates in list.

func DifferenceBool 

func DifferenceBool(arrList ...[]bool) []bool

DifferenceBool returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceBoolPtr 

func DifferenceBoolPtr(arrList ...[]*bool) []*bool

DifferenceBoolPtr returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceFloat32 

func DifferenceFloat32(arrList ...[]float32) []float32

DifferenceFloat32 returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceFloat32Ptr 

func DifferenceFloat32Ptr(arrList ...[]*float32) []*float32

DifferenceFloat32Ptr returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceFloat64 

func DifferenceFloat64(arrList ...[]float64) []float64

DifferenceFloat64 returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceFloat64Ptr 

func DifferenceFloat64Ptr(arrList ...[]*float64) []*float64

DifferenceFloat64Ptr returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceInt 

func DifferenceInt(arrList ...[]int) []int

DifferenceInt returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceInt16 

func DifferenceInt16(arrList ...[]int16) []int16

DifferenceInt16 returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceInt16Ptr 

func DifferenceInt16Ptr(arrList ...[]*int16) []*int16

DifferenceInt16Ptr returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceInt32 

func DifferenceInt32(arrList ...[]int32) []int32

DifferenceInt32 returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceInt32Ptr 

func DifferenceInt32Ptr(arrList ...[]*int32) []*int32

DifferenceInt32Ptr returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceInt64 

func DifferenceInt64(arrList ...[]int64) []int64

DifferenceInt64 returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceInt64Ptr 

func DifferenceInt64Ptr(arrList ...[]*int64) []*int64

DifferenceInt64Ptr returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceInt8 

func DifferenceInt8(arrList ...[]int8) []int8

DifferenceInt8 returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceInt8Ptr 

func DifferenceInt8Ptr(arrList ...[]*int8) []*int8

DifferenceInt8Ptr returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceIntPtr 

func DifferenceIntPtr(arrList ...[]*int) []*int

DifferenceIntPtr returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceStr 

func DifferenceStr(arrList ...[]string) []string

DifferenceStr returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceStrPtr 

func DifferenceStrPtr(arrList ...[]*string) []*string

DifferenceStrPtr returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceUint 

func DifferenceUint(arrList ...[]uint) []uint

DifferenceUint returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceUint16 

func DifferenceUint16(arrList ...[]uint16) []uint16

DifferenceUint16 returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceUint16Ptr 

func DifferenceUint16Ptr(arrList ...[]*uint16) []*uint16

DifferenceUint16Ptr returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceUint32 

func DifferenceUint32(arrList ...[]uint32) []uint32

DifferenceUint32 returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceUint32Ptr 

func DifferenceUint32Ptr(arrList ...[]*uint32) []*uint32

DifferenceUint32Ptr returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceUint64 

func DifferenceUint64(arrList ...[]uint64) []uint64

DifferenceUint64 returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceUint64Ptr 

func DifferenceUint64Ptr(arrList ...[]*uint64) []*uint64

DifferenceUint64Ptr returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceUint8 

func DifferenceUint8(arrList ...[]uint8) []uint8

DifferenceUint8 returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceUint8Ptr 

func DifferenceUint8Ptr(arrList ...[]*uint8) []*uint8

DifferenceUint8Ptr returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DifferenceUintPtr 

func DifferenceUintPtr(arrList ...[]*uint) []*uint

DifferenceUintPtr returns a set that is the first set without elements of the remaining sets repeated value within list parameter will be ignored

func DistinctBool 

func DistinctBool(list []bool) []bool

DistinctBool removes duplicates.

func DistinctBoolP 

func DistinctBoolP(list []bool) bool

DistinctBoolP returns true if no two of the arguments are =

func DistinctBoolPPtr 

func DistinctBoolPPtr(list []*bool) bool

DistinctBoolPPtr returns true if no two of the arguments are =

func DistinctBoolPtr 

func DistinctBoolPtr(list []*bool) []*bool

DistinctBoolPtr removes duplicates.

func DistinctFloat32 

func DistinctFloat32(list []float32) []float32

DistinctFloat32 removes duplicates.

Example 

list := []float32{8.1, 2.1, 8.1, 0, 2.1, 0}
fp.DistinctFloat32(list) // returns [8.1, 2.1, 0]

func DistinctFloat32P 

func DistinctFloat32P(list []float32) bool

DistinctFloat32P returns true if no two of the arguments are =

func DistinctFloat32PPtr 

func DistinctFloat32PPtr(list []*float32) bool

DistinctFloat32PPtr returns true if no two of the arguments are =

func DistinctFloat32Ptr 

func DistinctFloat32Ptr(list []*float32) []*float32

DistinctFloat32Ptr removes duplicates.

func DistinctFloat64 

func DistinctFloat64(list []float64) []float64

DistinctFloat64 removes duplicates.

Example 

list := []float64{8.1, 2.1, 8.1, 0, 2.1, 0}
fp.DistinctFloat64(list) // returns [8.1, 2.1, 0]

func DistinctFloat64P 

func DistinctFloat64P(list []float64) bool

DistinctFloat64P returns true if no two of the arguments are =

func DistinctFloat64PPtr 

func DistinctFloat64PPtr(list []*float64) bool

DistinctFloat64PPtr returns true if no two of the arguments are =

func DistinctFloat64Ptr 

func DistinctFloat64Ptr(list []*float64) []*float64

DistinctFloat64Ptr removes duplicates.

func DistinctInt 

func DistinctInt(list []int) []int

DistinctInt removes duplicates.

Example 

list := []int{8, 2, 8, 0, 2, 0}
fp.DistinctInt(list) // returns [8, 2, 0]

func DistinctInt16 

func DistinctInt16(list []int16) []int16

DistinctInt16 removes duplicates.

Example 

list := []int16{8, 2, 8, 0, 2, 0}
fp.DistinctInt16(list) // returns [8, 2, 0]

func DistinctInt16P 

func DistinctInt16P(list []int16) bool

DistinctInt16P returns true if no two of the arguments are =

func DistinctInt16PPtr 

func DistinctInt16PPtr(list []*int16) bool

DistinctInt16PPtr returns true if no two of the arguments are =

func DistinctInt16Ptr 

func DistinctInt16Ptr(list []*int16) []*int16

DistinctInt16Ptr removes duplicates.

func DistinctInt32 

func DistinctInt32(list []int32) []int32

DistinctInt32 removes duplicates.

Example 

list := []int32{8, 2, 8, 0, 2, 0}
fp.DistinctInt32(list) // returns [8, 2, 0]

func DistinctInt32P 

func DistinctInt32P(list []int32) bool

DistinctInt32P returns true if no two of the arguments are =

func DistinctInt32PPtr 

func DistinctInt32PPtr(list []*int32) bool

DistinctInt32PPtr returns true if no two of the arguments are =

func DistinctInt32Ptr 

func DistinctInt32Ptr(list []*int32) []*int32

DistinctInt32Ptr removes duplicates.

func DistinctInt64 

func DistinctInt64(list []int64) []int64

DistinctInt64 removes duplicates.

Example 

list := []int64{8, 2, 8, 0, 2, 0}
fp.DistinctInt64(list) // returns [8, 2, 0]

func DistinctInt64P 

func DistinctInt64P(list []int64) bool

DistinctInt64P returns true if no two of the arguments are =

func DistinctInt64PPtr 

func DistinctInt64PPtr(list []*int64) bool

DistinctInt64PPtr returns true if no two of the arguments are =

func DistinctInt64Ptr 

func DistinctInt64Ptr(list []*int64) []*int64

DistinctInt64Ptr removes duplicates.

func DistinctInt8 

func DistinctInt8(list []int8) []int8

DistinctInt8 removes duplicates.

Example 

list := []int8{8, 2, 8, 0, 2, 0}
fp.DistinctInt8(list) // returns [8, 2, 0]

func DistinctInt8P 

func DistinctInt8P(list []int8) bool

DistinctInt8P returns true if no two of the arguments are =

func DistinctInt8PPtr 

func DistinctInt8PPtr(list []*int8) bool

DistinctInt8PPtr returns true if no two of the arguments are =

func DistinctInt8Ptr 

func DistinctInt8Ptr(list []*int8) []*int8

DistinctInt8Ptr removes duplicates.

func DistinctIntP 

func DistinctIntP(list []int) bool

DistinctIntP returns true if no two of the arguments are =

func DistinctIntPPtr 

func DistinctIntPPtr(list []*int) bool

DistinctIntPPtr returns true if no two of the arguments are =

func DistinctIntPtr 

func DistinctIntPtr(list []*int) []*int

DistinctIntPtr removes duplicates.

func DistinctStr 

func DistinctStr(list []string) []string

DistinctStr removes duplicates.

Example 

list := []string{"Bharat", "Hanuman", "Bharat", "Sita", "Hanuman", "Sita"}
fp.DistinctStr(list) // returns ["Bharat", "Hanuman", "Sita"]

func DistinctStrIgnoreCase 

func DistinctStrIgnoreCase(list []string) []string

DistinctStrIgnoreCase ignores case and removes duplicates.

Example 

list := []string{"Bharat", "HanumaN", "BharaT", "SiTa", "Hanuman", "Sita"}
fp.DistinctStrIgnoreCase(list) // returns ["Bharat", "HanumaN", "SiTa"]

func DistinctStrP 

func DistinctStrP(list []string) bool

DistinctStrP returns true if no two of the arguments are =

func DistinctStrPPtr 

func DistinctStrPPtr(list []*string) bool

DistinctStrPPtr returns true if no two of the arguments are =

func DistinctStrPtr 

func DistinctStrPtr(list []*string) []*string

DistinctStrPtr removes duplicates.

func DistinctUint 

func DistinctUint(list []uint) []uint

DistinctUint removes duplicates.

Example 

list := []uint{8, 2, 8, 0, 2, 0}
fp.DistinctUint(list) // returns [8, 2, 0]

func DistinctUint16 

func DistinctUint16(list []uint16) []uint16

DistinctUint16 removes duplicates.

Example 

list := []uint16{8, 2, 8, 0, 2, 0}
fp.DistinctUint16(list) // returns [8, 2, 0]

func DistinctUint16P 

func DistinctUint16P(list []uint16) bool

DistinctUint16P returns true if no two of the arguments are =

func DistinctUint16PPtr 

func DistinctUint16PPtr(list []*uint16) bool

DistinctUint16PPtr returns true if no two of the arguments are =

func DistinctUint16Ptr 

func DistinctUint16Ptr(list []*uint16) []*uint16

DistinctUint16Ptr removes duplicates.

func DistinctUint32 

func DistinctUint32(list []uint32) []uint32

DistinctUint32 removes duplicates.

Example 

list := []uint32{8, 2, 8, 0, 2, 0}
fp.DistinctUint32(list) // returns [8, 2, 0]

func DistinctUint32P 

func DistinctUint32P(list []uint32) bool

DistinctUint32P returns true if no two of the arguments are =

func DistinctUint32PPtr 

func DistinctUint32PPtr(list []*uint32) bool

DistinctUint32PPtr returns true if no two of the arguments are =

func DistinctUint32Ptr 

func DistinctUint32Ptr(list []*uint32) []*uint32

DistinctUint32Ptr removes duplicates.

func DistinctUint64 

func DistinctUint64(list []uint64) []uint64

DistinctUint64 removes duplicates.

Example 

list := []uint64{8, 2, 8, 0, 2, 0}
fp.DistinctUint64(list) // returns [8, 2, 0]

func DistinctUint64P 

func DistinctUint64P(list []uint64) bool

DistinctUint64P returns true if no two of the arguments are =

func DistinctUint64PPtr 

func DistinctUint64PPtr(list []*uint64) bool

DistinctUint64PPtr returns true if no two of the arguments are =

func DistinctUint64Ptr 

func DistinctUint64Ptr(list []*uint64) []*uint64

DistinctUint64Ptr removes duplicates.

func DistinctUint8 

func DistinctUint8(list []uint8) []uint8

DistinctUint8 removes duplicates.

Example 

list := []uint8{8, 2, 8, 0, 2, 0}
fp.DistinctUint8(list) // returns [8, 2, 0]

func DistinctUint8P 

func DistinctUint8P(list []uint8) bool

DistinctUint8P returns true if no two of the arguments are =

func DistinctUint8PPtr 

func DistinctUint8PPtr(list []*uint8) bool

DistinctUint8PPtr returns true if no two of the arguments are =

func DistinctUint8Ptr 

func DistinctUint8Ptr(list []*uint8) []*uint8

DistinctUint8Ptr removes duplicates.

func DistinctUintP 

func DistinctUintP(list []uint) bool

DistinctUintP returns true if no two of the arguments are =

func DistinctUintPPtr 

func DistinctUintPPtr(list []*uint) bool

DistinctUintPPtr returns true if no two of the arguments are =

func DistinctUintPtr 

func DistinctUintPtr(list []*uint) []*uint

DistinctUintPtr removes duplicates.

func DropBoolPtr 

func DropBoolPtr(num *bool, list []*bool) []*bool

DropBoolPtr returns a new list after dropping the given item

func DropBoolsPtr 

func DropBoolsPtr(nums []*bool, list []*bool) []*bool

DropBoolsPtr returns a new list after dropping the given items

func DropFloat32 

func DropFloat32(num float32, list []float32) []float32

DropFloat32 returns a new list after dropping the given item

Example: 

fp.DropFloat32(1.1, []float32{1.1, 2.1, 3.1, 1.1}) // returns [2.1, 3.1]

func DropFloat32Ptr 

func DropFloat32Ptr(num *float32, list []*float32) []*float32

DropFloat32Ptr returns a new list after dropping the given item

func DropFloat32sPtr 

func DropFloat32sPtr(nums []*float32, list []*float32) []*float32

DropFloat32sPtr returns a new list after dropping the given items

func DropFloat64 

func DropFloat64(num float64, list []float64) []float64

DropFloat64 returns a new list after dropping the given item

Example: 

fp.DropFloat64(1.1, []float64{1.1, 2.1, 3.1, 1.1}) // returns [2.1, 3.1]

func DropFloat64Ptr 

func DropFloat64Ptr(num *float64, list []*float64) []*float64

DropFloat64Ptr returns a new list after dropping the given item

func DropFloat64sPtr 

func DropFloat64sPtr(nums []*float64, list []*float64) []*float64

DropFloat64sPtr returns a new list after dropping the given items

func DropFloats32 

func DropFloats32(nums []float32, list []float32) []float32

DropFloats32 returns a new list after dropping the given items

Example: 

fp.DropFloats32([]float32{1.1, 4.1}, []float32{1.1, 2.1, 3.1, 1.1, 4.1}) // returns [2.1, 3.1]

func DropFloats64 

func DropFloats64(nums []float64, list []float64) []float64

DropFloats64 returns a new list after dropping the given items

Example: 

fp.DropFloats64([]float64{1.1, 4.1}, []float64{1.1, 2.1, 3.1, 1.1, 4.1}) // returns [2.1, 3.1]

func DropInt 

func DropInt(num int, list []int) []int

DropInt returns a new list after dropping the given item

Example: 

fp.DropInt(1, []int{1, 2, 3, 1}) // returns [2, 3]

func DropInt16 

func DropInt16(num int16, list []int16) []int16

DropInt16 returns a new list after dropping the given item

Example: 

fp.DropInt16(1, []int16{1, 2, 3, 1}) // returns [2, 3]

func DropInt16Ptr 

func DropInt16Ptr(num *int16, list []*int16) []*int16

DropInt16Ptr returns a new list after dropping the given item

func DropInt32 

func DropInt32(num int32, list []int32) []int32

DropInt32 returns a new list after dropping the given item

Example: 

fp.DropInt32(1, []int32{1, 2, 3, 1}) // returns [2, 3]

func DropInt32Ptr 

func DropInt32Ptr(num *int32, list []*int32) []*int32

DropInt32Ptr returns a new list after dropping the given item

func DropInt64 

func DropInt64(num int64, list []int64) []int64

DropInt64 returns a new list after dropping the given item

Example: 

fp.DropInt64(1, []int64{1, 2, 3, 1}) // returns [2, 3]

func DropInt64Ptr 

func DropInt64Ptr(num *int64, list []*int64) []*int64

DropInt64Ptr returns a new list after dropping the given item

func DropInt8 

func DropInt8(num int8, list []int8) []int8

DropInt8 returns a new list after dropping the given item

Example: 

fp.DropInt8(1, []int8{1, 2, 3, 1}) // returns [2, 3]

func DropInt8Ptr 

func DropInt8Ptr(num *int8, list []*int8) []*int8

DropInt8Ptr returns a new list after dropping the given item

func DropIntPtr 

func DropIntPtr(num *int, list []*int) []*int

DropIntPtr returns a new list after dropping the given item

func DropInts 

func DropInts(nums []int, list []int) []int

DropInts returns a new list after dropping the given items

Example: 

fp.DropInts([]int{1, 4}, []int{1, 2, 3, 1, 4}) // returns [2, 3]

func DropInts16 

func DropInts16(nums []int16, list []int16) []int16

DropInts16 returns a new list after dropping the given items

Example: 

fp.DropInts16([]int16{1, 4}, []int16{1, 2, 3, 1, 4}) // returns [2, 3]

func DropInts16Ptr 

func DropInts16Ptr(nums []*int16, list []*int16) []*int16

DropInts16Ptr returns a new list after dropping the given items

func DropInts32 

func DropInts32(nums []int32, list []int32) []int32

DropInts32 returns a new list after dropping the given items

Example: 

fp.DropInts32([]int32{1, 4}, []int32{1, 2, 3, 1, 4}) // returns [2, 3]

func DropInts32Ptr 

func DropInts32Ptr(nums []*int32, list []*int32) []*int32

DropInts32Ptr returns a new list after dropping the given items

func DropInts64 

func DropInts64(nums []int64, list []int64) []int64

DropInts64 returns a new list after dropping the given items

Example: 

fp.DropInts64([]int64{1, 4}, []int64{1, 2, 3, 1, 4}) // returns [2, 3]

func DropInts64Ptr 

func DropInts64Ptr(nums []*int64, list []*int64) []*int64

DropInts64Ptr returns a new list after dropping the given items

func DropInts8 

func DropInts8(nums []int8, list []int8) []int8

DropInts8 returns a new list after dropping the given items

Example: 

fp.DropInts8([]int8{1, 4}, []int8{1, 2, 3, 1, 4}) // returns [2, 3]

func DropInts8Ptr 

func DropInts8Ptr(nums []*int8, list []*int8) []*int8

DropInts8Ptr returns a new list after dropping the given items

func DropIntsPtr 

func DropIntsPtr(nums []*int, list []*int) []*int

DropIntsPtr returns a new list after dropping the given items

func DropLastBool 

func DropLastBool(list []bool) []bool

DropLastBool drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastBoolPtr 

func DropLastBoolPtr(list []*bool) []*bool

DropLastBoolPtr drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastFloat32 

func DropLastFloat32(list []float32) []float32

DropLastFloat32 drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastFloat32Ptr 

func DropLastFloat32Ptr(list []*float32) []*float32

DropLastFloat32Ptr drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastFloat64 

func DropLastFloat64(list []float64) []float64

DropLastFloat64 drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastFloat64Ptr 

func DropLastFloat64Ptr(list []*float64) []*float64

DropLastFloat64Ptr drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastInt 

func DropLastInt(list []int) []int

DropLastInt drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastInt16 

func DropLastInt16(list []int16) []int16

DropLastInt16 drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastInt16Ptr 

func DropLastInt16Ptr(list []*int16) []*int16

DropLastInt16Ptr drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastInt32 

func DropLastInt32(list []int32) []int32

DropLastInt32 drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastInt32Ptr 

func DropLastInt32Ptr(list []*int32) []*int32

DropLastInt32Ptr drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastInt64 

func DropLastInt64(list []int64) []int64

DropLastInt64 drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastInt64Ptr 

func DropLastInt64Ptr(list []*int64) []*int64

DropLastInt64Ptr drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastInt8 

func DropLastInt8(list []int8) []int8

DropLastInt8 drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastInt8Ptr 

func DropLastInt8Ptr(list []*int8) []*int8

DropLastInt8Ptr drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastIntPtr 

func DropLastIntPtr(list []*int) []*int

DropLastIntPtr drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastStr 

func DropLastStr(list []string) []string

DropLastStr drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastStrPtr 

func DropLastStrPtr(list []*string) []*string

DropLastStrPtr drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastUint 

func DropLastUint(list []uint) []uint

DropLastUint drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastUint16 

func DropLastUint16(list []uint16) []uint16

DropLastUint16 drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastUint16Ptr 

func DropLastUint16Ptr(list []*uint16) []*uint16

DropLastUint16Ptr drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastUint32 

func DropLastUint32(list []uint32) []uint32

DropLastUint32 drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastUint32Ptr 

func DropLastUint32Ptr(list []*uint32) []*uint32

DropLastUint32Ptr drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastUint64 

func DropLastUint64(list []uint64) []uint64

DropLastUint64 drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastUint64Ptr 

func DropLastUint64Ptr(list []*uint64) []*uint64

DropLastUint64Ptr drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastUint8 

func DropLastUint8(list []uint8) []uint8

DropLastUint8 drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastUint8Ptr 

func DropLastUint8Ptr(list []*uint8) []*uint8

DropLastUint8Ptr drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropLastUintPtr 

func DropLastUintPtr(list []*uint) []*uint

DropLastUintPtr drops last item from the list and returns new list. Returns empty list if there is only one item in the list or list empty

func DropStr 

func DropStr(str string, list []string) []string

DropStr returns a new list after dropping the given item

Example: 

fp.DropStr("Ravan", []string{"Ravan", "Ram", "Shyam", "Ravan"} // returns ["Ram", "Shyam"]

func DropStrIgnoreCase 

func DropStrIgnoreCase(str string, list []string) []string

DropStrIgnoreCase returns a new list after dropping the given item. It ignores case.

Example: 

fp.DropStrIgnoreCase("ravan", []string{"Ravan", "Ram", "Shyam", "Ravan"} // returns ["Ram", "Shyam"]

func DropStrPtr 

func DropStrPtr(num *string, list []*string) []*string

DropStrPtr returns a new list after dropping the given item

func DropStrs 

func DropStrs(strs []string, list []string) []string

DropStrs returns a new list after dropping the given items

Example: 

fp.DropStrs([]string{"nks", "bharat"}, []string{"nks", "Ram", "Shyam", "Nks", "bharat"}) // returns ["Ram", "Shyam"]

func DropStrsIgnoreCase 

func DropStrsIgnoreCase(strs []string, list []string) []string

DropStrsIgnoreCase returns a new list after dropping the given items. It ignores the case.

Example: 

fp.DropStrs([]string{"nks", "bharat"}, []string{"Nks", "Ram", "Shyam", "Nks", "Bharat"}) // returns ["Ram", "Shyam"]

func DropStrsPtr 

func DropStrsPtr(nums []*string, list []*string) []*string

DropStrsPtr returns a new list after dropping the given items

func DropUint 

func DropUint(num uint, list []uint) []uint

DropUint returns a new list after dropping the given item

Example: 

fp.DropUint(1, []uint{1, 2, 3, 1}) // returns [2, 3]

func DropUint16 

func DropUint16(num uint16, list []uint16) []uint16

DropUint16 returns a new list after dropping the given item

Example: 

fp.DropUint16(1, []uint16{1, 2, 3, 1}) // returns [2, 3]

func DropUint16Ptr 

func DropUint16Ptr(num *uint16, list []*uint16) []*uint16

DropUint16Ptr returns a new list after dropping the given item

func DropUint32 

func DropUint32(num uint32, list []uint32) []uint32

DropUint32 returns a new list after dropping the given item

Example: 

fp.DropUint32(1, []uint32{1, 2, 3, 1}) // returns [2, 3]

func DropUint32Ptr 

func DropUint32Ptr(num *uint32, list []*uint32) []*uint32

DropUint32Ptr returns a new list after dropping the given item

func DropUint64 

func DropUint64(num uint64, list []uint64) []uint64

DropUint64 returns a new list after dropping the given item

Example: 

fp.DropUint64(1, []uint64{1, 2, 3, 1}) // returns [2, 3]

func DropUint64Ptr 

func DropUint64Ptr(num *uint64, list []*uint64) []*uint64

DropUint64Ptr returns a new list after dropping the given item

func DropUint64sPtr 

func DropUint64sPtr(nums []*uint64, list []*uint64) []*uint64

DropUint64sPtr returns a new list after dropping the given items

func DropUint8 

func DropUint8(num uint8, list []uint8) []uint8

DropUint8 returns a new list after dropping the given item

Example: 

fp.DropUint8(1, []uint8{1, 2, 3, 1}) // returns [2, 3]

func DropUint8Ptr 

func DropUint8Ptr(num *uint8, list []*uint8) []*uint8

DropUint8Ptr returns a new list after dropping the given item

func DropUintPtr 

func DropUintPtr(num *uint, list []*uint) []*uint

DropUintPtr returns a new list after dropping the given item

func DropUints 

func DropUints(nums []uint, list []uint) []uint

DropUints returns a new list after dropping the given items

Example: 

fp.DropUints([]uint{1, 4}, []uint{1, 2, 3, 1, 4}) // returns [2, 3]

func DropUints16 

func DropUints16(nums []uint16, list []uint16) []uint16

DropUints16 returns a new list after dropping the given items

Example: 

fp.DropUints16([]uint16{1, 4}, []uint16{1, 2, 3, 1, 4}) // returns [2, 3]

func DropUints16Ptr 

func DropUints16Ptr(nums []*uint16, list []*uint16) []*uint16

DropUints16Ptr returns a new list after dropping the given items

func DropUints32 

func DropUints32(nums []uint32, list []uint32) []uint32

DropUints32 returns a new list after dropping the given items

Example: 

fp.DropUints32([]uint32{1, 4}, []uint32{1, 2, 3, 1, 4}) // returns [2, 3]

func DropUints32Ptr 

func DropUints32Ptr(nums []*uint32, list []*uint32) []*uint32

DropUints32Ptr returns a new list after dropping the given items

func DropUints64 

func DropUints64(nums []uint64, list []uint64) []uint64

DropUints64 returns a new list after dropping the given items

Example: 

fp.DropUints64([]uint64{1, 4}, []uint64{1, 2, 3, 1, 4}) // returns [2, 3]

func DropUints8 

func DropUints8(nums []uint8, list []uint8) []uint8

DropUints8 returns a new list after dropping the given items

Example: 

fp.DropUints8([]uint8{1, 4}, []uint8{1, 2, 3, 1, 4}) // returns [2, 3]

func DropUints8Ptr 

func DropUints8Ptr(nums []*uint8, list []*uint8) []*uint8

DropUints8Ptr returns a new list after dropping the given items

func DropUintsPtr 

func DropUintsPtr(nums []*uint, list []*uint) []*uint

DropUintsPtr returns a new list after dropping the given items

func DropWhileBool 

func DropWhileBool(f func(bool) bool, list []bool) []bool

DropWhileBool drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

func DropWhileBoolErr 

func DropWhileBoolErr(f func(bool) (bool, error), list []bool) ([]bool, error)

DropWhileBoolErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileBoolPtr 

func DropWhileBoolPtr(f func(*bool) bool, list []*bool) []*bool

DropWhileBoolPtr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

func DropWhileBoolPtrErr 

func DropWhileBoolPtrErr(f func(*bool) (bool, error), list []*bool) ([]*bool, error)

DropWhileBoolPtrErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileFloat32 

func DropWhileFloat32(f func(float32) bool, list []float32) []float32

DropWhileFloat32 drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

Example: Drops positive numbers. Returns the remaining items once negative number is found in the list. 

fp. DropWhileFloat32(isPositive, []float32{4, 2, 3, -1, 4, 5}) // Returns [-1, 4, 5]

func isPositiveFloat64(num float32) bool {
	return num > 0
}

func DropWhileFloat32Err 

func DropWhileFloat32Err(f func(float32) (bool, error), list []float32) ([]float32, error)

DropWhileFloat32Err drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileFloat32Ptr 

func DropWhileFloat32Ptr(f func(*float32) bool, list []*float32) []*float32

DropWhileFloat32Ptr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

func DropWhileFloat32PtrErr 

func DropWhileFloat32PtrErr(f func(*float32) (bool, error), list []*float32) ([]*float32, error)

DropWhileFloat32PtrErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileFloat64 

func DropWhileFloat64(f func(float64) bool, list []float64) []float64

DropWhileFloat64 drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

Example: Drops positive numbers. Returns the remaining items once negative number is found in the list. 

fp. DropWhileFloat64(isPositive, []float64{4, 2, 3, -1, 4, 5}) // Returns [-1, 4, 5]

func isPositiveFloat64(num float64) bool {
	return num > 0
}

func DropWhileFloat64Err 

func DropWhileFloat64Err(f func(float64) (bool, error), list []float64) ([]float64, error)

DropWhileFloat64Err drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileFloat64Ptr 

func DropWhileFloat64Ptr(f func(*float64) bool, list []*float64) []*float64

DropWhileFloat64Ptr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

func DropWhileFloat64PtrErr 

func DropWhileFloat64PtrErr(f func(*float64) (bool, error), list []*float64) ([]*float64, error)

DropWhileFloat64PtrErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileInt 

func DropWhileInt(f func(int) bool, list []int) []int

DropWhileInt drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

Example: Drops even number. Returns the remaining items once odd number is found in the list. 

fp.DropWhileInt(isEven, []int{4, 2, 3, 4, 5}) // Returns [3, 4, 5]

func isEven(num int) bool {
	return num%2 == 0
}

func DropWhileInt16 

func DropWhileInt16(f func(int16) bool, list []int16) []int16

DropWhileInt16 drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

Example: Drops even number. Returns the remaining items once odd number is found in the list. 

fp.DropWhileInt16(isEven, []int16{4, 2, 3, 4, 5}) // Returns [3, 4, 5]

func isEven(num int16) bool {
	return num%2 == 0
}

func DropWhileInt16Err 

func DropWhileInt16Err(f func(int16) (bool, error), list []int16) ([]int16, error)

DropWhileInt16Err drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileInt16Ptr 

func DropWhileInt16Ptr(f func(*int16) bool, list []*int16) []*int16

DropWhileInt16Ptr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

func DropWhileInt16PtrErr 

func DropWhileInt16PtrErr(f func(*int16) (bool, error), list []*int16) ([]*int16, error)

DropWhileInt16PtrErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileInt32 

func DropWhileInt32(f func(int32) bool, list []int32) []int32

DropWhileInt32 drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

Example: Drops even number. Returns the remaining items once odd number is found in the list. 

fp.DropWhileInt32(isEven, []int32{4, 2, 3, 4, 5}) // Returns [3, 4, 5]

func isEven(num int32) bool {
	return num%2 == 0
}

func DropWhileInt32Err 

func DropWhileInt32Err(f func(int32) (bool, error), list []int32) ([]int32, error)

DropWhileInt32Err drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileInt32Ptr 

func DropWhileInt32Ptr(f func(*int32) bool, list []*int32) []*int32

DropWhileInt32Ptr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

func DropWhileInt32PtrErr 

func DropWhileInt32PtrErr(f func(*int32) (bool, error), list []*int32) ([]*int32, error)

DropWhileInt32PtrErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileInt64 

func DropWhileInt64(f func(int64) bool, list []int64) []int64

DropWhileInt64 drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

Example: Drops even number. Returns the remaining items once odd number is found in the list. 

fp.DropWhileInt64(isEven, []int64{4, 2, 3, 4, 5}) // Returns [3, 4, 5]

func isEven(num int64) bool {
	return num%2 == 0
}

func DropWhileInt64Err 

func DropWhileInt64Err(f func(int64) (bool, error), list []int64) ([]int64, error)

DropWhileInt64Err drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileInt64Ptr 

func DropWhileInt64Ptr(f func(*int64) bool, list []*int64) []*int64

DropWhileInt64Ptr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

func DropWhileInt64PtrErr 

func DropWhileInt64PtrErr(f func(*int64) (bool, error), list []*int64) ([]*int64, error)

DropWhileInt64PtrErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileInt8 

func DropWhileInt8(f func(int8) bool, list []int8) []int8

DropWhileInt8 drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

Example: Drops even number. Returns the remaining items once odd number is found in the list. 

fp.DropWhileInt8(isEven, []int8{4, 2, 3, 4, 5}) // Returns [3, 4, 5]

func isEven(num int8) bool {
	return num%2 == 0
}

func DropWhileInt8Err 

func DropWhileInt8Err(f func(int8) (bool, error), list []int8) ([]int8, error)

DropWhileInt8Err drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileInt8Ptr 

func DropWhileInt8Ptr(f func(*int8) bool, list []*int8) []*int8

DropWhileInt8Ptr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

func DropWhileInt8PtrErr 

func DropWhileInt8PtrErr(f func(*int8) (bool, error), list []*int8) ([]*int8, error)

DropWhileInt8PtrErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileIntErr 

func DropWhileIntErr(f func(int) (bool, error), list []int) ([]int, error)

DropWhileIntErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileIntPtr 

func DropWhileIntPtr(f func(*int) bool, list []*int) []*int

DropWhileIntPtr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

func DropWhileIntPtrErr 

func DropWhileIntPtrErr(f func(*int) (bool, error), list []*int) ([]*int, error)

DropWhileIntPtrErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileStr 

func DropWhileStr(f func(string) bool, list []string) []string

DropWhileStr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

Example: Drops names as long as it's length is <10. 

fp.DropWhileStr(
func(str string) bool {
	return len(str) < 10
},
[]string{"Ram", "Shyam", "Nandeshwar", "ShyamSundar", "Hari Shankar"}) // Returns ["Nandeshwar", "ShyamSundar", "Hari Shankar"]

func DropWhileStrErr 

func DropWhileStrErr(f func(string) (bool, error), list []string) ([]string, error)

DropWhileStrErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileStrPtr 

func DropWhileStrPtr(f func(*string) bool, list []*string) []*string

DropWhileStrPtr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

func DropWhileStrPtrErr 

func DropWhileStrPtrErr(f func(*string) (bool, error), list []*string) ([]*string, error)

DropWhileStrPtrErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileUint 

func DropWhileUint(f func(uint) bool, list []uint) []uint

DropWhileUint drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

Example: Drops even number. Returns the remaining items once odd number is found in the list. 

fp.DropWhileUint(isEven, []uint{4, 2, 3, 4, 5}) // Returns [3, 4, 5]

func isEven(num uint) bool {
	return num%2 == 0
}

func DropWhileUint16 

func DropWhileUint16(f func(uint16) bool, list []uint16) []uint16

DropWhileUint16 drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

Example: Drops even number. Returns the remaining items once odd number is found in the list. 

fp.DropWhileUint16(isEven, []uint16{4, 2, 3, 4, 5}) // Returns [3, 4, 5]

func isEven(num uint16) bool {
	return num%2 == 0
}

func DropWhileUint16Err 

func DropWhileUint16Err(f func(uint16) (bool, error), list []uint16) ([]uint16, error)

DropWhileUint16Err drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileUint16Ptr 

func DropWhileUint16Ptr(f func(*uint16) bool, list []*uint16) []*uint16

DropWhileUint16Ptr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

func DropWhileUint16PtrErr 

func DropWhileUint16PtrErr(f func(*uint16) (bool, error), list []*uint16) ([]*uint16, error)

DropWhileUint16PtrErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileUint32 

func DropWhileUint32(f func(uint32) bool, list []uint32) []uint32

DropWhileUint32 drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

Example: Drops even number. Returns the remaining items once odd number is found in the list. 

fp.DropWhileUint32(isEven, []uint32{4, 2, 3, 4, 5}) // Returns [3, 4, 5]

func isEven(num uint32) bool {
	return num%2 == 0
}

func DropWhileUint32Err 

func DropWhileUint32Err(f func(uint32) (bool, error), list []uint32) ([]uint32, error)

DropWhileUint32Err drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileUint32Ptr 

func DropWhileUint32Ptr(f func(*uint32) bool, list []*uint32) []*uint32

DropWhileUint32Ptr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

func DropWhileUint32PtrErr 

func DropWhileUint32PtrErr(f func(*uint32) (bool, error), list []*uint32) ([]*uint32, error)

DropWhileUint32PtrErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileUint64 

func DropWhileUint64(f func(uint64) bool, list []uint64) []uint64

DropWhileUint64 drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

Example: Drops even number. Returns the remaining items once odd number is found in the list. 

fp.DropWhileUint64(isEven, []uint64{4, 2, 3, 4, 5}) // Returns [3, 4, 5]

func isEven(num uint64) bool {
	return num%2 == 0
}

func DropWhileUint64Err 

func DropWhileUint64Err(f func(uint64) (bool, error), list []uint64) ([]uint64, error)

DropWhileUint64Err drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileUint64Ptr 

func DropWhileUint64Ptr(f func(*uint64) bool, list []*uint64) []*uint64

DropWhileUint64Ptr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

func DropWhileUint64PtrErr 

func DropWhileUint64PtrErr(f func(*uint64) (bool, error), list []*uint64) ([]*uint64, error)

DropWhileUint64PtrErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileUint8 

func DropWhileUint8(f func(uint8) bool, list []uint8) []uint8

DropWhileUint8 drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

Example: Drops even number. Returns the remaining items once odd number is found in the list. 

fp.DropWhileUint8(isEven, []uint8{4, 2, 3, 4, 5}) // Returns [3, 4, 5]

func isEven(num uint8) bool {
	return num%2 == 0
}

func DropWhileUint8Err 

func DropWhileUint8Err(f func(uint8) (bool, error), list []uint8) ([]uint8, error)

DropWhileUint8Err drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileUint8Ptr 

func DropWhileUint8Ptr(f func(*uint8) bool, list []*uint8) []*uint8

DropWhileUint8Ptr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

func DropWhileUint8PtrErr 

func DropWhileUint8PtrErr(f func(*uint8) (bool, error), list []*uint8) ([]*uint8, error)

DropWhileUint8PtrErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileUintErr 

func DropWhileUintErr(f func(uint) (bool, error), list []uint) ([]uint, error)

DropWhileUintErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func DropWhileUintPtr 

func DropWhileUintPtr(f func(*uint) bool, list []*uint) []*uint

DropWhileUintPtr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns boolean
  2. list

Returns: 

	New List.
 Empty list if either one of arguments or both of them are nil

func DropWhileUintPtrErr 

func DropWhileUintPtrErr(f func(*uint) (bool, error), list []*uint) ([]*uint, error)

DropWhileUintPtrErr drops the items from the list as long as condition satisfies.

Takes two inputs

  1. Function: takes one input and returns (boolean, error)
  2. list

Returns: 

	New List, error
 Empty list if either one of arguments or both of them are nil

func EqualBoolsP 

func EqualBoolsP(list1, list2 []bool) bool

EqualBoolsP Returns true if both list are equal else returns false

func EqualBoolsPPtr 

func EqualBoolsPPtr(list1, list2 []*bool) bool

EqualBoolsPPtr Returns true if both list are equal else returns false

func EqualFloat32sP 

func EqualFloat32sP(list1, list2 []float32) bool

EqualFloat32sP Returns true if both list are equal else returns false

func EqualFloat32sPPtr 

func EqualFloat32sPPtr(list1, list2 []*float32) bool

EqualFloat32sPPtr Returns true if both list are equal else returns false

func EqualFloat64sP 

func EqualFloat64sP(list1, list2 []float64) bool

EqualFloat64sP Returns true if both list are equal else returns false

func EqualFloat64sPPtr 

func EqualFloat64sPPtr(list1, list2 []*float64) bool

EqualFloat64sPPtr Returns true if both list are equal else returns false

func EqualInts16P 

func EqualInts16P(list1, list2 []int16) bool

EqualInts16P Returns true if both list are equal else returns false

func EqualInts16PPtr 

func EqualInts16PPtr(list1, list2 []*int16) bool

EqualInts16PPtr Returns true if both list are equal else returns false

func EqualInts32P 

func EqualInts32P(list1, list2 []int32) bool

EqualInts32P Returns true if both list are equal else returns false

func EqualInts32PPtr 

func EqualInts32PPtr(list1, list2 []*int32) bool

EqualInts32PPtr Returns true if both list are equal else returns false

func EqualInts64P 

func EqualInts64P(list1, list2 []int64) bool

EqualInts64P Returns true if both list are equal else returns false

func EqualInts64PPtr 

func EqualInts64PPtr(list1, list2 []*int64) bool

EqualInts64PPtr Returns true if both list are equal else returns false

func EqualInts8P 

func EqualInts8P(list1, list2 []int8) bool

EqualInts8P Returns true if both list are equal else returns false

func EqualInts8PPtr 

func EqualInts8PPtr(list1, list2 []*int8) bool

EqualInts8PPtr Returns true if both list are equal else returns false

func EqualIntsP 

func EqualIntsP(list1, list2 []int) bool

EqualIntsP Returns true if both list are equal else returns false

func EqualIntsPPtr 

func EqualIntsPPtr(list1, list2 []*int) bool

EqualIntsPPtr Returns true if both list are equal else returns false

func EqualMapBoolFloat32P 

func EqualMapBoolFloat32P(map1, map2 map[bool]float32) bool

EqualMapBoolFloat32P Returns true if both maps are equal else returns false

func EqualMapBoolFloat32PPtr 

func EqualMapBoolFloat32PPtr(map1, map2 map[*bool]*float32) bool

EqualMapBoolFloat32PPtr Returns true if both maps are equal else returns false

func EqualMapBoolFloat64P 

func EqualMapBoolFloat64P(map1, map2 map[bool]float64) bool

EqualMapBoolFloat64P Returns true if both maps are equal else returns false

func EqualMapBoolFloat64PPtr 

func EqualMapBoolFloat64PPtr(map1, map2 map[*bool]*float64) bool

EqualMapBoolFloat64PPtr Returns true if both maps are equal else returns false

func EqualMapBoolInt16P 

func EqualMapBoolInt16P(map1, map2 map[bool]int16) bool

EqualMapBoolInt16P Returns true if both maps are equal else returns false

func EqualMapBoolInt16PPtr 

func EqualMapBoolInt16PPtr(map1, map2 map[*bool]*int16) bool

EqualMapBoolInt16PPtr Returns true if both maps are equal else returns false

func EqualMapBoolInt32P 

func EqualMapBoolInt32P(map1, map2 map[bool]int32) bool

EqualMapBoolInt32P Returns true if both maps are equal else returns false

func EqualMapBoolInt32PPtr 

func EqualMapBoolInt32PPtr(map1, map2 map[*bool]*int32) bool

EqualMapBoolInt32PPtr Returns true if both maps are equal else returns false

func EqualMapBoolInt64P 

func EqualMapBoolInt64P(map1, map2 map[bool]int64) bool

EqualMapBoolInt64P Returns true if both maps are equal else returns false

func EqualMapBoolInt64PPtr 

func EqualMapBoolInt64PPtr(map1, map2 map[*bool]*int64) bool

EqualMapBoolInt64PPtr Returns true if both maps are equal else returns false

func EqualMapBoolInt8P 

func EqualMapBoolInt8P(map1, map2 map[bool]int8) bool

EqualMapBoolInt8P Returns true if both maps are equal else returns false

func EqualMapBoolInt8PPtr 

func EqualMapBoolInt8PPtr(map1, map2 map[*bool]*int8) bool

EqualMapBoolInt8PPtr Returns true if both maps are equal else returns false

func EqualMapBoolIntP 

func EqualMapBoolIntP(map1, map2 map[bool]int) bool

EqualMapBoolIntP Returns true if both maps are equal else returns false

func EqualMapBoolIntPPtr 

func EqualMapBoolIntPPtr(map1, map2 map[*bool]*int) bool

EqualMapBoolIntPPtr Returns true if both maps are equal else returns false

func EqualMapBoolP 

func EqualMapBoolP(map1, map2 map[bool]bool) bool

EqualMapBoolP Returns true if both maps are equal else returns false

func EqualMapBoolPPtr 

func EqualMapBoolPPtr(map1, map2 map[*bool]*bool) bool

EqualMapBoolPPtr Returns true if both maps are equal else returns false

func EqualMapBoolStrP 

func EqualMapBoolStrP(map1, map2 map[bool]string) bool

EqualMapBoolStrP Returns true if both maps are equal else returns false

func EqualMapBoolStrPPtr 

func EqualMapBoolStrPPtr(map1, map2 map[*bool]*string) bool

EqualMapBoolStrPPtr Returns true if both maps are equal else returns false

func EqualMapBoolUint16P 

func EqualMapBoolUint16P(map1, map2 map[bool]uint16) bool

EqualMapBoolUint16P Returns true if both maps are equal else returns false

func EqualMapBoolUint16PPtr 

func EqualMapBoolUint16PPtr(map1, map2 map[*bool]*uint16) bool

EqualMapBoolUint16PPtr Returns true if both maps are equal else returns false

func EqualMapBoolUint32P 

func EqualMapBoolUint32P(map1, map2 map[bool]uint32) bool

EqualMapBoolUint32P Returns true if both maps are equal else returns false

func EqualMapBoolUint32PPtr 

func EqualMapBoolUint32PPtr(map1, map2 map[*bool]*uint32) bool

EqualMapBoolUint32PPtr Returns true if both maps are equal else returns false

func EqualMapBoolUint64P 

func EqualMapBoolUint64P(map1, map2 map[bool]uint64) bool

EqualMapBoolUint64P Returns true if both maps are equal else returns false

func EqualMapBoolUint64PPtr 

func EqualMapBoolUint64PPtr(map1, map2 map[*bool]*uint64) bool

EqualMapBoolUint64PPtr Returns true if both maps are equal else returns false

func EqualMapBoolUint8P 

func EqualMapBoolUint8P(map1, map2 map[bool]uint8) bool

EqualMapBoolUint8P Returns true if both maps are equal else returns false

func EqualMapBoolUint8PPtr 

func EqualMapBoolUint8PPtr(map1, map2 map[*bool]*uint8) bool

EqualMapBoolUint8PPtr Returns true if both maps are equal else returns false

func EqualMapBoolUintP 

func EqualMapBoolUintP(map1, map2 map[bool]uint) bool

EqualMapBoolUintP Returns true if both maps are equal else returns false

func EqualMapBoolUintPPtr 

func EqualMapBoolUintPPtr(map1, map2 map[*bool]*uint) bool

EqualMapBoolUintPPtr Returns true if both maps are equal else returns false

func EqualMapFloat32BoolP 

func EqualMapFloat32BoolP(map1, map2 map[float32]bool) bool

EqualMapFloat32BoolP Returns true if both maps are equal else returns false

func EqualMapFloat32BoolPPtr 

func EqualMapFloat32BoolPPtr(map1, map2 map[*float32]*bool) bool

EqualMapFloat32BoolPPtr Returns true if both maps are equal else returns false

func EqualMapFloat32Float64P 

func EqualMapFloat32Float64P(map1, map2 map[float32]float64) bool

EqualMapFloat32Float64P Returns true if both maps are equal else returns false

func EqualMapFloat32Float64PPtr 

func EqualMapFloat32Float64PPtr(map1, map2 map[*float32]*float64) bool

EqualMapFloat32Float64PPtr Returns true if both maps are equal else returns false

func EqualMapFloat32Int16P 

func EqualMapFloat32Int16P(map1, map2 map[float32]int16) bool

EqualMapFloat32Int16P Returns true if both maps are equal else returns false

func EqualMapFloat32Int16PPtr 

func EqualMapFloat32Int16PPtr(map1, map2 map[*float32]*int16) bool

EqualMapFloat32Int16PPtr Returns true if both maps are equal else returns false

func EqualMapFloat32Int32P 

func EqualMapFloat32Int32P(map1, map2 map[float32]int32) bool

EqualMapFloat32Int32P Returns true if both maps are equal else returns false

func EqualMapFloat32Int32PPtr 

func EqualMapFloat32Int32PPtr(map1, map2 map[*float32]*int32) bool

EqualMapFloat32Int32PPtr Returns true if both maps are equal else returns false

func EqualMapFloat32Int64P 

func EqualMapFloat32Int64P(map1, map2 map[float32]int64) bool

EqualMapFloat32Int64P Returns true if both maps are equal else returns false

func EqualMapFloat32Int64PPtr 

func EqualMapFloat32Int64PPtr(map1, map2 map[*float32]*int64) bool

EqualMapFloat32Int64PPtr Returns true if both maps are equal else returns false

func EqualMapFloat32Int8P 

func EqualMapFloat32Int8P(map1, map2 map[float32]int8) bool

EqualMapFloat32Int8P Returns true if both maps are equal else returns false

func EqualMapFloat32Int8PPtr 

func EqualMapFloat32Int8PPtr(map1, map2 map[*float32]*int8) bool

EqualMapFloat32Int8PPtr Returns true if both maps are equal else returns false

func EqualMapFloat32IntP 

func EqualMapFloat32IntP(map1, map2 map[float32]int) bool

EqualMapFloat32IntP Returns true if both maps are equal else returns false

func EqualMapFloat32IntPPtr 

func EqualMapFloat32IntPPtr(map1, map2 map[*float32]*int) bool

EqualMapFloat32IntPPtr Returns true if both maps are equal else returns false

func EqualMapFloat32P 

func EqualMapFloat32P(map1, map2 map[float32]float32) bool

EqualMapFloat32P Returns true if both maps are equal else returns false

func EqualMapFloat32PPtr 

func EqualMapFloat32PPtr(map1, map2 map[*float32]*float32) bool

EqualMapFloat32PPtr Returns true if both maps are equal else returns false

func EqualMapFloat32StrP 

func EqualMapFloat32StrP(map1, map2 map[float32]string) bool

EqualMapFloat32StrP Returns true if both maps are equal else returns false

func EqualMapFloat32StrPPtr 

func EqualMapFloat32StrPPtr(map1, map2 map[*float32]*string) bool

EqualMapFloat32StrPPtr Returns true if both maps are equal else returns false

func EqualMapFloat32Uint16P 

func EqualMapFloat32Uint16P(map1, map2 map[float32]uint16) bool

EqualMapFloat32Uint16P Returns true if both maps are equal else returns false

func EqualMapFloat32Uint16PPtr 

func EqualMapFloat32Uint16PPtr(map1, map2 map[*float32]*uint16) bool

EqualMapFloat32Uint16PPtr Returns true if both maps are equal else returns false

func EqualMapFloat32Uint32P 

func EqualMapFloat32Uint32P(map1, map2 map[float32]uint32) bool

EqualMapFloat32Uint32P Returns true if both maps are equal else returns false

func EqualMapFloat32Uint32PPtr 

func EqualMapFloat32Uint32PPtr(map1, map2 map[*float32]*uint32) bool

EqualMapFloat32Uint32PPtr Returns true if both maps are equal else returns false

func EqualMapFloat32Uint64P 

func EqualMapFloat32Uint64P(map1, map2 map[float32]uint64) bool

EqualMapFloat32Uint64P Returns true if both maps are equal else returns false

func EqualMapFloat32Uint64PPtr 

func EqualMapFloat32Uint64PPtr(map1, map2 map[*float32]*uint64) bool

EqualMapFloat32Uint64PPtr Returns true if both maps are equal else returns false

func EqualMapFloat32Uint8P 

func EqualMapFloat32Uint8P(map1, map2 map[float32]uint8) bool

EqualMapFloat32Uint8P Returns true if both maps are equal else returns false

func EqualMapFloat32Uint8PPtr 

func EqualMapFloat32Uint8PPtr(map1, map2 map[*float32]*uint8) bool

EqualMapFloat32Uint8PPtr Returns true if both maps are equal else returns false

func EqualMapFloat32UintP 

func EqualMapFloat32UintP(map1, map2 map[float32]uint) bool

EqualMapFloat32UintP Returns true if both maps are equal else returns false

func EqualMapFloat32UintPPtr 

func EqualMapFloat32UintPPtr(map1, map2 map[*float32]*uint) bool

EqualMapFloat32UintPPtr Returns true if both maps are equal else returns false

func EqualMapFloat64BoolP 

func EqualMapFloat64BoolP(map1, map2 map[float64]bool) bool

EqualMapFloat64BoolP Returns true if both maps are equal else returns false

func EqualMapFloat64BoolPPtr 

func EqualMapFloat64BoolPPtr(map1, map2 map[*float64]*bool) bool

EqualMapFloat64BoolPPtr Returns true if both maps are equal else returns false

func EqualMapFloat64Float32P 

func EqualMapFloat64Float32P(map1, map2 map[float64]float32) bool

EqualMapFloat64Float32P Returns true if both maps are equal else returns false

func EqualMapFloat64Float32PPtr 

func EqualMapFloat64Float32PPtr(map1, map2 map[*float64]*float32) bool

EqualMapFloat64Float32PPtr Returns true if both maps are equal else returns false

func EqualMapFloat64Int16P 

func EqualMapFloat64Int16P(map1, map2 map[float64]int16) bool

EqualMapFloat64Int16P Returns true if both maps are equal else returns false

func EqualMapFloat64Int16PPtr 

func EqualMapFloat64Int16PPtr(map1, map2 map[*float64]*int16) bool

EqualMapFloat64Int16PPtr Returns true if both maps are equal else returns false

func EqualMapFloat64Int32P 

func EqualMapFloat64Int32P(map1, map2 map[float64]int32) bool

EqualMapFloat64Int32P Returns true if both maps are equal else returns false

func EqualMapFloat64Int32PPtr 

func EqualMapFloat64Int32PPtr(map1, map2 map[*float64]*int32) bool

EqualMapFloat64Int32PPtr Returns true if both maps are equal else returns false

func EqualMapFloat64Int64P 

func EqualMapFloat64Int64P(map1, map2 map[float64]int64) bool

EqualMapFloat64Int64P Returns true if both maps are equal else returns false

func EqualMapFloat64Int64PPtr 

func EqualMapFloat64Int64PPtr(map1, map2 map[*float64]*int64) bool

EqualMapFloat64Int64PPtr Returns true if both maps are equal else returns false

func EqualMapFloat64Int8P 

func EqualMapFloat64Int8P(map1, map2 map[float64]int8) bool

EqualMapFloat64Int8P Returns true if both maps are equal else returns false

func EqualMapFloat64Int8PPtr 

func EqualMapFloat64Int8PPtr(map1, map2 map[*float64]*int8) bool

EqualMapFloat64Int8PPtr Returns true if both maps are equal else returns false

func EqualMapFloat64IntP 

func EqualMapFloat64IntP(map1, map2 map[float64]int) bool

EqualMapFloat64IntP Returns true if both maps are equal else returns false

func EqualMapFloat64IntPPtr 

func EqualMapFloat64IntPPtr(map1, map2 map[*float64]*int) bool

EqualMapFloat64IntPPtr Returns true if both maps are equal else returns false

func EqualMapFloat64P 

func EqualMapFloat64P(map1, map2 map[float64]float64) bool

EqualMapFloat64P Returns true if both maps are equal else returns false

func EqualMapFloat64PPtr 

func EqualMapFloat64PPtr(map1, map2 map[*float64]*float64) bool

EqualMapFloat64PPtr Returns true if both maps are equal else returns false

func EqualMapFloat64StrP 

func EqualMapFloat64StrP(map1, map2 map[float64]string) bool

EqualMapFloat64StrP Returns true if both maps are equal else returns false

func EqualMapFloat64StrPPtr 

func EqualMapFloat64StrPPtr(map1, map2 map[*float64]*string) bool

EqualMapFloat64StrPPtr Returns true if both maps are equal else returns false

func EqualMapFloat64Uint16P 

func EqualMapFloat64Uint16P(map1, map2 map[float64]uint16) bool

EqualMapFloat64Uint16P Returns true if both maps are equal else returns false

func EqualMapFloat64Uint16PPtr 

func EqualMapFloat64Uint16PPtr(map1, map2 map[*float64]*uint16) bool

EqualMapFloat64Uint16PPtr Returns true if both maps are equal else returns false

func EqualMapFloat64Uint32P 

func EqualMapFloat64Uint32P(map1, map2 map[float64]uint32) bool

EqualMapFloat64Uint32P Returns true if both maps are equal else returns false

func EqualMapFloat64Uint32PPtr 

func EqualMapFloat64Uint32PPtr(map1, map2 map[*float64]*uint32) bool

EqualMapFloat64Uint32PPtr Returns true if both maps are equal else returns false

func EqualMapFloat64Uint64P 

func EqualMapFloat64Uint64P(map1, map2 map[float64]uint64) bool

EqualMapFloat64Uint64P Returns true if both maps are equal else returns false

func EqualMapFloat64Uint64PPtr 

func EqualMapFloat64Uint64PPtr(map1, map2 map[*float64]*uint64) bool

EqualMapFloat64Uint64PPtr Returns true if both maps are equal else returns false

func EqualMapFloat64Uint8P 

func EqualMapFloat64Uint8P(map1, map2 map[float64]uint8) bool

EqualMapFloat64Uint8P Returns true if both maps are equal else returns false

func EqualMapFloat64Uint8PPtr 

func EqualMapFloat64Uint8PPtr(map1, map2 map[*float64]*uint8) bool

EqualMapFloat64Uint8PPtr Returns true if both maps are equal else returns false

func EqualMapFloat64UintP 

func EqualMapFloat64UintP(map1, map2 map[float64]uint) bool

EqualMapFloat64UintP Returns true if both maps are equal else returns false

func EqualMapFloat64UintPPtr 

func EqualMapFloat64UintPPtr(map1, map2 map[*float64]*uint) bool

EqualMapFloat64UintPPtr Returns true if both maps are equal else returns false

func EqualMapInt16BoolP 

func EqualMapInt16BoolP(map1, map2 map[int16]bool) bool

EqualMapInt16BoolP Returns true if both maps are equal else returns false

func EqualMapInt16BoolPPtr 

func EqualMapInt16BoolPPtr(map1, map2 map[*int16]*bool) bool

EqualMapInt16BoolPPtr Returns true if both maps are equal else returns false

func EqualMapInt16Float32P 

func EqualMapInt16Float32P(map1, map2 map[int16]float32) bool

EqualMapInt16Float32P Returns true if both maps are equal else returns false

func EqualMapInt16Float32PPtr 

func EqualMapInt16Float32PPtr(map1, map2 map[*int16]*float32) bool

EqualMapInt16Float32PPtr Returns true if both maps are equal else returns false

func EqualMapInt16Float64P 

func EqualMapInt16Float64P(map1, map2 map[int16]float64) bool

EqualMapInt16Float64P Returns true if both maps are equal else returns false

func EqualMapInt16Float64PPtr 

func EqualMapInt16Float64PPtr(map1, map2 map[*int16]*float64) bool

EqualMapInt16Float64PPtr Returns true if both maps are equal else returns false

func EqualMapInt16Int32P 

func EqualMapInt16Int32P(map1, map2 map[int16]int32) bool

EqualMapInt16Int32P Returns true if both maps are equal else returns false

func EqualMapInt16Int32PPtr 

func EqualMapInt16Int32PPtr(map1, map2 map[*int16]*int32) bool

EqualMapInt16Int32PPtr Returns true if both maps are equal else returns false

func EqualMapInt16Int64P 

func EqualMapInt16Int64P(map1, map2 map[int16]int64) bool

EqualMapInt16Int64P Returns true if both maps are equal else returns false

func EqualMapInt16Int64PPtr 

func EqualMapInt16Int64PPtr(map1, map2 map[*int16]*int64) bool

EqualMapInt16Int64PPtr Returns true if both maps are equal else returns false

func EqualMapInt16Int8P 

func EqualMapInt16Int8P(map1, map2 map[int16]int8) bool

EqualMapInt16Int8P Returns true if both maps are equal else returns false

func EqualMapInt16Int8PPtr 

func EqualMapInt16Int8PPtr(map1, map2 map[*int16]*int8) bool

EqualMapInt16Int8PPtr Returns true if both maps are equal else returns false

func EqualMapInt16IntP 

func EqualMapInt16IntP(map1, map2 map[int16]int) bool

EqualMapInt16IntP Returns true if both maps are equal else returns false

func EqualMapInt16IntPPtr 

func EqualMapInt16IntPPtr(map1, map2 map[*int16]*int) bool

EqualMapInt16IntPPtr Returns true if both maps are equal else returns false

func EqualMapInt16P 

func EqualMapInt16P(map1, map2 map[int16]int16) bool

EqualMapInt16P Returns true if both maps are equal else returns false

func EqualMapInt16PPtr 

func EqualMapInt16PPtr(map1, map2 map[*int16]*int16) bool

EqualMapInt16PPtr Returns true if both maps are equal else returns false

func EqualMapInt16StrP 

func EqualMapInt16StrP(map1, map2 map[int16]string) bool

EqualMapInt16StrP Returns true if both maps are equal else returns false

func EqualMapInt16StrPPtr 

func EqualMapInt16StrPPtr(map1, map2 map[*int16]*string) bool

EqualMapInt16StrPPtr Returns true if both maps are equal else returns false

func EqualMapInt16Uint16P 

func EqualMapInt16Uint16P(map1, map2 map[int16]uint16) bool

EqualMapInt16Uint16P Returns true if both maps are equal else returns false

func EqualMapInt16Uint16PPtr 

func EqualMapInt16Uint16PPtr(map1, map2 map[*int16]*uint16) bool

EqualMapInt16Uint16PPtr Returns true if both maps are equal else returns false

func EqualMapInt16Uint32P 

func EqualMapInt16Uint32P(map1, map2 map[int16]uint32) bool

EqualMapInt16Uint32P Returns true if both maps are equal else returns false

func EqualMapInt16Uint32PPtr 

func EqualMapInt16Uint32PPtr(map1, map2 map[*int16]*uint32) bool

EqualMapInt16Uint32PPtr Returns true if both maps are equal else returns false

func EqualMapInt16Uint64P 

func EqualMapInt16Uint64P(map1, map2 map[int16]uint64) bool

EqualMapInt16Uint64P Returns true if both maps are equal else returns false

func EqualMapInt16Uint64PPtr 

func EqualMapInt16Uint64PPtr(map1, map2 map[*int16]*uint64) bool

EqualMapInt16Uint64PPtr Returns true if both maps are equal else returns false

func EqualMapInt16Uint8P 

func EqualMapInt16Uint8P(map1, map2 map[int16]uint8) bool

EqualMapInt16Uint8P Returns true if both maps are equal else returns false

func EqualMapInt16Uint8PPtr 

func EqualMapInt16Uint8PPtr(map1, map2 map[*int16]*uint8) bool

EqualMapInt16Uint8PPtr Returns true if both maps are equal else returns false

func EqualMapInt16UintP 

func EqualMapInt16UintP(map1, map2 map[int16]uint) bool

EqualMapInt16UintP Returns true if both maps are equal else returns false

func EqualMapInt16UintPPtr 

func EqualMapInt16UintPPtr(map1, map2 map[*int16]*uint) bool

EqualMapInt16UintPPtr Returns true if both maps are equal else returns false

func EqualMapInt32BoolP 

func EqualMapInt32BoolP(map1, map2 map[int32]bool) bool

EqualMapInt32BoolP Returns true if both maps are equal else returns false

func EqualMapInt32BoolPPtr 

func EqualMapInt32BoolPPtr(map1, map2 map[*int32]*bool) bool

EqualMapInt32BoolPPtr Returns true if both maps are equal else returns false

func EqualMapInt32Float32P 

func EqualMapInt32Float32P(map1, map2 map[int32]float32) bool

EqualMapInt32Float32P Returns true if both maps are equal else returns false

func EqualMapInt32Float32PPtr 

func EqualMapInt32Float32PPtr(map1, map2 map[*int32]*float32) bool

EqualMapInt32Float32PPtr Returns true if both maps are equal else returns false

func EqualMapInt32Float64P 

func EqualMapInt32Float64P(map1, map2 map[int32]float64) bool

EqualMapInt32Float64P Returns true if both maps are equal else returns false

func EqualMapInt32Float64PPtr 

func EqualMapInt32Float64PPtr(map1, map2 map[*int32]*float64) bool

EqualMapInt32Float64PPtr Returns true if both maps are equal else returns false

func EqualMapInt32Int16P 

func EqualMapInt32Int16P(map1, map2 map[int32]int16) bool

EqualMapInt32Int16P Returns true if both maps are equal else returns false

func EqualMapInt32Int16PPtr 

func EqualMapInt32Int16PPtr(map1, map2 map[*int32]*int16) bool

EqualMapInt32Int16PPtr Returns true if both maps are equal else returns false

func EqualMapInt32Int64P 

func EqualMapInt32Int64P(map1, map2 map[int32]int64) bool

EqualMapInt32Int64P Returns true if both maps are equal else returns false

func EqualMapInt32Int64PPtr 

func EqualMapInt32Int64PPtr(map1, map2 map[*int32]*int64) bool

EqualMapInt32Int64PPtr Returns true if both maps are equal else returns false

func EqualMapInt32Int8P 

func EqualMapInt32Int8P(map1, map2 map[int32]int8) bool

EqualMapInt32Int8P Returns true if both maps are equal else returns false

func EqualMapInt32Int8PPtr 

func EqualMapInt32Int8PPtr(map1, map2 map[*int32]*int8) bool

EqualMapInt32Int8PPtr Returns true if both maps are equal else returns false

func EqualMapInt32IntP 

func EqualMapInt32IntP(map1, map2 map[int32]int) bool

EqualMapInt32IntP Returns true if both maps are equal else returns false

func EqualMapInt32IntPPtr 

func EqualMapInt32IntPPtr(map1, map2 map[*int32]*int) bool

EqualMapInt32IntPPtr Returns true if both maps are equal else returns false

func EqualMapInt32P 

func EqualMapInt32P(map1, map2 map[int32]int32) bool

EqualMapInt32P Returns true if both maps are equal else returns false

func EqualMapInt32PPtr 

func EqualMapInt32PPtr(map1, map2 map[*int32]*int32) bool

EqualMapInt32PPtr Returns true if both maps are equal else returns false

func EqualMapInt32StrP 

func EqualMapInt32StrP(map1, map2 map[int32]string) bool

EqualMapInt32StrP Returns true if both maps are equal else returns false

func EqualMapInt32StrPPtr 

func EqualMapInt32StrPPtr(map1, map2 map[*int32]*string) bool

EqualMapInt32StrPPtr Returns true if both maps are equal else returns false

func EqualMapInt32Uint16P 

func EqualMapInt32Uint16P(map1, map2 map[int32]uint16) bool

EqualMapInt32Uint16P Returns true if both maps are equal else returns false

func EqualMapInt32Uint16PPtr 

func EqualMapInt32Uint16PPtr(map1, map2 map[*int32]*uint16) bool

EqualMapInt32Uint16PPtr Returns true if both maps are equal else returns false

func EqualMapInt32Uint32P 

func EqualMapInt32Uint32P(map1, map2 map[int32]uint32) bool

EqualMapInt32Uint32P Returns true if both maps are equal else returns false

func EqualMapInt32Uint32PPtr 

func EqualMapInt32Uint32PPtr(map1, map2 map[*int32]*uint32) bool

EqualMapInt32Uint32PPtr Returns true if both maps are equal else returns false

func EqualMapInt32Uint64P 

func EqualMapInt32Uint64P(map1, map2 map[int32]uint64) bool

EqualMapInt32Uint64P Returns true if both maps are equal else returns false

func EqualMapInt32Uint64PPtr 

func EqualMapInt32Uint64PPtr(map1, map2 map[*int32]*uint64) bool

EqualMapInt32Uint64PPtr Returns true if both maps are equal else returns false

func EqualMapInt32Uint8P 

func EqualMapInt32Uint8P(map1, map2 map[int32]uint8) bool

EqualMapInt32Uint8P Returns true if both maps are equal else returns false

func EqualMapInt32Uint8PPtr 

func EqualMapInt32Uint8PPtr(map1, map2 map[*int32]*uint8) bool

EqualMapInt32Uint8PPtr Returns true if both maps are equal else returns false

func EqualMapInt32UintP 

func EqualMapInt32UintP(map1, map2 map[int32]uint) bool

EqualMapInt32UintP Returns true if both maps are equal else returns false

func EqualMapInt32UintPPtr 

func EqualMapInt32UintPPtr(map1, map2 map[*int32]*uint) bool

EqualMapInt32UintPPtr Returns true if both maps are equal else returns false

func EqualMapInt64BoolP 

func EqualMapInt64BoolP(map1, map2 map[int64]bool) bool

EqualMapInt64BoolP Returns true if both maps are equal else returns false

func EqualMapInt64BoolPPtr 

func EqualMapInt64BoolPPtr(map1, map2 map[*int64]*bool) bool

EqualMapInt64BoolPPtr Returns true if both maps are equal else returns false

func EqualMapInt64Float32P 

func EqualMapInt64Float32P(map1, map2 map[int64]float32) bool

EqualMapInt64Float32P Returns true if both maps are equal else returns false

func EqualMapInt64Float32PPtr 

func EqualMapInt64Float32PPtr(map1, map2 map[*int64]*float32) bool

EqualMapInt64Float32PPtr Returns true if both maps are equal else returns false

func EqualMapInt64Float64P 

func EqualMapInt64Float64P(map1, map2 map[int64]float64) bool

EqualMapInt64Float64P Returns true if both maps are equal else returns false

func EqualMapInt64Float64PPtr 

func EqualMapInt64Float64PPtr(map1, map2 map[*int64]*float64) bool

EqualMapInt64Float64PPtr Returns true if both maps are equal else returns false

func EqualMapInt64Int16P 

func EqualMapInt64Int16P(map1, map2 map[int64]int16) bool

EqualMapInt64Int16P Returns true if both maps are equal else returns false

func EqualMapInt64Int16PPtr 

func EqualMapInt64Int16PPtr(map1, map2 map[*int64]*int16) bool

EqualMapInt64Int16PPtr Returns true if both maps are equal else returns false

func EqualMapInt64Int32P 

func EqualMapInt64Int32P(map1, map2 map[int64]int32) bool

EqualMapInt64Int32P Returns true if both maps are equal else returns false

func EqualMapInt64Int32PPtr 

func EqualMapInt64Int32PPtr(map1, map2 map[*int64]*int32) bool

EqualMapInt64Int32PPtr Returns true if both maps are equal else returns false

func EqualMapInt64Int8P 

func EqualMapInt64Int8P(map1, map2 map[int64]int8) bool

EqualMapInt64Int8P Returns true if both maps are equal else returns false

func EqualMapInt64Int8PPtr 

func EqualMapInt64Int8PPtr(map1, map2 map[*int64]*int8) bool

EqualMapInt64Int8PPtr Returns true if both maps are equal else returns false

func EqualMapInt64IntP 

func EqualMapInt64IntP(map1, map2 map[int64]int) bool

EqualMapInt64IntP Returns true if both maps are equal else returns false

func EqualMapInt64IntPPtr 

func EqualMapInt64IntPPtr(map1, map2 map[*int64]*int) bool

EqualMapInt64IntPPtr Returns true if both maps are equal else returns false

func EqualMapInt64P 

func EqualMapInt64P(map1, map2 map[int64]int64) bool

EqualMapInt64P Returns true if both maps are equal else returns false

func EqualMapInt64PPtr 

func EqualMapInt64PPtr(map1, map2 map[*int64]*int64) bool

EqualMapInt64PPtr Returns true if both maps are equal else returns false

func EqualMapInt64StrP 

func EqualMapInt64StrP(map1, map2 map[int64]string) bool

EqualMapInt64StrP Returns true if both maps are equal else returns false

func EqualMapInt64StrPPtr 

func EqualMapInt64StrPPtr(map1, map2 map[*int64]*string) bool

EqualMapInt64StrPPtr Returns true if both maps are equal else returns false

func EqualMapInt64Uint16P 

func EqualMapInt64Uint16P(map1, map2 map[int64]uint16) bool

EqualMapInt64Uint16P Returns true if both maps are equal else returns false

func EqualMapInt64Uint16PPtr 

func EqualMapInt64Uint16PPtr(map1, map2 map[*int64]*uint16) bool

EqualMapInt64Uint16PPtr Returns true if both maps are equal else returns false

func EqualMapInt64Uint32P 

func EqualMapInt64Uint32P(map1, map2 map[int64]uint32) bool

EqualMapInt64Uint32P Returns true if both maps are equal else returns false

func EqualMapInt64Uint32PPtr 

func EqualMapInt64Uint32PPtr(map1, map2 map[*int64]*uint32) bool

EqualMapInt64Uint32PPtr Returns true if both maps are equal else returns false

func EqualMapInt64Uint64P 

func EqualMapInt64Uint64P(map1, map2 map[int64]uint64) bool

EqualMapInt64Uint64P Returns true if both maps are equal else returns false

func EqualMapInt64Uint64PPtr 

func EqualMapInt64Uint64PPtr(map1, map2 map[*int64]*uint64) bool

EqualMapInt64Uint64PPtr Returns true if both maps are equal else returns false

func EqualMapInt64Uint8P 

func EqualMapInt64Uint8P(map1, map2 map[int64]uint8) bool

EqualMapInt64Uint8P Returns true if both maps are equal else returns false

func EqualMapInt64Uint8PPtr 

func EqualMapInt64Uint8PPtr(map1, map2 map[*int64]*uint8) bool

EqualMapInt64Uint8PPtr Returns true if both maps are equal else returns false

func EqualMapInt64UintP 

func EqualMapInt64UintP(map1, map2 map[int64]uint) bool

EqualMapInt64UintP Returns true if both maps are equal else returns false

func EqualMapInt64UintPPtr 

func EqualMapInt64UintPPtr(map1, map2 map[*int64]*uint) bool

EqualMapInt64UintPPtr Returns true if both maps are equal else returns false

func EqualMapInt8BoolP 

func EqualMapInt8BoolP(map1, map2 map[int8]bool) bool

EqualMapInt8BoolP Returns true if both maps are equal else returns false

func EqualMapInt8BoolPPtr 

func EqualMapInt8BoolPPtr(map1, map2 map[*int8]*bool) bool

EqualMapInt8BoolPPtr Returns true if both maps are equal else returns false

func EqualMapInt8Float32P 

func EqualMapInt8Float32P(map1, map2 map[int8]float32) bool

EqualMapInt8Float32P Returns true if both maps are equal else returns false

func EqualMapInt8Float32PPtr 

func EqualMapInt8Float32PPtr(map1, map2 map[*int8]*float32) bool

EqualMapInt8Float32PPtr Returns true if both maps are equal else returns false

func EqualMapInt8Float64P 

func EqualMapInt8Float64P(map1, map2 map[int8]float64) bool

EqualMapInt8Float64P Returns true if both maps are equal else returns false

func EqualMapInt8Float64PPtr 

func EqualMapInt8Float64PPtr(map1, map2 map[*int8]*float64) bool

EqualMapInt8Float64PPtr Returns true if both maps are equal else returns false

func EqualMapInt8Int16P 

func EqualMapInt8Int16P(map1, map2 map[int8]int16) bool

EqualMapInt8Int16P Returns true if both maps are equal else returns false

func EqualMapInt8Int16PPtr 

func EqualMapInt8Int16PPtr(map1, map2 map[*int8]*int16) bool

EqualMapInt8Int16PPtr Returns true if both maps are equal else returns false

func EqualMapInt8Int32P 

func EqualMapInt8Int32P(map1, map2 map[int8]int32) bool

EqualMapInt8Int32P Returns true if both maps are equal else returns false

func EqualMapInt8Int32PPtr 

func EqualMapInt8Int32PPtr(map1, map2 map[*int8]*int32) bool

EqualMapInt8Int32PPtr Returns true if both maps are equal else returns false

func EqualMapInt8Int64P 

func EqualMapInt8Int64P(map1, map2 map[int8]int64) bool

EqualMapInt8Int64P Returns true if both maps are equal else returns false

func EqualMapInt8Int64PPtr 

func EqualMapInt8Int64PPtr(map1, map2 map[*int8]*int64) bool

EqualMapInt8Int64PPtr Returns true if both maps are equal else returns false

func EqualMapInt8IntP 

func EqualMapInt8IntP(map1, map2 map[int8]int) bool

EqualMapInt8IntP Returns true if both maps are equal else returns false

func EqualMapInt8IntPPtr 

func EqualMapInt8IntPPtr(map1, map2 map[*int8]*int) bool

EqualMapInt8IntPPtr Returns true if both maps are equal else returns false

func EqualMapInt8P 

func EqualMapInt8P(map1, map2 map[int8]int8) bool

EqualMapInt8P Returns true if both maps are equal else returns false

func EqualMapInt8PPtr 

func EqualMapInt8PPtr(map1, map2 map[*int8]*int8) bool

EqualMapInt8PPtr Returns true if both maps are equal else returns false

func EqualMapInt8StrP 

func EqualMapInt8StrP(map1, map2 map[int8]string) bool

EqualMapInt8StrP Returns true if both maps are equal else returns false

func EqualMapInt8StrPPtr 

func EqualMapInt8StrPPtr(map1, map2 map[*int8]*string) bool

EqualMapInt8StrPPtr Returns true if both maps are equal else returns false

func EqualMapInt8Uint16P 

func EqualMapInt8Uint16P(map1, map2 map[int8]uint16) bool

EqualMapInt8Uint16P Returns true if both maps are equal else returns false

func EqualMapInt8Uint16PPtr 

func EqualMapInt8Uint16PPtr(map1, map2 map[*int8]*uint16) bool

EqualMapInt8Uint16PPtr Returns true if both maps are equal else returns false

func EqualMapInt8Uint32P 

func EqualMapInt8Uint32P(map1, map2 map[int8]uint32) bool

EqualMapInt8Uint32P Returns true if both maps are equal else returns false

func EqualMapInt8Uint32PPtr 

func EqualMapInt8Uint32PPtr(map1, map2 map[*int8]*uint32) bool

EqualMapInt8Uint32PPtr Returns true if both maps are equal else returns false

func EqualMapInt8Uint64P 

func EqualMapInt8Uint64P(map1, map2 map[int8]uint64) bool

EqualMapInt8Uint64P Returns true if both maps are equal else returns false

func EqualMapInt8Uint64PPtr 

func EqualMapInt8Uint64PPtr(map1, map2 map[*int8]*uint64) bool

EqualMapInt8Uint64PPtr Returns true if both maps are equal else returns false

func EqualMapInt8Uint8P 

func EqualMapInt8Uint8P(map1, map2 map[int8]uint8) bool

EqualMapInt8Uint8P Returns true if both maps are equal else returns false

func EqualMapInt8Uint8PPtr 

func EqualMapInt8Uint8PPtr(map1, map2 map[*int8]*uint8) bool

EqualMapInt8Uint8PPtr Returns true if both maps are equal else returns false

func EqualMapInt8UintP 

func EqualMapInt8UintP(map1, map2 map[int8]uint) bool

EqualMapInt8UintP Returns true if both maps are equal else returns false

func EqualMapInt8UintPPtr 

func EqualMapInt8UintPPtr(map1, map2 map[*int8]*uint) bool

EqualMapInt8UintPPtr Returns true if both maps are equal else returns false

func EqualMapIntBoolP 

func EqualMapIntBoolP(map1, map2 map[int]bool) bool

EqualMapIntBoolP Returns true if both maps are equal else returns false

func EqualMapIntBoolPPtr 

func EqualMapIntBoolPPtr(map1, map2 map[*int]*bool) bool

EqualMapIntBoolPPtr Returns true if both maps are equal else returns false

func EqualMapIntFloat32P 

func EqualMapIntFloat32P(map1, map2 map[int]float32) bool

EqualMapIntFloat32P Returns true if both maps are equal else returns false

func EqualMapIntFloat32PPtr 

func EqualMapIntFloat32PPtr(map1, map2 map[*int]*float32) bool

EqualMapIntFloat32PPtr Returns true if both maps are equal else returns false

func EqualMapIntFloat64P 

func EqualMapIntFloat64P(map1, map2 map[int]float64) bool

EqualMapIntFloat64P Returns true if both maps are equal else returns false

func EqualMapIntFloat64PPtr 

func EqualMapIntFloat64PPtr(map1, map2 map[*int]*float64) bool

EqualMapIntFloat64PPtr Returns true if both maps are equal else returns false

func EqualMapIntInt16P 

func EqualMapIntInt16P(map1, map2 map[int]int16) bool

EqualMapIntInt16P Returns true if both maps are equal else returns false

func EqualMapIntInt16PPtr 

func EqualMapIntInt16PPtr(map1, map2 map[*int]*int16) bool

EqualMapIntInt16PPtr Returns true if both maps are equal else returns false

func EqualMapIntInt32P 

func EqualMapIntInt32P(map1, map2 map[int]int32) bool

EqualMapIntInt32P Returns true if both maps are equal else returns false

func EqualMapIntInt32PPtr 

func EqualMapIntInt32PPtr(map1, map2 map[*int]*int32) bool

EqualMapIntInt32PPtr Returns true if both maps are equal else returns false

func EqualMapIntInt64P 

func EqualMapIntInt64P(map1, map2 map[int]int64) bool

EqualMapIntInt64P Returns true if both maps are equal else returns false

func EqualMapIntInt64PPtr 

func EqualMapIntInt64PPtr(map1, map2 map[*int]*int64) bool

EqualMapIntInt64PPtr Returns true if both maps are equal else returns false

func EqualMapIntInt8P 

func EqualMapIntInt8P(map1, map2 map[int]int8) bool

EqualMapIntInt8P Returns true if both maps are equal else returns false

func EqualMapIntInt8PPtr 

func EqualMapIntInt8PPtr(map1, map2 map[*int]*int8) bool

EqualMapIntInt8PPtr Returns true if both maps are equal else returns false

func EqualMapIntP 

func EqualMapIntP(map1, map2 map[int]int) bool

EqualMapIntP Returns true if both maps are equal else returns false

func EqualMapIntPPtr 

func EqualMapIntPPtr(map1, map2 map[*int]*int) bool

EqualMapIntPPtr Returns true if both maps are equal else returns false

func EqualMapIntStrP 

func EqualMapIntStrP(map1, map2 map[int]string) bool

EqualMapIntStrP Returns true if both maps are equal else returns false

func EqualMapIntStrPPtr 

func EqualMapIntStrPPtr(map1, map2 map[*int]*string) bool

EqualMapIntStrPPtr Returns true if both maps are equal else returns false

func EqualMapIntUint16P 

func EqualMapIntUint16P(map1, map2 map[int]uint16) bool

EqualMapIntUint16P Returns true if both maps are equal else returns false

func EqualMapIntUint16PPtr 

func EqualMapIntUint16PPtr(map1, map2 map[*int]*uint16) bool

EqualMapIntUint16PPtr Returns true if both maps are equal else returns false

func EqualMapIntUint32P 

func EqualMapIntUint32P(map1, map2 map[int]uint32) bool

EqualMapIntUint32P Returns true if both maps are equal else returns false

func EqualMapIntUint32PPtr 

func EqualMapIntUint32PPtr(map1, map2 map[*int]*uint32) bool

EqualMapIntUint32PPtr Returns true if both maps are equal else returns false

func EqualMapIntUint64P 

func EqualMapIntUint64P(map1, map2 map[int]uint64) bool

EqualMapIntUint64P Returns true if both maps are equal else returns false

func EqualMapIntUint64PPtr 

func EqualMapIntUint64PPtr(map1, map2 map[*int]*uint64) bool

EqualMapIntUint64PPtr Returns true if both maps are equal else returns false

func EqualMapIntUint8P 

func EqualMapIntUint8P(map1, map2 map[int]uint8) bool

EqualMapIntUint8P Returns true if both maps are equal else returns false

func EqualMapIntUint8PPtr 

func EqualMapIntUint8PPtr(map1, map2 map[*int]*uint8) bool

EqualMapIntUint8PPtr Returns true if both maps are equal else returns false

func EqualMapIntUintP 

func EqualMapIntUintP(map1, map2 map[int]uint) bool

EqualMapIntUintP Returns true if both maps are equal else returns false

func EqualMapIntUintPPtr 

func EqualMapIntUintPPtr(map1, map2 map[*int]*uint) bool

EqualMapIntUintPPtr Returns true if both maps are equal else returns false

func EqualMapStrBoolP 

func EqualMapStrBoolP(map1, map2 map[string]bool) bool

EqualMapStrBoolP Returns true if both maps are equal else returns false

func EqualMapStrBoolPPtr 

func EqualMapStrBoolPPtr(map1, map2 map[*string]*bool) bool

EqualMapStrBoolPPtr Returns true if both maps are equal else returns false

func EqualMapStrFloat32P 

func EqualMapStrFloat32P(map1, map2 map[string]float32) bool

EqualMapStrFloat32P Returns true if both maps are equal else returns false

func EqualMapStrFloat32PPtr 

func EqualMapStrFloat32PPtr(map1, map2 map[*string]*float32) bool

EqualMapStrFloat32PPtr Returns true if both maps are equal else returns false

func EqualMapStrFloat64P 

func EqualMapStrFloat64P(map1, map2 map[string]float64) bool

EqualMapStrFloat64P Returns true if both maps are equal else returns false

func EqualMapStrFloat64PPtr 

func EqualMapStrFloat64PPtr(map1, map2 map[*string]*float64) bool

EqualMapStrFloat64PPtr Returns true if both maps are equal else returns false

func EqualMapStrInt16P 

func EqualMapStrInt16P(map1, map2 map[string]int16) bool

EqualMapStrInt16P Returns true if both maps are equal else returns false

func EqualMapStrInt16PPtr 

func EqualMapStrInt16PPtr(map1, map2 map[*string]*int16) bool

EqualMapStrInt16PPtr Returns true if both maps are equal else returns false

func EqualMapStrInt32P 

func EqualMapStrInt32P(map1, map2 map[string]int32) bool

EqualMapStrInt32P Returns true if both maps are equal else returns false

func EqualMapStrInt32PPtr 

func EqualMapStrInt32PPtr(map1, map2 map[*string]*int32) bool

EqualMapStrInt32PPtr Returns true if both maps are equal else returns false

func EqualMapStrInt64P 

func EqualMapStrInt64P(map1, map2 map[string]int64) bool

EqualMapStrInt64P Returns true if both maps are equal else returns false

func EqualMapStrInt64PPtr 

func EqualMapStrInt64PPtr(map1, map2 map[*string]*int64) bool

EqualMapStrInt64PPtr Returns true if both maps are equal else returns false

func EqualMapStrInt8P 

func EqualMapStrInt8P(map1, map2 map[string]int8) bool

EqualMapStrInt8P Returns true if both maps are equal else returns false

func EqualMapStrInt8PPtr 

func EqualMapStrInt8PPtr(map1, map2 map[*string]*int8) bool

EqualMapStrInt8PPtr Returns true if both maps are equal else returns false

func EqualMapStrIntP 

func EqualMapStrIntP(map1, map2 map[string]int) bool

EqualMapStrIntP Returns true if both maps are equal else returns false

func EqualMapStrIntPPtr 

func EqualMapStrIntPPtr(map1, map2 map[*string]*int) bool

EqualMapStrIntPPtr Returns true if both maps are equal else returns false

func EqualMapStrP 

func EqualMapStrP(map1, map2 map[string]string) bool

EqualMapStrP Returns true if both maps are equal else returns false

func EqualMapStrPPtr 

func EqualMapStrPPtr(map1, map2 map[*string]*string) bool

EqualMapStrPPtr Returns true if both maps are equal else returns false

func EqualMapStrUint16P 

func EqualMapStrUint16P(map1, map2 map[string]uint16) bool

EqualMapStrUint16P Returns true if both maps are equal else returns false

func EqualMapStrUint16PPtr 

func EqualMapStrUint16PPtr(map1, map2 map[*string]*uint16) bool

EqualMapStrUint16PPtr Returns true if both maps are equal else returns false

func EqualMapStrUint32P 

func EqualMapStrUint32P(map1, map2 map[string]uint32) bool

EqualMapStrUint32P Returns true if both maps are equal else returns false

func EqualMapStrUint32PPtr 

func EqualMapStrUint32PPtr(map1, map2 map[*string]*uint32) bool

EqualMapStrUint32PPtr Returns true if both maps are equal else returns false

func EqualMapStrUint64P 

func EqualMapStrUint64P(map1, map2 map[string]uint64) bool

EqualMapStrUint64P Returns true if both maps are equal else returns false

func EqualMapStrUint64PPtr 

func EqualMapStrUint64PPtr(map1, map2 map[*string]*uint64) bool

EqualMapStrUint64PPtr Returns true if both maps are equal else returns false

func EqualMapStrUint8P 

func EqualMapStrUint8P(map1, map2 map[string]uint8) bool

EqualMapStrUint8P Returns true if both maps are equal else returns false

func EqualMapStrUint8PPtr 

func EqualMapStrUint8PPtr(map1, map2 map[*string]*uint8) bool

EqualMapStrUint8PPtr Returns true if both maps are equal else returns false

func EqualMapStrUintP 

func EqualMapStrUintP(map1, map2 map[string]uint) bool

EqualMapStrUintP Returns true if both maps are equal else returns false

func EqualMapStrUintPPtr 

func EqualMapStrUintPPtr(map1, map2 map[*string]*uint) bool

EqualMapStrUintPPtr Returns true if both maps are equal else returns false

func EqualMapUint16BoolP 

func EqualMapUint16BoolP(map1, map2 map[uint16]bool) bool

EqualMapUint16BoolP Returns true if both maps are equal else returns false

func EqualMapUint16BoolPPtr 

func EqualMapUint16BoolPPtr(map1, map2 map[*uint16]*bool) bool

EqualMapUint16BoolPPtr Returns true if both maps are equal else returns false

func EqualMapUint16Float32P 

func EqualMapUint16Float32P(map1, map2 map[uint16]float32) bool

EqualMapUint16Float32P Returns true if both maps are equal else returns false

func EqualMapUint16Float32PPtr 

func EqualMapUint16Float32PPtr(map1, map2 map[*uint16]*float32) bool

EqualMapUint16Float32PPtr Returns true if both maps are equal else returns false

func EqualMapUint16Float64P 

func EqualMapUint16Float64P(map1, map2 map[uint16]float64) bool

EqualMapUint16Float64P Returns true if both maps are equal else returns false

func EqualMapUint16Float64PPtr 

func EqualMapUint16Float64PPtr(map1, map2 map[*uint16]*float64) bool

EqualMapUint16Float64PPtr Returns true if both maps are equal else returns false

func EqualMapUint16Int16P 

func EqualMapUint16Int16P(map1, map2 map[uint16]int16) bool

EqualMapUint16Int16P Returns true if both maps are equal else returns false

func EqualMapUint16Int16PPtr 

func EqualMapUint16Int16PPtr(map1, map2 map[*uint16]*int16) bool

EqualMapUint16Int16PPtr Returns true if both maps are equal else returns false

func EqualMapUint16Int32P 

func EqualMapUint16Int32P(map1, map2 map[uint16]int32) bool

EqualMapUint16Int32P Returns true if both maps are equal else returns false

func EqualMapUint16Int32PPtr 

func EqualMapUint16Int32PPtr(map1, map2 map[*uint16]*int32) bool

EqualMapUint16Int32PPtr Returns true if both maps are equal else returns false

func EqualMapUint16Int64P 

func EqualMapUint16Int64P(map1, map2 map[uint16]int64) bool

EqualMapUint16Int64P Returns true if both maps are equal else returns false

func EqualMapUint16Int64PPtr 

func EqualMapUint16Int64PPtr(map1, map2 map[*uint16]*int64) bool

EqualMapUint16Int64PPtr Returns true if both maps are equal else returns false

func EqualMapUint16Int8P 

func EqualMapUint16Int8P(map1, map2 map[uint16]int8) bool

EqualMapUint16Int8P Returns true if both maps are equal else returns false

func EqualMapUint16Int8PPtr 

func EqualMapUint16Int8PPtr(map1, map2 map[*uint16]*int8) bool

EqualMapUint16Int8PPtr Returns true if both maps are equal else returns false

func EqualMapUint16IntP 

func EqualMapUint16IntP(map1, map2 map[uint16]int) bool

EqualMapUint16IntP Returns true if both maps are equal else returns false

func EqualMapUint16IntPPtr 

func EqualMapUint16IntPPtr(map1, map2 map[*uint16]*int) bool

EqualMapUint16IntPPtr Returns true if both maps are equal else returns false

func EqualMapUint16P 

func EqualMapUint16P(map1, map2 map[uint16]uint16) bool

EqualMapUint16P Returns true if both maps are equal else returns false

func EqualMapUint16PPtr 

func EqualMapUint16PPtr(map1, map2 map[*uint16]*uint16) bool

EqualMapUint16PPtr Returns true if both maps are equal else returns false

func EqualMapUint16StrP 

func EqualMapUint16StrP(map1, map2 map[uint16]string) bool

EqualMapUint16StrP Returns true if both maps are equal else returns false

func EqualMapUint16StrPPtr 

func EqualMapUint16StrPPtr(map1, map2 map[*uint16]*string) bool

EqualMapUint16StrPPtr Returns true if both maps are equal else returns false

func EqualMapUint16Uint32P 

func EqualMapUint16Uint32P(map1, map2 map[uint16]uint32) bool

EqualMapUint16Uint32P Returns true if both maps are equal else returns false

func EqualMapUint16Uint32PPtr 

func EqualMapUint16Uint32PPtr(map1, map2 map[*uint16]*uint32) bool

EqualMapUint16Uint32PPtr Returns true if both maps are equal else returns false

func EqualMapUint16Uint64P 

func EqualMapUint16Uint64P(map1, map2 map[uint16]uint64) bool

EqualMapUint16Uint64P Returns true if both maps are equal else returns false

func EqualMapUint16Uint64PPtr 

func EqualMapUint16Uint64PPtr(map1, map2 map[*uint16]*uint64) bool

EqualMapUint16Uint64PPtr Returns true if both maps are equal else returns false

func EqualMapUint16Uint8P 

func EqualMapUint16Uint8P(map1, map2 map[uint16]uint8) bool

EqualMapUint16Uint8P Returns true if both maps are equal else returns false

func EqualMapUint16Uint8PPtr 

func EqualMapUint16Uint8PPtr(map1, map2 map[*uint16]*uint8) bool

EqualMapUint16Uint8PPtr Returns true if both maps are equal else returns false

func EqualMapUint16UintP 

func EqualMapUint16UintP(map1, map2 map[uint16]uint) bool

EqualMapUint16UintP Returns true if both maps are equal else returns false

func EqualMapUint16UintPPtr 

func EqualMapUint16UintPPtr(map1, map2 map[*uint16]*uint) bool

EqualMapUint16UintPPtr Returns true if both maps are equal else returns false

func EqualMapUint32BoolP 

func EqualMapUint32BoolP(map1, map2 map[uint32]bool) bool

EqualMapUint32BoolP Returns true if both maps are equal else returns false

func EqualMapUint32BoolPPtr 

func EqualMapUint32BoolPPtr(map1, map2 map[*uint32]*bool) bool

EqualMapUint32BoolPPtr Returns true if both maps are equal else returns false

func EqualMapUint32Float32P 

func EqualMapUint32Float32P(map1, map2 map[uint32]float32) bool

EqualMapUint32Float32P Returns true if both maps are equal else returns false

func EqualMapUint32Float32PPtr 

func EqualMapUint32Float32PPtr(map1, map2 map[*uint32]*float32) bool

EqualMapUint32Float32PPtr Returns true if both maps are equal else returns false

func EqualMapUint32Float64P 

func EqualMapUint32Float64P(map1, map2 map[uint32]float64) bool

EqualMapUint32Float64P Returns true if both maps are equal else returns false

func EqualMapUint32Float64PPtr 

func EqualMapUint32Float64PPtr(map1, map2 map[*uint32]*float64) bool

EqualMapUint32Float64PPtr Returns true if both maps are equal else returns false

func EqualMapUint32Int16P 

func EqualMapUint32Int16P(map1, map2 map[uint32]int16) bool

EqualMapUint32Int16P Returns true if both maps are equal else returns false

func EqualMapUint32Int16PPtr 

func EqualMapUint32Int16PPtr(map1, map2 map[*uint32]*int16) bool

EqualMapUint32Int16PPtr Returns true if both maps are equal else returns false

func EqualMapUint32Int32P 

func EqualMapUint32Int32P(map1, map2 map[uint32]int32) bool

EqualMapUint32Int32P Returns true if both maps are equal else returns false

func EqualMapUint32Int32PPtr 

func EqualMapUint32Int32PPtr(map1, map2 map[*uint32]*int32) bool

EqualMapUint32Int32PPtr Returns true if both maps are equal else returns false

func EqualMapUint32Int64P 

func EqualMapUint32Int64P(map1, map2 map[uint32]int64) bool

EqualMapUint32Int64P Returns true if both maps are equal else returns false

func EqualMapUint32Int64PPtr 

func EqualMapUint32Int64PPtr(map1, map2 map[*uint32]*int64) bool

EqualMapUint32Int64PPtr Returns true if both maps are equal else returns false

func EqualMapUint32Int8P 

func EqualMapUint32Int8P(map1, map2 map[uint32]int8) bool

EqualMapUint32Int8P Returns true if both maps are equal else returns false

func EqualMapUint32Int8PPtr 

func EqualMapUint32Int8PPtr(map1, map2 map[*uint32]*int8) bool

EqualMapUint32Int8PPtr Returns true if both maps are equal else returns false

func EqualMapUint32IntP 

func EqualMapUint32IntP(map1, map2 map[uint32]int) bool

EqualMapUint32IntP Returns true if both maps are equal else returns false

func EqualMapUint32IntPPtr 

func EqualMapUint32IntPPtr(map1, map2 map[*uint32]*int) bool

EqualMapUint32IntPPtr Returns true if both maps are equal else returns false

func EqualMapUint32P 

func EqualMapUint32P(map1, map2 map[uint32]uint32) bool

EqualMapUint32P Returns true if both maps are equal else returns false

func EqualMapUint32PPtr 

func EqualMapUint32PPtr(map1, map2 map[*uint32]*uint32) bool

EqualMapUint32PPtr Returns true if both maps are equal else returns false

func EqualMapUint32StrP 

func EqualMapUint32StrP(map1, map2 map[uint32]string) bool

EqualMapUint32StrP Returns true if both maps are equal else returns false

func EqualMapUint32StrPPtr 

func EqualMapUint32StrPPtr(map1, map2 map[*uint32]*string) bool

EqualMapUint32StrPPtr Returns true if both maps are equal else returns false

func EqualMapUint32Uint16P 

func EqualMapUint32Uint16P(map1, map2 map[uint32]uint16) bool

EqualMapUint32Uint16P Returns true if both maps are equal else returns false

func EqualMapUint32Uint16PPtr 

func EqualMapUint32Uint16PPtr(map1, map2 map[*uint32]*uint16) bool

EqualMapUint32Uint16PPtr Returns true if both maps are equal else returns false

func EqualMapUint32Uint64P 

func EqualMapUint32Uint64P(map1, map2 map[uint32]uint64) bool

EqualMapUint32Uint64P Returns true if both maps are equal else returns false

func EqualMapUint32Uint64PPtr 

func EqualMapUint32Uint64PPtr(map1, map2 map[*uint32]*uint64) bool

EqualMapUint32Uint64PPtr Returns true if both maps are equal else returns false

func EqualMapUint32Uint8P 

func EqualMapUint32Uint8P(map1, map2 map[uint32]uint8) bool

EqualMapUint32Uint8P Returns true if both maps are equal else returns false

func EqualMapUint32Uint8PPtr 

func EqualMapUint32Uint8PPtr(map1, map2 map[*uint32]*uint8) bool

EqualMapUint32Uint8PPtr Returns true if both maps are equal else returns false

func EqualMapUint32UintP 

func EqualMapUint32UintP(map1, map2 map[uint32]uint) bool

EqualMapUint32UintP Returns true if both maps are equal else returns false

func EqualMapUint32UintPPtr 

func EqualMapUint32UintPPtr(map1, map2 map[*uint32]*uint) bool

EqualMapUint32UintPPtr Returns true if both maps are equal else returns false

func EqualMapUint64BoolP 

func EqualMapUint64BoolP(map1, map2 map[uint64]bool) bool

EqualMapUint64BoolP Returns true if both maps are equal else returns false

func EqualMapUint64BoolPPtr 

func EqualMapUint64BoolPPtr(map1, map2 map[*uint64]*bool) bool

EqualMapUint64BoolPPtr Returns true if both maps are equal else returns false

func EqualMapUint64Float32P 

func EqualMapUint64Float32P(map1, map2 map[uint64]float32) bool

EqualMapUint64Float32P Returns true if both maps are equal else returns false

func EqualMapUint64Float32PPtr 

func EqualMapUint64Float32PPtr(map1, map2 map[*uint64]*float32) bool

EqualMapUint64Float32PPtr Returns true if both maps are equal else returns false

func EqualMapUint64Float64P 

func EqualMapUint64Float64P(map1, map2 map[uint64]float64) bool

EqualMapUint64Float64P Returns true if both maps are equal else returns false

func EqualMapUint64Float64PPtr 

func EqualMapUint64Float64PPtr(map1, map2 map[*uint64]*float64) bool

EqualMapUint64Float64PPtr Returns true if both maps are equal else returns false

func EqualMapUint64Int16P 

func EqualMapUint64Int16P(map1, map2 map[uint64]int16) bool

EqualMapUint64Int16P Returns true if both maps are equal else returns false

func EqualMapUint64Int16PPtr 

func EqualMapUint64Int16PPtr(map1, map2 map[*uint64]*int16) bool

EqualMapUint64Int16PPtr Returns true if both maps are equal else returns false

func EqualMapUint64Int32P 

func EqualMapUint64Int32P(map1, map2 map[uint64]int32) bool

EqualMapUint64Int32P Returns true if both maps are equal else returns false

func EqualMapUint64Int32PPtr 

func EqualMapUint64Int32PPtr(map1, map2 map[*uint64]*int32) bool

EqualMapUint64Int32PPtr Returns true if both maps are equal else returns false

func EqualMapUint64Int64P 

func EqualMapUint64Int64P(map1, map2 map[uint64]int64) bool

EqualMapUint64Int64P Returns true if both maps are equal else returns false

func EqualMapUint64Int64PPtr 

func EqualMapUint64Int64PPtr(map1, map2 map[*uint64]*int64) bool

EqualMapUint64Int64PPtr Returns true if both maps are equal else returns false

func EqualMapUint64Int8P 

func EqualMapUint64Int8P(map1, map2 map[uint64]int8) bool

EqualMapUint64Int8P Returns true if both maps are equal else returns false

func EqualMapUint64Int8PPtr 

func EqualMapUint64Int8PPtr(map1, map2 map[*uint64]*int8) bool

EqualMapUint64Int8PPtr Returns true if both maps are equal else returns false

func EqualMapUint64IntP 

func EqualMapUint64IntP(map1, map2 map[uint64]int) bool

EqualMapUint64IntP Returns true if both maps are equal else returns false

func EqualMapUint64IntPPtr 

func EqualMapUint64IntPPtr(map1, map2 map[*uint64]*int) bool

EqualMapUint64IntPPtr Returns true if both maps are equal else returns false

func EqualMapUint64P 

func EqualMapUint64P(map1, map2 map[uint64]uint64) bool

EqualMapUint64P Returns true if both maps are equal else returns false

func EqualMapUint64PPtr 

func EqualMapUint64PPtr(map1, map2 map[*uint64]*uint64) bool

EqualMapUint64PPtr Returns true if both maps are equal else returns false

func EqualMapUint64StrP 

func EqualMapUint64StrP(map1, map2 map[uint64]string) bool

EqualMapUint64StrP Returns true if both maps are equal else returns false

func EqualMapUint64StrPPtr 

func EqualMapUint64StrPPtr(map1, map2 map[*uint64]*string) bool

EqualMapUint64StrPPtr Returns true if both maps are equal else returns false

func EqualMapUint64Uint16P 

func EqualMapUint64Uint16P(map1, map2 map[uint64]uint16) bool

EqualMapUint64Uint16P Returns true if both maps are equal else returns false

func EqualMapUint64Uint16PPtr 

func EqualMapUint64Uint16PPtr(map1, map2 map[*uint64]*uint16) bool

EqualMapUint64Uint16PPtr Returns true if both maps are equal else returns false

func EqualMapUint64Uint32P 

func EqualMapUint64Uint32P(map1, map2 map[uint64]uint32) bool

EqualMapUint64Uint32P Returns true if both maps are equal else returns false

func EqualMapUint64Uint32PPtr 

func EqualMapUint64Uint32PPtr(map1, map2 map[*uint64]*uint32) bool

EqualMapUint64Uint32PPtr Returns true if both maps are equal else returns false

func EqualMapUint64Uint8P 

func EqualMapUint64Uint8P(map1, map2 map[uint64]uint8) bool

EqualMapUint64Uint8P Returns true if both maps are equal else returns false

func EqualMapUint64Uint8PPtr 

func EqualMapUint64Uint8PPtr(map1, map2 map[*uint64]*uint8) bool

EqualMapUint64Uint8PPtr Returns true if both maps are equal else returns false

func EqualMapUint64UintP 

func EqualMapUint64UintP(map1, map2 map[uint64]uint) bool

EqualMapUint64UintP Returns true if both maps are equal else returns false

func EqualMapUint64UintPPtr 

func EqualMapUint64UintPPtr(map1, map2 map[*uint64]*uint) bool

EqualMapUint64UintPPtr Returns true if both maps are equal else returns false

func EqualMapUint8BoolP 

func EqualMapUint8BoolP(map1, map2 map[uint8]bool) bool

EqualMapUint8BoolP Returns true if both maps are equal else returns false

func EqualMapUint8BoolPPtr 

func EqualMapUint8BoolPPtr(map1, map2 map[*uint8]*bool) bool

EqualMapUint8BoolPPtr Returns true if both maps are equal else returns false

func EqualMapUint8Float32P 

func EqualMapUint8Float32P(map1, map2 map[uint8]float32) bool

EqualMapUint8Float32P Returns true if both maps are equal else returns false

func EqualMapUint8Float32PPtr 

func EqualMapUint8Float32PPtr(map1, map2 map[*uint8]*float32) bool

EqualMapUint8Float32PPtr Returns true if both maps are equal else returns false

func EqualMapUint8Float64P 

func EqualMapUint8Float64P(map1, map2 map[uint8]float64) bool

EqualMapUint8Float64P Returns true if both maps are equal else returns false

func EqualMapUint8Float64PPtr 

func EqualMapUint8Float64PPtr(map1, map2 map[*uint8]*float64) bool

EqualMapUint8Float64PPtr Returns true if both maps are equal else returns false

func EqualMapUint8Int16P 

func EqualMapUint8Int16P(map1, map2 map[uint8]int16) bool

EqualMapUint8Int16P Returns true if both maps are equal else returns false

func EqualMapUint8Int16PPtr 

func EqualMapUint8Int16PPtr(map1, map2 map[*uint8]*int16) bool

EqualMapUint8Int16PPtr Returns true if both maps are equal else returns false

func EqualMapUint8Int32P 

func EqualMapUint8Int32P(map1, map2 map[uint8]int32) bool

EqualMapUint8Int32P Returns true if both maps are equal else returns false

func EqualMapUint8Int32PPtr 

func EqualMapUint8Int32PPtr(map1, map2 map[*uint8]*int32) bool

EqualMapUint8Int32PPtr Returns true if both maps are equal else returns false

func EqualMapUint8Int64P 

func EqualMapUint8Int64P(map1, map2 map[uint8]int64) bool

EqualMapUint8Int64P Returns true if both maps are equal else returns false

func EqualMapUint8Int64PPtr 

func EqualMapUint8Int64PPtr(map1, map2 map[*uint8]*int64) bool

EqualMapUint8Int64PPtr Returns true if both maps are equal else returns false

func EqualMapUint8Int8P 

func EqualMapUint8Int8P(map1, map2 map[uint8]int8) bool

EqualMapUint8Int8P Returns true if both maps are equal else returns false

func EqualMapUint8Int8PPtr 

func EqualMapUint8Int8PPtr(map1, map2 map[*uint8]*int8) bool

EqualMapUint8Int8PPtr Returns true if both maps are equal else returns false

func EqualMapUint8IntP 

func EqualMapUint8IntP(map1, map2 map[uint8]int) bool

EqualMapUint8IntP Returns true if both maps are equal else returns false

func EqualMapUint8IntPPtr 

func EqualMapUint8IntPPtr(map1, map2 map[*uint8]*int) bool

EqualMapUint8IntPPtr Returns true if both maps are equal else returns false

func EqualMapUint8P 

func EqualMapUint8P(map1, map2 map[uint8]uint8) bool

EqualMapUint8P Returns true if both maps are equal else returns false

func EqualMapUint8PPtr 

func EqualMapUint8PPtr(map1, map2 map[*uint8]*uint8) bool

EqualMapUint8PPtr Returns true if both maps are equal else returns false

func EqualMapUint8StrP 

func EqualMapUint8StrP(map1, map2 map[uint8]string) bool

EqualMapUint8StrP Returns true if both maps are equal else returns false

func EqualMapUint8StrPPtr 

func EqualMapUint8StrPPtr(map1, map2 map[*uint8]*string) bool

EqualMapUint8StrPPtr Returns true if both maps are equal else returns false

func EqualMapUint8Uint16P 

func EqualMapUint8Uint16P(map1, map2 map[uint8]uint16) bool

EqualMapUint8Uint16P Returns true if both maps are equal else returns false

func EqualMapUint8Uint16PPtr 

func EqualMapUint8Uint16PPtr(map1, map2 map[*uint8]*uint16) bool

EqualMapUint8Uint16PPtr Returns true if both maps are equal else returns false

func EqualMapUint8Uint32P 

func EqualMapUint8Uint32P(map1, map2 map[uint8]uint32) bool

EqualMapUint8Uint32P Returns true if both maps are equal else returns false

func EqualMapUint8Uint32PPtr 

func EqualMapUint8Uint32PPtr(map1, map2 map[*uint8]*uint32) bool

EqualMapUint8Uint32PPtr Returns true if both maps are equal else returns false

func EqualMapUint8Uint64P 

func EqualMapUint8Uint64P(map1, map2 map[uint8]uint64) bool

EqualMapUint8Uint64P Returns true if both maps are equal else returns false

func EqualMapUint8Uint64PPtr 

func EqualMapUint8Uint64PPtr(map1, map2 map[*uint8]*uint64) bool

EqualMapUint8Uint64PPtr Returns true if both maps are equal else returns false

func EqualMapUint8UintP 

func EqualMapUint8UintP(map1, map2 map[uint8]uint) bool

EqualMapUint8UintP Returns true if both maps are equal else returns false

func EqualMapUint8UintPPtr 

func EqualMapUint8UintPPtr(map1, map2 map[*uint8]*uint) bool

EqualMapUint8UintPPtr Returns true if both maps are equal else returns false

func EqualMapUintBoolP 

func EqualMapUintBoolP(map1, map2 map[uint]bool) bool

EqualMapUintBoolP Returns true if both maps are equal else returns false

func EqualMapUintBoolPPtr 

func EqualMapUintBoolPPtr(map1, map2 map[*uint]*bool) bool

EqualMapUintBoolPPtr Returns true if both maps are equal else returns false

func EqualMapUintFloat32P 

func EqualMapUintFloat32P(map1, map2 map[uint]float32) bool

EqualMapUintFloat32P Returns true if both maps are equal else returns false

func EqualMapUintFloat32PPtr 

func EqualMapUintFloat32PPtr(map1, map2 map[*uint]*float32) bool

EqualMapUintFloat32PPtr Returns true if both maps are equal else returns false

func EqualMapUintFloat64P 

func EqualMapUintFloat64P(map1, map2 map[uint]float64) bool

EqualMapUintFloat64P Returns true if both maps are equal else returns false

func EqualMapUintFloat64PPtr 

func EqualMapUintFloat64PPtr(map1, map2 map[*uint]*float64) bool

EqualMapUintFloat64PPtr Returns true if both maps are equal else returns false

func EqualMapUintInt16P 

func EqualMapUintInt16P(map1, map2 map[uint]int16) bool

EqualMapUintInt16P Returns true if both maps are equal else returns false

func EqualMapUintInt16PPtr 

func EqualMapUintInt16PPtr(map1, map2 map[*uint]*int16) bool

EqualMapUintInt16PPtr Returns true if both maps are equal else returns false

func EqualMapUintInt32P 

func EqualMapUintInt32P(map1, map2 map[uint]int32) bool

EqualMapUintInt32P Returns true if both maps are equal else returns false

func EqualMapUintInt32PPtr 

func EqualMapUintInt32PPtr(map1, map2 map[*uint]*int32) bool

EqualMapUintInt32PPtr Returns true if both maps are equal else returns false

func EqualMapUintInt64P 

func EqualMapUintInt64P(map1, map2 map[uint]int64) bool

EqualMapUintInt64P Returns true if both maps are equal else returns false

func EqualMapUintInt64PPtr 

func EqualMapUintInt64PPtr(map1, map2 map[*uint]*int64) bool

EqualMapUintInt64PPtr Returns true if both maps are equal else returns false

func EqualMapUintInt8P 

func EqualMapUintInt8P(map1, map2 map[uint]int8) bool

EqualMapUintInt8P Returns true if both maps are equal else returns false

func EqualMapUintInt8PPtr 

func EqualMapUintInt8PPtr(map1, map2 map[*uint]*int8) bool

EqualMapUintInt8PPtr Returns true if both maps are equal else returns false

func EqualMapUintIntP 

func EqualMapUintIntP(map1, map2 map[uint]int) bool

EqualMapUintIntP Returns true if both maps are equal else returns false

func EqualMapUintIntPPtr 

func EqualMapUintIntPPtr(map1, map2 map[*uint]*int) bool

EqualMapUintIntPPtr Returns true if both maps are equal else returns false

func EqualMapUintP 

func EqualMapUintP(map1, map2 map[uint]uint) bool

EqualMapUintP Returns true if both maps are equal else returns false

func EqualMapUintPPtr 

func EqualMapUintPPtr(map1, map2 map[*uint]*uint) bool

EqualMapUintPPtr Returns true if both maps are equal else returns false

func EqualMapUintStrP 

func EqualMapUintStrP(map1, map2 map[uint]string) bool

EqualMapUintStrP Returns true if both maps are equal else returns false

func EqualMapUintStrPPtr 

func EqualMapUintStrPPtr(map1, map2 map[*uint]*string) bool

EqualMapUintStrPPtr Returns true if both maps are equal else returns false

func EqualMapUintUint16P 

func EqualMapUintUint16P(map1, map2 map[uint]uint16) bool

EqualMapUintUint16P Returns true if both maps are equal else returns false

func EqualMapUintUint16PPtr 

func EqualMapUintUint16PPtr(map1, map2 map[*uint]*uint16) bool

EqualMapUintUint16PPtr Returns true if both maps are equal else returns false

func EqualMapUintUint32P 

func EqualMapUintUint32P(map1, map2 map[uint]uint32) bool

EqualMapUintUint32P Returns true if both maps are equal else returns false

func EqualMapUintUint32PPtr 

func EqualMapUintUint32PPtr(map1, map2 map[*uint]*uint32) bool

EqualMapUintUint32PPtr Returns true if both maps are equal else returns false

func EqualMapUintUint64P 

func EqualMapUintUint64P(map1, map2 map[uint]uint64) bool

EqualMapUintUint64P Returns true if both maps are equal else returns false

func EqualMapUintUint64PPtr 

func EqualMapUintUint64PPtr(map1, map2 map[*uint]*uint64) bool

EqualMapUintUint64PPtr Returns true if both maps are equal else returns false

func EqualMapUintUint8P 

func EqualMapUintUint8P(map1, map2 map[uint]uint8) bool

EqualMapUintUint8P Returns true if both maps are equal else returns false

func EqualMapUintUint8PPtr 

func EqualMapUintUint8PPtr(map1, map2 map[*uint]*uint8) bool

EqualMapUintUint8PPtr Returns true if both maps are equal else returns false

func EqualStrsP 

func EqualStrsP(list1, list2 []string) bool

EqualStrsP Returns true if both list are equal else returns false

func EqualStrsPPtr 

func EqualStrsPPtr(list1, list2 []*string) bool

EqualStrsPPtr Returns true if both list are equal else returns false

func EqualUint64sP 

func EqualUint64sP(list1, list2 []uint64) bool

EqualUint64sP Returns true if both list are equal else returns false

func EqualUint64sPPtr 

func EqualUint64sPPtr(list1, list2 []*uint64) bool

EqualUint64sPPtr Returns true if both list are equal else returns false

func EqualUints16P 

func EqualUints16P(list1, list2 []uint16) bool

EqualUints16P Returns true if both list are equal else returns false

func EqualUints16PPtr 

func EqualUints16PPtr(list1, list2 []*uint16) bool

EqualUints16PPtr Returns true if both list are equal else returns false

func EqualUints32P 

func EqualUints32P(list1, list2 []uint32) bool

EqualUints32P Returns true if both list are equal else returns false

func EqualUints32PPtr 

func EqualUints32PPtr(list1, list2 []*uint32) bool

EqualUints32PPtr Returns true if both list are equal else returns false

func EqualUints8P 

func EqualUints8P(list1, list2 []uint8) bool

EqualUints8P Returns true if both list are equal else returns false

func EqualUints8PPtr 

func EqualUints8PPtr(list1, list2 []*uint8) bool

EqualUints8PPtr Returns true if both list are equal else returns false

func EqualUintsP 

func EqualUintsP(list1, list2 []uint) bool

EqualUintsP Returns true if both list are equal else returns false

func EqualUintsPPtr 

func EqualUintsPPtr(list1, list2 []*uint) bool

EqualUintsPPtr Returns true if both list are equal else returns false

func EvenInt16P 

func EvenInt16P(v int16) bool

EvenInt16P Returns true if n is even

func EvenInt16PPtr 

func EvenInt16PPtr(v *int16) bool

EvenInt16PPtr Returns true if n is even

func EvenInt32P 

func EvenInt32P(v int32) bool

EvenInt32P Returns true if n is even

func EvenInt32PPtr 

func EvenInt32PPtr(v *int32) bool

EvenInt32PPtr Returns true if n is even

func EvenInt64P 

func EvenInt64P(v int64) bool

EvenInt64P Returns true if n is even

func EvenInt64PPtr 

func EvenInt64PPtr(v *int64) bool

EvenInt64PPtr Returns true if n is even

func EvenInt8P 

func EvenInt8P(v int8) bool

EvenInt8P Returns true if n is even

func EvenInt8PPtr 

func EvenInt8PPtr(v *int8) bool

EvenInt8PPtr Returns true if n is even

func EvenIntP 

func EvenIntP(v int) bool

EvenIntP Returns true if n is even

func EvenIntPPtr 

func EvenIntPPtr(v *int) bool

EvenIntPPtr Returns true if n is even

func EvenUint16P 

func EvenUint16P(v uint16) bool

EvenUint16P Returns true if n is even

func EvenUint16PPtr 

func EvenUint16PPtr(v *uint16) bool

EvenUint16PPtr Returns true if n is even

func EvenUint32P 

func EvenUint32P(v uint32) bool

EvenUint32P Returns true if n is even

func EvenUint32PPtr 

func EvenUint32PPtr(v *uint32) bool

EvenUint32PPtr Returns true if n is even

func EvenUint64P 

func EvenUint64P(v uint64) bool

EvenUint64P Returns true if n is even

func EvenUint64PPtr 

func EvenUint64PPtr(v *uint64) bool

EvenUint64PPtr Returns true if n is even

func EvenUint8P 

func EvenUint8P(v uint8) bool

EvenUint8P Returns true if n is even

func EvenUint8PPtr 

func EvenUint8PPtr(v *uint8) bool

EvenUint8PPtr Returns true if n is even

func EvenUintP 

func EvenUintP(v uint) bool

EvenUintP Returns true if n is even

func EvenUintPPtr 

func EvenUintPPtr(v *uint) bool

EvenUintPPtr Returns true if n is even

func EveryBool 

func EveryBool(f func() bool, list []bool) bool

EveryBool returns true if supplied function returns logical true for every item in the list

Example: 

fp.EveryBool(fp.True, []bool{true, true, true, true}) // Returns true
fp.EveryBool(fp.True, []bool{true, false, true, true}) // Returns false
fp.EveryBool(fp.False, []bool{false, false, false, false}) // Returns true
fp.EveryBool(fp.False, []bool{}) // Returns false
fp.EveryBool(fp.True, []bool{}) // Returns false
fp.EveryBool(fp.True, nil) // Returns false

func EveryBoolErr 

func EveryBoolErr(f func(bool) (bool, error), list []bool) (bool, error)

EveryBoolErr returns true if supplied function returns logical true for every item in the list

func EveryBoolPtr 

func EveryBoolPtr(f func(*bool) bool, list []*bool) bool

EveryBoolPtr returns true if supplied function returns logical true for every item in the list

func EveryBoolPtrErr 

func EveryBoolPtrErr(f func(*bool) (bool, error), list []*bool) (bool, error)

EveryBoolPtrErr returns true if supplied function returns logical true for every item in the list

func EveryFloat32 

func EveryFloat32(f func(float32) bool, list []float32) bool

EveryFloat32 returns true if supplied function returns logical true for every item in the list

Example: 

fp.EveryFloat32(isPositive, []float32{8.2, 2.3, 10.4, 4}) // Returns true

func isPositive(num float32) bool {
	return num > 0
}

fp.EveryFloat32(even, []float32{}) // Returns false fp.EveryFloat32(nil, []float32{}) // Returns false fp.EveryFloat32(nil, nil) // Returns false

func EveryFloat32Err 

func EveryFloat32Err(f func(float32) (bool, error), list []float32) (bool, error)

EveryFloat32Err returns true if supplied function returns logical true for every item in the list

func EveryFloat32Ptr 

func EveryFloat32Ptr(f func(*float32) bool, list []*float32) bool

EveryFloat32Ptr returns true if supplied function returns logical true for every item in the list

func EveryFloat32PtrErr 

func EveryFloat32PtrErr(f func(*float32) (bool, error), list []*float32) (bool, error)

EveryFloat32PtrErr returns true if supplied function returns logical true for every item in the list

func EveryFloat64 

func EveryFloat64(f func(float64) bool, list []float64) bool

EveryFloat64 returns true if supplied function returns logical true for every item in the list

Example: 

fp.EveryFloat64(isPositive, []float64{8.2, 2.3, 10.4, 4}) // Returns true

func isPositive(num float64) bool {
	return num > 0
}

fp.EveryFloat64(even, []float64{}) // Returns false fp.EveryFloat64(nil, []float64{}) // Returns false fp.EveryFloat64(nil, nil) // Returns false

func EveryFloat64Err 

func EveryFloat64Err(f func(float64) (bool, error), list []float64) (bool, error)

EveryFloat64Err returns true if supplied function returns logical true for every item in the list

func EveryFloat64Ptr 

func EveryFloat64Ptr(f func(*float64) bool, list []*float64) bool

EveryFloat64Ptr returns true if supplied function returns logical true for every item in the list

func EveryFloat64PtrErr 

func EveryFloat64PtrErr(f func(*float64) (bool, error), list []*float64) (bool, error)

EveryFloat64PtrErr returns true if supplied function returns logical true for every item in the list

func EveryInt 

func EveryInt(f func(int) bool, list []int) bool

EveryInt returns true if supplied function returns logical true for every item in the list

Example: 

fp.EveryInt(even, []int{8, 2, 10, 4}) // Returns true

func isEven(num int) bool {
	return num%2 == 0
}

fp.EveryInt(even, []int{}) // Returns false fp.EveryInt(nil, []int{}) // Returns false fp.EveryInt(nil, nil) // Returns false

func EveryInt16 

func EveryInt16(f func(int16) bool, list []int16) bool

EveryInt16 returns true if supplied function returns logical true for every item in the list

Example: 

fp.EveryInt16(even, []int16{8, 2, 10, 4}) // Returns true

func isEven(num int16) bool {
	return num%2 == 0
}

fp.EveryInt16(even, []int16{}) // Returns false fp.EveryInt16(nil, []int16{}) // Returns false fp.EveryInt16(nil, nil) // Returns false

func EveryInt16Err 

func EveryInt16Err(f func(int16) (bool, error), list []int16) (bool, error)

EveryInt16Err returns true if supplied function returns logical true for every item in the list

func EveryInt16Ptr 

func EveryInt16Ptr(f func(*int16) bool, list []*int16) bool

EveryInt16Ptr returns true if supplied function returns logical true for every item in the list

func EveryInt16PtrErr 

func EveryInt16PtrErr(f func(*int16) (bool, error), list []*int16) (bool, error)

EveryInt16PtrErr returns true if supplied function returns logical true for every item in the list

func EveryInt32 

func EveryInt32(f func(int32) bool, list []int32) bool

EveryInt32 returns true if supplied function returns logical true for every item in the list

Example: 

fp.EveryInt32(even, []int32{8, 2, 10, 4}) // Returns true

func isEven(num int32) bool {
	return num%2 == 0
}

fp.EveryInt32(even, []int32{}) // Returns false fp.EveryInt32(nil, []int32{}) // Returns false fp.EveryInt32(nil, nil) // Returns false

func EveryInt32Err 

func EveryInt32Err(f func(int32) (bool, error), list []int32) (bool, error)

EveryInt32Err returns true if supplied function returns logical true for every item in the list

func EveryInt32Ptr 

func EveryInt32Ptr(f func(*int32) bool, list []*int32) bool

EveryInt32Ptr returns true if supplied function returns logical true for every item in the list

func EveryInt32PtrErr 

func EveryInt32PtrErr(f func(*int32) (bool, error), list []*int32) (bool, error)

EveryInt32PtrErr returns true if supplied function returns logical true for every item in the list

func EveryInt64 

func EveryInt64(f func(int64) bool, list []int64) bool

EveryInt64 returns true if supplied function returns logical true for every item in the list

Example: 

fp.EveryInt64(even, []int64{8, 2, 10, 4}) // Returns true

func isEven(num int64) bool {
	return num%2 == 0
}

fp.EveryInt64(even, []int64{}) // Returns false fp.EveryInt64(nil, []int64{}) // Returns false fp.EveryInt64(nil, nil) // Returns false

func EveryInt64Err 

func EveryInt64Err(f func(int64) (bool, error), list []int64) (bool, error)

EveryInt64Err returns true if supplied function returns logical true for every item in the list

func EveryInt64Ptr 

func EveryInt64Ptr(f func(*int64) bool, list []*int64) bool

EveryInt64Ptr returns true if supplied function returns logical true for every item in the list

func EveryInt64PtrErr 

func EveryInt64PtrErr(f func(*int64) (bool, error), list []*int64) (bool, error)

EveryInt64PtrErr returns true if supplied function returns logical true for every item in the list

func EveryInt8 

func EveryInt8(f func(int8) bool, list []int8) bool

EveryInt8 returns true if supplied function returns logical true for every item in the list

Example: 

fp.EveryInt8(even, []int8{8, 2, 10, 4}) // Returns true

func isEven(num int8) bool {
	return num%2 == 0
}

fp.EveryInt8(even, []int8{}) // Returns false fp.EveryInt8(nil, []int8{}) // Returns false fp.EveryInt8(nil, nil) // Returns false

func EveryInt8Err 

func EveryInt8Err(f func(int8) (bool, error), list []int8) (bool, error)

EveryInt8Err returns true if supplied function returns logical true for every item in the list

func EveryInt8Ptr 

func EveryInt8Ptr(f func(*int8) bool, list []*int8) bool

EveryInt8Ptr returns true if supplied function returns logical true for every item in the list

func EveryInt8PtrErr 

func EveryInt8PtrErr(f func(*int8) (bool, error), list []*int8) (bool, error)

EveryInt8PtrErr returns true if supplied function returns logical true for every item in the list

func EveryIntErr 

func EveryIntErr(f func(int) (bool, error), list []int) (bool, error)

EveryIntErr returns true if supplied function returns logical true for every item in the list

func EveryIntPtr 

func EveryIntPtr(f func(*int) bool, list []*int) bool

EveryIntPtr returns true if supplied function returns logical true for every item in the list

func EveryIntPtrErr 

func EveryIntPtrErr(f func(*int) (bool, error), list []*int) (bool, error)

EveryIntPtrErr returns true if supplied function returns logical true for every item in the list

func EveryStr 

func EveryStr(f func(string) bool, list []string) bool

EveryStr returns true if supplied function returns logical true for every item in the list

Example: 

fp.EveryStr(isStrLen3, []string{"Ram", "Raj", "Sai"}) // Returns true

func isStrLen3(str string) bool {
	return len(str) == 3
}

fp.EveryStr(even, []string{}) // Returns false fp.EveryStr(nil, []string{}) // Returns false fp.EveryStr(nil, nil) // Returns false

func EveryStrErr 

func EveryStrErr(f func(string) (bool, error), list []string) (bool, error)

EveryStrErr returns true if supplied function returns logical true for every item in the list

func EveryStrPtr 

func EveryStrPtr(f func(*string) bool, list []*string) bool

EveryStrPtr returns true if supplied function returns logical true for every item in the list

func EveryStrPtrErr 

func EveryStrPtrErr(f func(*string) (bool, error), list []*string) (bool, error)

EveryStrPtrErr returns true if supplied function returns logical true for every item in the list

func EveryUint 

func EveryUint(f func(uint) bool, list []uint) bool

EveryUint returns true if supplied function returns logical true for every item in the list

Example: 

fp.EveryUint(even, []uint{8, 2, 10, 4}) // Returns true

func isEven(num uint) bool {
	return num%2 == 0
}

fp.EveryUint(even, []uint{}) // Returns false fp.EveryUint(nil, []uint{}) // Returns false fp.EveryUint(nil, nil) // Returns false

func EveryUint16 

func EveryUint16(f func(uint16) bool, list []uint16) bool

EveryUint16 returns true if supplied function returns logical true for every item in the list

Example: 

fp.EveryUint16(even, []uint16{8, 2, 10, 4}) // Returns true

func isEven(num uint16) bool {
	return num%2 == 0
}

fp.EveryUint16(even, []uint16{}) // Returns false fp.EveryUint16(nil, []uint16{}) // Returns false fp.EveryUint16(nil, nil) // Returns false

func EveryUint16Err 

func EveryUint16Err(f func(uint16) (bool, error), list []uint16) (bool, error)

EveryUint16Err returns true if supplied function returns logical true for every item in the list

func EveryUint16Ptr 

func EveryUint16Ptr(f func(*uint16) bool, list []*uint16) bool

EveryUint16Ptr returns true if supplied function returns logical true for every item in the list

func EveryUint16PtrErr 

func EveryUint16PtrErr(f func(*uint16) (bool, error), list []*uint16) (bool, error)

EveryUint16PtrErr returns true if supplied function returns logical true for every item in the list

func EveryUint32 

func EveryUint32(f func(uint32) bool, list []uint32) bool

EveryUint32 returns true if supplied function returns logical true for every item in the list

Example: 

fp.EveryUint32(even, []uint32{8, 2, 10, 4}) // Returns true

func isEven(num uint32) bool {
	return num%2 == 0
}

fp.EveryUint32(even, []uint32{}) // Returns false fp.EveryUint32(nil, []uint32{}) // Returns false fp.EveryUint32(nil, nil) // Returns false

func EveryUint32Err 

func EveryUint32Err(f func(uint32) (bool, error), list []uint32) (bool, error)

EveryUint32Err returns true if supplied function returns logical true for every item in the list

func EveryUint32Ptr 

func EveryUint32Ptr(f func(*uint32) bool, list []*uint32) bool

EveryUint32Ptr returns true if supplied function returns logical true for every item in the list

func EveryUint32PtrErr 

func EveryUint32PtrErr(f func(*uint32) (bool, error), list []*uint32) (bool, error)

EveryUint32PtrErr returns true if supplied function returns logical true for every item in the list

func EveryUint64 

func EveryUint64(f func(uint64) bool, list []uint64) bool

EveryUint64 returns true if supplied function returns logical true for every item in the list

Example: 

fp.EveryUint64(even, []uint64{8, 2, 10, 4}) // Returns true

func isEven(num uint64) bool {
	return num%2 == 0
}

fp.EveryUint64(even, []uint64{}) // Returns false fp.EveryUint64(nil, []uint64{}) // Returns false fp.EveryUint64(nil, nil) // Returns false

func EveryUint64Err 

func EveryUint64Err(f func(uint64) (bool, error), list []uint64) (bool, error)

EveryUint64Err returns true if supplied function returns logical true for every item in the list

func EveryUint64Ptr 

func EveryUint64Ptr(f func(*uint64) bool, list []*uint64) bool

EveryUint64Ptr returns true if supplied function returns logical true for every item in the list

func EveryUint64PtrErr 

func EveryUint64PtrErr(f func(*uint64) (bool, error), list []*uint64) (bool, error)

EveryUint64PtrErr returns true if supplied function returns logical true for every item in the list

func EveryUint8 

func EveryUint8(f func(uint8) bool, list []uint8) bool

EveryUint8 returns true if supplied function returns logical true for every item in the list

Example: 

fp.EveryUint8(even, []uint8{8, 2, 10, 4}) // Returns true

func isEven(num uint8) bool {
	return num%2 == 0
}

fp.EveryUint8(even, []uint8{}) // Returns false fp.EveryUint8(nil, []uint8{}) // Returns false fp.EveryUint8(nil, nil) // Returns false

func EveryUint8Err 

func EveryUint8Err(f func(uint8) (bool, error), list []uint8) (bool, error)

EveryUint8Err returns true if supplied function returns logical true for every item in the list

func EveryUint8Ptr 

func EveryUint8Ptr(f func(*uint8) bool, list []*uint8) bool

EveryUint8Ptr returns true if supplied function returns logical true for every item in the list

func EveryUint8PtrErr 

func EveryUint8PtrErr(f func(*uint8) (bool, error), list []*uint8) (bool, error)

EveryUint8PtrErr returns true if supplied function returns logical true for every item in the list

func EveryUintErr 

func EveryUintErr(f func(uint) (bool, error), list []uint) (bool, error)

EveryUintErr returns true if supplied function returns logical true for every item in the list

func EveryUintPtr 

func EveryUintPtr(f func(*uint) bool, list []*uint) bool

EveryUintPtr returns true if supplied function returns logical true for every item in the list

func EveryUintPtrErr 

func EveryUintPtrErr(f func(*uint) (bool, error), list []*uint) (bool, error)

EveryUintPtrErr returns true if supplied function returns logical true for every item in the list

func ExistsBool 

func ExistsBool(num bool, list []bool) bool

ExistsBool checks if given item exists in the list

func ExistsBoolPtr 

func ExistsBoolPtr(num *bool, list []*bool) bool

ExistsBoolPtr checks if given item exists in the list

func ExistsFloat32 

func ExistsFloat32(num float32, list []float32) bool

ExistsFloat32 checks if given item exists in the list

Example: 

ExistsFloat32(8, []float32{8, 2, 10, 4}) // Returns true
ExistsFloat32(8, []float32{}) // Returns false
ExistsFloat32(8, nil) // Returns false

func ExistsFloat32Ptr 

func ExistsFloat32Ptr(num *float32, list []*float32) bool

ExistsFloat32Ptr checks if given item exists in the list

func ExistsFloat64 

func ExistsFloat64(num float64, list []float64) bool

ExistsFloat64 checks if given item exists in the list

Example: 

ExistsFloat64(8, []float64{8, 2, 10, 4}) // Returns true
ExistsFloat64(8, []float64{}) // Returns false
ExistsFloat64(8, nil) // Returns false

func ExistsFloat64Ptr 

func ExistsFloat64Ptr(num *float64, list []*float64) bool

ExistsFloat64Ptr checks if given item exists in the list

func ExistsInt 

func ExistsInt(num int, list []int) bool

ExistsInt checks if given item exists in the list

Example: 

ExistsInt(8, []int{8, 2, 10, 4}) // Returns true
ExistsInt(8, []int{}) // Returns false
ExistsInt(8, nil) // Returns false

func ExistsInt16 

func ExistsInt16(num int16, list []int16) bool

ExistsInt16 checks if given item exists in the list

Example: 

ExistsInt16(8, []int16{8, 2, 10, 4}) // Returns true
ExistsInt16(8, []int16{}) // Returns false
ExistsInt16(8, nil) // Returns false

func ExistsInt16Ptr 

func ExistsInt16Ptr(num *int16, list []*int16) bool

ExistsInt16Ptr checks if given item exists in the list

func ExistsInt32 

func ExistsInt32(num int32, list []int32) bool

ExistsInt32 checks if given item exists in the list

Example: 

ExistsInt32(8, []int32{8, 2, 10, 4}) // Returns true
ExistsInt32(8, []int32{}) // Returns false
ExistsInt32(8, nil) // Returns false

func ExistsInt32Ptr 

func ExistsInt32Ptr(num *int32, list []*int32) bool

ExistsInt32Ptr checks if given item exists in the list

func ExistsInt64 

func ExistsInt64(num int64, list []int64) bool

ExistsInt64 checks if given item exists in the list

Example: 

ExistsInt64(8, []int64{8, 2, 10, 4}) // Returns true
ExistsInt(8, []int64{}) // Returns false
ExistsInt(8, nil) // Returns false

func ExistsInt64Ptr 

func ExistsInt64Ptr(num *int64, list []*int64) bool

ExistsInt64Ptr checks if given item exists in the list

func ExistsInt8 

func ExistsInt8(num int8, list []int8) bool

ExistsInt8 checks if given item exists in the list

Example: 

ExistsInt8(8, []int8{8, 2, 10, 4}) // Returns true
ExistsInt8(8, []int8{}) // Returns false
ExistsInt8(8, nil) // Returns false

func ExistsInt8Ptr 

func ExistsInt8Ptr(num *int8, list []*int8) bool

ExistsInt8Ptr checks if given item exists in the list

func ExistsIntPtr 

func ExistsIntPtr(num *int, list []*int) bool

ExistsIntPtr checks if given item exists in the list

func ExistsStr 

func ExistsStr(num string, list []string) bool

ExistsStr checks if given item exists in the list

Example: 

ExistsStr("ram", []string{"shyam", "ram", "Hanuman"}) // Returns true
ExistsStr("ram", []string{}) // Returns false
ExistsStr("ram", nil) // Returns false

func ExistsStrIgnoreCase 

func ExistsStrIgnoreCase(str string, list []string) bool

ExistsStrIgnoreCase checks if given item exists in the list

Example: 

ExistsStrIgnoreCase("Ram", []string{"shyam", "ram", "Hanuman"}) // Returns true
ExistsStrIgnoreCase("ram", []string{}) // Returns false
ExistsStrIgnoreCase("ram", nil) // Returns false

func ExistsStrPtr 

func ExistsStrPtr(num *string, list []*string) bool

ExistsStrPtr checks if given item exists in the list

func ExistsUint 

func ExistsUint(num uint, list []uint) bool

ExistsUint checks if given item exists in the list

Example: 

ExistsUint(8, []uint{8, 2, 10, 4}) // Returns true
ExistsUint(8, []uint{}) // Returns false
ExistsUint(8, nil) // Returns false

func ExistsUint16 

func ExistsUint16(num uint16, list []uint16) bool

ExistsUint16 checks if given item exists in the list

Example: 

ExistsUint16(8, []uint16{8, 2, 10, 4}) // Returns true
ExistsUint16(8, []uint16{}) // Returns false
ExistsUint16(8, nil) // Returns false

func ExistsUint16Ptr 

func ExistsUint16Ptr(num *uint16, list []*uint16) bool

ExistsUint16Ptr checks if given item exists in the list

func ExistsUint32 

func ExistsUint32(num uint32, list []uint32) bool

ExistsUint32 checks if given item exists in the list

Example: 

ExistsUint32(8, []uint32{8, 2, 10, 4}) // Returns true
ExistsUint32(8, []uint32{}) // Returns false
ExistsUint32(8, nil) // Returns false

func ExistsUint32Ptr 

func ExistsUint32Ptr(num *uint32, list []*uint32) bool

ExistsUint32Ptr checks if given item exists in the list

func ExistsUint64 

func ExistsUint64(num uint64, list []uint64) bool

ExistsUint64 checks if given item exists in the list

Example: 

ExistsUint64(8, []uint64{8, 2, 10, 4}) // Returns true
ExistsUint64(8, []uint64{}) // Returns false
ExistsUint64(8, nil) // Returns false

func ExistsUint64Ptr 

func ExistsUint64Ptr(num *uint64, list []*uint64) bool

ExistsUint64Ptr checks if given item exists in the list

func ExistsUint8 

func ExistsUint8(num uint8, list []uint8) bool

ExistsUint8 checks if given item exists in the list

Example: 

ExistsUint8(8, []uint8{8, 2, 10, 4}) // Returns true
ExistsUint8(8, []uint8{}) // Returns false
ExistsUint8(8, nil) // Returns false

func ExistsUint8Ptr 

func ExistsUint8Ptr(num *uint8, list []*uint8) bool

ExistsUint8Ptr checks if given item exists in the list

func ExistsUintPtr 

func ExistsUintPtr(num *uint, list []*uint) bool

ExistsUintPtr checks if given item exists in the list

func False 

func False() bool

False returns false

func FilterBool 

func FilterBool(f func(bool) bool, list []bool) []bool

FilterBool takes two arguments

  1. Function: takes 1 argument of type bool and returns bool
  2. slice of type []bool

Returns: 

new filtered list

func FilterBoolErr 

func FilterBoolErr(f func(bool) (bool, error), list []bool) ([]bool, error)

FilterBoolErr takes two arguments

  1. Function: takes 1 argument of type bool and returns (bool, error)
  2. slice of type []bool

Returns: 

new filtered list and error

func FilterBoolPtr 

func FilterBoolPtr(f func(*bool) bool, list []*bool) []*bool

FilterBoolPtr takes two arguments

  1. Function: takes 1 argument of type bool and returns bool
  2. slice of type []*bool

Returns: 

new filtered list

func FilterBoolPtrErr 

func FilterBoolPtrErr(f func(*bool) (bool, error), list []*bool) ([]*bool, error)

FilterBoolPtrErr takes two arguments

  1. Function: takes 1 argument of type bool and returns (bool, error)
  2. slice of type []*bool

Returns: 

new filtered list and error

func FilterFloat32 

func FilterFloat32(f func(float32) bool, list []float32) []float32

FilterFloat32 filters list based on function passed as 1st argument

Takes two inputs

  1. function - Takes 1 input and returns bool
  2. list

Returns: 

New Filtered List.
Empty list if either of arguments or both of them are nil

Example: Filter all positive numbers 

fp.FilterFloat32(isPositive, []float32{0, -2, 2, 40.50}) // Returns [2, 40.50]

func isPositive(num float32) bool {
	return num > 0
}

func FilterFloat32Err 

func FilterFloat32Err(f func(float32) (bool, error), list []float32) ([]float32, error)

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

func FilterFloat32Ptr 

func FilterFloat32Ptr(f func(*float32) bool, list []*float32) []*float32

FilterFloat32Ptr takes two arguments

  1. Function: takes 1 argument of type float32 and returns bool
  2. slice of type []*float32

Returns: 

new filtered list

func FilterFloat32PtrErr 

func FilterFloat32PtrErr(f func(*float32) (bool, error), list []*float32) ([]*float32, error)

FilterFloat32PtrErr 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

func FilterFloat64 

func FilterFloat64(f func(float64) bool, list []float64) []float64

FilterFloat64 filters list based on function passed as 1st argument

Takes two inputs

  1. function - Takes 1 input and returns bool
  2. list

Returns: 

New Filtered List.
Empty list if either of arguments or both of them are nil

Example: Filter all positive numbers 

fp.FilterFloat64(isPositive, []float64{0, -2, 2, 40.50}) // Returns [2, 40.50]

func isPositive(num float64) bool {
	return num > 0
}

func FilterFloat64Err 

func FilterFloat64Err(f func(float64) (bool, error), list []float64) ([]float64, error)

FilterFloat64Err takes two arguments

  1. Function: takes 1 argument of type float64 and returns (bool, error)
  2. slice of type []float64

Returns: 

new filtered list and error

func FilterFloat64Ptr 

func FilterFloat64Ptr(f func(*float64) bool, list []*float64) []*float64

FilterFloat64Ptr takes two arguments

  1. Function: takes 1 argument of type float64 and returns bool
  2. slice of type []*float64

Returns: 

new filtered list

func FilterFloat64PtrErr 

func FilterFloat64PtrErr(f func(*float64) (bool, error), list []*float64) ([]*float64, error)

FilterFloat64PtrErr takes two arguments

  1. Function: takes 1 argument of type float64 and returns (bool, error)
  2. slice of type []*float64

Returns: 

new filtered list and error

func FilterInt 

func FilterInt(f func(int) bool, list []int) []int

FilterInt filters list based on function passed as 1st argument

Takes two inputs

  1. function - Takes 1 input and returns bool
  2. list

Returns: 

New Filtered List.
Empty list if either of arguments or both of them are nil

Example: Filter all even numbers 

fp.FilterInt(isEven, []int{1, 2, 3, 4}) // Returns [2, 4]

func isEven(num int) bool {
	return num%2 == 0
}

func FilterInt16 

func FilterInt16(f func(int16) bool, list []int16) []int16

FilterInt16 filters list based on function passed as 1st argument

Takes two inputs

  1. function - Takes 1 input and returns bool
  2. list

Returns: 

New Filtered List.
Empty list if either of arguments or both of them are nil

Example: Filter all even numbers 

fp.FilterInt16(isEven, []int32{1, 2, 3, 4}) // Returns [2, 4]

func isEven(num int32) bool {
	return num%2 == 0
}

func FilterInt16Err 

func FilterInt16Err(f func(int16) (bool, error), list []int16) ([]int16, error)

FilterInt16Err takes two arguments

  1. Function: takes 1 argument of type int16 and returns (bool, error)
  2. slice of type []int16

Returns: 

new filtered list and error

func FilterInt16Ptr 

func FilterInt16Ptr(f func(*int16) bool, list []*int16) []*int16

FilterInt16Ptr takes two arguments

  1. Function: takes 1 argument of type int16 and returns bool
  2. slice of type []*int16

Returns: 

new filtered list

func FilterInt16PtrErr 

func FilterInt16PtrErr(f func(*int16) (bool, error), list []*int16) ([]*int16, error)

FilterInt16PtrErr takes two arguments

  1. Function: takes 1 argument of type int16 and returns (bool, error)
  2. slice of type []*int16

Returns: 

new filtered list and error

func FilterInt32 

func FilterInt32(f func(int32) bool, list []int32) []int32

FilterInt32 filters list based on function passed as 1st argument

Takes two inputs

  1. function - Takes 1 input and returns bool
  2. list

Returns: 

New Filtered List.
Empty list if either of arguments or both of them are nil

Example: Filter all even numbers 

fp.FilterInt(isEven, []int32{1, 2, 3, 4}) // Returns [2, 4]

func isEven(num int32) bool {
	return num%2 == 0
}

func FilterInt32Err 

func FilterInt32Err(f func(int32) (bool, error), list []int32) ([]int32, error)

FilterInt32Err takes two arguments

  1. Function: takes 1 argument of type int32 and returns (bool, error)
  2. slice of type []int32

Returns: 

new filtered list and error

func FilterInt32Ptr 

func FilterInt32Ptr(f func(*int32) bool, list []*int32) []*int32

FilterInt32Ptr takes two arguments

  1. Function: takes 1 argument of type int32 and returns bool
  2. slice of type []*int32

Returns: 

new filtered list

func FilterInt32PtrErr 

func FilterInt32PtrErr(f func(*int32) (bool, error), list []*int32) ([]*int32, error)

FilterInt32PtrErr takes two arguments

  1. Function: takes 1 argument of type int32 and returns (bool, error)
  2. slice of type []*int32

Returns: 

new filtered list and error

func FilterInt64 

func FilterInt64(f func(int64) bool, list []int64) []int64

FilterInt64 filters list based on function passed as 1st argument

Takes two inputs

  1. function - Takes 1 input and returns bool
  2. list

Returns: 

New Filtered List.
Empty list if either of arguments or both of them are nil

Example: FilterInt64 all even numbers 

fp.FilterInt(isEven, []int64{1, 2, 3, 4}) // Returns [2, 4]

func isEven(num int64) bool {
	return num%2 == 0
}

func FilterInt64Err 

func FilterInt64Err(f func(int64) (bool, error), list []int64) ([]int64, error)

FilterInt64Err takes two arguments

  1. Function: takes 1 argument of type int64 and returns (bool, error)
  2. slice of type []int64

Returns: 

new filtered list and error

func FilterInt64Ptr 

func FilterInt64Ptr(f func(*int64) bool, list []*int64) []*int64

FilterInt64Ptr takes two arguments

  1. Function: takes 1 argument of type int64 and returns bool
  2. slice of type []*int64

Returns: 

new filtered list

func FilterInt64PtrErr 

func FilterInt64PtrErr(f func(*int64) (bool, error), list []*int64) ([]*int64, error)

FilterInt64PtrErr takes two arguments

  1. Function: takes 1 argument of type int64 and returns (bool, error)
  2. slice of type []*int64

Returns: 

new filtered list and error

func FilterInt8 

func FilterInt8(f func(int8) bool, list []int8) []int8

FilterInt8 filters list based on function passed as 1st argument

Takes two inputs

  1. function - Takes 1 input and returns bool
  2. list

Returns: 

New Filtered List.
Empty list if either of arguments or both of them are nil

Example: Filter all even numbers 

fp.FilterInt8(isEven, []int8{1, 2, 3, 4}) // Returns [2, 4]

func isEven(num int8) bool {
	return num%2 == 0
}

func FilterInt8Err 

func FilterInt8Err(f func(int8) (bool, error), list []int8) ([]int8, error)

FilterInt8Err takes two arguments

  1. Function: takes 1 argument of type int8 and returns (bool, error)
  2. slice of type []int8

Returns: 

new filtered list and error

func FilterInt8Ptr 

func FilterInt8Ptr(f func(*int8) bool, list []*int8) []*int8

FilterInt8Ptr takes two arguments

  1. Function: takes 1 argument of type int8 and returns bool
  2. slice of type []*int8

Returns: 

new filtered list

func FilterInt8PtrErr 

func FilterInt8PtrErr(f func(*int8) (bool, error), list []*int8) ([]*int8, error)

FilterInt8PtrErr takes two arguments

  1. Function: takes 1 argument of type int8 and returns (bool, error)
  2. slice of type []*int8

Returns: 

new filtered list and error

func FilterIntErr 

func FilterIntErr(f func(int) (bool, error), list []int) ([]int, error)

FilterIntErr takes two arguments

  1. Function: takes 1 argument of type int and returns (bool, error)
  2. slice of type []int

Returns: 

new filtered list and error

func FilterIntPtr 

func FilterIntPtr(f func(*int) bool, list []*int) []*int

FilterIntPtr takes two arguments

  1. Function: takes 1 argument of type int and returns bool
  2. slice of type []*int

Returns: 

new filtered list

func FilterIntPtrErr 

func FilterIntPtrErr(f func(*int) (bool, error), list []*int) ([]*int, error)

FilterIntPtrErr takes two arguments

  1. Function: takes 1 argument of type int and returns (bool, error)
  2. slice of type []*int

Returns: 

new filtered list and error

func FilterMapBoolFloat32 

func FilterMapBoolFloat32(fFilter func(bool) bool, fMap func(bool) float32, list []bool) []float32

FilterMapBoolFloat32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - bool and returns true/false.
  2. Function: takes bool as argument and returns float32
  3. List of type bool

Returns: 

	New List of type float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolFloat32Err 

func FilterMapBoolFloat32Err(fFilter func(bool) (bool, error), fMap func(bool) (float32, error), list []bool) ([]float32, error)

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

Returns: 

	New List of type float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolFloat32Ptr 

func FilterMapBoolFloat32Ptr(fFilter func(*bool) bool, fMap func(*bool) *float32, list []*bool) []*float32

FilterMapBoolFloat32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *bool and returns true/false.
  2. Function: takes *bool as argument and returns *float32
  3. List of type *[]bool

Returns: 

	New List of type *float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolFloat32PtrErr 

func FilterMapBoolFloat32PtrErr(fFilter func(*bool) (bool, error), fMap func(*bool) (*float32, error), list []*bool) ([]*float32, error)

FilterMapBoolFloat32PtrErr 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 - *bool and returns (bool, error).
  2. Function: takes *bool as argument and returns (*float32, error)
  3. List of type *bool

Returns: 

	New List of type *float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolFloat64 

func FilterMapBoolFloat64(fFilter func(bool) bool, fMap func(bool) float64, list []bool) []float64

FilterMapBoolFloat64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - bool and returns true/false.
  2. Function: takes bool as argument and returns float64
  3. List of type bool

Returns: 

	New List of type float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolFloat64Err 

func FilterMapBoolFloat64Err(fFilter func(bool) (bool, error), fMap func(bool) (float64, error), list []bool) ([]float64, error)

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

Returns: 

	New List of type float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolFloat64Ptr 

func FilterMapBoolFloat64Ptr(fFilter func(*bool) bool, fMap func(*bool) *float64, list []*bool) []*float64

FilterMapBoolFloat64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *bool and returns true/false.
  2. Function: takes *bool as argument and returns *float64
  3. List of type *[]bool

Returns: 

	New List of type *float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolFloat64PtrErr 

func FilterMapBoolFloat64PtrErr(fFilter func(*bool) (bool, error), fMap func(*bool) (*float64, error), list []*bool) ([]*float64, error)

FilterMapBoolFloat64PtrErr 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 - *bool and returns (bool, error).
  2. Function: takes *bool as argument and returns (*float64, error)
  3. List of type *bool

Returns: 

	New List of type *float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt 

func FilterMapBoolInt(fFilter func(bool) bool, fMap func(bool) int, list []bool) []int

FilterMapBoolInt filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - bool and returns true/false.
  2. Function: takes bool as argument and returns int
  3. List of type bool

Returns: 

	New List of type int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt16 

func FilterMapBoolInt16(fFilter func(bool) bool, fMap func(bool) int16, list []bool) []int16

FilterMapBoolInt16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - bool and returns true/false.
  2. Function: takes bool as argument and returns int16
  3. List of type bool

Returns: 

	New List of type int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt16Err 

func FilterMapBoolInt16Err(fFilter func(bool) (bool, error), fMap func(bool) (int16, error), list []bool) ([]int16, error)

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

Returns: 

	New List of type int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt16Ptr 

func FilterMapBoolInt16Ptr(fFilter func(*bool) bool, fMap func(*bool) *int16, list []*bool) []*int16

FilterMapBoolInt16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *bool and returns true/false.
  2. Function: takes *bool as argument and returns *int16
  3. List of type *[]bool

Returns: 

	New List of type *int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt16PtrErr 

func FilterMapBoolInt16PtrErr(fFilter func(*bool) (bool, error), fMap func(*bool) (*int16, error), list []*bool) ([]*int16, error)

FilterMapBoolInt16PtrErr 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 - *bool and returns (bool, error).
  2. Function: takes *bool as argument and returns (*int16, error)
  3. List of type *bool

Returns: 

	New List of type *int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt32 

func FilterMapBoolInt32(fFilter func(bool) bool, fMap func(bool) int32, list []bool) []int32

FilterMapBoolInt32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - bool and returns true/false.
  2. Function: takes bool as argument and returns int32
  3. List of type bool

Returns: 

	New List of type int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt32Err 

func FilterMapBoolInt32Err(fFilter func(bool) (bool, error), fMap func(bool) (int32, error), list []bool) ([]int32, error)

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

Returns: 

	New List of type int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt32Ptr 

func FilterMapBoolInt32Ptr(fFilter func(*bool) bool, fMap func(*bool) *int32, list []*bool) []*int32

FilterMapBoolInt32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *bool and returns true/false.
  2. Function: takes *bool as argument and returns *int32
  3. List of type *[]bool

Returns: 

	New List of type *int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt32PtrErr 

func FilterMapBoolInt32PtrErr(fFilter func(*bool) (bool, error), fMap func(*bool) (*int32, error), list []*bool) ([]*int32, error)

FilterMapBoolInt32PtrErr 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 - *bool and returns (bool, error).
  2. Function: takes *bool as argument and returns (*int32, error)
  3. List of type *bool

Returns: 

	New List of type *int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt64 

func FilterMapBoolInt64(fFilter func(bool) bool, fMap func(bool) int64, list []bool) []int64

FilterMapBoolInt64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - bool and returns true/false.
  2. Function: takes bool as argument and returns int64
  3. List of type bool

Returns: 

	New List of type int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt64Err 

func FilterMapBoolInt64Err(fFilter func(bool) (bool, error), fMap func(bool) (int64, error), list []bool) ([]int64, error)

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

Returns: 

	New List of type int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt64Ptr 

func FilterMapBoolInt64Ptr(fFilter func(*bool) bool, fMap func(*bool) *int64, list []*bool) []*int64

FilterMapBoolInt64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *bool and returns true/false.
  2. Function: takes *bool as argument and returns *int64
  3. List of type *[]bool

Returns: 

	New List of type *int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt64PtrErr 

func FilterMapBoolInt64PtrErr(fFilter func(*bool) (bool, error), fMap func(*bool) (*int64, error), list []*bool) ([]*int64, error)

FilterMapBoolInt64PtrErr 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 - *bool and returns (bool, error).
  2. Function: takes *bool as argument and returns (*int64, error)
  3. List of type *bool

Returns: 

	New List of type *int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt8 

func FilterMapBoolInt8(fFilter func(bool) bool, fMap func(bool) int8, list []bool) []int8

FilterMapBoolInt8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - bool and returns true/false.
  2. Function: takes bool as argument and returns int8
  3. List of type bool

Returns: 

	New List of type int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt8Err 

func FilterMapBoolInt8Err(fFilter func(bool) (bool, error), fMap func(bool) (int8, error), list []bool) ([]int8, error)

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

Returns: 

	New List of type int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt8Ptr 

func FilterMapBoolInt8Ptr(fFilter func(*bool) bool, fMap func(*bool) *int8, list []*bool) []*int8

FilterMapBoolInt8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *bool and returns true/false.
  2. Function: takes *bool as argument and returns *int8
  3. List of type *[]bool

Returns: 

	New List of type *int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolInt8PtrErr 

func FilterMapBoolInt8PtrErr(fFilter func(*bool) (bool, error), fMap func(*bool) (*int8, error), list []*bool) ([]*int8, error)

FilterMapBoolInt8PtrErr 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 - *bool and returns (bool, error).
  2. Function: takes *bool as argument and returns (*int8, error)
  3. List of type *bool

Returns: 

	New List of type *int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolIntErr 

func FilterMapBoolIntErr(fFilter func(bool) (bool, error), fMap func(bool) (int, error), list []bool) ([]int, error)

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

Returns: 

	New List of type int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolIntPtr 

func FilterMapBoolIntPtr(fFilter func(*bool) bool, fMap func(*bool) *int, list []*bool) []*int

FilterMapBoolIntPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *bool and returns true/false.
  2. Function: takes *bool as argument and returns *int
  3. List of type *[]bool

Returns: 

	New List of type *int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolIntPtrErr 

func FilterMapBoolIntPtrErr(fFilter func(*bool) (bool, error), fMap func(*bool) (*int, error), list []*bool) ([]*int, error)

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

Returns: 

	New List of type *int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolPtr 

func FilterMapBoolPtr(fFilter func(*bool) bool, fMap func(*bool) *bool, list []*bool) []*bool

FilterMapBoolPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns (bool).
  2. Function: takes bool as argument and returns (bool)
  3. Slice of type []*bool

Returns: 

	New List of type []*bool.
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolStr 

func FilterMapBoolStr(fFilter func(bool) bool, fMap func(bool) string, list []bool) []string

FilterMapBoolStr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - bool and returns true/false.
  2. Function: takes bool as argument and returns string
  3. List of type bool

Returns: 

	New List of type string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolStrErr 

func FilterMapBoolStrErr(fFilter func(bool) (bool, error), fMap func(bool) (string, error), list []bool) ([]string, error)

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

Returns: 

	New List of type string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolStrPtr 

func FilterMapBoolStrPtr(fFilter func(*bool) bool, fMap func(*bool) *string, list []*bool) []*string

FilterMapBoolStrPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *bool and returns true/false.
  2. Function: takes *bool as argument and returns *string
  3. List of type *[]bool

Returns: 

	New List of type *string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolStrPtrErr 

func FilterMapBoolStrPtrErr(fFilter func(*bool) (bool, error), fMap func(*bool) (*string, error), list []*bool) ([]*string, error)

FilterMapBoolStrPtrErr 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 - *bool and returns (bool, error).
  2. Function: takes *bool as argument and returns (*string, error)
  3. List of type *bool

Returns: 

	New List of type *string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint 

func FilterMapBoolUint(fFilter func(bool) bool, fMap func(bool) uint, list []bool) []uint

FilterMapBoolUint filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - bool and returns true/false.
  2. Function: takes bool as argument and returns uint
  3. List of type bool

Returns: 

	New List of type uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint16 

func FilterMapBoolUint16(fFilter func(bool) bool, fMap func(bool) uint16, list []bool) []uint16

FilterMapBoolUint16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - bool and returns true/false.
  2. Function: takes bool as argument and returns uint16
  3. List of type bool

Returns: 

	New List of type uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint16Err 

func FilterMapBoolUint16Err(fFilter func(bool) (bool, error), fMap func(bool) (uint16, error), list []bool) ([]uint16, error)

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

Returns: 

	New List of type uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint16Ptr 

func FilterMapBoolUint16Ptr(fFilter func(*bool) bool, fMap func(*bool) *uint16, list []*bool) []*uint16

FilterMapBoolUint16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *bool and returns true/false.
  2. Function: takes *bool as argument and returns *uint16
  3. List of type *[]bool

Returns: 

	New List of type *uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint16PtrErr 

func FilterMapBoolUint16PtrErr(fFilter func(*bool) (bool, error), fMap func(*bool) (*uint16, error), list []*bool) ([]*uint16, error)

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

Returns: 

	New List of type *uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint32 

func FilterMapBoolUint32(fFilter func(bool) bool, fMap func(bool) uint32, list []bool) []uint32

FilterMapBoolUint32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - bool and returns true/false.
  2. Function: takes bool as argument and returns uint32
  3. List of type bool

Returns: 

	New List of type uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint32Err 

func FilterMapBoolUint32Err(fFilter func(bool) (bool, error), fMap func(bool) (uint32, error), list []bool) ([]uint32, error)

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

Returns: 

	New List of type uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint32Ptr 

func FilterMapBoolUint32Ptr(fFilter func(*bool) bool, fMap func(*bool) *uint32, list []*bool) []*uint32

FilterMapBoolUint32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *bool and returns true/false.
  2. Function: takes *bool as argument and returns *uint32
  3. List of type *[]bool

Returns: 

	New List of type *uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint32PtrErr 

func FilterMapBoolUint32PtrErr(fFilter func(*bool) (bool, error), fMap func(*bool) (*uint32, error), list []*bool) ([]*uint32, error)

FilterMapBoolUint32PtrErr 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 - *bool and returns (bool, error).
  2. Function: takes *bool as argument and returns (*uint32, error)
  3. List of type *bool

Returns: 

	New List of type *uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint64 

func FilterMapBoolUint64(fFilter func(bool) bool, fMap func(bool) uint64, list []bool) []uint64

FilterMapBoolUint64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - bool and returns true/false.
  2. Function: takes bool as argument and returns uint64
  3. List of type bool

Returns: 

	New List of type uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint64Err 

func FilterMapBoolUint64Err(fFilter func(bool) (bool, error), fMap func(bool) (uint64, error), list []bool) ([]uint64, error)

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

Returns: 

	New List of type uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint64Ptr 

func FilterMapBoolUint64Ptr(fFilter func(*bool) bool, fMap func(*bool) *uint64, list []*bool) []*uint64

FilterMapBoolUint64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *bool and returns true/false.
  2. Function: takes *bool as argument and returns *uint64
  3. List of type *[]bool

Returns: 

	New List of type *uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint64PtrErr 

func FilterMapBoolUint64PtrErr(fFilter func(*bool) (bool, error), fMap func(*bool) (*uint64, error), list []*bool) ([]*uint64, error)

FilterMapBoolUint64PtrErr 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 - *bool and returns (bool, error).
  2. Function: takes *bool as argument and returns (*uint64, error)
  3. List of type *bool

Returns: 

	New List of type *uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint8 

func FilterMapBoolUint8(fFilter func(bool) bool, fMap func(bool) uint8, list []bool) []uint8

FilterMapBoolUint8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - bool and returns true/false.
  2. Function: takes bool as argument and returns uint8
  3. List of type bool

Returns: 

	New List of type uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint8Err 

func FilterMapBoolUint8Err(fFilter func(bool) (bool, error), fMap func(bool) (uint8, error), list []bool) ([]uint8, error)

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

Returns: 

	New List of type uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint8Ptr 

func FilterMapBoolUint8Ptr(fFilter func(*bool) bool, fMap func(*bool) *uint8, list []*bool) []*uint8

FilterMapBoolUint8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *bool and returns true/false.
  2. Function: takes *bool as argument and returns *uint8
  3. List of type *[]bool

Returns: 

	New List of type *uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUint8PtrErr 

func FilterMapBoolUint8PtrErr(fFilter func(*bool) (bool, error), fMap func(*bool) (*uint8, error), list []*bool) ([]*uint8, error)

FilterMapBoolUint8PtrErr 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 - *bool and returns (bool, error).
  2. Function: takes *bool as argument and returns (*uint8, error)
  3. List of type *bool

Returns: 

	New List of type *uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUintErr 

func FilterMapBoolUintErr(fFilter func(bool) (bool, error), fMap func(bool) (uint, error), list []bool) ([]uint, error)

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

Returns: 

	New List of type uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUintPtr 

func FilterMapBoolUintPtr(fFilter func(*bool) bool, fMap func(*bool) *uint, list []*bool) []*uint

FilterMapBoolUintPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *bool and returns true/false.
  2. Function: takes *bool as argument and returns *uint
  3. List of type *[]bool

Returns: 

	New List of type *uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapBoolUintPtrErr 

func FilterMapBoolUintPtrErr(fFilter func(*bool) (bool, error), fMap func(*bool) (*uint, error), list []*bool) ([]*uint, error)

FilterMapBoolUintPtrErr 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 - *bool and returns (bool, error).
  2. Function: takes *bool as argument and returns (*uint, error)
  3. List of type *bool

Returns: 

	New List of type *uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32 

func FilterMapFloat32(fFilter func(float32) bool, fMap func(float32) float32, list []float32) []float32

FilterMapFloat32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns true/false.
  2. Function: takes int as argument and returns int
  3. List

Returns: 

	New List.
 Empty list if all there parameters are nil or either of parameter is nil

Example: Multiply all positive numbers in the list by 2 

fp.FilterMapFloat32(isPositive, multiplyBy2, []float32{-1, 0, 2, 4}) // Returns [4, 8]

func isPositive(num float32) bool {
	return num > 0
}

func multiplyBy2(num float32) float32 {
	return num * 2
}

func FilterMapFloat32Bool 

func FilterMapFloat32Bool(fFilter func(float32) bool, fMap func(float32) bool, list []float32) []bool

FilterMapFloat32Bool filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float32 and returns true/false.
  2. Function: takes float32 as argument and returns bool
  3. List of type float32

Returns: 

	New List of type bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32BoolErr 

func FilterMapFloat32BoolErr(fFilter func(float32) (bool, error), fMap func(float32) (bool, error), list []float32) ([]bool, error)

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

Returns: 

	New List of type bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32BoolPtr 

func FilterMapFloat32BoolPtr(fFilter func(*float32) bool, fMap func(*float32) *bool, list []*float32) []*bool

FilterMapFloat32BoolPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float32 and returns true/false.
  2. Function: takes *float32 as argument and returns *bool
  3. List of type *[]float32

Returns: 

	New List of type *bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32BoolPtrErr 

func FilterMapFloat32BoolPtrErr(fFilter func(*float32) (bool, error), fMap func(*float32) (*bool, error), list []*float32) ([]*bool, error)

FilterMapFloat32BoolPtrErr 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 - *float32 and returns (bool, error).
  2. Function: takes *float32 as argument and returns (*bool, error)
  3. List of type *float32

Returns: 

	New List of type *bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Err 

func FilterMapFloat32Err(fFilter func(float32) (bool, error), fMap func(float32) (float32, error), list []float32) ([]float32, error)

FilterMapFloat32Err filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(float32) and returns (bool, error).
  2. Function: takes float32 as argument and returns (float32, error)
  3. Slice of type []float32

Returns: 

	New List ([]float32, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Float64 

func FilterMapFloat32Float64(fFilter func(float32) bool, fMap func(float32) float64, list []float32) []float64

FilterMapFloat32Float64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float32 and returns true/false.
  2. Function: takes float32 as argument and returns float64
  3. List of type float32

Returns: 

	New List of type float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Float64Err 

func FilterMapFloat32Float64Err(fFilter func(float32) (bool, error), fMap func(float32) (float64, error), list []float32) ([]float64, error)

FilterMapFloat32Float64Err 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 - float32 and returns (bool, error).
  2. Function: takes float32 as argument and returns (float64, error)
  3. List of type float32

Returns: 

	New List of type float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Float64Ptr 

func FilterMapFloat32Float64Ptr(fFilter func(*float32) bool, fMap func(*float32) *float64, list []*float32) []*float64

FilterMapFloat32Float64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float32 and returns true/false.
  2. Function: takes *float32 as argument and returns *float64
  3. List of type *[]float32

Returns: 

	New List of type *float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Float64PtrErr 

func FilterMapFloat32Float64PtrErr(fFilter func(*float32) (bool, error), fMap func(*float32) (*float64, error), list []*float32) ([]*float64, error)

FilterMapFloat32Float64PtrErr 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 - *float32 and returns (bool, error).
  2. Function: takes *float32 as argument and returns (*float64, error)
  3. List of type *float32

Returns: 

	New List of type *float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int 

func FilterMapFloat32Int(fFilter func(float32) bool, fMap func(float32) int, list []float32) []int

FilterMapFloat32Int filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float32 and returns true/false.
  2. Function: takes float32 as argument and returns int
  3. List of type float32

Returns: 

	New List of type int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int16 

func FilterMapFloat32Int16(fFilter func(float32) bool, fMap func(float32) int16, list []float32) []int16

FilterMapFloat32Int16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float32 and returns true/false.
  2. Function: takes float32 as argument and returns int16
  3. List of type float32

Returns: 

	New List of type int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int16Err 

func FilterMapFloat32Int16Err(fFilter func(float32) (bool, error), fMap func(float32) (int16, error), list []float32) ([]int16, error)

FilterMapFloat32Int16Err 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 - float32 and returns (bool, error).
  2. Function: takes float32 as argument and returns (int16, error)
  3. List of type float32

Returns: 

	New List of type int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int16Ptr 

func FilterMapFloat32Int16Ptr(fFilter func(*float32) bool, fMap func(*float32) *int16, list []*float32) []*int16

FilterMapFloat32Int16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float32 and returns true/false.
  2. Function: takes *float32 as argument and returns *int16
  3. List of type *[]float32

Returns: 

	New List of type *int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int16PtrErr 

func FilterMapFloat32Int16PtrErr(fFilter func(*float32) (bool, error), fMap func(*float32) (*int16, error), list []*float32) ([]*int16, error)

FilterMapFloat32Int16PtrErr 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 - *float32 and returns (bool, error).
  2. Function: takes *float32 as argument and returns (*int16, error)
  3. List of type *float32

Returns: 

	New List of type *int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int32 

func FilterMapFloat32Int32(fFilter func(float32) bool, fMap func(float32) int32, list []float32) []int32

FilterMapFloat32Int32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float32 and returns true/false.
  2. Function: takes float32 as argument and returns int32
  3. List of type float32

Returns: 

	New List of type int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int32Err 

func FilterMapFloat32Int32Err(fFilter func(float32) (bool, error), fMap func(float32) (int32, error), list []float32) ([]int32, error)

FilterMapFloat32Int32Err 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 - float32 and returns (bool, error).
  2. Function: takes float32 as argument and returns (int32, error)
  3. List of type float32

Returns: 

	New List of type int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int32Ptr 

func FilterMapFloat32Int32Ptr(fFilter func(*float32) bool, fMap func(*float32) *int32, list []*float32) []*int32

FilterMapFloat32Int32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float32 and returns true/false.
  2. Function: takes *float32 as argument and returns *int32
  3. List of type *[]float32

Returns: 

	New List of type *int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int32PtrErr 

func FilterMapFloat32Int32PtrErr(fFilter func(*float32) (bool, error), fMap func(*float32) (*int32, error), list []*float32) ([]*int32, error)

FilterMapFloat32Int32PtrErr 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 - *float32 and returns (bool, error).
  2. Function: takes *float32 as argument and returns (*int32, error)
  3. List of type *float32

Returns: 

	New List of type *int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int64 

func FilterMapFloat32Int64(fFilter func(float32) bool, fMap func(float32) int64, list []float32) []int64

FilterMapFloat32Int64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float32 and returns true/false.
  2. Function: takes float32 as argument and returns int64
  3. List of type float32

Returns: 

	New List of type int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int64Err 

func FilterMapFloat32Int64Err(fFilter func(float32) (bool, error), fMap func(float32) (int64, error), list []float32) ([]int64, error)

FilterMapFloat32Int64Err 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 - float32 and returns (bool, error).
  2. Function: takes float32 as argument and returns (int64, error)
  3. List of type float32

Returns: 

	New List of type int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int64Ptr 

func FilterMapFloat32Int64Ptr(fFilter func(*float32) bool, fMap func(*float32) *int64, list []*float32) []*int64

FilterMapFloat32Int64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float32 and returns true/false.
  2. Function: takes *float32 as argument and returns *int64
  3. List of type *[]float32

Returns: 

	New List of type *int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int64PtrErr 

func FilterMapFloat32Int64PtrErr(fFilter func(*float32) (bool, error), fMap func(*float32) (*int64, error), list []*float32) ([]*int64, error)

FilterMapFloat32Int64PtrErr 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 - *float32 and returns (bool, error).
  2. Function: takes *float32 as argument and returns (*int64, error)
  3. List of type *float32

Returns: 

	New List of type *int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int8 

func FilterMapFloat32Int8(fFilter func(float32) bool, fMap func(float32) int8, list []float32) []int8

FilterMapFloat32Int8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float32 and returns true/false.
  2. Function: takes float32 as argument and returns int8
  3. List of type float32

Returns: 

	New List of type int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int8Err 

func FilterMapFloat32Int8Err(fFilter func(float32) (bool, error), fMap func(float32) (int8, error), list []float32) ([]int8, error)

FilterMapFloat32Int8Err 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 - float32 and returns (bool, error).
  2. Function: takes float32 as argument and returns (int8, error)
  3. List of type float32

Returns: 

	New List of type int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int8Ptr 

func FilterMapFloat32Int8Ptr(fFilter func(*float32) bool, fMap func(*float32) *int8, list []*float32) []*int8

FilterMapFloat32Int8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float32 and returns true/false.
  2. Function: takes *float32 as argument and returns *int8
  3. List of type *[]float32

Returns: 

	New List of type *int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Int8PtrErr 

func FilterMapFloat32Int8PtrErr(fFilter func(*float32) (bool, error), fMap func(*float32) (*int8, error), list []*float32) ([]*int8, error)

FilterMapFloat32Int8PtrErr 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 - *float32 and returns (bool, error).
  2. Function: takes *float32 as argument and returns (*int8, error)
  3. List of type *float32

Returns: 

	New List of type *int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32IntErr 

func FilterMapFloat32IntErr(fFilter func(float32) (bool, error), fMap func(float32) (int, error), list []float32) ([]int, error)

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

Returns: 

	New List of type int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32IntPtr 

func FilterMapFloat32IntPtr(fFilter func(*float32) bool, fMap func(*float32) *int, list []*float32) []*int

FilterMapFloat32IntPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float32 and returns true/false.
  2. Function: takes *float32 as argument and returns *int
  3. List of type *[]float32

Returns: 

	New List of type *int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32IntPtrErr 

func FilterMapFloat32IntPtrErr(fFilter func(*float32) (bool, error), fMap func(*float32) (*int, error), list []*float32) ([]*int, error)

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

Returns: 

	New List of type *int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Ptr 

func FilterMapFloat32Ptr(fFilter func(*float32) bool, fMap func(*float32) *float32, list []*float32) []*float32

FilterMapFloat32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns (bool).
  2. Function: takes float32 as argument and returns (float32)
  3. Slice of type []*float32

Returns: 

	New List of type []*float32.
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32PtrErr 

func FilterMapFloat32PtrErr(fFilter func(*float32) (bool, error), fMap func(*float32) (*float32, error), list []*float32) ([]*float32, error)

FilterMapFloat32PtrErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(*float32) and returns (bool, error).
  2. Function: takes *float32 as argument and returns (*float32, error)
  3. Slice of type []*float32

Returns: 

	New List ([]*float32, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Str 

func FilterMapFloat32Str(fFilter func(float32) bool, fMap func(float32) string, list []float32) []string

FilterMapFloat32Str filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float32 and returns true/false.
  2. Function: takes float32 as argument and returns string
  3. List of type float32

Returns: 

	New List of type string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32StrErr 

func FilterMapFloat32StrErr(fFilter func(float32) (bool, error), fMap func(float32) (string, error), list []float32) ([]string, error)

FilterMapFloat32StrErr 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 - float32 and returns (bool, error).
  2. Function: takes float32 as argument and returns (string, error)
  3. List of type float32

Returns: 

	New List of type string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32StrPtr 

func FilterMapFloat32StrPtr(fFilter func(*float32) bool, fMap func(*float32) *string, list []*float32) []*string

FilterMapFloat32StrPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float32 and returns true/false.
  2. Function: takes *float32 as argument and returns *string
  3. List of type *[]float32

Returns: 

	New List of type *string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32StrPtrErr 

func FilterMapFloat32StrPtrErr(fFilter func(*float32) (bool, error), fMap func(*float32) (*string, error), list []*float32) ([]*string, error)

FilterMapFloat32StrPtrErr 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 - *float32 and returns (bool, error).
  2. Function: takes *float32 as argument and returns (*string, error)
  3. List of type *float32

Returns: 

	New List of type *string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint 

func FilterMapFloat32Uint(fFilter func(float32) bool, fMap func(float32) uint, list []float32) []uint

FilterMapFloat32Uint filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float32 and returns true/false.
  2. Function: takes float32 as argument and returns uint
  3. List of type float32

Returns: 

	New List of type uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint16 

func FilterMapFloat32Uint16(fFilter func(float32) bool, fMap func(float32) uint16, list []float32) []uint16

FilterMapFloat32Uint16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float32 and returns true/false.
  2. Function: takes float32 as argument and returns uint16
  3. List of type float32

Returns: 

	New List of type uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint16Err 

func FilterMapFloat32Uint16Err(fFilter func(float32) (bool, error), fMap func(float32) (uint16, error), list []float32) ([]uint16, error)

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

Returns: 

	New List of type uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint16Ptr 

func FilterMapFloat32Uint16Ptr(fFilter func(*float32) bool, fMap func(*float32) *uint16, list []*float32) []*uint16

FilterMapFloat32Uint16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float32 and returns true/false.
  2. Function: takes *float32 as argument and returns *uint16
  3. List of type *[]float32

Returns: 

	New List of type *uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint16PtrErr 

func FilterMapFloat32Uint16PtrErr(fFilter func(*float32) (bool, error), fMap func(*float32) (*uint16, error), list []*float32) ([]*uint16, error)

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

Returns: 

	New List of type *uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint32 

func FilterMapFloat32Uint32(fFilter func(float32) bool, fMap func(float32) uint32, list []float32) []uint32

FilterMapFloat32Uint32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float32 and returns true/false.
  2. Function: takes float32 as argument and returns uint32
  3. List of type float32

Returns: 

	New List of type uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint32Err 

func FilterMapFloat32Uint32Err(fFilter func(float32) (bool, error), fMap func(float32) (uint32, error), list []float32) ([]uint32, error)

FilterMapFloat32Uint32Err 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 - float32 and returns (bool, error).
  2. Function: takes float32 as argument and returns (uint32, error)
  3. List of type float32

Returns: 

	New List of type uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint32Ptr 

func FilterMapFloat32Uint32Ptr(fFilter func(*float32) bool, fMap func(*float32) *uint32, list []*float32) []*uint32

FilterMapFloat32Uint32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float32 and returns true/false.
  2. Function: takes *float32 as argument and returns *uint32
  3. List of type *[]float32

Returns: 

	New List of type *uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint32PtrErr 

func FilterMapFloat32Uint32PtrErr(fFilter func(*float32) (bool, error), fMap func(*float32) (*uint32, error), list []*float32) ([]*uint32, error)

FilterMapFloat32Uint32PtrErr 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 - *float32 and returns (bool, error).
  2. Function: takes *float32 as argument and returns (*uint32, error)
  3. List of type *float32

Returns: 

	New List of type *uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint64 

func FilterMapFloat32Uint64(fFilter func(float32) bool, fMap func(float32) uint64, list []float32) []uint64

FilterMapFloat32Uint64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float32 and returns true/false.
  2. Function: takes float32 as argument and returns uint64
  3. List of type float32

Returns: 

	New List of type uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint64Err 

func FilterMapFloat32Uint64Err(fFilter func(float32) (bool, error), fMap func(float32) (uint64, error), list []float32) ([]uint64, error)

FilterMapFloat32Uint64Err 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 - float32 and returns (bool, error).
  2. Function: takes float32 as argument and returns (uint64, error)
  3. List of type float32

Returns: 

	New List of type uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint64Ptr 

func FilterMapFloat32Uint64Ptr(fFilter func(*float32) bool, fMap func(*float32) *uint64, list []*float32) []*uint64

FilterMapFloat32Uint64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float32 and returns true/false.
  2. Function: takes *float32 as argument and returns *uint64
  3. List of type *[]float32

Returns: 

	New List of type *uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint64PtrErr 

func FilterMapFloat32Uint64PtrErr(fFilter func(*float32) (bool, error), fMap func(*float32) (*uint64, error), list []*float32) ([]*uint64, error)

FilterMapFloat32Uint64PtrErr 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 - *float32 and returns (bool, error).
  2. Function: takes *float32 as argument and returns (*uint64, error)
  3. List of type *float32

Returns: 

	New List of type *uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint8 

func FilterMapFloat32Uint8(fFilter func(float32) bool, fMap func(float32) uint8, list []float32) []uint8

FilterMapFloat32Uint8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float32 and returns true/false.
  2. Function: takes float32 as argument and returns uint8
  3. List of type float32

Returns: 

	New List of type uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint8Err 

func FilterMapFloat32Uint8Err(fFilter func(float32) (bool, error), fMap func(float32) (uint8, error), list []float32) ([]uint8, error)

FilterMapFloat32Uint8Err 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 - float32 and returns (bool, error).
  2. Function: takes float32 as argument and returns (uint8, error)
  3. List of type float32

Returns: 

	New List of type uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint8Ptr 

func FilterMapFloat32Uint8Ptr(fFilter func(*float32) bool, fMap func(*float32) *uint8, list []*float32) []*uint8

FilterMapFloat32Uint8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float32 and returns true/false.
  2. Function: takes *float32 as argument and returns *uint8
  3. List of type *[]float32

Returns: 

	New List of type *uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32Uint8PtrErr 

func FilterMapFloat32Uint8PtrErr(fFilter func(*float32) (bool, error), fMap func(*float32) (*uint8, error), list []*float32) ([]*uint8, error)

FilterMapFloat32Uint8PtrErr 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 - *float32 and returns (bool, error).
  2. Function: takes *float32 as argument and returns (*uint8, error)
  3. List of type *float32

Returns: 

	New List of type *uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32UintErr 

func FilterMapFloat32UintErr(fFilter func(float32) (bool, error), fMap func(float32) (uint, error), list []float32) ([]uint, error)

FilterMapFloat32UintErr 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 - float32 and returns (bool, error).
  2. Function: takes float32 as argument and returns (uint, error)
  3. List of type float32

Returns: 

	New List of type uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32UintPtr 

func FilterMapFloat32UintPtr(fFilter func(*float32) bool, fMap func(*float32) *uint, list []*float32) []*uint

FilterMapFloat32UintPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float32 and returns true/false.
  2. Function: takes *float32 as argument and returns *uint
  3. List of type *[]float32

Returns: 

	New List of type *uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat32UintPtrErr 

func FilterMapFloat32UintPtrErr(fFilter func(*float32) (bool, error), fMap func(*float32) (*uint, error), list []*float32) ([]*uint, error)

FilterMapFloat32UintPtrErr 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 - *float32 and returns (bool, error).
  2. Function: takes *float32 as argument and returns (*uint, error)
  3. List of type *float32

Returns: 

	New List of type *uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64 

func FilterMapFloat64(fFilter func(float64) bool, fMap func(float64) float64, list []float64) []float64

FilterMapFloat64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns true/false.
  2. Function: takes int as argument and returns int
  3. List

Returns: 

	New List.
 Empty list if all there parameters are nil or either of parameter is nil

Example: Multiply all positive numbers in the list by 2 

fp.FilterMapFloat64(isPositive, multiplyBy2, []float64{-1, 0, 2, 4}) // Returns [4, 8]

func isPositive(num float64) bool {
	return num > 0
}

func multiplyBy2(num float64) float64 {
	return num * 2
}

func FilterMapFloat64Bool 

func FilterMapFloat64Bool(fFilter func(float64) bool, fMap func(float64) bool, list []float64) []bool

FilterMapFloat64Bool filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float64 and returns true/false.
  2. Function: takes float64 as argument and returns bool
  3. List of type float64

Returns: 

	New List of type bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64BoolErr 

func FilterMapFloat64BoolErr(fFilter func(float64) (bool, error), fMap func(float64) (bool, error), list []float64) ([]bool, error)

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

Returns: 

	New List of type bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64BoolPtr 

func FilterMapFloat64BoolPtr(fFilter func(*float64) bool, fMap func(*float64) *bool, list []*float64) []*bool

FilterMapFloat64BoolPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float64 and returns true/false.
  2. Function: takes *float64 as argument and returns *bool
  3. List of type *[]float64

Returns: 

	New List of type *bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64BoolPtrErr 

func FilterMapFloat64BoolPtrErr(fFilter func(*float64) (bool, error), fMap func(*float64) (*bool, error), list []*float64) ([]*bool, error)

FilterMapFloat64BoolPtrErr 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 - *float64 and returns (bool, error).
  2. Function: takes *float64 as argument and returns (*bool, error)
  3. List of type *float64

Returns: 

	New List of type *bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Err 

func FilterMapFloat64Err(fFilter func(float64) (bool, error), fMap func(float64) (float64, error), list []float64) ([]float64, error)

FilterMapFloat64Err filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(float64) and returns (bool, error).
  2. Function: takes float64 as argument and returns (float64, error)
  3. Slice of type []float64

Returns: 

	New List ([]float64, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Float32 

func FilterMapFloat64Float32(fFilter func(float64) bool, fMap func(float64) float32, list []float64) []float32

FilterMapFloat64Float32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float64 and returns true/false.
  2. Function: takes float64 as argument and returns float32
  3. List of type float64

Returns: 

	New List of type float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Float32Err 

func FilterMapFloat64Float32Err(fFilter func(float64) (bool, error), fMap func(float64) (float32, error), list []float64) ([]float32, error)

FilterMapFloat64Float32Err 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 - float64 and returns (bool, error).
  2. Function: takes float64 as argument and returns (float32, error)
  3. List of type float64

Returns: 

	New List of type float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Float32Ptr 

func FilterMapFloat64Float32Ptr(fFilter func(*float64) bool, fMap func(*float64) *float32, list []*float64) []*float32

FilterMapFloat64Float32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float64 and returns true/false.
  2. Function: takes *float64 as argument and returns *float32
  3. List of type *[]float64

Returns: 

	New List of type *float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Float32PtrErr 

func FilterMapFloat64Float32PtrErr(fFilter func(*float64) (bool, error), fMap func(*float64) (*float32, error), list []*float64) ([]*float32, error)

FilterMapFloat64Float32PtrErr 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 - *float64 and returns (bool, error).
  2. Function: takes *float64 as argument and returns (*float32, error)
  3. List of type *float64

Returns: 

	New List of type *float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int 

func FilterMapFloat64Int(fFilter func(float64) bool, fMap func(float64) int, list []float64) []int

FilterMapFloat64Int filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float64 and returns true/false.
  2. Function: takes float64 as argument and returns int
  3. List of type float64

Returns: 

	New List of type int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int16 

func FilterMapFloat64Int16(fFilter func(float64) bool, fMap func(float64) int16, list []float64) []int16

FilterMapFloat64Int16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float64 and returns true/false.
  2. Function: takes float64 as argument and returns int16
  3. List of type float64

Returns: 

	New List of type int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int16Err 

func FilterMapFloat64Int16Err(fFilter func(float64) (bool, error), fMap func(float64) (int16, error), list []float64) ([]int16, error)

FilterMapFloat64Int16Err 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 - float64 and returns (bool, error).
  2. Function: takes float64 as argument and returns (int16, error)
  3. List of type float64

Returns: 

	New List of type int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int16Ptr 

func FilterMapFloat64Int16Ptr(fFilter func(*float64) bool, fMap func(*float64) *int16, list []*float64) []*int16

FilterMapFloat64Int16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float64 and returns true/false.
  2. Function: takes *float64 as argument and returns *int16
  3. List of type *[]float64

Returns: 

	New List of type *int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int16PtrErr 

func FilterMapFloat64Int16PtrErr(fFilter func(*float64) (bool, error), fMap func(*float64) (*int16, error), list []*float64) ([]*int16, error)

FilterMapFloat64Int16PtrErr 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 - *float64 and returns (bool, error).
  2. Function: takes *float64 as argument and returns (*int16, error)
  3. List of type *float64

Returns: 

	New List of type *int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int32 

func FilterMapFloat64Int32(fFilter func(float64) bool, fMap func(float64) int32, list []float64) []int32

FilterMapFloat64Int32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float64 and returns true/false.
  2. Function: takes float64 as argument and returns int32
  3. List of type float64

Returns: 

	New List of type int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int32Err 

func FilterMapFloat64Int32Err(fFilter func(float64) (bool, error), fMap func(float64) (int32, error), list []float64) ([]int32, error)

FilterMapFloat64Int32Err 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 - float64 and returns (bool, error).
  2. Function: takes float64 as argument and returns (int32, error)
  3. List of type float64

Returns: 

	New List of type int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int32Ptr 

func FilterMapFloat64Int32Ptr(fFilter func(*float64) bool, fMap func(*float64) *int32, list []*float64) []*int32

FilterMapFloat64Int32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float64 and returns true/false.
  2. Function: takes *float64 as argument and returns *int32
  3. List of type *[]float64

Returns: 

	New List of type *int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int32PtrErr 

func FilterMapFloat64Int32PtrErr(fFilter func(*float64) (bool, error), fMap func(*float64) (*int32, error), list []*float64) ([]*int32, error)

FilterMapFloat64Int32PtrErr 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 - *float64 and returns (bool, error).
  2. Function: takes *float64 as argument and returns (*int32, error)
  3. List of type *float64

Returns: 

	New List of type *int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int64 

func FilterMapFloat64Int64(fFilter func(float64) bool, fMap func(float64) int64, list []float64) []int64

FilterMapFloat64Int64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float64 and returns true/false.
  2. Function: takes float64 as argument and returns int64
  3. List of type float64

Returns: 

	New List of type int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int64Err 

func FilterMapFloat64Int64Err(fFilter func(float64) (bool, error), fMap func(float64) (int64, error), list []float64) ([]int64, error)

FilterMapFloat64Int64Err 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 - float64 and returns (bool, error).
  2. Function: takes float64 as argument and returns (int64, error)
  3. List of type float64

Returns: 

	New List of type int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int64Ptr 

func FilterMapFloat64Int64Ptr(fFilter func(*float64) bool, fMap func(*float64) *int64, list []*float64) []*int64

FilterMapFloat64Int64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float64 and returns true/false.
  2. Function: takes *float64 as argument and returns *int64
  3. List of type *[]float64

Returns: 

	New List of type *int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int64PtrErr 

func FilterMapFloat64Int64PtrErr(fFilter func(*float64) (bool, error), fMap func(*float64) (*int64, error), list []*float64) ([]*int64, error)

FilterMapFloat64Int64PtrErr 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 - *float64 and returns (bool, error).
  2. Function: takes *float64 as argument and returns (*int64, error)
  3. List of type *float64

Returns: 

	New List of type *int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int8 

func FilterMapFloat64Int8(fFilter func(float64) bool, fMap func(float64) int8, list []float64) []int8

FilterMapFloat64Int8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float64 and returns true/false.
  2. Function: takes float64 as argument and returns int8
  3. List of type float64

Returns: 

	New List of type int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int8Err 

func FilterMapFloat64Int8Err(fFilter func(float64) (bool, error), fMap func(float64) (int8, error), list []float64) ([]int8, error)

FilterMapFloat64Int8Err 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 - float64 and returns (bool, error).
  2. Function: takes float64 as argument and returns (int8, error)
  3. List of type float64

Returns: 

	New List of type int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int8Ptr 

func FilterMapFloat64Int8Ptr(fFilter func(*float64) bool, fMap func(*float64) *int8, list []*float64) []*int8

FilterMapFloat64Int8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float64 and returns true/false.
  2. Function: takes *float64 as argument and returns *int8
  3. List of type *[]float64

Returns: 

	New List of type *int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Int8PtrErr 

func FilterMapFloat64Int8PtrErr(fFilter func(*float64) (bool, error), fMap func(*float64) (*int8, error), list []*float64) ([]*int8, error)

FilterMapFloat64Int8PtrErr 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 - *float64 and returns (bool, error).
  2. Function: takes *float64 as argument and returns (*int8, error)
  3. List of type *float64

Returns: 

	New List of type *int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64IntErr 

func FilterMapFloat64IntErr(fFilter func(float64) (bool, error), fMap func(float64) (int, error), list []float64) ([]int, error)

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

Returns: 

	New List of type int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64IntPtr 

func FilterMapFloat64IntPtr(fFilter func(*float64) bool, fMap func(*float64) *int, list []*float64) []*int

FilterMapFloat64IntPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float64 and returns true/false.
  2. Function: takes *float64 as argument and returns *int
  3. List of type *[]float64

Returns: 

	New List of type *int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64IntPtrErr 

func FilterMapFloat64IntPtrErr(fFilter func(*float64) (bool, error), fMap func(*float64) (*int, error), list []*float64) ([]*int, error)

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

Returns: 

	New List of type *int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Ptr 

func FilterMapFloat64Ptr(fFilter func(*float64) bool, fMap func(*float64) *float64, list []*float64) []*float64

FilterMapFloat64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns (bool).
  2. Function: takes float64 as argument and returns (float64)
  3. Slice of type []*float64

Returns: 

	New List of type []*float64.
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64PtrErr 

func FilterMapFloat64PtrErr(fFilter func(*float64) (bool, error), fMap func(*float64) (*float64, error), list []*float64) ([]*float64, error)

FilterMapFloat64PtrErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(*float64) and returns (bool, error).
  2. Function: takes *float64 as argument and returns (*float64, error)
  3. Slice of type []*float64

Returns: 

	New List ([]*float64, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Str 

func FilterMapFloat64Str(fFilter func(float64) bool, fMap func(float64) string, list []float64) []string

FilterMapFloat64Str filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float64 and returns true/false.
  2. Function: takes float64 as argument and returns string
  3. List of type float64

Returns: 

	New List of type string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64StrErr 

func FilterMapFloat64StrErr(fFilter func(float64) (bool, error), fMap func(float64) (string, error), list []float64) ([]string, error)

FilterMapFloat64StrErr 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 - float64 and returns (bool, error).
  2. Function: takes float64 as argument and returns (string, error)
  3. List of type float64

Returns: 

	New List of type string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64StrPtr 

func FilterMapFloat64StrPtr(fFilter func(*float64) bool, fMap func(*float64) *string, list []*float64) []*string

FilterMapFloat64StrPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float64 and returns true/false.
  2. Function: takes *float64 as argument and returns *string
  3. List of type *[]float64

Returns: 

	New List of type *string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64StrPtrErr 

func FilterMapFloat64StrPtrErr(fFilter func(*float64) (bool, error), fMap func(*float64) (*string, error), list []*float64) ([]*string, error)

FilterMapFloat64StrPtrErr 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 - *float64 and returns (bool, error).
  2. Function: takes *float64 as argument and returns (*string, error)
  3. List of type *float64

Returns: 

	New List of type *string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint 

func FilterMapFloat64Uint(fFilter func(float64) bool, fMap func(float64) uint, list []float64) []uint

FilterMapFloat64Uint filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float64 and returns true/false.
  2. Function: takes float64 as argument and returns uint
  3. List of type float64

Returns: 

	New List of type uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint16 

func FilterMapFloat64Uint16(fFilter func(float64) bool, fMap func(float64) uint16, list []float64) []uint16

FilterMapFloat64Uint16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float64 and returns true/false.
  2. Function: takes float64 as argument and returns uint16
  3. List of type float64

Returns: 

	New List of type uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint16Err 

func FilterMapFloat64Uint16Err(fFilter func(float64) (bool, error), fMap func(float64) (uint16, error), list []float64) ([]uint16, error)

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

Returns: 

	New List of type uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint16Ptr 

func FilterMapFloat64Uint16Ptr(fFilter func(*float64) bool, fMap func(*float64) *uint16, list []*float64) []*uint16

FilterMapFloat64Uint16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float64 and returns true/false.
  2. Function: takes *float64 as argument and returns *uint16
  3. List of type *[]float64

Returns: 

	New List of type *uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint16PtrErr 

func FilterMapFloat64Uint16PtrErr(fFilter func(*float64) (bool, error), fMap func(*float64) (*uint16, error), list []*float64) ([]*uint16, error)

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

Returns: 

	New List of type *uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint32 

func FilterMapFloat64Uint32(fFilter func(float64) bool, fMap func(float64) uint32, list []float64) []uint32

FilterMapFloat64Uint32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float64 and returns true/false.
  2. Function: takes float64 as argument and returns uint32
  3. List of type float64

Returns: 

	New List of type uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint32Err 

func FilterMapFloat64Uint32Err(fFilter func(float64) (bool, error), fMap func(float64) (uint32, error), list []float64) ([]uint32, error)

FilterMapFloat64Uint32Err 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 - float64 and returns (bool, error).
  2. Function: takes float64 as argument and returns (uint32, error)
  3. List of type float64

Returns: 

	New List of type uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint32Ptr 

func FilterMapFloat64Uint32Ptr(fFilter func(*float64) bool, fMap func(*float64) *uint32, list []*float64) []*uint32

FilterMapFloat64Uint32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float64 and returns true/false.
  2. Function: takes *float64 as argument and returns *uint32
  3. List of type *[]float64

Returns: 

	New List of type *uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint32PtrErr 

func FilterMapFloat64Uint32PtrErr(fFilter func(*float64) (bool, error), fMap func(*float64) (*uint32, error), list []*float64) ([]*uint32, error)

FilterMapFloat64Uint32PtrErr 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 - *float64 and returns (bool, error).
  2. Function: takes *float64 as argument and returns (*uint32, error)
  3. List of type *float64

Returns: 

	New List of type *uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint64 

func FilterMapFloat64Uint64(fFilter func(float64) bool, fMap func(float64) uint64, list []float64) []uint64

FilterMapFloat64Uint64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float64 and returns true/false.
  2. Function: takes float64 as argument and returns uint64
  3. List of type float64

Returns: 

	New List of type uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint64Err 

func FilterMapFloat64Uint64Err(fFilter func(float64) (bool, error), fMap func(float64) (uint64, error), list []float64) ([]uint64, error)

FilterMapFloat64Uint64Err 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 - float64 and returns (bool, error).
  2. Function: takes float64 as argument and returns (uint64, error)
  3. List of type float64

Returns: 

	New List of type uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint64Ptr 

func FilterMapFloat64Uint64Ptr(fFilter func(*float64) bool, fMap func(*float64) *uint64, list []*float64) []*uint64

FilterMapFloat64Uint64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float64 and returns true/false.
  2. Function: takes *float64 as argument and returns *uint64
  3. List of type *[]float64

Returns: 

	New List of type *uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint64PtrErr 

func FilterMapFloat64Uint64PtrErr(fFilter func(*float64) (bool, error), fMap func(*float64) (*uint64, error), list []*float64) ([]*uint64, error)

FilterMapFloat64Uint64PtrErr 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 - *float64 and returns (bool, error).
  2. Function: takes *float64 as argument and returns (*uint64, error)
  3. List of type *float64

Returns: 

	New List of type *uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint8 

func FilterMapFloat64Uint8(fFilter func(float64) bool, fMap func(float64) uint8, list []float64) []uint8

FilterMapFloat64Uint8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - float64 and returns true/false.
  2. Function: takes float64 as argument and returns uint8
  3. List of type float64

Returns: 

	New List of type uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint8Err 

func FilterMapFloat64Uint8Err(fFilter func(float64) (bool, error), fMap func(float64) (uint8, error), list []float64) ([]uint8, error)

FilterMapFloat64Uint8Err 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 - float64 and returns (bool, error).
  2. Function: takes float64 as argument and returns (uint8, error)
  3. List of type float64

Returns: 

	New List of type uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint8Ptr 

func FilterMapFloat64Uint8Ptr(fFilter func(*float64) bool, fMap func(*float64) *uint8, list []*float64) []*uint8

FilterMapFloat64Uint8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float64 and returns true/false.
  2. Function: takes *float64 as argument and returns *uint8
  3. List of type *[]float64

Returns: 

	New List of type *uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64Uint8PtrErr 

func FilterMapFloat64Uint8PtrErr(fFilter func(*float64) (bool, error), fMap func(*float64) (*uint8, error), list []*float64) ([]*uint8, error)

FilterMapFloat64Uint8PtrErr 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 - *float64 and returns (bool, error).
  2. Function: takes *float64 as argument and returns (*uint8, error)
  3. List of type *float64

Returns: 

	New List of type *uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64UintErr 

func FilterMapFloat64UintErr(fFilter func(float64) (bool, error), fMap func(float64) (uint, error), list []float64) ([]uint, error)

FilterMapFloat64UintErr 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 - float64 and returns (bool, error).
  2. Function: takes float64 as argument and returns (uint, error)
  3. List of type float64

Returns: 

	New List of type uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64UintPtr 

func FilterMapFloat64UintPtr(fFilter func(*float64) bool, fMap func(*float64) *uint, list []*float64) []*uint

FilterMapFloat64UintPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *float64 and returns true/false.
  2. Function: takes *float64 as argument and returns *uint
  3. List of type *[]float64

Returns: 

	New List of type *uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapFloat64UintPtrErr 

func FilterMapFloat64UintPtrErr(fFilter func(*float64) (bool, error), fMap func(*float64) (*uint, error), list []*float64) ([]*uint, error)

FilterMapFloat64UintPtrErr 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 - *float64 and returns (bool, error).
  2. Function: takes *float64 as argument and returns (*uint, error)
  3. List of type *float64

Returns: 

	New List of type *uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt 

func FilterMapInt(fFilter func(int) bool, fMap func(int) int, list []int) []int

FilterMapInt filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns true/false.
  2. Function: takes int as argument and returns int
  3. List

Returns: 

	New List.
 Empty list if all there parameters are nil or either of parameter is nil

Example: Multiply all positive numbers in the list by 2 

fp.FilterMapInt(isPositive, multiplyBy2, []int{-1, 0, 2, 4}) // Returns [4, 8]

func isPositive(num int) bool {
	return num > 0
}

func multiplyBy2(num int) int {
	return num * 2
}

func FilterMapInt16 

func FilterMapInt16(fFilter func(int16) bool, fMap func(int16) int16, list []int16) []int16

FilterMapInt16 filter the list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns true/false.
  2. Function: takes int as argument and returns int
  3. List

Returns: 

	New List.
 Empty list if all there parameters are nil or either of parameter is nil

Example: Multiply all positive numbers in the list by 2 

fp.FilterMapInt16(isPositive, multiplyBy2, []int16{-1, 0, 2, 4}) // Returns [4, 8]

func isPositive(num int16) bool {
	return num > 0
}

func multiplyBy2(num int16) int16 {
	return num * 2
}

func FilterMapInt16Bool 

func FilterMapInt16Bool(fFilter func(int16) bool, fMap func(int16) bool, list []int16) []bool

FilterMapInt16Bool filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int16 and returns true/false.
  2. Function: takes int16 as argument and returns bool
  3. List of type int16

Returns: 

	New List of type bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16BoolErr 

func FilterMapInt16BoolErr(fFilter func(int16) (bool, error), fMap func(int16) (bool, error), list []int16) ([]bool, error)

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

Returns: 

	New List of type bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16BoolPtr 

func FilterMapInt16BoolPtr(fFilter func(*int16) bool, fMap func(*int16) *bool, list []*int16) []*bool

FilterMapInt16BoolPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int16 and returns true/false.
  2. Function: takes *int16 as argument and returns *bool
  3. List of type *[]int16

Returns: 

	New List of type *bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16BoolPtrErr 

func FilterMapInt16BoolPtrErr(fFilter func(*int16) (bool, error), fMap func(*int16) (*bool, error), list []*int16) ([]*bool, error)

FilterMapInt16BoolPtrErr 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 - *int16 and returns (bool, error).
  2. Function: takes *int16 as argument and returns (*bool, error)
  3. List of type *int16

Returns: 

	New List of type *bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Err 

func FilterMapInt16Err(fFilter func(int16) (bool, error), fMap func(int16) (int16, error), list []int16) ([]int16, error)

FilterMapInt16Err filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(int16) and returns (bool, error).
  2. Function: takes int16 as argument and returns (int16, error)
  3. Slice of type []int16

Returns: 

	New List ([]int16, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Float32 

func FilterMapInt16Float32(fFilter func(int16) bool, fMap func(int16) float32, list []int16) []float32

FilterMapInt16Float32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int16 and returns true/false.
  2. Function: takes int16 as argument and returns float32
  3. List of type int16

Returns: 

	New List of type float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Float32Err 

func FilterMapInt16Float32Err(fFilter func(int16) (bool, error), fMap func(int16) (float32, error), list []int16) ([]float32, error)

FilterMapInt16Float32Err 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 - int16 and returns (bool, error).
  2. Function: takes int16 as argument and returns (float32, error)
  3. List of type int16

Returns: 

	New List of type float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Float32Ptr 

func FilterMapInt16Float32Ptr(fFilter func(*int16) bool, fMap func(*int16) *float32, list []*int16) []*float32

FilterMapInt16Float32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int16 and returns true/false.
  2. Function: takes *int16 as argument and returns *float32
  3. List of type *[]int16

Returns: 

	New List of type *float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Float32PtrErr 

func FilterMapInt16Float32PtrErr(fFilter func(*int16) (bool, error), fMap func(*int16) (*float32, error), list []*int16) ([]*float32, error)

FilterMapInt16Float32PtrErr 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 - *int16 and returns (bool, error).
  2. Function: takes *int16 as argument and returns (*float32, error)
  3. List of type *int16

Returns: 

	New List of type *float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Float64 

func FilterMapInt16Float64(fFilter func(int16) bool, fMap func(int16) float64, list []int16) []float64

FilterMapInt16Float64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int16 and returns true/false.
  2. Function: takes int16 as argument and returns float64
  3. List of type int16

Returns: 

	New List of type float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Float64Err 

func FilterMapInt16Float64Err(fFilter func(int16) (bool, error), fMap func(int16) (float64, error), list []int16) ([]float64, error)

FilterMapInt16Float64Err 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 - int16 and returns (bool, error).
  2. Function: takes int16 as argument and returns (float64, error)
  3. List of type int16

Returns: 

	New List of type float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Float64Ptr 

func FilterMapInt16Float64Ptr(fFilter func(*int16) bool, fMap func(*int16) *float64, list []*int16) []*float64

FilterMapInt16Float64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int16 and returns true/false.
  2. Function: takes *int16 as argument and returns *float64
  3. List of type *[]int16

Returns: 

	New List of type *float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Float64PtrErr 

func FilterMapInt16Float64PtrErr(fFilter func(*int16) (bool, error), fMap func(*int16) (*float64, error), list []*int16) ([]*float64, error)

FilterMapInt16Float64PtrErr 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 - *int16 and returns (bool, error).
  2. Function: takes *int16 as argument and returns (*float64, error)
  3. List of type *int16

Returns: 

	New List of type *float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Int 

func FilterMapInt16Int(fFilter func(int16) bool, fMap func(int16) int, list []int16) []int

FilterMapInt16Int filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int16 and returns true/false.
  2. Function: takes int16 as argument and returns int
  3. List of type int16

Returns: 

	New List of type int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Int32 

func FilterMapInt16Int32(fFilter func(int16) bool, fMap func(int16) int32, list []int16) []int32

FilterMapInt16Int32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int16 and returns true/false.
  2. Function: takes int16 as argument and returns int32
  3. List of type int16

Returns: 

	New List of type int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Int32Err 

func FilterMapInt16Int32Err(fFilter func(int16) (bool, error), fMap func(int16) (int32, error), list []int16) ([]int32, error)

FilterMapInt16Int32Err 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 - int16 and returns (bool, error).
  2. Function: takes int16 as argument and returns (int32, error)
  3. List of type int16

Returns: 

	New List of type int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Int32Ptr 

func FilterMapInt16Int32Ptr(fFilter func(*int16) bool, fMap func(*int16) *int32, list []*int16) []*int32

FilterMapInt16Int32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int16 and returns true/false.
  2. Function: takes *int16 as argument and returns *int32
  3. List of type *[]int16

Returns: 

	New List of type *int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Int32PtrErr 

func FilterMapInt16Int32PtrErr(fFilter func(*int16) (bool, error), fMap func(*int16) (*int32, error), list []*int16) ([]*int32, error)

FilterMapInt16Int32PtrErr 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 - *int16 and returns (bool, error).
  2. Function: takes *int16 as argument and returns (*int32, error)
  3. List of type *int16

Returns: 

	New List of type *int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Int64 

func FilterMapInt16Int64(fFilter func(int16) bool, fMap func(int16) int64, list []int16) []int64

FilterMapInt16Int64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int16 and returns true/false.
  2. Function: takes int16 as argument and returns int64
  3. List of type int16

Returns: 

	New List of type int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Int64Err 

func FilterMapInt16Int64Err(fFilter func(int16) (bool, error), fMap func(int16) (int64, error), list []int16) ([]int64, error)

FilterMapInt16Int64Err 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 - int16 and returns (bool, error).
  2. Function: takes int16 as argument and returns (int64, error)
  3. List of type int16

Returns: 

	New List of type int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Int64Ptr 

func FilterMapInt16Int64Ptr(fFilter func(*int16) bool, fMap func(*int16) *int64, list []*int16) []*int64

FilterMapInt16Int64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int16 and returns true/false.
  2. Function: takes *int16 as argument and returns *int64
  3. List of type *[]int16

Returns: 

	New List of type *int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Int64PtrErr 

func FilterMapInt16Int64PtrErr(fFilter func(*int16) (bool, error), fMap func(*int16) (*int64, error), list []*int16) ([]*int64, error)

FilterMapInt16Int64PtrErr 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 - *int16 and returns (bool, error).
  2. Function: takes *int16 as argument and returns (*int64, error)
  3. List of type *int16

Returns: 

	New List of type *int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Int8 

func FilterMapInt16Int8(fFilter func(int16) bool, fMap func(int16) int8, list []int16) []int8

FilterMapInt16Int8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int16 and returns true/false.
  2. Function: takes int16 as argument and returns int8
  3. List of type int16

Returns: 

	New List of type int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Int8Err 

func FilterMapInt16Int8Err(fFilter func(int16) (bool, error), fMap func(int16) (int8, error), list []int16) ([]int8, error)

FilterMapInt16Int8Err 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 - int16 and returns (bool, error).
  2. Function: takes int16 as argument and returns (int8, error)
  3. List of type int16

Returns: 

	New List of type int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Int8Ptr 

func FilterMapInt16Int8Ptr(fFilter func(*int16) bool, fMap func(*int16) *int8, list []*int16) []*int8

FilterMapInt16Int8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int16 and returns true/false.
  2. Function: takes *int16 as argument and returns *int8
  3. List of type *[]int16

Returns: 

	New List of type *int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Int8PtrErr 

func FilterMapInt16Int8PtrErr(fFilter func(*int16) (bool, error), fMap func(*int16) (*int8, error), list []*int16) ([]*int8, error)

FilterMapInt16Int8PtrErr 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 - *int16 and returns (bool, error).
  2. Function: takes *int16 as argument and returns (*int8, error)
  3. List of type *int16

Returns: 

	New List of type *int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16IntErr 

func FilterMapInt16IntErr(fFilter func(int16) (bool, error), fMap func(int16) (int, error), list []int16) ([]int, error)

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

Returns: 

	New List of type int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16IntPtr 

func FilterMapInt16IntPtr(fFilter func(*int16) bool, fMap func(*int16) *int, list []*int16) []*int

FilterMapInt16IntPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int16 and returns true/false.
  2. Function: takes *int16 as argument and returns *int
  3. List of type *[]int16

Returns: 

	New List of type *int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16IntPtrErr 

func FilterMapInt16IntPtrErr(fFilter func(*int16) (bool, error), fMap func(*int16) (*int, error), list []*int16) ([]*int, error)

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

Returns: 

	New List of type *int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Ptr 

func FilterMapInt16Ptr(fFilter func(*int16) bool, fMap func(*int16) *int16, list []*int16) []*int16

FilterMapInt16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns (bool).
  2. Function: takes int16 as argument and returns (int16)
  3. Slice of type []*int16

Returns: 

	New List of type []*int16.
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16PtrErr 

func FilterMapInt16PtrErr(fFilter func(*int16) (bool, error), fMap func(*int16) (*int16, error), list []*int16) ([]*int16, error)

FilterMapInt16PtrErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(*int16) and returns (bool, error).
  2. Function: takes *int16 as argument and returns (*int16, error)
  3. Slice of type []*int16

Returns: 

	New List ([]*int16, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Str 

func FilterMapInt16Str(fFilter func(int16) bool, fMap func(int16) string, list []int16) []string

FilterMapInt16Str filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int16 and returns true/false.
  2. Function: takes int16 as argument and returns string
  3. List of type int16

Returns: 

	New List of type string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16StrErr 

func FilterMapInt16StrErr(fFilter func(int16) (bool, error), fMap func(int16) (string, error), list []int16) ([]string, error)

FilterMapInt16StrErr 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 - int16 and returns (bool, error).
  2. Function: takes int16 as argument and returns (string, error)
  3. List of type int16

Returns: 

	New List of type string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16StrPtr 

func FilterMapInt16StrPtr(fFilter func(*int16) bool, fMap func(*int16) *string, list []*int16) []*string

FilterMapInt16StrPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int16 and returns true/false.
  2. Function: takes *int16 as argument and returns *string
  3. List of type *[]int16

Returns: 

	New List of type *string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16StrPtrErr 

func FilterMapInt16StrPtrErr(fFilter func(*int16) (bool, error), fMap func(*int16) (*string, error), list []*int16) ([]*string, error)

FilterMapInt16StrPtrErr 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 - *int16 and returns (bool, error).
  2. Function: takes *int16 as argument and returns (*string, error)
  3. List of type *int16

Returns: 

	New List of type *string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint 

func FilterMapInt16Uint(fFilter func(int16) bool, fMap func(int16) uint, list []int16) []uint

FilterMapInt16Uint filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int16 and returns true/false.
  2. Function: takes int16 as argument and returns uint
  3. List of type int16

Returns: 

	New List of type uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint16 

func FilterMapInt16Uint16(fFilter func(int16) bool, fMap func(int16) uint16, list []int16) []uint16

FilterMapInt16Uint16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int16 and returns true/false.
  2. Function: takes int16 as argument and returns uint16
  3. List of type int16

Returns: 

	New List of type uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint16Err 

func FilterMapInt16Uint16Err(fFilter func(int16) (bool, error), fMap func(int16) (uint16, error), list []int16) ([]uint16, error)

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

Returns: 

	New List of type uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint16Ptr 

func FilterMapInt16Uint16Ptr(fFilter func(*int16) bool, fMap func(*int16) *uint16, list []*int16) []*uint16

FilterMapInt16Uint16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int16 and returns true/false.
  2. Function: takes *int16 as argument and returns *uint16
  3. List of type *[]int16

Returns: 

	New List of type *uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint16PtrErr 

func FilterMapInt16Uint16PtrErr(fFilter func(*int16) (bool, error), fMap func(*int16) (*uint16, error), list []*int16) ([]*uint16, error)

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

Returns: 

	New List of type *uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint32 

func FilterMapInt16Uint32(fFilter func(int16) bool, fMap func(int16) uint32, list []int16) []uint32

FilterMapInt16Uint32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int16 and returns true/false.
  2. Function: takes int16 as argument and returns uint32
  3. List of type int16

Returns: 

	New List of type uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint32Err 

func FilterMapInt16Uint32Err(fFilter func(int16) (bool, error), fMap func(int16) (uint32, error), list []int16) ([]uint32, error)

FilterMapInt16Uint32Err 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 - int16 and returns (bool, error).
  2. Function: takes int16 as argument and returns (uint32, error)
  3. List of type int16

Returns: 

	New List of type uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint32Ptr 

func FilterMapInt16Uint32Ptr(fFilter func(*int16) bool, fMap func(*int16) *uint32, list []*int16) []*uint32

FilterMapInt16Uint32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int16 and returns true/false.
  2. Function: takes *int16 as argument and returns *uint32
  3. List of type *[]int16

Returns: 

	New List of type *uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint32PtrErr 

func FilterMapInt16Uint32PtrErr(fFilter func(*int16) (bool, error), fMap func(*int16) (*uint32, error), list []*int16) ([]*uint32, error)

FilterMapInt16Uint32PtrErr 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 - *int16 and returns (bool, error).
  2. Function: takes *int16 as argument and returns (*uint32, error)
  3. List of type *int16

Returns: 

	New List of type *uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint64 

func FilterMapInt16Uint64(fFilter func(int16) bool, fMap func(int16) uint64, list []int16) []uint64

FilterMapInt16Uint64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int16 and returns true/false.
  2. Function: takes int16 as argument and returns uint64
  3. List of type int16

Returns: 

	New List of type uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint64Err 

func FilterMapInt16Uint64Err(fFilter func(int16) (bool, error), fMap func(int16) (uint64, error), list []int16) ([]uint64, error)

FilterMapInt16Uint64Err 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 - int16 and returns (bool, error).
  2. Function: takes int16 as argument and returns (uint64, error)
  3. List of type int16

Returns: 

	New List of type uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint64Ptr 

func FilterMapInt16Uint64Ptr(fFilter func(*int16) bool, fMap func(*int16) *uint64, list []*int16) []*uint64

FilterMapInt16Uint64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int16 and returns true/false.
  2. Function: takes *int16 as argument and returns *uint64
  3. List of type *[]int16

Returns: 

	New List of type *uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint64PtrErr 

func FilterMapInt16Uint64PtrErr(fFilter func(*int16) (bool, error), fMap func(*int16) (*uint64, error), list []*int16) ([]*uint64, error)

FilterMapInt16Uint64PtrErr 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 - *int16 and returns (bool, error).
  2. Function: takes *int16 as argument and returns (*uint64, error)
  3. List of type *int16

Returns: 

	New List of type *uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint8 

func FilterMapInt16Uint8(fFilter func(int16) bool, fMap func(int16) uint8, list []int16) []uint8

FilterMapInt16Uint8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int16 and returns true/false.
  2. Function: takes int16 as argument and returns uint8
  3. List of type int16

Returns: 

	New List of type uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint8Err 

func FilterMapInt16Uint8Err(fFilter func(int16) (bool, error), fMap func(int16) (uint8, error), list []int16) ([]uint8, error)

FilterMapInt16Uint8Err 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 - int16 and returns (bool, error).
  2. Function: takes int16 as argument and returns (uint8, error)
  3. List of type int16

Returns: 

	New List of type uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint8Ptr 

func FilterMapInt16Uint8Ptr(fFilter func(*int16) bool, fMap func(*int16) *uint8, list []*int16) []*uint8

FilterMapInt16Uint8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int16 and returns true/false.
  2. Function: takes *int16 as argument and returns *uint8
  3. List of type *[]int16

Returns: 

	New List of type *uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16Uint8PtrErr 

func FilterMapInt16Uint8PtrErr(fFilter func(*int16) (bool, error), fMap func(*int16) (*uint8, error), list []*int16) ([]*uint8, error)

FilterMapInt16Uint8PtrErr 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 - *int16 and returns (bool, error).
  2. Function: takes *int16 as argument and returns (*uint8, error)
  3. List of type *int16

Returns: 

	New List of type *uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16UintErr 

func FilterMapInt16UintErr(fFilter func(int16) (bool, error), fMap func(int16) (uint, error), list []int16) ([]uint, error)

FilterMapInt16UintErr 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 - int16 and returns (bool, error).
  2. Function: takes int16 as argument and returns (uint, error)
  3. List of type int16

Returns: 

	New List of type uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16UintPtr 

func FilterMapInt16UintPtr(fFilter func(*int16) bool, fMap func(*int16) *uint, list []*int16) []*uint

FilterMapInt16UintPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int16 and returns true/false.
  2. Function: takes *int16 as argument and returns *uint
  3. List of type *[]int16

Returns: 

	New List of type *uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt16UintPtrErr 

func FilterMapInt16UintPtrErr(fFilter func(*int16) (bool, error), fMap func(*int16) (*uint, error), list []*int16) ([]*uint, error)

FilterMapInt16UintPtrErr 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 - *int16 and returns (bool, error).
  2. Function: takes *int16 as argument and returns (*uint, error)
  3. List of type *int16

Returns: 

	New List of type *uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32 

func FilterMapInt32(fFilter func(int32) bool, fMap func(int32) int32, list []int32) []int32

FilterMapInt32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns true/false.
  2. Function: takes int as argument and returns int
  3. List

Returns: 

	New List.
 Empty list if all there parameters are nil or either of parameter is nil

Example: Multiply all positive numbers in the list by 2 

fp.FilterMapInt32(isPositive, multiplyBy2, []int32{-1, 0, 2, 4}) // Returns [4, 8]

func isPositive(num int32) bool {
	return num > 0
}

func multiplyBy2(num int32) int32 {
	return num * 2
}

func FilterMapInt32Bool 

func FilterMapInt32Bool(fFilter func(int32) bool, fMap func(int32) bool, list []int32) []bool

FilterMapInt32Bool filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int32 and returns true/false.
  2. Function: takes int32 as argument and returns bool
  3. List of type int32

Returns: 

	New List of type bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32BoolErr 

func FilterMapInt32BoolErr(fFilter func(int32) (bool, error), fMap func(int32) (bool, error), list []int32) ([]bool, error)

FilterMapInt32BoolErr 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 (bool, error)
  3. List of type int32

Returns: 

	New List of type bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32BoolPtr 

func FilterMapInt32BoolPtr(fFilter func(*int32) bool, fMap func(*int32) *bool, list []*int32) []*bool

FilterMapInt32BoolPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int32 and returns true/false.
  2. Function: takes *int32 as argument and returns *bool
  3. List of type *[]int32

Returns: 

	New List of type *bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32BoolPtrErr 

func FilterMapInt32BoolPtrErr(fFilter func(*int32) (bool, error), fMap func(*int32) (*bool, error), list []*int32) ([]*bool, error)

FilterMapInt32BoolPtrErr 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 (*bool, error)
  3. List of type *int32

Returns: 

	New List of type *bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Err 

func FilterMapInt32Err(fFilter func(int32) (bool, error), fMap func(int32) (int32, error), list []int32) ([]int32, error)

FilterMapInt32Err filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(int32) and returns (bool, error).
  2. Function: takes int32 as argument and returns (int32, error)
  3. Slice of type []int32

Returns: 

	New List ([]int32, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Float32 

func FilterMapInt32Float32(fFilter func(int32) bool, fMap func(int32) float32, list []int32) []float32

FilterMapInt32Float32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int32 and returns true/false.
  2. Function: takes int32 as argument and returns float32
  3. List of type int32

Returns: 

	New List of type float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Float32Err 

func FilterMapInt32Float32Err(fFilter func(int32) (bool, error), fMap func(int32) (float32, error), list []int32) ([]float32, error)

FilterMapInt32Float32Err 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 (float32, error)
  3. List of type int32

Returns: 

	New List of type float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Float32Ptr 

func FilterMapInt32Float32Ptr(fFilter func(*int32) bool, fMap func(*int32) *float32, list []*int32) []*float32

FilterMapInt32Float32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int32 and returns true/false.
  2. Function: takes *int32 as argument and returns *float32
  3. List of type *[]int32

Returns: 

	New List of type *float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Float32PtrErr 

func FilterMapInt32Float32PtrErr(fFilter func(*int32) (bool, error), fMap func(*int32) (*float32, error), list []*int32) ([]*float32, error)

FilterMapInt32Float32PtrErr 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 (*float32, error)
  3. List of type *int32

Returns: 

	New List of type *float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Float64 

func FilterMapInt32Float64(fFilter func(int32) bool, fMap func(int32) float64, list []int32) []float64

FilterMapInt32Float64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int32 and returns true/false.
  2. Function: takes int32 as argument and returns float64
  3. List of type int32

Returns: 

	New List of type float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Float64Err 

func FilterMapInt32Float64Err(fFilter func(int32) (bool, error), fMap func(int32) (float64, error), list []int32) ([]float64, error)

FilterMapInt32Float64Err 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 (float64, error)
  3. List of type int32

Returns: 

	New List of type float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Float64Ptr 

func FilterMapInt32Float64Ptr(fFilter func(*int32) bool, fMap func(*int32) *float64, list []*int32) []*float64

FilterMapInt32Float64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int32 and returns true/false.
  2. Function: takes *int32 as argument and returns *float64
  3. List of type *[]int32

Returns: 

	New List of type *float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Float64PtrErr 

func FilterMapInt32Float64PtrErr(fFilter func(*int32) (bool, error), fMap func(*int32) (*float64, error), list []*int32) ([]*float64, error)

FilterMapInt32Float64PtrErr 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 (*float64, error)
  3. List of type *int32

Returns: 

	New List of type *float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Int 

func FilterMapInt32Int(fFilter func(int32) bool, fMap func(int32) int, list []int32) []int

FilterMapInt32Int filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int32 and returns true/false.
  2. Function: takes int32 as argument and returns int
  3. List of type int32

Returns: 

	New List of type int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Int16 

func FilterMapInt32Int16(fFilter func(int32) bool, fMap func(int32) int16, list []int32) []int16

FilterMapInt32Int16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int32 and returns true/false.
  2. Function: takes int32 as argument and returns int16
  3. List of type int32

Returns: 

	New List of type int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Int16Err 

func FilterMapInt32Int16Err(fFilter func(int32) (bool, error), fMap func(int32) (int16, error), list []int32) ([]int16, error)

FilterMapInt32Int16Err 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 (int16, error)
  3. List of type int32

Returns: 

	New List of type int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Int16Ptr 

func FilterMapInt32Int16Ptr(fFilter func(*int32) bool, fMap func(*int32) *int16, list []*int32) []*int16

FilterMapInt32Int16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int32 and returns true/false.
  2. Function: takes *int32 as argument and returns *int16
  3. List of type *[]int32

Returns: 

	New List of type *int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Int16PtrErr 

func FilterMapInt32Int16PtrErr(fFilter func(*int32) (bool, error), fMap func(*int32) (*int16, error), list []*int32) ([]*int16, error)

FilterMapInt32Int16PtrErr 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 (*int16, error)
  3. List of type *int32

Returns: 

	New List of type *int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Int64 

func FilterMapInt32Int64(fFilter func(int32) bool, fMap func(int32) int64, list []int32) []int64

FilterMapInt32Int64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int32 and returns true/false.
  2. Function: takes int32 as argument and returns int64
  3. List of type int32

Returns: 

	New List of type int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Int64Err 

func FilterMapInt32Int64Err(fFilter func(int32) (bool, error), fMap func(int32) (int64, error), list []int32) ([]int64, error)

FilterMapInt32Int64Err 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 (int64, error)
  3. List of type int32

Returns: 

	New List of type int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Int64Ptr 

func FilterMapInt32Int64Ptr(fFilter func(*int32) bool, fMap func(*int32) *int64, list []*int32) []*int64

FilterMapInt32Int64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int32 and returns true/false.
  2. Function: takes *int32 as argument and returns *int64
  3. List of type *[]int32

Returns: 

	New List of type *int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Int64PtrErr 

func FilterMapInt32Int64PtrErr(fFilter func(*int32) (bool, error), fMap func(*int32) (*int64, error), list []*int32) ([]*int64, error)

FilterMapInt32Int64PtrErr 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 (*int64, error)
  3. List of type *int32

Returns: 

	New List of type *int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Int8 

func FilterMapInt32Int8(fFilter func(int32) bool, fMap func(int32) int8, list []int32) []int8

FilterMapInt32Int8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int32 and returns true/false.
  2. Function: takes int32 as argument and returns int8
  3. List of type int32

Returns: 

	New List of type int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Int8Err 

func FilterMapInt32Int8Err(fFilter func(int32) (bool, error), fMap func(int32) (int8, error), list []int32) ([]int8, error)

FilterMapInt32Int8Err 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 (int8, error)
  3. List of type int32

Returns: 

	New List of type int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Int8Ptr 

func FilterMapInt32Int8Ptr(fFilter func(*int32) bool, fMap func(*int32) *int8, list []*int32) []*int8

FilterMapInt32Int8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int32 and returns true/false.
  2. Function: takes *int32 as argument and returns *int8
  3. List of type *[]int32

Returns: 

	New List of type *int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Int8PtrErr 

func FilterMapInt32Int8PtrErr(fFilter func(*int32) (bool, error), fMap func(*int32) (*int8, error), list []*int32) ([]*int8, error)

FilterMapInt32Int8PtrErr 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 (*int8, error)
  3. List of type *int32

Returns: 

	New List of type *int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32IntErr 

func FilterMapInt32IntErr(fFilter func(int32) (bool, error), fMap func(int32) (int, error), list []int32) ([]int, error)

FilterMapInt32IntErr 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 (int, error)
  3. List of type int32

Returns: 

	New List of type int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32IntPtr 

func FilterMapInt32IntPtr(fFilter func(*int32) bool, fMap func(*int32) *int, list []*int32) []*int

FilterMapInt32IntPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int32 and returns true/false.
  2. Function: takes *int32 as argument and returns *int
  3. List of type *[]int32

Returns: 

	New List of type *int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32IntPtrErr 

func FilterMapInt32IntPtrErr(fFilter func(*int32) (bool, error), fMap func(*int32) (*int, error), list []*int32) ([]*int, error)

FilterMapInt32IntPtrErr 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 (*int, error)
  3. List of type *int32

Returns: 

	New List of type *int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Ptr 

func FilterMapInt32Ptr(fFilter func(*int32) bool, fMap func(*int32) *int32, list []*int32) []*int32

FilterMapInt32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns (bool).
  2. Function: takes int32 as argument and returns (int32)
  3. Slice of type []*int32

Returns: 

	New List of type []*int32.
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32PtrErr 

func FilterMapInt32PtrErr(fFilter func(*int32) (bool, error), fMap func(*int32) (*int32, error), list []*int32) ([]*int32, error)

FilterMapInt32PtrErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(*int32) and returns (bool, error).
  2. Function: takes *int32 as argument and returns (*int32, error)
  3. Slice of type []*int32

Returns: 

	New List ([]*int32, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Str 

func FilterMapInt32Str(fFilter func(int32) bool, fMap func(int32) string, list []int32) []string

FilterMapInt32Str filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int32 and returns true/false.
  2. Function: takes int32 as argument and returns string
  3. List of type int32

Returns: 

	New List of type string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32StrErr 

func FilterMapInt32StrErr(fFilter func(int32) (bool, error), fMap func(int32) (string, error), list []int32) ([]string, error)

FilterMapInt32StrErr 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 (string, error)
  3. List of type int32

Returns: 

	New List of type string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32StrPtr 

func FilterMapInt32StrPtr(fFilter func(*int32) bool, fMap func(*int32) *string, list []*int32) []*string

FilterMapInt32StrPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int32 and returns true/false.
  2. Function: takes *int32 as argument and returns *string
  3. List of type *[]int32

Returns: 

	New List of type *string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32StrPtrErr 

func FilterMapInt32StrPtrErr(fFilter func(*int32) (bool, error), fMap func(*int32) (*string, error), list []*int32) ([]*string, error)

FilterMapInt32StrPtrErr 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 (*string, error)
  3. List of type *int32

Returns: 

	New List of type *string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Uint 

func FilterMapInt32Uint(fFilter func(int32) bool, fMap func(int32) uint, list []int32) []uint

FilterMapInt32Uint filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int32 and returns true/false.
  2. Function: takes int32 as argument and returns uint
  3. List of type int32

Returns: 

	New List of type uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Uint16 

func FilterMapInt32Uint16(fFilter func(int32) bool, fMap func(int32) uint16, list []int32) []uint16

FilterMapInt32Uint16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int32 and returns true/false.
  2. Function: takes int32 as argument and returns uint16
  3. List of type int32

Returns: 

	New List of type uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Uint16Err 

func FilterMapInt32Uint16Err(fFilter func(int32) (bool, error), fMap func(int32) (uint16, error), list []int32) ([]uint16, error)

FilterMapInt32Uint16Err 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 (uint16, error)
  3. List of type int32

Returns: 

	New List of type uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Uint16Ptr 

func FilterMapInt32Uint16Ptr(fFilter func(*int32) bool, fMap func(*int32) *uint16, list []*int32) []*uint16

FilterMapInt32Uint16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int32 and returns true/false.
  2. Function: takes *int32 as argument and returns *uint16
  3. List of type *[]int32

Returns: 

	New List of type *uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Uint16PtrErr 

func FilterMapInt32Uint16PtrErr(fFilter func(*int32) (bool, error), fMap func(*int32) (*uint16, error), list []*int32) ([]*uint16, error)

FilterMapInt32Uint16PtrErr 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 (*uint16, error)
  3. List of type *int32

Returns: 

	New List of type *uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Uint32 

func FilterMapInt32Uint32(fFilter func(int32) bool, fMap func(int32) uint32, list []int32) []uint32

FilterMapInt32Uint32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int32 and returns true/false.
  2. Function: takes int32 as argument and returns uint32
  3. List of type int32

Returns: 

	New List of type uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Uint32Err 

func FilterMapInt32Uint32Err(fFilter func(int32) (bool, error), fMap func(int32) (uint32, error), list []int32) ([]uint32, error)

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

func FilterMapInt32Uint32Ptr 

func FilterMapInt32Uint32Ptr(fFilter func(*int32) bool, fMap func(*int32) *uint32, list []*int32) []*uint32

FilterMapInt32Uint32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int32 and returns true/false.
  2. Function: takes *int32 as argument and returns *uint32
  3. List of type *[]int32

Returns: 

	New List of type *uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Uint32PtrErr 

func FilterMapInt32Uint32PtrErr(fFilter func(*int32) (bool, error), fMap func(*int32) (*uint32, error), list []*int32) ([]*uint32, error)

FilterMapInt32Uint32PtrErr 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

func FilterMapInt32Uint64 

func FilterMapInt32Uint64(fFilter func(int32) bool, fMap func(int32) uint64, list []int32) []uint64

FilterMapInt32Uint64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int32 and returns true/false.
  2. Function: takes int32 as argument and returns uint64
  3. List of type int32

Returns: 

	New List of type uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Uint64Err 

func FilterMapInt32Uint64Err(fFilter func(int32) (bool, error), fMap func(int32) (uint64, error), list []int32) ([]uint64, error)

FilterMapInt32Uint64Err 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 (uint64, error)
  3. List of type int32

Returns: 

	New List of type uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Uint64Ptr 

func FilterMapInt32Uint64Ptr(fFilter func(*int32) bool, fMap func(*int32) *uint64, list []*int32) []*uint64

FilterMapInt32Uint64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int32 and returns true/false.
  2. Function: takes *int32 as argument and returns *uint64
  3. List of type *[]int32

Returns: 

	New List of type *uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Uint64PtrErr 

func FilterMapInt32Uint64PtrErr(fFilter func(*int32) (bool, error), fMap func(*int32) (*uint64, error), list []*int32) ([]*uint64, error)

FilterMapInt32Uint64PtrErr 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 (*uint64, error)
  3. List of type *int32

Returns: 

	New List of type *uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Uint8 

func FilterMapInt32Uint8(fFilter func(int32) bool, fMap func(int32) uint8, list []int32) []uint8

FilterMapInt32Uint8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int32 and returns true/false.
  2. Function: takes int32 as argument and returns uint8
  3. List of type int32

Returns: 

	New List of type uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Uint8Err 

func FilterMapInt32Uint8Err(fFilter func(int32) (bool, error), fMap func(int32) (uint8, error), list []int32) ([]uint8, error)

FilterMapInt32Uint8Err 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 (uint8, error)
  3. List of type int32

Returns: 

	New List of type uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Uint8Ptr 

func FilterMapInt32Uint8Ptr(fFilter func(*int32) bool, fMap func(*int32) *uint8, list []*int32) []*uint8

FilterMapInt32Uint8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int32 and returns true/false.
  2. Function: takes *int32 as argument and returns *uint8
  3. List of type *[]int32

Returns: 

	New List of type *uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32Uint8PtrErr 

func FilterMapInt32Uint8PtrErr(fFilter func(*int32) (bool, error), fMap func(*int32) (*uint8, error), list []*int32) ([]*uint8, error)

FilterMapInt32Uint8PtrErr 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 (*uint8, error)
  3. List of type *int32

Returns: 

	New List of type *uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32UintErr 

func FilterMapInt32UintErr(fFilter func(int32) (bool, error), fMap func(int32) (uint, error), list []int32) ([]uint, error)

FilterMapInt32UintErr 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 (uint, error)
  3. List of type int32

Returns: 

	New List of type uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32UintPtr 

func FilterMapInt32UintPtr(fFilter func(*int32) bool, fMap func(*int32) *uint, list []*int32) []*uint

FilterMapInt32UintPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int32 and returns true/false.
  2. Function: takes *int32 as argument and returns *uint
  3. List of type *[]int32

Returns: 

	New List of type *uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt32UintPtrErr 

func FilterMapInt32UintPtrErr(fFilter func(*int32) (bool, error), fMap func(*int32) (*uint, error), list []*int32) ([]*uint, error)

FilterMapInt32UintPtrErr 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 (*uint, error)
  3. List of type *int32

Returns: 

	New List of type *uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64 

func FilterMapInt64(fFilter func(int64) bool, fMap func(int64) int64, list []int64) []int64

FilterMapInt64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns true/false.
  2. Function: takes int as argument and returns int
  3. List

Returns: 

	New List.
 Empty list if all there parameters are nil or either of parameter is nil

Example: Multiply all positive numbers in the list by 2 

fp.FilterMapInt64(isPositive, multiplyBy2, []int64{-1, 0, 2, 4}) // Returns [4, 8]

func isPositive(num int64) bool {
	return num > 0
}

func multiplyBy2(num int64) int64 {
	return num * 2
}

func FilterMapInt64Bool 

func FilterMapInt64Bool(fFilter func(int64) bool, fMap func(int64) bool, list []int64) []bool

FilterMapInt64Bool filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int64 and returns true/false.
  2. Function: takes int64 as argument and returns bool
  3. List of type int64

Returns: 

	New List of type bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64BoolErr 

func FilterMapInt64BoolErr(fFilter func(int64) (bool, error), fMap func(int64) (bool, error), list []int64) ([]bool, error)

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

Returns: 

	New List of type bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64BoolPtr 

func FilterMapInt64BoolPtr(fFilter func(*int64) bool, fMap func(*int64) *bool, list []*int64) []*bool

FilterMapInt64BoolPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int64 and returns true/false.
  2. Function: takes *int64 as argument and returns *bool
  3. List of type *[]int64

Returns: 

	New List of type *bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64BoolPtrErr 

func FilterMapInt64BoolPtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*bool, error), list []*int64) ([]*bool, error)

FilterMapInt64BoolPtrErr 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 - *int64 and returns (bool, error).
  2. Function: takes *int64 as argument and returns (*bool, error)
  3. List of type *int64

Returns: 

	New List of type *bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Err 

func FilterMapInt64Err(fFilter func(int64) (bool, error), fMap func(int64) (int64, error), list []int64) ([]int64, error)

FilterMapInt64Err filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(int64) and returns (bool, error).
  2. Function: takes int64 as argument and returns (int64, error)
  3. Slice of type []int64

Returns: 

	New List ([]int64, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Float32 

func FilterMapInt64Float32(fFilter func(int64) bool, fMap func(int64) float32, list []int64) []float32

FilterMapInt64Float32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int64 and returns true/false.
  2. Function: takes int64 as argument and returns float32
  3. List of type int64

Returns: 

	New List of type float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Float32Err 

func FilterMapInt64Float32Err(fFilter func(int64) (bool, error), fMap func(int64) (float32, error), list []int64) ([]float32, error)

FilterMapInt64Float32Err 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 - int64 and returns (bool, error).
  2. Function: takes int64 as argument and returns (float32, error)
  3. List of type int64

Returns: 

	New List of type float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Float32Ptr 

func FilterMapInt64Float32Ptr(fFilter func(*int64) bool, fMap func(*int64) *float32, list []*int64) []*float32

FilterMapInt64Float32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int64 and returns true/false.
  2. Function: takes *int64 as argument and returns *float32
  3. List of type *[]int64

Returns: 

	New List of type *float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Float32PtrErr 

func FilterMapInt64Float32PtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*float32, error), list []*int64) ([]*float32, error)

FilterMapInt64Float32PtrErr 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 - *int64 and returns (bool, error).
  2. Function: takes *int64 as argument and returns (*float32, error)
  3. List of type *int64

Returns: 

	New List of type *float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Float64 

func FilterMapInt64Float64(fFilter func(int64) bool, fMap func(int64) float64, list []int64) []float64

FilterMapInt64Float64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int64 and returns true/false.
  2. Function: takes int64 as argument and returns float64
  3. List of type int64

Returns: 

	New List of type float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Float64Err 

func FilterMapInt64Float64Err(fFilter func(int64) (bool, error), fMap func(int64) (float64, error), list []int64) ([]float64, error)

FilterMapInt64Float64Err 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 - int64 and returns (bool, error).
  2. Function: takes int64 as argument and returns (float64, error)
  3. List of type int64

Returns: 

	New List of type float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Float64Ptr 

func FilterMapInt64Float64Ptr(fFilter func(*int64) bool, fMap func(*int64) *float64, list []*int64) []*float64

FilterMapInt64Float64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int64 and returns true/false.
  2. Function: takes *int64 as argument and returns *float64
  3. List of type *[]int64

Returns: 

	New List of type *float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Float64PtrErr 

func FilterMapInt64Float64PtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*float64, error), list []*int64) ([]*float64, error)

FilterMapInt64Float64PtrErr 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 - *int64 and returns (bool, error).
  2. Function: takes *int64 as argument and returns (*float64, error)
  3. List of type *int64

Returns: 

	New List of type *float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Int 

func FilterMapInt64Int(fFilter func(int64) bool, fMap func(int64) int, list []int64) []int

FilterMapInt64Int filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int64 and returns true/false.
  2. Function: takes int64 as argument and returns int
  3. List of type int64

Returns: 

	New List of type int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Int16 

func FilterMapInt64Int16(fFilter func(int64) bool, fMap func(int64) int16, list []int64) []int16

FilterMapInt64Int16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int64 and returns true/false.
  2. Function: takes int64 as argument and returns int16
  3. List of type int64

Returns: 

	New List of type int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Int16Err 

func FilterMapInt64Int16Err(fFilter func(int64) (bool, error), fMap func(int64) (int16, error), list []int64) ([]int16, error)

FilterMapInt64Int16Err 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 - int64 and returns (bool, error).
  2. Function: takes int64 as argument and returns (int16, error)
  3. List of type int64

Returns: 

	New List of type int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Int16Ptr 

func FilterMapInt64Int16Ptr(fFilter func(*int64) bool, fMap func(*int64) *int16, list []*int64) []*int16

FilterMapInt64Int16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int64 and returns true/false.
  2. Function: takes *int64 as argument and returns *int16
  3. List of type *[]int64

Returns: 

	New List of type *int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Int16PtrErr 

func FilterMapInt64Int16PtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*int16, error), list []*int64) ([]*int16, error)

FilterMapInt64Int16PtrErr 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 - *int64 and returns (bool, error).
  2. Function: takes *int64 as argument and returns (*int16, error)
  3. List of type *int64

Returns: 

	New List of type *int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Int32 

func FilterMapInt64Int32(fFilter func(int64) bool, fMap func(int64) int32, list []int64) []int32

FilterMapInt64Int32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int64 and returns true/false.
  2. Function: takes int64 as argument and returns int32
  3. List of type int64

Returns: 

	New List of type int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Int32Err 

func FilterMapInt64Int32Err(fFilter func(int64) (bool, error), fMap func(int64) (int32, error), list []int64) ([]int32, error)

FilterMapInt64Int32Err 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 - int64 and returns (bool, error).
  2. Function: takes int64 as argument and returns (int32, error)
  3. List of type int64

Returns: 

	New List of type int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Int32Ptr 

func FilterMapInt64Int32Ptr(fFilter func(*int64) bool, fMap func(*int64) *int32, list []*int64) []*int32

FilterMapInt64Int32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int64 and returns true/false.
  2. Function: takes *int64 as argument and returns *int32
  3. List of type *[]int64

Returns: 

	New List of type *int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Int32PtrErr 

func FilterMapInt64Int32PtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*int32, error), list []*int64) ([]*int32, error)

FilterMapInt64Int32PtrErr 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 - *int64 and returns (bool, error).
  2. Function: takes *int64 as argument and returns (*int32, error)
  3. List of type *int64

Returns: 

	New List of type *int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Int8 

func FilterMapInt64Int8(fFilter func(int64) bool, fMap func(int64) int8, list []int64) []int8

FilterMapInt64Int8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int64 and returns true/false.
  2. Function: takes int64 as argument and returns int8
  3. List of type int64

Returns: 

	New List of type int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Int8Err 

func FilterMapInt64Int8Err(fFilter func(int64) (bool, error), fMap func(int64) (int8, error), list []int64) ([]int8, error)

FilterMapInt64Int8Err 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 - int64 and returns (bool, error).
  2. Function: takes int64 as argument and returns (int8, error)
  3. List of type int64

Returns: 

	New List of type int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Int8Ptr 

func FilterMapInt64Int8Ptr(fFilter func(*int64) bool, fMap func(*int64) *int8, list []*int64) []*int8

FilterMapInt64Int8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int64 and returns true/false.
  2. Function: takes *int64 as argument and returns *int8
  3. List of type *[]int64

Returns: 

	New List of type *int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Int8PtrErr 

func FilterMapInt64Int8PtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*int8, error), list []*int64) ([]*int8, error)

FilterMapInt64Int8PtrErr 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 - *int64 and returns (bool, error).
  2. Function: takes *int64 as argument and returns (*int8, error)
  3. List of type *int64

Returns: 

	New List of type *int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64IntErr 

func FilterMapInt64IntErr(fFilter func(int64) (bool, error), fMap func(int64) (int, error), list []int64) ([]int, error)

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

Returns: 

	New List of type int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64IntPtr 

func FilterMapInt64IntPtr(fFilter func(*int64) bool, fMap func(*int64) *int, list []*int64) []*int

FilterMapInt64IntPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int64 and returns true/false.
  2. Function: takes *int64 as argument and returns *int
  3. List of type *[]int64

Returns: 

	New List of type *int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64IntPtrErr 

func FilterMapInt64IntPtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*int, error), list []*int64) ([]*int, error)

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

Returns: 

	New List of type *int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Ptr 

func FilterMapInt64Ptr(fFilter func(*int64) bool, fMap func(*int64) *int64, list []*int64) []*int64

FilterMapInt64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns (bool).
  2. Function: takes int64 as argument and returns (int64)
  3. Slice of type []*int64

Returns: 

	New List of type []*int64.
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64PtrErr 

func FilterMapInt64PtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*int64, error), list []*int64) ([]*int64, error)

FilterMapInt64PtrErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(*int64) and returns (bool, error).
  2. Function: takes *int64 as argument and returns (*int64, error)
  3. Slice of type []*int64

Returns: 

	New List ([]*int64, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Str 

func FilterMapInt64Str(fFilter func(int64) bool, fMap func(int64) string, list []int64) []string

FilterMapInt64Str filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int64 and returns true/false.
  2. Function: takes int64 as argument and returns string
  3. List of type int64

Returns: 

	New List of type string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64StrErr 

func FilterMapInt64StrErr(fFilter func(int64) (bool, error), fMap func(int64) (string, error), list []int64) ([]string, error)

FilterMapInt64StrErr 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 - int64 and returns (bool, error).
  2. Function: takes int64 as argument and returns (string, error)
  3. List of type int64

Returns: 

	New List of type string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64StrPtr 

func FilterMapInt64StrPtr(fFilter func(*int64) bool, fMap func(*int64) *string, list []*int64) []*string

FilterMapInt64StrPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int64 and returns true/false.
  2. Function: takes *int64 as argument and returns *string
  3. List of type *[]int64

Returns: 

	New List of type *string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64StrPtrErr 

func FilterMapInt64StrPtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*string, error), list []*int64) ([]*string, error)

FilterMapInt64StrPtrErr 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 - *int64 and returns (bool, error).
  2. Function: takes *int64 as argument and returns (*string, error)
  3. List of type *int64

Returns: 

	New List of type *string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint 

func FilterMapInt64Uint(fFilter func(int64) bool, fMap func(int64) uint, list []int64) []uint

FilterMapInt64Uint filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int64 and returns true/false.
  2. Function: takes int64 as argument and returns uint
  3. List of type int64

Returns: 

	New List of type uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint16 

func FilterMapInt64Uint16(fFilter func(int64) bool, fMap func(int64) uint16, list []int64) []uint16

FilterMapInt64Uint16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int64 and returns true/false.
  2. Function: takes int64 as argument and returns uint16
  3. List of type int64

Returns: 

	New List of type uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint16Err 

func FilterMapInt64Uint16Err(fFilter func(int64) (bool, error), fMap func(int64) (uint16, error), list []int64) ([]uint16, error)

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

Returns: 

	New List of type uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint16Ptr 

func FilterMapInt64Uint16Ptr(fFilter func(*int64) bool, fMap func(*int64) *uint16, list []*int64) []*uint16

FilterMapInt64Uint16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int64 and returns true/false.
  2. Function: takes *int64 as argument and returns *uint16
  3. List of type *[]int64

Returns: 

	New List of type *uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint16PtrErr 

func FilterMapInt64Uint16PtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*uint16, error), list []*int64) ([]*uint16, error)

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

Returns: 

	New List of type *uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint32 

func FilterMapInt64Uint32(fFilter func(int64) bool, fMap func(int64) uint32, list []int64) []uint32

FilterMapInt64Uint32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int64 and returns true/false.
  2. Function: takes int64 as argument and returns uint32
  3. List of type int64

Returns: 

	New List of type uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint32Err 

func FilterMapInt64Uint32Err(fFilter func(int64) (bool, error), fMap func(int64) (uint32, error), list []int64) ([]uint32, error)

FilterMapInt64Uint32Err 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 - int64 and returns (bool, error).
  2. Function: takes int64 as argument and returns (uint32, error)
  3. List of type int64

Returns: 

	New List of type uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint32Ptr 

func FilterMapInt64Uint32Ptr(fFilter func(*int64) bool, fMap func(*int64) *uint32, list []*int64) []*uint32

FilterMapInt64Uint32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int64 and returns true/false.
  2. Function: takes *int64 as argument and returns *uint32
  3. List of type *[]int64

Returns: 

	New List of type *uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint32PtrErr 

func FilterMapInt64Uint32PtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*uint32, error), list []*int64) ([]*uint32, error)

FilterMapInt64Uint32PtrErr 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 - *int64 and returns (bool, error).
  2. Function: takes *int64 as argument and returns (*uint32, error)
  3. List of type *int64

Returns: 

	New List of type *uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint64 

func FilterMapInt64Uint64(fFilter func(int64) bool, fMap func(int64) uint64, list []int64) []uint64

FilterMapInt64Uint64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int64 and returns true/false.
  2. Function: takes int64 as argument and returns uint64
  3. List of type int64

Returns: 

	New List of type uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint64Err 

func FilterMapInt64Uint64Err(fFilter func(int64) (bool, error), fMap func(int64) (uint64, error), list []int64) ([]uint64, error)

FilterMapInt64Uint64Err 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 - int64 and returns (bool, error).
  2. Function: takes int64 as argument and returns (uint64, error)
  3. List of type int64

Returns: 

	New List of type uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint64Ptr 

func FilterMapInt64Uint64Ptr(fFilter func(*int64) bool, fMap func(*int64) *uint64, list []*int64) []*uint64

FilterMapInt64Uint64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int64 and returns true/false.
  2. Function: takes *int64 as argument and returns *uint64
  3. List of type *[]int64

Returns: 

	New List of type *uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint64PtrErr 

func FilterMapInt64Uint64PtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*uint64, error), list []*int64) ([]*uint64, error)

FilterMapInt64Uint64PtrErr 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 - *int64 and returns (bool, error).
  2. Function: takes *int64 as argument and returns (*uint64, error)
  3. List of type *int64

Returns: 

	New List of type *uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint8 

func FilterMapInt64Uint8(fFilter func(int64) bool, fMap func(int64) uint8, list []int64) []uint8

FilterMapInt64Uint8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int64 and returns true/false.
  2. Function: takes int64 as argument and returns uint8
  3. List of type int64

Returns: 

	New List of type uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint8Err 

func FilterMapInt64Uint8Err(fFilter func(int64) (bool, error), fMap func(int64) (uint8, error), list []int64) ([]uint8, error)

FilterMapInt64Uint8Err 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 - int64 and returns (bool, error).
  2. Function: takes int64 as argument and returns (uint8, error)
  3. List of type int64

Returns: 

	New List of type uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint8Ptr 

func FilterMapInt64Uint8Ptr(fFilter func(*int64) bool, fMap func(*int64) *uint8, list []*int64) []*uint8

FilterMapInt64Uint8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int64 and returns true/false.
  2. Function: takes *int64 as argument and returns *uint8
  3. List of type *[]int64

Returns: 

	New List of type *uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64Uint8PtrErr 

func FilterMapInt64Uint8PtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*uint8, error), list []*int64) ([]*uint8, error)

FilterMapInt64Uint8PtrErr 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 - *int64 and returns (bool, error).
  2. Function: takes *int64 as argument and returns (*uint8, error)
  3. List of type *int64

Returns: 

	New List of type *uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64UintErr 

func FilterMapInt64UintErr(fFilter func(int64) (bool, error), fMap func(int64) (uint, error), list []int64) ([]uint, error)

FilterMapInt64UintErr 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 - int64 and returns (bool, error).
  2. Function: takes int64 as argument and returns (uint, error)
  3. List of type int64

Returns: 

	New List of type uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64UintPtr 

func FilterMapInt64UintPtr(fFilter func(*int64) bool, fMap func(*int64) *uint, list []*int64) []*uint

FilterMapInt64UintPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int64 and returns true/false.
  2. Function: takes *int64 as argument and returns *uint
  3. List of type *[]int64

Returns: 

	New List of type *uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt64UintPtrErr 

func FilterMapInt64UintPtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*uint, error), list []*int64) ([]*uint, error)

FilterMapInt64UintPtrErr 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 - *int64 and returns (bool, error).
  2. Function: takes *int64 as argument and returns (*uint, error)
  3. List of type *int64

Returns: 

	New List of type *uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8 

func FilterMapInt8(fFilter func(int8) bool, fMap func(int8) int8, list []int8) []int8

FilterMapInt8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns true/false.
  2. Function: takes int as argument and returns int
  3. List

Returns: 

	New List.
 Empty list if all there parameters are nil or either of parameter is nil

Example: Multiply all positive numbers in the list by 2 

fp.FilterMapInt8(isPositive, multiplyBy2, []int8{-1, 0, 2, 4}) // Returns [4, 8]

func isPositive(num int8) bool {
	return num > 0
}

func multiplyBy2(num int8) int8 {
	return num * 2
}

func FilterMapInt8Bool 

func FilterMapInt8Bool(fFilter func(int8) bool, fMap func(int8) bool, list []int8) []bool

FilterMapInt8Bool filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int8 and returns true/false.
  2. Function: takes int8 as argument and returns bool
  3. List of type int8

Returns: 

	New List of type bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8BoolErr 

func FilterMapInt8BoolErr(fFilter func(int8) (bool, error), fMap func(int8) (bool, error), list []int8) ([]bool, error)

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

Returns: 

	New List of type bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8BoolPtr 

func FilterMapInt8BoolPtr(fFilter func(*int8) bool, fMap func(*int8) *bool, list []*int8) []*bool

FilterMapInt8BoolPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int8 and returns true/false.
  2. Function: takes *int8 as argument and returns *bool
  3. List of type *[]int8

Returns: 

	New List of type *bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8BoolPtrErr 

func FilterMapInt8BoolPtrErr(fFilter func(*int8) (bool, error), fMap func(*int8) (*bool, error), list []*int8) ([]*bool, error)

FilterMapInt8BoolPtrErr 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 - *int8 and returns (bool, error).
  2. Function: takes *int8 as argument and returns (*bool, error)
  3. List of type *int8

Returns: 

	New List of type *bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Err 

func FilterMapInt8Err(fFilter func(int8) (bool, error), fMap func(int8) (int8, error), list []int8) ([]int8, error)

FilterMapInt8Err filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(int8) and returns (bool, error).
  2. Function: takes int8 as argument and returns (int8, error)
  3. Slice of type []int8

Returns: 

	New List ([]int8, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Float32 

func FilterMapInt8Float32(fFilter func(int8) bool, fMap func(int8) float32, list []int8) []float32

FilterMapInt8Float32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int8 and returns true/false.
  2. Function: takes int8 as argument and returns float32
  3. List of type int8

Returns: 

	New List of type float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Float32Err 

func FilterMapInt8Float32Err(fFilter func(int8) (bool, error), fMap func(int8) (float32, error), list []int8) ([]float32, error)

FilterMapInt8Float32Err 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 - int8 and returns (bool, error).
  2. Function: takes int8 as argument and returns (float32, error)
  3. List of type int8

Returns: 

	New List of type float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Float32Ptr 

func FilterMapInt8Float32Ptr(fFilter func(*int8) bool, fMap func(*int8) *float32, list []*int8) []*float32

FilterMapInt8Float32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int8 and returns true/false.
  2. Function: takes *int8 as argument and returns *float32
  3. List of type *[]int8

Returns: 

	New List of type *float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Float32PtrErr 

func FilterMapInt8Float32PtrErr(fFilter func(*int8) (bool, error), fMap func(*int8) (*float32, error), list []*int8) ([]*float32, error)

FilterMapInt8Float32PtrErr 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 - *int8 and returns (bool, error).
  2. Function: takes *int8 as argument and returns (*float32, error)
  3. List of type *int8

Returns: 

	New List of type *float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Float64 

func FilterMapInt8Float64(fFilter func(int8) bool, fMap func(int8) float64, list []int8) []float64

FilterMapInt8Float64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int8 and returns true/false.
  2. Function: takes int8 as argument and returns float64
  3. List of type int8

Returns: 

	New List of type float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Float64Err 

func FilterMapInt8Float64Err(fFilter func(int8) (bool, error), fMap func(int8) (float64, error), list []int8) ([]float64, error)

FilterMapInt8Float64Err 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 - int8 and returns (bool, error).
  2. Function: takes int8 as argument and returns (float64, error)
  3. List of type int8

Returns: 

	New List of type float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Float64Ptr 

func FilterMapInt8Float64Ptr(fFilter func(*int8) bool, fMap func(*int8) *float64, list []*int8) []*float64

FilterMapInt8Float64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int8 and returns true/false.
  2. Function: takes *int8 as argument and returns *float64
  3. List of type *[]int8

Returns: 

	New List of type *float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Float64PtrErr 

func FilterMapInt8Float64PtrErr(fFilter func(*int8) (bool, error), fMap func(*int8) (*float64, error), list []*int8) ([]*float64, error)

FilterMapInt8Float64PtrErr 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 - *int8 and returns (bool, error).
  2. Function: takes *int8 as argument and returns (*float64, error)
  3. List of type *int8

Returns: 

	New List of type *float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Int 

func FilterMapInt8Int(fFilter func(int8) bool, fMap func(int8) int, list []int8) []int

FilterMapInt8Int filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int8 and returns true/false.
  2. Function: takes int8 as argument and returns int
  3. List of type int8

Returns: 

	New List of type int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Int16 

func FilterMapInt8Int16(fFilter func(int8) bool, fMap func(int8) int16, list []int8) []int16

FilterMapInt8Int16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int8 and returns true/false.
  2. Function: takes int8 as argument and returns int16
  3. List of type int8

Returns: 

	New List of type int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Int16Err 

func FilterMapInt8Int16Err(fFilter func(int8) (bool, error), fMap func(int8) (int16, error), list []int8) ([]int16, error)

FilterMapInt8Int16Err 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 - int8 and returns (bool, error).
  2. Function: takes int8 as argument and returns (int16, error)
  3. List of type int8

Returns: 

	New List of type int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Int16Ptr 

func FilterMapInt8Int16Ptr(fFilter func(*int8) bool, fMap func(*int8) *int16, list []*int8) []*int16

FilterMapInt8Int16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int8 and returns true/false.
  2. Function: takes *int8 as argument and returns *int16
  3. List of type *[]int8

Returns: 

	New List of type *int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Int16PtrErr 

func FilterMapInt8Int16PtrErr(fFilter func(*int8) (bool, error), fMap func(*int8) (*int16, error), list []*int8) ([]*int16, error)

FilterMapInt8Int16PtrErr 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 - *int8 and returns (bool, error).
  2. Function: takes *int8 as argument and returns (*int16, error)
  3. List of type *int8

Returns: 

	New List of type *int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Int32 

func FilterMapInt8Int32(fFilter func(int8) bool, fMap func(int8) int32, list []int8) []int32

FilterMapInt8Int32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int8 and returns true/false.
  2. Function: takes int8 as argument and returns int32
  3. List of type int8

Returns: 

	New List of type int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Int32Err 

func FilterMapInt8Int32Err(fFilter func(int8) (bool, error), fMap func(int8) (int32, error), list []int8) ([]int32, error)

FilterMapInt8Int32Err 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 - int8 and returns (bool, error).
  2. Function: takes int8 as argument and returns (int32, error)
  3. List of type int8

Returns: 

	New List of type int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Int32Ptr 

func FilterMapInt8Int32Ptr(fFilter func(*int8) bool, fMap func(*int8) *int32, list []*int8) []*int32

FilterMapInt8Int32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int8 and returns true/false.
  2. Function: takes *int8 as argument and returns *int32
  3. List of type *[]int8

Returns: 

	New List of type *int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Int32PtrErr 

func FilterMapInt8Int32PtrErr(fFilter func(*int8) (bool, error), fMap func(*int8) (*int32, error), list []*int8) ([]*int32, error)

FilterMapInt8Int32PtrErr 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 - *int8 and returns (bool, error).
  2. Function: takes *int8 as argument and returns (*int32, error)
  3. List of type *int8

Returns: 

	New List of type *int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Int64 

func FilterMapInt8Int64(fFilter func(int8) bool, fMap func(int8) int64, list []int8) []int64

FilterMapInt8Int64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int8 and returns true/false.
  2. Function: takes int8 as argument and returns int64
  3. List of type int8

Returns: 

	New List of type int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Int64Err 

func FilterMapInt8Int64Err(fFilter func(int8) (bool, error), fMap func(int8) (int64, error), list []int8) ([]int64, error)

FilterMapInt8Int64Err 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 - int8 and returns (bool, error).
  2. Function: takes int8 as argument and returns (int64, error)
  3. List of type int8

Returns: 

	New List of type int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Int64Ptr 

func FilterMapInt8Int64Ptr(fFilter func(*int8) bool, fMap func(*int8) *int64, list []*int8) []*int64

FilterMapInt8Int64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int8 and returns true/false.
  2. Function: takes *int8 as argument and returns *int64
  3. List of type *[]int8

Returns: 

	New List of type *int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Int64PtrErr 

func FilterMapInt8Int64PtrErr(fFilter func(*int8) (bool, error), fMap func(*int8) (*int64, error), list []*int8) ([]*int64, error)

FilterMapInt8Int64PtrErr 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 - *int8 and returns (bool, error).
  2. Function: takes *int8 as argument and returns (*int64, error)
  3. List of type *int8

Returns: 

	New List of type *int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8IntErr 

func FilterMapInt8IntErr(fFilter func(int8) (bool, error), fMap func(int8) (int, error), list []int8) ([]int, error)

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

Returns: 

	New List of type int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8IntPtr 

func FilterMapInt8IntPtr(fFilter func(*int8) bool, fMap func(*int8) *int, list []*int8) []*int

FilterMapInt8IntPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int8 and returns true/false.
  2. Function: takes *int8 as argument and returns *int
  3. List of type *[]int8

Returns: 

	New List of type *int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8IntPtrErr 

func FilterMapInt8IntPtrErr(fFilter func(*int8) (bool, error), fMap func(*int8) (*int, error), list []*int8) ([]*int, error)

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

Returns: 

	New List of type *int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Ptr 

func FilterMapInt8Ptr(fFilter func(*int8) bool, fMap func(*int8) *int8, list []*int8) []*int8

FilterMapInt8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns (bool).
  2. Function: takes int8 as argument and returns (int8)
  3. Slice of type []*int8

Returns: 

	New List of type []*int8.
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8PtrErr 

func FilterMapInt8PtrErr(fFilter func(*int8) (bool, error), fMap func(*int8) (*int8, error), list []*int8) ([]*int8, error)

FilterMapInt8PtrErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(*int8) and returns (bool, error).
  2. Function: takes *int8 as argument and returns (*int8, error)
  3. Slice of type []*int8

Returns: 

	New List ([]*int8, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Str 

func FilterMapInt8Str(fFilter func(int8) bool, fMap func(int8) string, list []int8) []string

FilterMapInt8Str filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int8 and returns true/false.
  2. Function: takes int8 as argument and returns string
  3. List of type int8

Returns: 

	New List of type string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8StrErr 

func FilterMapInt8StrErr(fFilter func(int8) (bool, error), fMap func(int8) (string, error), list []int8) ([]string, error)

FilterMapInt8StrErr 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 - int8 and returns (bool, error).
  2. Function: takes int8 as argument and returns (string, error)
  3. List of type int8

Returns: 

	New List of type string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8StrPtr 

func FilterMapInt8StrPtr(fFilter func(*int8) bool, fMap func(*int8) *string, list []*int8) []*string

FilterMapInt8StrPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int8 and returns true/false.
  2. Function: takes *int8 as argument and returns *string
  3. List of type *[]int8

Returns: 

	New List of type *string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8StrPtrErr 

func FilterMapInt8StrPtrErr(fFilter func(*int8) (bool, error), fMap func(*int8) (*string, error), list []*int8) ([]*string, error)

FilterMapInt8StrPtrErr 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 - *int8 and returns (bool, error).
  2. Function: takes *int8 as argument and returns (*string, error)
  3. List of type *int8

Returns: 

	New List of type *string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint 

func FilterMapInt8Uint(fFilter func(int8) bool, fMap func(int8) uint, list []int8) []uint

FilterMapInt8Uint filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int8 and returns true/false.
  2. Function: takes int8 as argument and returns uint
  3. List of type int8

Returns: 

	New List of type uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint16 

func FilterMapInt8Uint16(fFilter func(int8) bool, fMap func(int8) uint16, list []int8) []uint16

FilterMapInt8Uint16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int8 and returns true/false.
  2. Function: takes int8 as argument and returns uint16
  3. List of type int8

Returns: 

	New List of type uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint16Err 

func FilterMapInt8Uint16Err(fFilter func(int8) (bool, error), fMap func(int8) (uint16, error), list []int8) ([]uint16, error)

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

Returns: 

	New List of type uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint16Ptr 

func FilterMapInt8Uint16Ptr(fFilter func(*int8) bool, fMap func(*int8) *uint16, list []*int8) []*uint16

FilterMapInt8Uint16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int8 and returns true/false.
  2. Function: takes *int8 as argument and returns *uint16
  3. List of type *[]int8

Returns: 

	New List of type *uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint16PtrErr 

func FilterMapInt8Uint16PtrErr(fFilter func(*int8) (bool, error), fMap func(*int8) (*uint16, error), list []*int8) ([]*uint16, error)

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

Returns: 

	New List of type *uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint32 

func FilterMapInt8Uint32(fFilter func(int8) bool, fMap func(int8) uint32, list []int8) []uint32

FilterMapInt8Uint32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int8 and returns true/false.
  2. Function: takes int8 as argument and returns uint32
  3. List of type int8

Returns: 

	New List of type uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint32Err 

func FilterMapInt8Uint32Err(fFilter func(int8) (bool, error), fMap func(int8) (uint32, error), list []int8) ([]uint32, error)

FilterMapInt8Uint32Err 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 - int8 and returns (bool, error).
  2. Function: takes int8 as argument and returns (uint32, error)
  3. List of type int8

Returns: 

	New List of type uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint32Ptr 

func FilterMapInt8Uint32Ptr(fFilter func(*int8) bool, fMap func(*int8) *uint32, list []*int8) []*uint32

FilterMapInt8Uint32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int8 and returns true/false.
  2. Function: takes *int8 as argument and returns *uint32
  3. List of type *[]int8

Returns: 

	New List of type *uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint32PtrErr 

func FilterMapInt8Uint32PtrErr(fFilter func(*int8) (bool, error), fMap func(*int8) (*uint32, error), list []*int8) ([]*uint32, error)

FilterMapInt8Uint32PtrErr 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 - *int8 and returns (bool, error).
  2. Function: takes *int8 as argument and returns (*uint32, error)
  3. List of type *int8

Returns: 

	New List of type *uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint64 

func FilterMapInt8Uint64(fFilter func(int8) bool, fMap func(int8) uint64, list []int8) []uint64

FilterMapInt8Uint64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int8 and returns true/false.
  2. Function: takes int8 as argument and returns uint64
  3. List of type int8

Returns: 

	New List of type uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint64Err 

func FilterMapInt8Uint64Err(fFilter func(int8) (bool, error), fMap func(int8) (uint64, error), list []int8) ([]uint64, error)

FilterMapInt8Uint64Err 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 - int8 and returns (bool, error).
  2. Function: takes int8 as argument and returns (uint64, error)
  3. List of type int8

Returns: 

	New List of type uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint64Ptr 

func FilterMapInt8Uint64Ptr(fFilter func(*int8) bool, fMap func(*int8) *uint64, list []*int8) []*uint64

FilterMapInt8Uint64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int8 and returns true/false.
  2. Function: takes *int8 as argument and returns *uint64
  3. List of type *[]int8

Returns: 

	New List of type *uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint64PtrErr 

func FilterMapInt8Uint64PtrErr(fFilter func(*int8) (bool, error), fMap func(*int8) (*uint64, error), list []*int8) ([]*uint64, error)

FilterMapInt8Uint64PtrErr 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 - *int8 and returns (bool, error).
  2. Function: takes *int8 as argument and returns (*uint64, error)
  3. List of type *int8

Returns: 

	New List of type *uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint8 

func FilterMapInt8Uint8(fFilter func(int8) bool, fMap func(int8) uint8, list []int8) []uint8

FilterMapInt8Uint8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int8 and returns true/false.
  2. Function: takes int8 as argument and returns uint8
  3. List of type int8

Returns: 

	New List of type uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint8Err 

func FilterMapInt8Uint8Err(fFilter func(int8) (bool, error), fMap func(int8) (uint8, error), list []int8) ([]uint8, error)

FilterMapInt8Uint8Err 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 - int8 and returns (bool, error).
  2. Function: takes int8 as argument and returns (uint8, error)
  3. List of type int8

Returns: 

	New List of type uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint8Ptr 

func FilterMapInt8Uint8Ptr(fFilter func(*int8) bool, fMap func(*int8) *uint8, list []*int8) []*uint8

FilterMapInt8Uint8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int8 and returns true/false.
  2. Function: takes *int8 as argument and returns *uint8
  3. List of type *[]int8

Returns: 

	New List of type *uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8Uint8PtrErr 

func FilterMapInt8Uint8PtrErr(fFilter func(*int8) (bool, error), fMap func(*int8) (*uint8, error), list []*int8) ([]*uint8, error)

FilterMapInt8Uint8PtrErr 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 - *int8 and returns (bool, error).
  2. Function: takes *int8 as argument and returns (*uint8, error)
  3. List of type *int8

Returns: 

	New List of type *uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8UintErr 

func FilterMapInt8UintErr(fFilter func(int8) (bool, error), fMap func(int8) (uint, error), list []int8) ([]uint, error)

FilterMapInt8UintErr 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 - int8 and returns (bool, error).
  2. Function: takes int8 as argument and returns (uint, error)
  3. List of type int8

Returns: 

	New List of type uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8UintPtr 

func FilterMapInt8UintPtr(fFilter func(*int8) bool, fMap func(*int8) *uint, list []*int8) []*uint

FilterMapInt8UintPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int8 and returns true/false.
  2. Function: takes *int8 as argument and returns *uint
  3. List of type *[]int8

Returns: 

	New List of type *uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapInt8UintPtrErr 

func FilterMapInt8UintPtrErr(fFilter func(*int8) (bool, error), fMap func(*int8) (*uint, error), list []*int8) ([]*uint, error)

FilterMapInt8UintPtrErr 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 - *int8 and returns (bool, error).
  2. Function: takes *int8 as argument and returns (*uint, error)
  3. List of type *int8

Returns: 

	New List of type *uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntBool 

func FilterMapIntBool(fFilter func(int) bool, fMap func(int) bool, list []int) []bool

FilterMapIntBool filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int and returns true/false.
  2. Function: takes int as argument and returns bool
  3. List of type int

Returns: 

	New List of type bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntBoolErr 

func FilterMapIntBoolErr(fFilter func(int) (bool, error), fMap func(int) (bool, error), list []int) ([]bool, error)

FilterMapIntBoolErr 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 (bool, error)
  3. List of type int

Returns: 

	New List of type bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntBoolPtr 

func FilterMapIntBoolPtr(fFilter func(*int) bool, fMap func(*int) *bool, list []*int) []*bool

FilterMapIntBoolPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int and returns true/false.
  2. Function: takes *int as argument and returns *bool
  3. List of type *[]int

Returns: 

	New List of type *bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntBoolPtrErr 

func FilterMapIntBoolPtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*bool, error), list []*int) ([]*bool, error)

FilterMapIntBoolPtrErr 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 (*bool, error)
  3. List of type *int

Returns: 

	New List of type *bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntErr 

func FilterMapIntErr(fFilter func(int) (bool, error), fMap func(int) (int, error), list []int) ([]int, error)

FilterMapIntErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(int) and returns (bool, error).
  2. Function: takes int as argument and returns (int, error)
  3. Slice of type []int

Returns: 

	New List ([]int, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntFloat32 

func FilterMapIntFloat32(fFilter func(int) bool, fMap func(int) float32, list []int) []float32

FilterMapIntFloat32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int and returns true/false.
  2. Function: takes int as argument and returns float32
  3. List of type int

Returns: 

	New List of type float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntFloat32Err 

func FilterMapIntFloat32Err(fFilter func(int) (bool, error), fMap func(int) (float32, error), list []int) ([]float32, error)

FilterMapIntFloat32Err 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 (float32, error)
  3. List of type int

Returns: 

	New List of type float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntFloat32Ptr 

func FilterMapIntFloat32Ptr(fFilter func(*int) bool, fMap func(*int) *float32, list []*int) []*float32

FilterMapIntFloat32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int and returns true/false.
  2. Function: takes *int as argument and returns *float32
  3. List of type *[]int

Returns: 

	New List of type *float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntFloat32PtrErr 

func FilterMapIntFloat32PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*float32, error), list []*int) ([]*float32, error)

FilterMapIntFloat32PtrErr 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 (*float32, error)
  3. List of type *int

Returns: 

	New List of type *float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntFloat64 

func FilterMapIntFloat64(fFilter func(int) bool, fMap func(int) float64, list []int) []float64

FilterMapIntFloat64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int and returns true/false.
  2. Function: takes int as argument and returns float64
  3. List of type int

Returns: 

	New List of type float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntFloat64Err 

func FilterMapIntFloat64Err(fFilter func(int) (bool, error), fMap func(int) (float64, error), list []int) ([]float64, error)

FilterMapIntFloat64Err 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 (float64, error)
  3. List of type int

Returns: 

	New List of type float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntFloat64Ptr 

func FilterMapIntFloat64Ptr(fFilter func(*int) bool, fMap func(*int) *float64, list []*int) []*float64

FilterMapIntFloat64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int and returns true/false.
  2. Function: takes *int as argument and returns *float64
  3. List of type *[]int

Returns: 

	New List of type *float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntFloat64PtrErr 

func FilterMapIntFloat64PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*float64, error), list []*int) ([]*float64, error)

FilterMapIntFloat64PtrErr 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 (*float64, error)
  3. List of type *int

Returns: 

	New List of type *float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntInt16 

func FilterMapIntInt16(fFilter func(int) bool, fMap func(int) int16, list []int) []int16

FilterMapIntInt16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int and returns true/false.
  2. Function: takes int as argument and returns int16
  3. List of type int

Returns: 

	New List of type int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntInt16Err 

func FilterMapIntInt16Err(fFilter func(int) (bool, error), fMap func(int) (int16, error), list []int) ([]int16, error)

FilterMapIntInt16Err 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 (int16, error)
  3. List of type int

Returns: 

	New List of type int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntInt16Ptr 

func FilterMapIntInt16Ptr(fFilter func(*int) bool, fMap func(*int) *int16, list []*int) []*int16

FilterMapIntInt16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int and returns true/false.
  2. Function: takes *int as argument and returns *int16
  3. List of type *[]int

Returns: 

	New List of type *int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntInt16PtrErr 

func FilterMapIntInt16PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*int16, error), list []*int) ([]*int16, error)

FilterMapIntInt16PtrErr 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 (*int16, error)
  3. List of type *int

Returns: 

	New List of type *int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntInt32 

func FilterMapIntInt32(fFilter func(int) bool, fMap func(int) int32, list []int) []int32

FilterMapIntInt32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int and returns true/false.
  2. Function: takes int as argument and returns int32
  3. List of type int

Returns: 

	New List of type int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntInt32Err 

func FilterMapIntInt32Err(fFilter func(int) (bool, error), fMap func(int) (int32, error), list []int) ([]int32, error)

FilterMapIntInt32Err 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 (int32, error)
  3. List of type int

Returns: 

	New List of type int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntInt32Ptr 

func FilterMapIntInt32Ptr(fFilter func(*int) bool, fMap func(*int) *int32, list []*int) []*int32

FilterMapIntInt32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int and returns true/false.
  2. Function: takes *int as argument and returns *int32
  3. List of type *[]int

Returns: 

	New List of type *int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntInt32PtrErr 

func FilterMapIntInt32PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*int32, error), list []*int) ([]*int32, error)

FilterMapIntInt32PtrErr 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 (*int32, error)
  3. List of type *int

Returns: 

	New List of type *int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntInt64 

func FilterMapIntInt64(fFilter func(int) bool, fMap func(int) int64, list []int) []int64

FilterMapIntInt64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int and returns true/false.
  2. Function: takes int as argument and returns int64
  3. List of type int

Returns: 

	New List of type int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntInt64Err 

func FilterMapIntInt64Err(fFilter func(int) (bool, error), fMap func(int) (int64, error), list []int) ([]int64, error)

FilterMapIntInt64Err 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 (int64, error)
  3. List of type int

Returns: 

	New List of type int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntInt64Ptr 

func FilterMapIntInt64Ptr(fFilter func(*int) bool, fMap func(*int) *int64, list []*int) []*int64

FilterMapIntInt64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int and returns true/false.
  2. Function: takes *int as argument and returns *int64
  3. List of type *[]int

Returns: 

	New List of type *int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntInt64PtrErr 

func FilterMapIntInt64PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*int64, error), list []*int) ([]*int64, error)

FilterMapIntInt64PtrErr 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 (*int64, error)
  3. List of type *int

Returns: 

	New List of type *int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntInt8 

func FilterMapIntInt8(fFilter func(int) bool, fMap func(int) int8, list []int) []int8

FilterMapIntInt8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int and returns true/false.
  2. Function: takes int as argument and returns int8
  3. List of type int

Returns: 

	New List of type int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntInt8Err 

func FilterMapIntInt8Err(fFilter func(int) (bool, error), fMap func(int) (int8, error), list []int) ([]int8, error)

FilterMapIntInt8Err 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 (int8, error)
  3. List of type int

Returns: 

	New List of type int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntInt8Ptr 

func FilterMapIntInt8Ptr(fFilter func(*int) bool, fMap func(*int) *int8, list []*int) []*int8

FilterMapIntInt8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int and returns true/false.
  2. Function: takes *int as argument and returns *int8
  3. List of type *[]int

Returns: 

	New List of type *int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntInt8PtrErr 

func FilterMapIntInt8PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*int8, error), list []*int) ([]*int8, error)

FilterMapIntInt8PtrErr 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 (*int8, error)
  3. List of type *int

Returns: 

	New List of type *int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntPtr 

func FilterMapIntPtr(fFilter func(*int) bool, fMap func(*int) *int, list []*int) []*int

FilterMapIntPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns (bool).
  2. Function: takes int as argument and returns (int)
  3. Slice of type []*int

Returns: 

	New List of type []*int.
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntPtrErr 

func FilterMapIntPtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*int, error), list []*int) ([]*int, error)

FilterMapIntPtrErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(*int) and returns (bool, error).
  2. Function: takes *int as argument and returns (*int, error)
  3. Slice of type []*int

Returns: 

	New List ([]*int, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntStr 

func FilterMapIntStr(fFilter func(int) bool, fMap func(int) string, list []int) []string

FilterMapIntStr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int and returns true/false.
  2. Function: takes int as argument and returns string
  3. List of type int

Returns: 

	New List of type string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntStrErr 

func FilterMapIntStrErr(fFilter func(int) (bool, error), fMap func(int) (string, error), list []int) ([]string, error)

FilterMapIntStrErr 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 (string, error)
  3. List of type int

Returns: 

	New List of type string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntStrPtr 

func FilterMapIntStrPtr(fFilter func(*int) bool, fMap func(*int) *string, list []*int) []*string

FilterMapIntStrPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int and returns true/false.
  2. Function: takes *int as argument and returns *string
  3. List of type *[]int

Returns: 

	New List of type *string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntStrPtrErr 

func FilterMapIntStrPtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*string, error), list []*int) ([]*string, error)

FilterMapIntStrPtrErr 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 (*string, error)
  3. List of type *int

Returns: 

	New List of type *string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUint 

func FilterMapIntUint(fFilter func(int) bool, fMap func(int) uint, list []int) []uint

FilterMapIntUint filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int and returns true/false.
  2. Function: takes int as argument and returns uint
  3. List of type int

Returns: 

	New List of type uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUint16 

func FilterMapIntUint16(fFilter func(int) bool, fMap func(int) uint16, list []int) []uint16

FilterMapIntUint16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int and returns true/false.
  2. Function: takes int as argument and returns uint16
  3. List of type int

Returns: 

	New List of type uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUint16Err 

func FilterMapIntUint16Err(fFilter func(int) (bool, error), fMap func(int) (uint16, error), list []int) ([]uint16, error)

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

func FilterMapIntUint16Ptr 

func FilterMapIntUint16Ptr(fFilter func(*int) bool, fMap func(*int) *uint16, list []*int) []*uint16

FilterMapIntUint16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int and returns true/false.
  2. Function: takes *int as argument and returns *uint16
  3. List of type *[]int

Returns: 

	New List of type *uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUint16PtrErr 

func FilterMapIntUint16PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*uint16, error), list []*int) ([]*uint16, error)

FilterMapIntUint16PtrErr 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

func FilterMapIntUint32 

func FilterMapIntUint32(fFilter func(int) bool, fMap func(int) uint32, list []int) []uint32

FilterMapIntUint32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int and returns true/false.
  2. Function: takes int as argument and returns uint32
  3. List of type int

Returns: 

	New List of type uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUint32Err 

func FilterMapIntUint32Err(fFilter func(int) (bool, error), fMap func(int) (uint32, error), list []int) ([]uint32, error)

FilterMapIntUint32Err 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 (uint32, error)
  3. List of type int

Returns: 

	New List of type uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUint32Ptr 

func FilterMapIntUint32Ptr(fFilter func(*int) bool, fMap func(*int) *uint32, list []*int) []*uint32

FilterMapIntUint32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int and returns true/false.
  2. Function: takes *int as argument and returns *uint32
  3. List of type *[]int

Returns: 

	New List of type *uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUint32PtrErr 

func FilterMapIntUint32PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*uint32, error), list []*int) ([]*uint32, error)

FilterMapIntUint32PtrErr 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 (*uint32, error)
  3. List of type *int

Returns: 

	New List of type *uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUint64 

func FilterMapIntUint64(fFilter func(int) bool, fMap func(int) uint64, list []int) []uint64

FilterMapIntUint64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int and returns true/false.
  2. Function: takes int as argument and returns uint64
  3. List of type int

Returns: 

	New List of type uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUint64Err 

func FilterMapIntUint64Err(fFilter func(int) (bool, error), fMap func(int) (uint64, error), list []int) ([]uint64, error)

FilterMapIntUint64Err 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 (uint64, error)
  3. List of type int

Returns: 

	New List of type uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUint64Ptr 

func FilterMapIntUint64Ptr(fFilter func(*int) bool, fMap func(*int) *uint64, list []*int) []*uint64

FilterMapIntUint64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int and returns true/false.
  2. Function: takes *int as argument and returns *uint64
  3. List of type *[]int

Returns: 

	New List of type *uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUint64PtrErr 

func FilterMapIntUint64PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*uint64, error), list []*int) ([]*uint64, error)

FilterMapIntUint64PtrErr 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 (*uint64, error)
  3. List of type *int

Returns: 

	New List of type *uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUint8 

func FilterMapIntUint8(fFilter func(int) bool, fMap func(int) uint8, list []int) []uint8

FilterMapIntUint8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - int and returns true/false.
  2. Function: takes int as argument and returns uint8
  3. List of type int

Returns: 

	New List of type uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUint8Err 

func FilterMapIntUint8Err(fFilter func(int) (bool, error), fMap func(int) (uint8, error), list []int) ([]uint8, error)

FilterMapIntUint8Err 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 (uint8, error)
  3. List of type int

Returns: 

	New List of type uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUint8Ptr 

func FilterMapIntUint8Ptr(fFilter func(*int) bool, fMap func(*int) *uint8, list []*int) []*uint8

FilterMapIntUint8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int and returns true/false.
  2. Function: takes *int as argument and returns *uint8
  3. List of type *[]int

Returns: 

	New List of type *uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUint8PtrErr 

func FilterMapIntUint8PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*uint8, error), list []*int) ([]*uint8, error)

FilterMapIntUint8PtrErr 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 (*uint8, error)
  3. List of type *int

Returns: 

	New List of type *uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUintErr 

func FilterMapIntUintErr(fFilter func(int) (bool, error), fMap func(int) (uint, error), list []int) ([]uint, error)

FilterMapIntUintErr 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 (uint, error)
  3. List of type int

Returns: 

	New List of type uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUintPtr 

func FilterMapIntUintPtr(fFilter func(*int) bool, fMap func(*int) *uint, list []*int) []*uint

FilterMapIntUintPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *int and returns true/false.
  2. Function: takes *int as argument and returns *uint
  3. List of type *[]int

Returns: 

	New List of type *uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapIntUintPtrErr 

func FilterMapIntUintPtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*uint, error), list []*int) ([]*uint, error)

FilterMapIntUintPtrErr 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 (*uint, error)
  3. List of type *int

Returns: 

	New List of type *uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStr 

func FilterMapStr(fFilter func(string) bool, fMap func(string) string, list []string) []string

FilterMapStr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns true/false.
  2. Function: takes int as argument and returns int
  3. List

Returns: 

	New List.
 Empty list if all there parameters are nil or either of parameter is nil

Example: filter all the names in the list which length is <10 and change them to upper case 

fp.FilterMapStr(isStringLengthLessThan10, strings.ToUpper, []string{"gopal", "govinda", "nandeshwar", "Nandeshwar Sah"}) // Returns [{"GOPAL", "GOVINDA"]

func isStringLengthLessThan10(str string) bool {
	return len(str) < 10
}

func FilterMapStrBool 

func FilterMapStrBool(fFilter func(string) bool, fMap func(string) bool, list []string) []bool

FilterMapStrBool filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - string and returns true/false.
  2. Function: takes string as argument and returns bool
  3. List of type string

Returns: 

	New List of type bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrBoolErr 

func FilterMapStrBoolErr(fFilter func(string) (bool, error), fMap func(string) (bool, error), list []string) ([]bool, error)

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

Returns: 

	New List of type bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrBoolPtr 

func FilterMapStrBoolPtr(fFilter func(*string) bool, fMap func(*string) *bool, list []*string) []*bool

FilterMapStrBoolPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *string and returns true/false.
  2. Function: takes *string as argument and returns *bool
  3. List of type *[]string

Returns: 

	New List of type *bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrBoolPtrErr 

func FilterMapStrBoolPtrErr(fFilter func(*string) (bool, error), fMap func(*string) (*bool, error), list []*string) ([]*bool, error)

FilterMapStrBoolPtrErr 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 - *string and returns (bool, error).
  2. Function: takes *string as argument and returns (*bool, error)
  3. List of type *string

Returns: 

	New List of type *bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrErr 

func FilterMapStrErr(fFilter func(string) (bool, error), fMap func(string) (string, error), list []string) ([]string, error)

FilterMapStrErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(string) and returns (bool, error).
  2. Function: takes string as argument and returns (string, error)
  3. Slice of type []string

Returns: 

	New List ([]string, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrFloat32 

func FilterMapStrFloat32(fFilter func(string) bool, fMap func(string) float32, list []string) []float32

FilterMapStrFloat32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - string and returns true/false.
  2. Function: takes string as argument and returns float32
  3. List of type string

Returns: 

	New List of type float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrFloat32Err 

func FilterMapStrFloat32Err(fFilter func(string) (bool, error), fMap func(string) (float32, error), list []string) ([]float32, error)

FilterMapStrFloat32Err 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 - string and returns (bool, error).
  2. Function: takes string as argument and returns (float32, error)
  3. List of type string

Returns: 

	New List of type float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrFloat32Ptr 

func FilterMapStrFloat32Ptr(fFilter func(*string) bool, fMap func(*string) *float32, list []*string) []*float32

FilterMapStrFloat32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *string and returns true/false.
  2. Function: takes *string as argument and returns *float32
  3. List of type *[]string

Returns: 

	New List of type *float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrFloat32PtrErr 

func FilterMapStrFloat32PtrErr(fFilter func(*string) (bool, error), fMap func(*string) (*float32, error), list []*string) ([]*float32, error)

FilterMapStrFloat32PtrErr 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 - *string and returns (bool, error).
  2. Function: takes *string as argument and returns (*float32, error)
  3. List of type *string

Returns: 

	New List of type *float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrFloat64 

func FilterMapStrFloat64(fFilter func(string) bool, fMap func(string) float64, list []string) []float64

FilterMapStrFloat64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - string and returns true/false.
  2. Function: takes string as argument and returns float64
  3. List of type string

Returns: 

	New List of type float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrFloat64Err 

func FilterMapStrFloat64Err(fFilter func(string) (bool, error), fMap func(string) (float64, error), list []string) ([]float64, error)

FilterMapStrFloat64Err 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 - string and returns (bool, error).
  2. Function: takes string as argument and returns (float64, error)
  3. List of type string

Returns: 

	New List of type float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrFloat64Ptr 

func FilterMapStrFloat64Ptr(fFilter func(*string) bool, fMap func(*string) *float64, list []*string) []*float64

FilterMapStrFloat64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *string and returns true/false.
  2. Function: takes *string as argument and returns *float64
  3. List of type *[]string

Returns: 

	New List of type *float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrFloat64PtrErr 

func FilterMapStrFloat64PtrErr(fFilter func(*string) (bool, error), fMap func(*string) (*float64, error), list []*string) ([]*float64, error)

FilterMapStrFloat64PtrErr 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 - *string and returns (bool, error).
  2. Function: takes *string as argument and returns (*float64, error)
  3. List of type *string

Returns: 

	New List of type *float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt 

func FilterMapStrInt(fFilter func(string) bool, fMap func(string) int, list []string) []int

FilterMapStrInt filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - string and returns true/false.
  2. Function: takes string as argument and returns int
  3. List of type string

Returns: 

	New List of type int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt16 

func FilterMapStrInt16(fFilter func(string) bool, fMap func(string) int16, list []string) []int16

FilterMapStrInt16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - string and returns true/false.
  2. Function: takes string as argument and returns int16
  3. List of type string

Returns: 

	New List of type int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt16Err 

func FilterMapStrInt16Err(fFilter func(string) (bool, error), fMap func(string) (int16, error), list []string) ([]int16, error)

FilterMapStrInt16Err 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 - string and returns (bool, error).
  2. Function: takes string as argument and returns (int16, error)
  3. List of type string

Returns: 

	New List of type int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt16Ptr 

func FilterMapStrInt16Ptr(fFilter func(*string) bool, fMap func(*string) *int16, list []*string) []*int16

FilterMapStrInt16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *string and returns true/false.
  2. Function: takes *string as argument and returns *int16
  3. List of type *[]string

Returns: 

	New List of type *int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt16PtrErr 

func FilterMapStrInt16PtrErr(fFilter func(*string) (bool, error), fMap func(*string) (*int16, error), list []*string) ([]*int16, error)

FilterMapStrInt16PtrErr 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 - *string and returns (bool, error).
  2. Function: takes *string as argument and returns (*int16, error)
  3. List of type *string

Returns: 

	New List of type *int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt32 

func FilterMapStrInt32(fFilter func(string) bool, fMap func(string) int32, list []string) []int32

FilterMapStrInt32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - string and returns true/false.
  2. Function: takes string as argument and returns int32
  3. List of type string

Returns: 

	New List of type int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt32Err 

func FilterMapStrInt32Err(fFilter func(string) (bool, error), fMap func(string) (int32, error), list []string) ([]int32, error)

FilterMapStrInt32Err 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 - string and returns (bool, error).
  2. Function: takes string as argument and returns (int32, error)
  3. List of type string

Returns: 

	New List of type int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt32Ptr 

func FilterMapStrInt32Ptr(fFilter func(*string) bool, fMap func(*string) *int32, list []*string) []*int32

FilterMapStrInt32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *string and returns true/false.
  2. Function: takes *string as argument and returns *int32
  3. List of type *[]string

Returns: 

	New List of type *int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt32PtrErr 

func FilterMapStrInt32PtrErr(fFilter func(*string) (bool, error), fMap func(*string) (*int32, error), list []*string) ([]*int32, error)

FilterMapStrInt32PtrErr 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 - *string and returns (bool, error).
  2. Function: takes *string as argument and returns (*int32, error)
  3. List of type *string

Returns: 

	New List of type *int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt64 

func FilterMapStrInt64(fFilter func(string) bool, fMap func(string) int64, list []string) []int64

FilterMapStrInt64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - string and returns true/false.
  2. Function: takes string as argument and returns int64
  3. List of type string

Returns: 

	New List of type int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt64Err 

func FilterMapStrInt64Err(fFilter func(string) (bool, error), fMap func(string) (int64, error), list []string) ([]int64, error)

FilterMapStrInt64Err 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 - string and returns (bool, error).
  2. Function: takes string as argument and returns (int64, error)
  3. List of type string

Returns: 

	New List of type int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt64Ptr 

func FilterMapStrInt64Ptr(fFilter func(*string) bool, fMap func(*string) *int64, list []*string) []*int64

FilterMapStrInt64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *string and returns true/false.
  2. Function: takes *string as argument and returns *int64
  3. List of type *[]string

Returns: 

	New List of type *int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt64PtrErr 

func FilterMapStrInt64PtrErr(fFilter func(*string) (bool, error), fMap func(*string) (*int64, error), list []*string) ([]*int64, error)

FilterMapStrInt64PtrErr 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 - *string and returns (bool, error).
  2. Function: takes *string as argument and returns (*int64, error)
  3. List of type *string

Returns: 

	New List of type *int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt8 

func FilterMapStrInt8(fFilter func(string) bool, fMap func(string) int8, list []string) []int8

FilterMapStrInt8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - string and returns true/false.
  2. Function: takes string as argument and returns int8
  3. List of type string

Returns: 

	New List of type int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt8Err 

func FilterMapStrInt8Err(fFilter func(string) (bool, error), fMap func(string) (int8, error), list []string) ([]int8, error)

FilterMapStrInt8Err 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 - string and returns (bool, error).
  2. Function: takes string as argument and returns (int8, error)
  3. List of type string

Returns: 

	New List of type int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt8Ptr 

func FilterMapStrInt8Ptr(fFilter func(*string) bool, fMap func(*string) *int8, list []*string) []*int8

FilterMapStrInt8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *string and returns true/false.
  2. Function: takes *string as argument and returns *int8
  3. List of type *[]string

Returns: 

	New List of type *int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrInt8PtrErr 

func FilterMapStrInt8PtrErr(fFilter func(*string) (bool, error), fMap func(*string) (*int8, error), list []*string) ([]*int8, error)

FilterMapStrInt8PtrErr 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 - *string and returns (bool, error).
  2. Function: takes *string as argument and returns (*int8, error)
  3. List of type *string

Returns: 

	New List of type *int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrIntErr 

func FilterMapStrIntErr(fFilter func(string) (bool, error), fMap func(string) (int, error), list []string) ([]int, error)

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

Returns: 

	New List of type int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrIntPtr 

func FilterMapStrIntPtr(fFilter func(*string) bool, fMap func(*string) *int, list []*string) []*int

FilterMapStrIntPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *string and returns true/false.
  2. Function: takes *string as argument and returns *int
  3. List of type *[]string

Returns: 

	New List of type *int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrIntPtrErr 

func FilterMapStrIntPtrErr(fFilter func(*string) (bool, error), fMap func(*string) (*int, error), list []*string) ([]*int, error)

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

Returns: 

	New List of type *int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrPtr 

func FilterMapStrPtr(fFilter func(*string) bool, fMap func(*string) *string, list []*string) []*string

FilterMapStrPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns (bool).
  2. Function: takes string as argument and returns (string)
  3. Slice of type []*string

Returns: 

	New List of type []*string.
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrPtrErr 

func FilterMapStrPtrErr(fFilter func(*string) (bool, error), fMap func(*string) (*string, error), list []*string) ([]*string, error)

FilterMapStrPtrErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(*string) and returns (bool, error).
  2. Function: takes *string as argument and returns (*string, error)
  3. Slice of type []*string

Returns: 

	New List ([]*string, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint 

func FilterMapStrUint(fFilter func(string) bool, fMap func(string) uint, list []string) []uint

FilterMapStrUint filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - string and returns true/false.
  2. Function: takes string as argument and returns uint
  3. List of type string

Returns: 

	New List of type uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint16 

func FilterMapStrUint16(fFilter func(string) bool, fMap func(string) uint16, list []string) []uint16

FilterMapStrUint16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - string and returns true/false.
  2. Function: takes string as argument and returns uint16
  3. List of type string

Returns: 

	New List of type uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint16Err 

func FilterMapStrUint16Err(fFilter func(string) (bool, error), fMap func(string) (uint16, error), list []string) ([]uint16, error)

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

Returns: 

	New List of type uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint16Ptr 

func FilterMapStrUint16Ptr(fFilter func(*string) bool, fMap func(*string) *uint16, list []*string) []*uint16

FilterMapStrUint16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *string and returns true/false.
  2. Function: takes *string as argument and returns *uint16
  3. List of type *[]string

Returns: 

	New List of type *uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint16PtrErr 

func FilterMapStrUint16PtrErr(fFilter func(*string) (bool, error), fMap func(*string) (*uint16, error), list []*string) ([]*uint16, error)

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

Returns: 

	New List of type *uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint32 

func FilterMapStrUint32(fFilter func(string) bool, fMap func(string) uint32, list []string) []uint32

FilterMapStrUint32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - string and returns true/false.
  2. Function: takes string as argument and returns uint32
  3. List of type string

Returns: 

	New List of type uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint32Err 

func FilterMapStrUint32Err(fFilter func(string) (bool, error), fMap func(string) (uint32, error), list []string) ([]uint32, error)

FilterMapStrUint32Err 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 - string and returns (bool, error).
  2. Function: takes string as argument and returns (uint32, error)
  3. List of type string

Returns: 

	New List of type uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint32Ptr 

func FilterMapStrUint32Ptr(fFilter func(*string) bool, fMap func(*string) *uint32, list []*string) []*uint32

FilterMapStrUint32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *string and returns true/false.
  2. Function: takes *string as argument and returns *uint32
  3. List of type *[]string

Returns: 

	New List of type *uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint32PtrErr 

func FilterMapStrUint32PtrErr(fFilter func(*string) (bool, error), fMap func(*string) (*uint32, error), list []*string) ([]*uint32, error)

FilterMapStrUint32PtrErr 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 - *string and returns (bool, error).
  2. Function: takes *string as argument and returns (*uint32, error)
  3. List of type *string

Returns: 

	New List of type *uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint64 

func FilterMapStrUint64(fFilter func(string) bool, fMap func(string) uint64, list []string) []uint64

FilterMapStrUint64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - string and returns true/false.
  2. Function: takes string as argument and returns uint64
  3. List of type string

Returns: 

	New List of type uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint64Err 

func FilterMapStrUint64Err(fFilter func(string) (bool, error), fMap func(string) (uint64, error), list []string) ([]uint64, error)

FilterMapStrUint64Err 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 - string and returns (bool, error).
  2. Function: takes string as argument and returns (uint64, error)
  3. List of type string

Returns: 

	New List of type uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint64Ptr 

func FilterMapStrUint64Ptr(fFilter func(*string) bool, fMap func(*string) *uint64, list []*string) []*uint64

FilterMapStrUint64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *string and returns true/false.
  2. Function: takes *string as argument and returns *uint64
  3. List of type *[]string

Returns: 

	New List of type *uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint64PtrErr 

func FilterMapStrUint64PtrErr(fFilter func(*string) (bool, error), fMap func(*string) (*uint64, error), list []*string) ([]*uint64, error)

FilterMapStrUint64PtrErr 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 - *string and returns (bool, error).
  2. Function: takes *string as argument and returns (*uint64, error)
  3. List of type *string

Returns: 

	New List of type *uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint8 

func FilterMapStrUint8(fFilter func(string) bool, fMap func(string) uint8, list []string) []uint8

FilterMapStrUint8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - string and returns true/false.
  2. Function: takes string as argument and returns uint8
  3. List of type string

Returns: 

	New List of type uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint8Err 

func FilterMapStrUint8Err(fFilter func(string) (bool, error), fMap func(string) (uint8, error), list []string) ([]uint8, error)

FilterMapStrUint8Err 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 - string and returns (bool, error).
  2. Function: takes string as argument and returns (uint8, error)
  3. List of type string

Returns: 

	New List of type uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint8Ptr 

func FilterMapStrUint8Ptr(fFilter func(*string) bool, fMap func(*string) *uint8, list []*string) []*uint8

FilterMapStrUint8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *string and returns true/false.
  2. Function: takes *string as argument and returns *uint8
  3. List of type *[]string

Returns: 

	New List of type *uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUint8PtrErr 

func FilterMapStrUint8PtrErr(fFilter func(*string) (bool, error), fMap func(*string) (*uint8, error), list []*string) ([]*uint8, error)

FilterMapStrUint8PtrErr 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 - *string and returns (bool, error).
  2. Function: takes *string as argument and returns (*uint8, error)
  3. List of type *string

Returns: 

	New List of type *uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUintErr 

func FilterMapStrUintErr(fFilter func(string) (bool, error), fMap func(string) (uint, error), list []string) ([]uint, error)

FilterMapStrUintErr 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 - string and returns (bool, error).
  2. Function: takes string as argument and returns (uint, error)
  3. List of type string

Returns: 

	New List of type uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUintPtr 

func FilterMapStrUintPtr(fFilter func(*string) bool, fMap func(*string) *uint, list []*string) []*uint

FilterMapStrUintPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *string and returns true/false.
  2. Function: takes *string as argument and returns *uint
  3. List of type *[]string

Returns: 

	New List of type *uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapStrUintPtrErr 

func FilterMapStrUintPtrErr(fFilter func(*string) (bool, error), fMap func(*string) (*uint, error), list []*string) ([]*uint, error)

FilterMapStrUintPtrErr 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 - *string and returns (bool, error).
  2. Function: takes *string as argument and returns (*uint, error)
  3. List of type *string

Returns: 

	New List of type *uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint 

func FilterMapUint(fFilter func(uint) bool, fMap func(uint) uint, list []uint) []uint

FilterMapUint filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns true/false.
  2. Function: takes int as argument and returns int
  3. List

Returns: 

	New List.
 Empty list if all there parameters are nil or either of parameter is nil

Example: Multiply all positive numbers in the list by 2 

fp.FilterMapUint(isPositive, multiplyBy2, []uint{-1, 0, 2, 4}) // Returns [4, 8]

func isPositive(num uint) bool {
	return num > 0
}

func multiplyBy2(num uint) uint {
	return num * 2
}

func FilterMapUint16 

func FilterMapUint16(fFilter func(uint16) bool, fMap func(uint16) uint16, list []uint16) []uint16

FilterMapUint16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns true/false.
  2. Function: takes int as argument and returns int
  3. List

Returns: 

	New List.
 Empty list if all there parameters are nil or either of parameter is nil

Example: Multiply all positive numbers in the list by 2 

fp.FilterMapUint16(isPositive, multiplyBy2, []uint16{-1, 0, 2, 4}) // Returns [4, 8]

func isPositive(num uint16) bool {
	return num > 0
}

func multiplyBy2(num uint16) uint16 {
	return num * 2
}

func FilterMapUint16Bool 

func FilterMapUint16Bool(fFilter func(uint16) bool, fMap func(uint16) bool, list []uint16) []bool

FilterMapUint16Bool filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint16 and returns true/false.
  2. Function: takes uint16 as argument and returns bool
  3. List of type uint16

Returns: 

	New List of type bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16BoolErr 

func FilterMapUint16BoolErr(fFilter func(uint16) (bool, error), fMap func(uint16) (bool, error), list []uint16) ([]bool, error)

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

Returns: 

	New List of type bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16BoolPtr 

func FilterMapUint16BoolPtr(fFilter func(*uint16) bool, fMap func(*uint16) *bool, list []*uint16) []*bool

FilterMapUint16BoolPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint16 and returns true/false.
  2. Function: takes *uint16 as argument and returns *bool
  3. List of type *[]uint16

Returns: 

	New List of type *bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16BoolPtrErr 

func FilterMapUint16BoolPtrErr(fFilter func(*uint16) (bool, error), fMap func(*uint16) (*bool, error), list []*uint16) ([]*bool, error)

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

Returns: 

	New List of type *bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Err 

func FilterMapUint16Err(fFilter func(uint16) (bool, error), fMap func(uint16) (uint16, error), list []uint16) ([]uint16, error)

FilterMapUint16Err filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(uint16) and returns (bool, error).
  2. Function: takes uint16 as argument and returns (uint16, error)
  3. Slice of type []uint16

Returns: 

	New List ([]uint16, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Float32 

func FilterMapUint16Float32(fFilter func(uint16) bool, fMap func(uint16) float32, list []uint16) []float32

FilterMapUint16Float32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint16 and returns true/false.
  2. Function: takes uint16 as argument and returns float32
  3. List of type uint16

Returns: 

	New List of type float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Float32Err 

func FilterMapUint16Float32Err(fFilter func(uint16) (bool, error), fMap func(uint16) (float32, error), list []uint16) ([]float32, error)

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

Returns: 

	New List of type float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Float32Ptr 

func FilterMapUint16Float32Ptr(fFilter func(*uint16) bool, fMap func(*uint16) *float32, list []*uint16) []*float32

FilterMapUint16Float32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint16 and returns true/false.
  2. Function: takes *uint16 as argument and returns *float32
  3. List of type *[]uint16

Returns: 

	New List of type *float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Float32PtrErr 

func FilterMapUint16Float32PtrErr(fFilter func(*uint16) (bool, error), fMap func(*uint16) (*float32, error), list []*uint16) ([]*float32, error)

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

Returns: 

	New List of type *float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Float64 

func FilterMapUint16Float64(fFilter func(uint16) bool, fMap func(uint16) float64, list []uint16) []float64

FilterMapUint16Float64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint16 and returns true/false.
  2. Function: takes uint16 as argument and returns float64
  3. List of type uint16

Returns: 

	New List of type float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Float64Err 

func FilterMapUint16Float64Err(fFilter func(uint16) (bool, error), fMap func(uint16) (float64, error), list []uint16) ([]float64, error)

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

Returns: 

	New List of type float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Float64Ptr 

func FilterMapUint16Float64Ptr(fFilter func(*uint16) bool, fMap func(*uint16) *float64, list []*uint16) []*float64

FilterMapUint16Float64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint16 and returns true/false.
  2. Function: takes *uint16 as argument and returns *float64
  3. List of type *[]uint16

Returns: 

	New List of type *float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Float64PtrErr 

func FilterMapUint16Float64PtrErr(fFilter func(*uint16) (bool, error), fMap func(*uint16) (*float64, error), list []*uint16) ([]*float64, error)

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

Returns: 

	New List of type *float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int 

func FilterMapUint16Int(fFilter func(uint16) bool, fMap func(uint16) int, list []uint16) []int

FilterMapUint16Int filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint16 and returns true/false.
  2. Function: takes uint16 as argument and returns int
  3. List of type uint16

Returns: 

	New List of type int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int16 

func FilterMapUint16Int16(fFilter func(uint16) bool, fMap func(uint16) int16, list []uint16) []int16

FilterMapUint16Int16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint16 and returns true/false.
  2. Function: takes uint16 as argument and returns int16
  3. List of type uint16

Returns: 

	New List of type int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int16Err 

func FilterMapUint16Int16Err(fFilter func(uint16) (bool, error), fMap func(uint16) (int16, error), list []uint16) ([]int16, error)

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

Returns: 

	New List of type int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int16Ptr 

func FilterMapUint16Int16Ptr(fFilter func(*uint16) bool, fMap func(*uint16) *int16, list []*uint16) []*int16

FilterMapUint16Int16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint16 and returns true/false.
  2. Function: takes *uint16 as argument and returns *int16
  3. List of type *[]uint16

Returns: 

	New List of type *int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int16PtrErr 

func FilterMapUint16Int16PtrErr(fFilter func(*uint16) (bool, error), fMap func(*uint16) (*int16, error), list []*uint16) ([]*int16, error)

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

Returns: 

	New List of type *int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int32 

func FilterMapUint16Int32(fFilter func(uint16) bool, fMap func(uint16) int32, list []uint16) []int32

FilterMapUint16Int32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint16 and returns true/false.
  2. Function: takes uint16 as argument and returns int32
  3. List of type uint16

Returns: 

	New List of type int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int32Err 

func FilterMapUint16Int32Err(fFilter func(uint16) (bool, error), fMap func(uint16) (int32, error), list []uint16) ([]int32, error)

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

Returns: 

	New List of type int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int32Ptr 

func FilterMapUint16Int32Ptr(fFilter func(*uint16) bool, fMap func(*uint16) *int32, list []*uint16) []*int32

FilterMapUint16Int32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint16 and returns true/false.
  2. Function: takes *uint16 as argument and returns *int32
  3. List of type *[]uint16

Returns: 

	New List of type *int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int32PtrErr 

func FilterMapUint16Int32PtrErr(fFilter func(*uint16) (bool, error), fMap func(*uint16) (*int32, error), list []*uint16) ([]*int32, error)

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

Returns: 

	New List of type *int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int64 

func FilterMapUint16Int64(fFilter func(uint16) bool, fMap func(uint16) int64, list []uint16) []int64

FilterMapUint16Int64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint16 and returns true/false.
  2. Function: takes uint16 as argument and returns int64
  3. List of type uint16

Returns: 

	New List of type int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int64Err 

func FilterMapUint16Int64Err(fFilter func(uint16) (bool, error), fMap func(uint16) (int64, error), list []uint16) ([]int64, error)

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

Returns: 

	New List of type int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int64Ptr 

func FilterMapUint16Int64Ptr(fFilter func(*uint16) bool, fMap func(*uint16) *int64, list []*uint16) []*int64

FilterMapUint16Int64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint16 and returns true/false.
  2. Function: takes *uint16 as argument and returns *int64
  3. List of type *[]uint16

Returns: 

	New List of type *int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int64PtrErr 

func FilterMapUint16Int64PtrErr(fFilter func(*uint16) (bool, error), fMap func(*uint16) (*int64, error), list []*uint16) ([]*int64, error)

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

Returns: 

	New List of type *int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int8 

func FilterMapUint16Int8(fFilter func(uint16) bool, fMap func(uint16) int8, list []uint16) []int8

FilterMapUint16Int8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint16 and returns true/false.
  2. Function: takes uint16 as argument and returns int8
  3. List of type uint16

Returns: 

	New List of type int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int8Err 

func FilterMapUint16Int8Err(fFilter func(uint16) (bool, error), fMap func(uint16) (int8, error), list []uint16) ([]int8, error)

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

Returns: 

	New List of type int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int8Ptr 

func FilterMapUint16Int8Ptr(fFilter func(*uint16) bool, fMap func(*uint16) *int8, list []*uint16) []*int8

FilterMapUint16Int8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint16 and returns true/false.
  2. Function: takes *uint16 as argument and returns *int8
  3. List of type *[]uint16

Returns: 

	New List of type *int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Int8PtrErr 

func FilterMapUint16Int8PtrErr(fFilter func(*uint16) (bool, error), fMap func(*uint16) (*int8, error), list []*uint16) ([]*int8, error)

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

Returns: 

	New List of type *int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16IntErr 

func FilterMapUint16IntErr(fFilter func(uint16) (bool, error), fMap func(uint16) (int, error), list []uint16) ([]int, error)

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

Returns: 

	New List of type int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16IntPtr 

func FilterMapUint16IntPtr(fFilter func(*uint16) bool, fMap func(*uint16) *int, list []*uint16) []*int

FilterMapUint16IntPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint16 and returns true/false.
  2. Function: takes *uint16 as argument and returns *int
  3. List of type *[]uint16

Returns: 

	New List of type *int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16IntPtrErr 

func FilterMapUint16IntPtrErr(fFilter func(*uint16) (bool, error), fMap func(*uint16) (*int, error), list []*uint16) ([]*int, error)

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

Returns: 

	New List of type *int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Ptr 

func FilterMapUint16Ptr(fFilter func(*uint16) bool, fMap func(*uint16) *uint16, list []*uint16) []*uint16

FilterMapUint16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns (bool).
  2. Function: takes uint16 as argument and returns (uint16)
  3. Slice of type []*uint16

Returns: 

	New List of type []*uint16.
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16PtrErr 

func FilterMapUint16PtrErr(fFilter func(*uint16) (bool, error), fMap func(*uint16) (*uint16, error), list []*uint16) ([]*uint16, error)

FilterMapUint16PtrErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(*uint16) and returns (bool, error).
  2. Function: takes *uint16 as argument and returns (*uint16, error)
  3. Slice of type []*uint16

Returns: 

	New List ([]*uint16, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Str 

func FilterMapUint16Str(fFilter func(uint16) bool, fMap func(uint16) string, list []uint16) []string

FilterMapUint16Str filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint16 and returns true/false.
  2. Function: takes uint16 as argument and returns string
  3. List of type uint16

Returns: 

	New List of type string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16StrErr 

func FilterMapUint16StrErr(fFilter func(uint16) (bool, error), fMap func(uint16) (string, error), list []uint16) ([]string, error)

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

Returns: 

	New List of type string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16StrPtr 

func FilterMapUint16StrPtr(fFilter func(*uint16) bool, fMap func(*uint16) *string, list []*uint16) []*string

FilterMapUint16StrPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint16 and returns true/false.
  2. Function: takes *uint16 as argument and returns *string
  3. List of type *[]uint16

Returns: 

	New List of type *string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16StrPtrErr 

func FilterMapUint16StrPtrErr(fFilter func(*uint16) (bool, error), fMap func(*uint16) (*string, error), list []*uint16) ([]*string, error)

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

Returns: 

	New List of type *string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Uint 

func FilterMapUint16Uint(fFilter func(uint16) bool, fMap func(uint16) uint, list []uint16) []uint

FilterMapUint16Uint filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint16 and returns true/false.
  2. Function: takes uint16 as argument and returns uint
  3. List of type uint16

Returns: 

	New List of type uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Uint32 

func FilterMapUint16Uint32(fFilter func(uint16) bool, fMap func(uint16) uint32, list []uint16) []uint32

FilterMapUint16Uint32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint16 and returns true/false.
  2. Function: takes uint16 as argument and returns uint32
  3. List of type uint16

Returns: 

	New List of type uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Uint32Err 

func FilterMapUint16Uint32Err(fFilter func(uint16) (bool, error), fMap func(uint16) (uint32, error), list []uint16) ([]uint32, error)

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

Returns: 

	New List of type uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Uint32Ptr 

func FilterMapUint16Uint32Ptr(fFilter func(*uint16) bool, fMap func(*uint16) *uint32, list []*uint16) []*uint32

FilterMapUint16Uint32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint16 and returns true/false.
  2. Function: takes *uint16 as argument and returns *uint32
  3. List of type *[]uint16

Returns: 

	New List of type *uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Uint32PtrErr 

func FilterMapUint16Uint32PtrErr(fFilter func(*uint16) (bool, error), fMap func(*uint16) (*uint32, error), list []*uint16) ([]*uint32, error)

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

Returns: 

	New List of type *uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Uint64 

func FilterMapUint16Uint64(fFilter func(uint16) bool, fMap func(uint16) uint64, list []uint16) []uint64

FilterMapUint16Uint64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint16 and returns true/false.
  2. Function: takes uint16 as argument and returns uint64
  3. List of type uint16

Returns: 

	New List of type uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Uint64Err 

func FilterMapUint16Uint64Err(fFilter func(uint16) (bool, error), fMap func(uint16) (uint64, error), list []uint16) ([]uint64, error)

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

Returns: 

	New List of type uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Uint64Ptr 

func FilterMapUint16Uint64Ptr(fFilter func(*uint16) bool, fMap func(*uint16) *uint64, list []*uint16) []*uint64

FilterMapUint16Uint64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint16 and returns true/false.
  2. Function: takes *uint16 as argument and returns *uint64
  3. List of type *[]uint16

Returns: 

	New List of type *uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Uint64PtrErr 

func FilterMapUint16Uint64PtrErr(fFilter func(*uint16) (bool, error), fMap func(*uint16) (*uint64, error), list []*uint16) ([]*uint64, error)

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

Returns: 

	New List of type *uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Uint8 

func FilterMapUint16Uint8(fFilter func(uint16) bool, fMap func(uint16) uint8, list []uint16) []uint8

FilterMapUint16Uint8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint16 and returns true/false.
  2. Function: takes uint16 as argument and returns uint8
  3. List of type uint16

Returns: 

	New List of type uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Uint8Err 

func FilterMapUint16Uint8Err(fFilter func(uint16) (bool, error), fMap func(uint16) (uint8, error), list []uint16) ([]uint8, error)

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

Returns: 

	New List of type uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Uint8Ptr 

func FilterMapUint16Uint8Ptr(fFilter func(*uint16) bool, fMap func(*uint16) *uint8, list []*uint16) []*uint8

FilterMapUint16Uint8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint16 and returns true/false.
  2. Function: takes *uint16 as argument and returns *uint8
  3. List of type *[]uint16

Returns: 

	New List of type *uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16Uint8PtrErr 

func FilterMapUint16Uint8PtrErr(fFilter func(*uint16) (bool, error), fMap func(*uint16) (*uint8, error), list []*uint16) ([]*uint8, error)

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

Returns: 

	New List of type *uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16UintErr 

func FilterMapUint16UintErr(fFilter func(uint16) (bool, error), fMap func(uint16) (uint, error), list []uint16) ([]uint, error)

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

Returns: 

	New List of type uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16UintPtr 

func FilterMapUint16UintPtr(fFilter func(*uint16) bool, fMap func(*uint16) *uint, list []*uint16) []*uint

FilterMapUint16UintPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint16 and returns true/false.
  2. Function: takes *uint16 as argument and returns *uint
  3. List of type *[]uint16

Returns: 

	New List of type *uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint16UintPtrErr 

func FilterMapUint16UintPtrErr(fFilter func(*uint16) (bool, error), fMap func(*uint16) (*uint, error), list []*uint16) ([]*uint, error)

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

Returns: 

	New List of type *uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32 

func FilterMapUint32(fFilter func(uint32) bool, fMap func(uint32) uint32, list []uint32) []uint32

FilterMapUint32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns true/false.
  2. Function: takes int as argument and returns int
  3. List

Returns: 

	New List.
 Empty list if all there parameters are nil or either of parameter is nil

Example: Multiply all positive numbers in the list by 2 

fp.FilterMapUint32(isPositive, multiplyBy2, []uint64{-1, 0, 2, 4}) // Returns [4, 8]

func isPositive(num uint32) bool {
	return num > 0
}

func multiplyBy2(num uint32) uint32 {
	return num * 2
}

func FilterMapUint32Bool 

func FilterMapUint32Bool(fFilter func(uint32) bool, fMap func(uint32) bool, list []uint32) []bool

FilterMapUint32Bool filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint32 and returns true/false.
  2. Function: takes uint32 as argument and returns bool
  3. List of type uint32

Returns: 

	New List of type bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32BoolErr 

func FilterMapUint32BoolErr(fFilter func(uint32) (bool, error), fMap func(uint32) (bool, error), list []uint32) ([]bool, error)

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

Returns: 

	New List of type bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32BoolPtr 

func FilterMapUint32BoolPtr(fFilter func(*uint32) bool, fMap func(*uint32) *bool, list []*uint32) []*bool

FilterMapUint32BoolPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint32 and returns true/false.
  2. Function: takes *uint32 as argument and returns *bool
  3. List of type *[]uint32

Returns: 

	New List of type *bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32BoolPtrErr 

func FilterMapUint32BoolPtrErr(fFilter func(*uint32) (bool, error), fMap func(*uint32) (*bool, error), list []*uint32) ([]*bool, error)

FilterMapUint32BoolPtrErr 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 - *uint32 and returns (bool, error).
  2. Function: takes *uint32 as argument and returns (*bool, error)
  3. List of type *uint32

Returns: 

	New List of type *bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Err 

func FilterMapUint32Err(fFilter func(uint32) (bool, error), fMap func(uint32) (uint32, error), list []uint32) ([]uint32, error)

FilterMapUint32Err filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(uint32) and returns (bool, error).
  2. Function: takes uint32 as argument and returns (uint32, error)
  3. Slice of type []uint32

Returns: 

	New List ([]uint32, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Float32 

func FilterMapUint32Float32(fFilter func(uint32) bool, fMap func(uint32) float32, list []uint32) []float32

FilterMapUint32Float32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint32 and returns true/false.
  2. Function: takes uint32 as argument and returns float32
  3. List of type uint32

Returns: 

	New List of type float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Float32Err 

func FilterMapUint32Float32Err(fFilter func(uint32) (bool, error), fMap func(uint32) (float32, error), list []uint32) ([]float32, error)

FilterMapUint32Float32Err 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 - uint32 and returns (bool, error).
  2. Function: takes uint32 as argument and returns (float32, error)
  3. List of type uint32

Returns: 

	New List of type float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Float32Ptr 

func FilterMapUint32Float32Ptr(fFilter func(*uint32) bool, fMap func(*uint32) *float32, list []*uint32) []*float32

FilterMapUint32Float32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint32 and returns true/false.
  2. Function: takes *uint32 as argument and returns *float32
  3. List of type *[]uint32

Returns: 

	New List of type *float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Float32PtrErr 

func FilterMapUint32Float32PtrErr(fFilter func(*uint32) (bool, error), fMap func(*uint32) (*float32, error), list []*uint32) ([]*float32, error)

FilterMapUint32Float32PtrErr 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 - *uint32 and returns (bool, error).
  2. Function: takes *uint32 as argument and returns (*float32, error)
  3. List of type *uint32

Returns: 

	New List of type *float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Float64 

func FilterMapUint32Float64(fFilter func(uint32) bool, fMap func(uint32) float64, list []uint32) []float64

FilterMapUint32Float64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint32 and returns true/false.
  2. Function: takes uint32 as argument and returns float64
  3. List of type uint32

Returns: 

	New List of type float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Float64Err 

func FilterMapUint32Float64Err(fFilter func(uint32) (bool, error), fMap func(uint32) (float64, error), list []uint32) ([]float64, error)

FilterMapUint32Float64Err 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 - uint32 and returns (bool, error).
  2. Function: takes uint32 as argument and returns (float64, error)
  3. List of type uint32

Returns: 

	New List of type float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Float64Ptr 

func FilterMapUint32Float64Ptr(fFilter func(*uint32) bool, fMap func(*uint32) *float64, list []*uint32) []*float64

FilterMapUint32Float64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint32 and returns true/false.
  2. Function: takes *uint32 as argument and returns *float64
  3. List of type *[]uint32

Returns: 

	New List of type *float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Float64PtrErr 

func FilterMapUint32Float64PtrErr(fFilter func(*uint32) (bool, error), fMap func(*uint32) (*float64, error), list []*uint32) ([]*float64, error)

FilterMapUint32Float64PtrErr 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 - *uint32 and returns (bool, error).
  2. Function: takes *uint32 as argument and returns (*float64, error)
  3. List of type *uint32

Returns: 

	New List of type *float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int 

func FilterMapUint32Int(fFilter func(uint32) bool, fMap func(uint32) int, list []uint32) []int

FilterMapUint32Int filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint32 and returns true/false.
  2. Function: takes uint32 as argument and returns int
  3. List of type uint32

Returns: 

	New List of type int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int16 

func FilterMapUint32Int16(fFilter func(uint32) bool, fMap func(uint32) int16, list []uint32) []int16

FilterMapUint32Int16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint32 and returns true/false.
  2. Function: takes uint32 as argument and returns int16
  3. List of type uint32

Returns: 

	New List of type int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int16Err 

func FilterMapUint32Int16Err(fFilter func(uint32) (bool, error), fMap func(uint32) (int16, error), list []uint32) ([]int16, error)

FilterMapUint32Int16Err 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 - uint32 and returns (bool, error).
  2. Function: takes uint32 as argument and returns (int16, error)
  3. List of type uint32

Returns: 

	New List of type int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int16Ptr 

func FilterMapUint32Int16Ptr(fFilter func(*uint32) bool, fMap func(*uint32) *int16, list []*uint32) []*int16

FilterMapUint32Int16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint32 and returns true/false.
  2. Function: takes *uint32 as argument and returns *int16
  3. List of type *[]uint32

Returns: 

	New List of type *int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int16PtrErr 

func FilterMapUint32Int16PtrErr(fFilter func(*uint32) (bool, error), fMap func(*uint32) (*int16, error), list []*uint32) ([]*int16, error)

FilterMapUint32Int16PtrErr 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 - *uint32 and returns (bool, error).
  2. Function: takes *uint32 as argument and returns (*int16, error)
  3. List of type *uint32

Returns: 

	New List of type *int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int32 

func FilterMapUint32Int32(fFilter func(uint32) bool, fMap func(uint32) int32, list []uint32) []int32

FilterMapUint32Int32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint32 and returns true/false.
  2. Function: takes uint32 as argument and returns int32
  3. List of type uint32

Returns: 

	New List of type int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int32Err 

func FilterMapUint32Int32Err(fFilter func(uint32) (bool, error), fMap func(uint32) (int32, error), list []uint32) ([]int32, error)

FilterMapUint32Int32Err 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 - uint32 and returns (bool, error).
  2. Function: takes uint32 as argument and returns (int32, error)
  3. List of type uint32

Returns: 

	New List of type int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int32Ptr 

func FilterMapUint32Int32Ptr(fFilter func(*uint32) bool, fMap func(*uint32) *int32, list []*uint32) []*int32

FilterMapUint32Int32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint32 and returns true/false.
  2. Function: takes *uint32 as argument and returns *int32
  3. List of type *[]uint32

Returns: 

	New List of type *int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int32PtrErr 

func FilterMapUint32Int32PtrErr(fFilter func(*uint32) (bool, error), fMap func(*uint32) (*int32, error), list []*uint32) ([]*int32, error)

FilterMapUint32Int32PtrErr 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 - *uint32 and returns (bool, error).
  2. Function: takes *uint32 as argument and returns (*int32, error)
  3. List of type *uint32

Returns: 

	New List of type *int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int64 

func FilterMapUint32Int64(fFilter func(uint32) bool, fMap func(uint32) int64, list []uint32) []int64

FilterMapUint32Int64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint32 and returns true/false.
  2. Function: takes uint32 as argument and returns int64
  3. List of type uint32

Returns: 

	New List of type int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int64Err 

func FilterMapUint32Int64Err(fFilter func(uint32) (bool, error), fMap func(uint32) (int64, error), list []uint32) ([]int64, error)

FilterMapUint32Int64Err 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 - uint32 and returns (bool, error).
  2. Function: takes uint32 as argument and returns (int64, error)
  3. List of type uint32

Returns: 

	New List of type int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int64Ptr 

func FilterMapUint32Int64Ptr(fFilter func(*uint32) bool, fMap func(*uint32) *int64, list []*uint32) []*int64

FilterMapUint32Int64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint32 and returns true/false.
  2. Function: takes *uint32 as argument and returns *int64
  3. List of type *[]uint32

Returns: 

	New List of type *int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int64PtrErr 

func FilterMapUint32Int64PtrErr(fFilter func(*uint32) (bool, error), fMap func(*uint32) (*int64, error), list []*uint32) ([]*int64, error)

FilterMapUint32Int64PtrErr 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 - *uint32 and returns (bool, error).
  2. Function: takes *uint32 as argument and returns (*int64, error)
  3. List of type *uint32

Returns: 

	New List of type *int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int8 

func FilterMapUint32Int8(fFilter func(uint32) bool, fMap func(uint32) int8, list []uint32) []int8

FilterMapUint32Int8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint32 and returns true/false.
  2. Function: takes uint32 as argument and returns int8
  3. List of type uint32

Returns: 

	New List of type int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int8Err 

func FilterMapUint32Int8Err(fFilter func(uint32) (bool, error), fMap func(uint32) (int8, error), list []uint32) ([]int8, error)

FilterMapUint32Int8Err 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 - uint32 and returns (bool, error).
  2. Function: takes uint32 as argument and returns (int8, error)
  3. List of type uint32

Returns: 

	New List of type int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int8Ptr 

func FilterMapUint32Int8Ptr(fFilter func(*uint32) bool, fMap func(*uint32) *int8, list []*uint32) []*int8

FilterMapUint32Int8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint32 and returns true/false.
  2. Function: takes *uint32 as argument and returns *int8
  3. List of type *[]uint32

Returns: 

	New List of type *int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Int8PtrErr 

func FilterMapUint32Int8PtrErr(fFilter func(*uint32) (bool, error), fMap func(*uint32) (*int8, error), list []*uint32) ([]*int8, error)

FilterMapUint32Int8PtrErr 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 - *uint32 and returns (bool, error).
  2. Function: takes *uint32 as argument and returns (*int8, error)
  3. List of type *uint32

Returns: 

	New List of type *int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32IntErr 

func FilterMapUint32IntErr(fFilter func(uint32) (bool, error), fMap func(uint32) (int, error), list []uint32) ([]int, error)

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

Returns: 

	New List of type int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32IntPtr 

func FilterMapUint32IntPtr(fFilter func(*uint32) bool, fMap func(*uint32) *int, list []*uint32) []*int

FilterMapUint32IntPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint32 and returns true/false.
  2. Function: takes *uint32 as argument and returns *int
  3. List of type *[]uint32

Returns: 

	New List of type *int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32IntPtrErr 

func FilterMapUint32IntPtrErr(fFilter func(*uint32) (bool, error), fMap func(*uint32) (*int, error), list []*uint32) ([]*int, error)

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

Returns: 

	New List of type *int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Ptr 

func FilterMapUint32Ptr(fFilter func(*uint32) bool, fMap func(*uint32) *uint32, list []*uint32) []*uint32

FilterMapUint32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns (bool).
  2. Function: takes uint32 as argument and returns (uint32)
  3. Slice of type []*uint32

Returns: 

	New List of type []*uint32.
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32PtrErr 

func FilterMapUint32PtrErr(fFilter func(*uint32) (bool, error), fMap func(*uint32) (*uint32, error), list []*uint32) ([]*uint32, error)

FilterMapUint32PtrErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(*uint32) and returns (bool, error).
  2. Function: takes *uint32 as argument and returns (*uint32, error)
  3. Slice of type []*uint32

Returns: 

	New List ([]*uint32, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Str 

func FilterMapUint32Str(fFilter func(uint32) bool, fMap func(uint32) string, list []uint32) []string

FilterMapUint32Str filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint32 and returns true/false.
  2. Function: takes uint32 as argument and returns string
  3. List of type uint32

Returns: 

	New List of type string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32StrErr 

func FilterMapUint32StrErr(fFilter func(uint32) (bool, error), fMap func(uint32) (string, error), list []uint32) ([]string, error)

FilterMapUint32StrErr 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 - uint32 and returns (bool, error).
  2. Function: takes uint32 as argument and returns (string, error)
  3. List of type uint32

Returns: 

	New List of type string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32StrPtr 

func FilterMapUint32StrPtr(fFilter func(*uint32) bool, fMap func(*uint32) *string, list []*uint32) []*string

FilterMapUint32StrPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint32 and returns true/false.
  2. Function: takes *uint32 as argument and returns *string
  3. List of type *[]uint32

Returns: 

	New List of type *string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32StrPtrErr 

func FilterMapUint32StrPtrErr(fFilter func(*uint32) (bool, error), fMap func(*uint32) (*string, error), list []*uint32) ([]*string, error)

FilterMapUint32StrPtrErr 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 - *uint32 and returns (bool, error).
  2. Function: takes *uint32 as argument and returns (*string, error)
  3. List of type *uint32

Returns: 

	New List of type *string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Uint 

func FilterMapUint32Uint(fFilter func(uint32) bool, fMap func(uint32) uint, list []uint32) []uint

FilterMapUint32Uint filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint32 and returns true/false.
  2. Function: takes uint32 as argument and returns uint
  3. List of type uint32

Returns: 

	New List of type uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Uint16 

func FilterMapUint32Uint16(fFilter func(uint32) bool, fMap func(uint32) uint16, list []uint32) []uint16

FilterMapUint32Uint16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint32 and returns true/false.
  2. Function: takes uint32 as argument and returns uint16
  3. List of type uint32

Returns: 

	New List of type uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Uint16Err 

func FilterMapUint32Uint16Err(fFilter func(uint32) (bool, error), fMap func(uint32) (uint16, error), list []uint32) ([]uint16, error)

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

Returns: 

	New List of type uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Uint16Ptr 

func FilterMapUint32Uint16Ptr(fFilter func(*uint32) bool, fMap func(*uint32) *uint16, list []*uint32) []*uint16

FilterMapUint32Uint16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint32 and returns true/false.
  2. Function: takes *uint32 as argument and returns *uint16
  3. List of type *[]uint32

Returns: 

	New List of type *uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Uint16PtrErr 

func FilterMapUint32Uint16PtrErr(fFilter func(*uint32) (bool, error), fMap func(*uint32) (*uint16, error), list []*uint32) ([]*uint16, error)

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

Returns: 

	New List of type *uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Uint64 

func FilterMapUint32Uint64(fFilter func(uint32) bool, fMap func(uint32) uint64, list []uint32) []uint64

FilterMapUint32Uint64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint32 and returns true/false.
  2. Function: takes uint32 as argument and returns uint64
  3. List of type uint32

Returns: 

	New List of type uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Uint64Err 

func FilterMapUint32Uint64Err(fFilter func(uint32) (bool, error), fMap func(uint32) (uint64, error), list []uint32) ([]uint64, error)

FilterMapUint32Uint64Err 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 - uint32 and returns (bool, error).
  2. Function: takes uint32 as argument and returns (uint64, error)
  3. List of type uint32

Returns: 

	New List of type uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Uint64Ptr 

func FilterMapUint32Uint64Ptr(fFilter func(*uint32) bool, fMap func(*uint32) *uint64, list []*uint32) []*uint64

FilterMapUint32Uint64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint32 and returns true/false.
  2. Function: takes *uint32 as argument and returns *uint64
  3. List of type *[]uint32

Returns: 

	New List of type *uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Uint64PtrErr 

func FilterMapUint32Uint64PtrErr(fFilter func(*uint32) (bool, error), fMap func(*uint32) (*uint64, error), list []*uint32) ([]*uint64, error)

FilterMapUint32Uint64PtrErr 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 - *uint32 and returns (bool, error).
  2. Function: takes *uint32 as argument and returns (*uint64, error)
  3. List of type *uint32

Returns: 

	New List of type *uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Uint8 

func FilterMapUint32Uint8(fFilter func(uint32) bool, fMap func(uint32) uint8, list []uint32) []uint8

FilterMapUint32Uint8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint32 and returns true/false.
  2. Function: takes uint32 as argument and returns uint8
  3. List of type uint32

Returns: 

	New List of type uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Uint8Err 

func FilterMapUint32Uint8Err(fFilter func(uint32) (bool, error), fMap func(uint32) (uint8, error), list []uint32) ([]uint8, error)

FilterMapUint32Uint8Err 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 - uint32 and returns (bool, error).
  2. Function: takes uint32 as argument and returns (uint8, error)
  3. List of type uint32

Returns: 

	New List of type uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Uint8Ptr 

func FilterMapUint32Uint8Ptr(fFilter func(*uint32) bool, fMap func(*uint32) *uint8, list []*uint32) []*uint8

FilterMapUint32Uint8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint32 and returns true/false.
  2. Function: takes *uint32 as argument and returns *uint8
  3. List of type *[]uint32

Returns: 

	New List of type *uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32Uint8PtrErr 

func FilterMapUint32Uint8PtrErr(fFilter func(*uint32) (bool, error), fMap func(*uint32) (*uint8, error), list []*uint32) ([]*uint8, error)

FilterMapUint32Uint8PtrErr 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 - *uint32 and returns (bool, error).
  2. Function: takes *uint32 as argument and returns (*uint8, error)
  3. List of type *uint32

Returns: 

	New List of type *uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32UintErr 

func FilterMapUint32UintErr(fFilter func(uint32) (bool, error), fMap func(uint32) (uint, error), list []uint32) ([]uint, error)

FilterMapUint32UintErr 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 - uint32 and returns (bool, error).
  2. Function: takes uint32 as argument and returns (uint, error)
  3. List of type uint32

Returns: 

	New List of type uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32UintPtr 

func FilterMapUint32UintPtr(fFilter func(*uint32) bool, fMap func(*uint32) *uint, list []*uint32) []*uint

FilterMapUint32UintPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint32 and returns true/false.
  2. Function: takes *uint32 as argument and returns *uint
  3. List of type *[]uint32

Returns: 

	New List of type *uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint32UintPtrErr 

func FilterMapUint32UintPtrErr(fFilter func(*uint32) (bool, error), fMap func(*uint32) (*uint, error), list []*uint32) ([]*uint, error)

FilterMapUint32UintPtrErr 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 - *uint32 and returns (bool, error).
  2. Function: takes *uint32 as argument and returns (*uint, error)
  3. List of type *uint32

Returns: 

	New List of type *uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64 

func FilterMapUint64(fFilter func(uint64) bool, fMap func(uint64) uint64, list []uint64) []uint64

FilterMapUint64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns true/false.
  2. Function: takes int as argument and returns int
  3. List

Returns: 

	New List.
 Empty list if all there parameters are nil or either of parameter is nil

Example: Multiply all positive numbers in the list by 2 

fp.FilterMapUint64(isPositive, multiplyBy2, []uint64{-1, 0, 2, 4}) // Returns [4, 8]

func isPositive(num uint64) bool {
	return num > 0
}

func multiplyBy2(num uint64) uint64 {
	return num * 2
}

func FilterMapUint64Bool 

func FilterMapUint64Bool(fFilter func(uint64) bool, fMap func(uint64) bool, list []uint64) []bool

FilterMapUint64Bool filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint64 and returns true/false.
  2. Function: takes uint64 as argument and returns bool
  3. List of type uint64

Returns: 

	New List of type bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64BoolErr 

func FilterMapUint64BoolErr(fFilter func(uint64) (bool, error), fMap func(uint64) (bool, error), list []uint64) ([]bool, error)

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

Returns: 

	New List of type bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64BoolPtr 

func FilterMapUint64BoolPtr(fFilter func(*uint64) bool, fMap func(*uint64) *bool, list []*uint64) []*bool

FilterMapUint64BoolPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint64 and returns true/false.
  2. Function: takes *uint64 as argument and returns *bool
  3. List of type *[]uint64

Returns: 

	New List of type *bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64BoolPtrErr 

func FilterMapUint64BoolPtrErr(fFilter func(*uint64) (bool, error), fMap func(*uint64) (*bool, error), list []*uint64) ([]*bool, error)

FilterMapUint64BoolPtrErr 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 - *uint64 and returns (bool, error).
  2. Function: takes *uint64 as argument and returns (*bool, error)
  3. List of type *uint64

Returns: 

	New List of type *bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Err 

func FilterMapUint64Err(fFilter func(uint64) (bool, error), fMap func(uint64) (uint64, error), list []uint64) ([]uint64, error)

FilterMapUint64Err filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(uint64) and returns (bool, error).
  2. Function: takes uint64 as argument and returns (uint64, error)
  3. Slice of type []uint64

Returns: 

	New List ([]uint64, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Float32 

func FilterMapUint64Float32(fFilter func(uint64) bool, fMap func(uint64) float32, list []uint64) []float32

FilterMapUint64Float32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint64 and returns true/false.
  2. Function: takes uint64 as argument and returns float32
  3. List of type uint64

Returns: 

	New List of type float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Float32Err 

func FilterMapUint64Float32Err(fFilter func(uint64) (bool, error), fMap func(uint64) (float32, error), list []uint64) ([]float32, error)

FilterMapUint64Float32Err 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 - uint64 and returns (bool, error).
  2. Function: takes uint64 as argument and returns (float32, error)
  3. List of type uint64

Returns: 

	New List of type float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Float32Ptr 

func FilterMapUint64Float32Ptr(fFilter func(*uint64) bool, fMap func(*uint64) *float32, list []*uint64) []*float32

FilterMapUint64Float32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint64 and returns true/false.
  2. Function: takes *uint64 as argument and returns *float32
  3. List of type *[]uint64

Returns: 

	New List of type *float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Float32PtrErr 

func FilterMapUint64Float32PtrErr(fFilter func(*uint64) (bool, error), fMap func(*uint64) (*float32, error), list []*uint64) ([]*float32, error)

FilterMapUint64Float32PtrErr 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 - *uint64 and returns (bool, error).
  2. Function: takes *uint64 as argument and returns (*float32, error)
  3. List of type *uint64

Returns: 

	New List of type *float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Float64 

func FilterMapUint64Float64(fFilter func(uint64) bool, fMap func(uint64) float64, list []uint64) []float64

FilterMapUint64Float64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint64 and returns true/false.
  2. Function: takes uint64 as argument and returns float64
  3. List of type uint64

Returns: 

	New List of type float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Float64Err 

func FilterMapUint64Float64Err(fFilter func(uint64) (bool, error), fMap func(uint64) (float64, error), list []uint64) ([]float64, error)

FilterMapUint64Float64Err 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 - uint64 and returns (bool, error).
  2. Function: takes uint64 as argument and returns (float64, error)
  3. List of type uint64

Returns: 

	New List of type float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Float64Ptr 

func FilterMapUint64Float64Ptr(fFilter func(*uint64) bool, fMap func(*uint64) *float64, list []*uint64) []*float64

FilterMapUint64Float64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint64 and returns true/false.
  2. Function: takes *uint64 as argument and returns *float64
  3. List of type *[]uint64

Returns: 

	New List of type *float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Float64PtrErr 

func FilterMapUint64Float64PtrErr(fFilter func(*uint64) (bool, error), fMap func(*uint64) (*float64, error), list []*uint64) ([]*float64, error)

FilterMapUint64Float64PtrErr 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 - *uint64 and returns (bool, error).
  2. Function: takes *uint64 as argument and returns (*float64, error)
  3. List of type *uint64

Returns: 

	New List of type *float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int 

func FilterMapUint64Int(fFilter func(uint64) bool, fMap func(uint64) int, list []uint64) []int

FilterMapUint64Int filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint64 and returns true/false.
  2. Function: takes uint64 as argument and returns int
  3. List of type uint64

Returns: 

	New List of type int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int16 

func FilterMapUint64Int16(fFilter func(uint64) bool, fMap func(uint64) int16, list []uint64) []int16

FilterMapUint64Int16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint64 and returns true/false.
  2. Function: takes uint64 as argument and returns int16
  3. List of type uint64

Returns: 

	New List of type int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int16Err 

func FilterMapUint64Int16Err(fFilter func(uint64) (bool, error), fMap func(uint64) (int16, error), list []uint64) ([]int16, error)

FilterMapUint64Int16Err 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 - uint64 and returns (bool, error).
  2. Function: takes uint64 as argument and returns (int16, error)
  3. List of type uint64

Returns: 

	New List of type int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int16Ptr 

func FilterMapUint64Int16Ptr(fFilter func(*uint64) bool, fMap func(*uint64) *int16, list []*uint64) []*int16

FilterMapUint64Int16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint64 and returns true/false.
  2. Function: takes *uint64 as argument and returns *int16
  3. List of type *[]uint64

Returns: 

	New List of type *int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int16PtrErr 

func FilterMapUint64Int16PtrErr(fFilter func(*uint64) (bool, error), fMap func(*uint64) (*int16, error), list []*uint64) ([]*int16, error)

FilterMapUint64Int16PtrErr 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 - *uint64 and returns (bool, error).
  2. Function: takes *uint64 as argument and returns (*int16, error)
  3. List of type *uint64

Returns: 

	New List of type *int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int32 

func FilterMapUint64Int32(fFilter func(uint64) bool, fMap func(uint64) int32, list []uint64) []int32

FilterMapUint64Int32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint64 and returns true/false.
  2. Function: takes uint64 as argument and returns int32
  3. List of type uint64

Returns: 

	New List of type int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int32Err 

func FilterMapUint64Int32Err(fFilter func(uint64) (bool, error), fMap func(uint64) (int32, error), list []uint64) ([]int32, error)

FilterMapUint64Int32Err 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 - uint64 and returns (bool, error).
  2. Function: takes uint64 as argument and returns (int32, error)
  3. List of type uint64

Returns: 

	New List of type int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int32Ptr 

func FilterMapUint64Int32Ptr(fFilter func(*uint64) bool, fMap func(*uint64) *int32, list []*uint64) []*int32

FilterMapUint64Int32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint64 and returns true/false.
  2. Function: takes *uint64 as argument and returns *int32
  3. List of type *[]uint64

Returns: 

	New List of type *int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int32PtrErr 

func FilterMapUint64Int32PtrErr(fFilter func(*uint64) (bool, error), fMap func(*uint64) (*int32, error), list []*uint64) ([]*int32, error)

FilterMapUint64Int32PtrErr 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 - *uint64 and returns (bool, error).
  2. Function: takes *uint64 as argument and returns (*int32, error)
  3. List of type *uint64

Returns: 

	New List of type *int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int64 

func FilterMapUint64Int64(fFilter func(uint64) bool, fMap func(uint64) int64, list []uint64) []int64

FilterMapUint64Int64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint64 and returns true/false.
  2. Function: takes uint64 as argument and returns int64
  3. List of type uint64

Returns: 

	New List of type int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int64Err 

func FilterMapUint64Int64Err(fFilter func(uint64) (bool, error), fMap func(uint64) (int64, error), list []uint64) ([]int64, error)

FilterMapUint64Int64Err 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 - uint64 and returns (bool, error).
  2. Function: takes uint64 as argument and returns (int64, error)
  3. List of type uint64

Returns: 

	New List of type int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int64Ptr 

func FilterMapUint64Int64Ptr(fFilter func(*uint64) bool, fMap func(*uint64) *int64, list []*uint64) []*int64

FilterMapUint64Int64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint64 and returns true/false.
  2. Function: takes *uint64 as argument and returns *int64
  3. List of type *[]uint64

Returns: 

	New List of type *int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int64PtrErr 

func FilterMapUint64Int64PtrErr(fFilter func(*uint64) (bool, error), fMap func(*uint64) (*int64, error), list []*uint64) ([]*int64, error)

FilterMapUint64Int64PtrErr 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 - *uint64 and returns (bool, error).
  2. Function: takes *uint64 as argument and returns (*int64, error)
  3. List of type *uint64

Returns: 

	New List of type *int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int8 

func FilterMapUint64Int8(fFilter func(uint64) bool, fMap func(uint64) int8, list []uint64) []int8

FilterMapUint64Int8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint64 and returns true/false.
  2. Function: takes uint64 as argument and returns int8
  3. List of type uint64

Returns: 

	New List of type int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int8Err 

func FilterMapUint64Int8Err(fFilter func(uint64) (bool, error), fMap func(uint64) (int8, error), list []uint64) ([]int8, error)

FilterMapUint64Int8Err 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 - uint64 and returns (bool, error).
  2. Function: takes uint64 as argument and returns (int8, error)
  3. List of type uint64

Returns: 

	New List of type int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int8Ptr 

func FilterMapUint64Int8Ptr(fFilter func(*uint64) bool, fMap func(*uint64) *int8, list []*uint64) []*int8

FilterMapUint64Int8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint64 and returns true/false.
  2. Function: takes *uint64 as argument and returns *int8
  3. List of type *[]uint64

Returns: 

	New List of type *int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Int8PtrErr 

func FilterMapUint64Int8PtrErr(fFilter func(*uint64) (bool, error), fMap func(*uint64) (*int8, error), list []*uint64) ([]*int8, error)

FilterMapUint64Int8PtrErr 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 - *uint64 and returns (bool, error).
  2. Function: takes *uint64 as argument and returns (*int8, error)
  3. List of type *uint64

Returns: 

	New List of type *int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64IntErr 

func FilterMapUint64IntErr(fFilter func(uint64) (bool, error), fMap func(uint64) (int, error), list []uint64) ([]int, error)

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

Returns: 

	New List of type int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64IntPtr 

func FilterMapUint64IntPtr(fFilter func(*uint64) bool, fMap func(*uint64) *int, list []*uint64) []*int

FilterMapUint64IntPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint64 and returns true/false.
  2. Function: takes *uint64 as argument and returns *int
  3. List of type *[]uint64

Returns: 

	New List of type *int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64IntPtrErr 

func FilterMapUint64IntPtrErr(fFilter func(*uint64) (bool, error), fMap func(*uint64) (*int, error), list []*uint64) ([]*int, error)

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

Returns: 

	New List of type *int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Ptr 

func FilterMapUint64Ptr(fFilter func(*uint64) bool, fMap func(*uint64) *uint64, list []*uint64) []*uint64

FilterMapUint64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns (bool).
  2. Function: takes uint64 as argument and returns (uint64)
  3. Slice of type []*uint64

Returns: 

	New List of type []*uint64.
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64PtrErr 

func FilterMapUint64PtrErr(fFilter func(*uint64) (bool, error), fMap func(*uint64) (*uint64, error), list []*uint64) ([]*uint64, error)

FilterMapUint64PtrErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(*uint64) and returns (bool, error).
  2. Function: takes *uint64 as argument and returns (*uint64, error)
  3. Slice of type []*uint64

Returns: 

	New List ([]*uint64, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Str 

func FilterMapUint64Str(fFilter func(uint64) bool, fMap func(uint64) string, list []uint64) []string

FilterMapUint64Str filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint64 and returns true/false.
  2. Function: takes uint64 as argument and returns string
  3. List of type uint64

Returns: 

	New List of type string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64StrErr 

func FilterMapUint64StrErr(fFilter func(uint64) (bool, error), fMap func(uint64) (string, error), list []uint64) ([]string, error)

FilterMapUint64StrErr 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 - uint64 and returns (bool, error).
  2. Function: takes uint64 as argument and returns (string, error)
  3. List of type uint64

Returns: 

	New List of type string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64StrPtr 

func FilterMapUint64StrPtr(fFilter func(*uint64) bool, fMap func(*uint64) *string, list []*uint64) []*string

FilterMapUint64StrPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint64 and returns true/false.
  2. Function: takes *uint64 as argument and returns *string
  3. List of type *[]uint64

Returns: 

	New List of type *string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64StrPtrErr 

func FilterMapUint64StrPtrErr(fFilter func(*uint64) (bool, error), fMap func(*uint64) (*string, error), list []*uint64) ([]*string, error)

FilterMapUint64StrPtrErr 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 - *uint64 and returns (bool, error).
  2. Function: takes *uint64 as argument and returns (*string, error)
  3. List of type *uint64

Returns: 

	New List of type *string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Uint 

func FilterMapUint64Uint(fFilter func(uint64) bool, fMap func(uint64) uint, list []uint64) []uint

FilterMapUint64Uint filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint64 and returns true/false.
  2. Function: takes uint64 as argument and returns uint
  3. List of type uint64

Returns: 

	New List of type uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Uint16 

func FilterMapUint64Uint16(fFilter func(uint64) bool, fMap func(uint64) uint16, list []uint64) []uint16

FilterMapUint64Uint16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint64 and returns true/false.
  2. Function: takes uint64 as argument and returns uint16
  3. List of type uint64

Returns: 

	New List of type uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Uint16Err 

func FilterMapUint64Uint16Err(fFilter func(uint64) (bool, error), fMap func(uint64) (uint16, error), list []uint64) ([]uint16, error)

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

Returns: 

	New List of type uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Uint16Ptr 

func FilterMapUint64Uint16Ptr(fFilter func(*uint64) bool, fMap func(*uint64) *uint16, list []*uint64) []*uint16

FilterMapUint64Uint16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint64 and returns true/false.
  2. Function: takes *uint64 as argument and returns *uint16
  3. List of type *[]uint64

Returns: 

	New List of type *uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Uint16PtrErr 

func FilterMapUint64Uint16PtrErr(fFilter func(*uint64) (bool, error), fMap func(*uint64) (*uint16, error), list []*uint64) ([]*uint16, error)

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

Returns: 

	New List of type *uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Uint32 

func FilterMapUint64Uint32(fFilter func(uint64) bool, fMap func(uint64) uint32, list []uint64) []uint32

FilterMapUint64Uint32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint64 and returns true/false.
  2. Function: takes uint64 as argument and returns uint32
  3. List of type uint64

Returns: 

	New List of type uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Uint32Err 

func FilterMapUint64Uint32Err(fFilter func(uint64) (bool, error), fMap func(uint64) (uint32, error), list []uint64) ([]uint32, error)

FilterMapUint64Uint32Err 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 - uint64 and returns (bool, error).
  2. Function: takes uint64 as argument and returns (uint32, error)
  3. List of type uint64

Returns: 

	New List of type uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Uint32Ptr 

func FilterMapUint64Uint32Ptr(fFilter func(*uint64) bool, fMap func(*uint64) *uint32, list []*uint64) []*uint32

FilterMapUint64Uint32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint64 and returns true/false.
  2. Function: takes *uint64 as argument and returns *uint32
  3. List of type *[]uint64

Returns: 

	New List of type *uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Uint32PtrErr 

func FilterMapUint64Uint32PtrErr(fFilter func(*uint64) (bool, error), fMap func(*uint64) (*uint32, error), list []*uint64) ([]*uint32, error)

FilterMapUint64Uint32PtrErr 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 - *uint64 and returns (bool, error).
  2. Function: takes *uint64 as argument and returns (*uint32, error)
  3. List of type *uint64

Returns: 

	New List of type *uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Uint8 

func FilterMapUint64Uint8(fFilter func(uint64) bool, fMap func(uint64) uint8, list []uint64) []uint8

FilterMapUint64Uint8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint64 and returns true/false.
  2. Function: takes uint64 as argument and returns uint8
  3. List of type uint64

Returns: 

	New List of type uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Uint8Err 

func FilterMapUint64Uint8Err(fFilter func(uint64) (bool, error), fMap func(uint64) (uint8, error), list []uint64) ([]uint8, error)

FilterMapUint64Uint8Err 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 - uint64 and returns (bool, error).
  2. Function: takes uint64 as argument and returns (uint8, error)
  3. List of type uint64

Returns: 

	New List of type uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Uint8Ptr 

func FilterMapUint64Uint8Ptr(fFilter func(*uint64) bool, fMap func(*uint64) *uint8, list []*uint64) []*uint8

FilterMapUint64Uint8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint64 and returns true/false.
  2. Function: takes *uint64 as argument and returns *uint8
  3. List of type *[]uint64

Returns: 

	New List of type *uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64Uint8PtrErr 

func FilterMapUint64Uint8PtrErr(fFilter func(*uint64) (bool, error), fMap func(*uint64) (*uint8, error), list []*uint64) ([]*uint8, error)

FilterMapUint64Uint8PtrErr 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 - *uint64 and returns (bool, error).
  2. Function: takes *uint64 as argument and returns (*uint8, error)
  3. List of type *uint64

Returns: 

	New List of type *uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64UintErr 

func FilterMapUint64UintErr(fFilter func(uint64) (bool, error), fMap func(uint64) (uint, error), list []uint64) ([]uint, error)

FilterMapUint64UintErr 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 - uint64 and returns (bool, error).
  2. Function: takes uint64 as argument and returns (uint, error)
  3. List of type uint64

Returns: 

	New List of type uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64UintPtr 

func FilterMapUint64UintPtr(fFilter func(*uint64) bool, fMap func(*uint64) *uint, list []*uint64) []*uint

FilterMapUint64UintPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint64 and returns true/false.
  2. Function: takes *uint64 as argument and returns *uint
  3. List of type *[]uint64

Returns: 

	New List of type *uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint64UintPtrErr 

func FilterMapUint64UintPtrErr(fFilter func(*uint64) (bool, error), fMap func(*uint64) (*uint, error), list []*uint64) ([]*uint, error)

FilterMapUint64UintPtrErr 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 - *uint64 and returns (bool, error).
  2. Function: takes *uint64 as argument and returns (*uint, error)
  3. List of type *uint64

Returns: 

	New List of type *uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8 

func FilterMapUint8(fFilter func(uint8) bool, fMap func(uint8) uint8, list []uint8) []uint8

FilterMapUint8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns true/false.
  2. Function: takes int as argument and returns int
  3. List

Returns: 

	New List.
 Empty list if all there parameters are nil or either of parameter is nil

Example: Multiply all positive numbers in the list by 2 

fp.FilterMapUint8(isPositive, multiplyBy2, []uint8{-1, 0, 2, 4}) // Returns [4, 8]

func isPositive(num uint8) bool {
	return num > 0
}

func multiplyBy2(num uint8) uint8 {
	return num * 2
}

func FilterMapUint8Bool 

func FilterMapUint8Bool(fFilter func(uint8) bool, fMap func(uint8) bool, list []uint8) []bool

FilterMapUint8Bool filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint8 and returns true/false.
  2. Function: takes uint8 as argument and returns bool
  3. List of type uint8

Returns: 

	New List of type bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8BoolErr 

func FilterMapUint8BoolErr(fFilter func(uint8) (bool, error), fMap func(uint8) (bool, error), list []uint8) ([]bool, error)

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

Returns: 

	New List of type bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8BoolPtr 

func FilterMapUint8BoolPtr(fFilter func(*uint8) bool, fMap func(*uint8) *bool, list []*uint8) []*bool

FilterMapUint8BoolPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint8 and returns true/false.
  2. Function: takes *uint8 as argument and returns *bool
  3. List of type *[]uint8

Returns: 

	New List of type *bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8BoolPtrErr 

func FilterMapUint8BoolPtrErr(fFilter func(*uint8) (bool, error), fMap func(*uint8) (*bool, error), list []*uint8) ([]*bool, error)

FilterMapUint8BoolPtrErr 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 - *uint8 and returns (bool, error).
  2. Function: takes *uint8 as argument and returns (*bool, error)
  3. List of type *uint8

Returns: 

	New List of type *bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Err 

func FilterMapUint8Err(fFilter func(uint8) (bool, error), fMap func(uint8) (uint8, error), list []uint8) ([]uint8, error)

FilterMapUint8Err filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(uint8) and returns (bool, error).
  2. Function: takes uint8 as argument and returns (uint8, error)
  3. Slice of type []uint8

Returns: 

	New List ([]uint8, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Float32 

func FilterMapUint8Float32(fFilter func(uint8) bool, fMap func(uint8) float32, list []uint8) []float32

FilterMapUint8Float32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint8 and returns true/false.
  2. Function: takes uint8 as argument and returns float32
  3. List of type uint8

Returns: 

	New List of type float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Float32Err 

func FilterMapUint8Float32Err(fFilter func(uint8) (bool, error), fMap func(uint8) (float32, error), list []uint8) ([]float32, error)

FilterMapUint8Float32Err 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 - uint8 and returns (bool, error).
  2. Function: takes uint8 as argument and returns (float32, error)
  3. List of type uint8

Returns: 

	New List of type float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Float32Ptr 

func FilterMapUint8Float32Ptr(fFilter func(*uint8) bool, fMap func(*uint8) *float32, list []*uint8) []*float32

FilterMapUint8Float32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint8 and returns true/false.
  2. Function: takes *uint8 as argument and returns *float32
  3. List of type *[]uint8

Returns: 

	New List of type *float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Float32PtrErr 

func FilterMapUint8Float32PtrErr(fFilter func(*uint8) (bool, error), fMap func(*uint8) (*float32, error), list []*uint8) ([]*float32, error)

FilterMapUint8Float32PtrErr 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 - *uint8 and returns (bool, error).
  2. Function: takes *uint8 as argument and returns (*float32, error)
  3. List of type *uint8

Returns: 

	New List of type *float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Float64 

func FilterMapUint8Float64(fFilter func(uint8) bool, fMap func(uint8) float64, list []uint8) []float64

FilterMapUint8Float64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint8 and returns true/false.
  2. Function: takes uint8 as argument and returns float64
  3. List of type uint8

Returns: 

	New List of type float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Float64Err 

func FilterMapUint8Float64Err(fFilter func(uint8) (bool, error), fMap func(uint8) (float64, error), list []uint8) ([]float64, error)

FilterMapUint8Float64Err 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 - uint8 and returns (bool, error).
  2. Function: takes uint8 as argument and returns (float64, error)
  3. List of type uint8

Returns: 

	New List of type float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Float64Ptr 

func FilterMapUint8Float64Ptr(fFilter func(*uint8) bool, fMap func(*uint8) *float64, list []*uint8) []*float64

FilterMapUint8Float64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint8 and returns true/false.
  2. Function: takes *uint8 as argument and returns *float64
  3. List of type *[]uint8

Returns: 

	New List of type *float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Float64PtrErr 

func FilterMapUint8Float64PtrErr(fFilter func(*uint8) (bool, error), fMap func(*uint8) (*float64, error), list []*uint8) ([]*float64, error)

FilterMapUint8Float64PtrErr 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 - *uint8 and returns (bool, error).
  2. Function: takes *uint8 as argument and returns (*float64, error)
  3. List of type *uint8

Returns: 

	New List of type *float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int 

func FilterMapUint8Int(fFilter func(uint8) bool, fMap func(uint8) int, list []uint8) []int

FilterMapUint8Int filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint8 and returns true/false.
  2. Function: takes uint8 as argument and returns int
  3. List of type uint8

Returns: 

	New List of type int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int16 

func FilterMapUint8Int16(fFilter func(uint8) bool, fMap func(uint8) int16, list []uint8) []int16

FilterMapUint8Int16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint8 and returns true/false.
  2. Function: takes uint8 as argument and returns int16
  3. List of type uint8

Returns: 

	New List of type int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int16Err 

func FilterMapUint8Int16Err(fFilter func(uint8) (bool, error), fMap func(uint8) (int16, error), list []uint8) ([]int16, error)

FilterMapUint8Int16Err 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 - uint8 and returns (bool, error).
  2. Function: takes uint8 as argument and returns (int16, error)
  3. List of type uint8

Returns: 

	New List of type int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int16Ptr 

func FilterMapUint8Int16Ptr(fFilter func(*uint8) bool, fMap func(*uint8) *int16, list []*uint8) []*int16

FilterMapUint8Int16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint8 and returns true/false.
  2. Function: takes *uint8 as argument and returns *int16
  3. List of type *[]uint8

Returns: 

	New List of type *int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int16PtrErr 

func FilterMapUint8Int16PtrErr(fFilter func(*uint8) (bool, error), fMap func(*uint8) (*int16, error), list []*uint8) ([]*int16, error)

FilterMapUint8Int16PtrErr 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 - *uint8 and returns (bool, error).
  2. Function: takes *uint8 as argument and returns (*int16, error)
  3. List of type *uint8

Returns: 

	New List of type *int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int32 

func FilterMapUint8Int32(fFilter func(uint8) bool, fMap func(uint8) int32, list []uint8) []int32

FilterMapUint8Int32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint8 and returns true/false.
  2. Function: takes uint8 as argument and returns int32
  3. List of type uint8

Returns: 

	New List of type int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int32Err 

func FilterMapUint8Int32Err(fFilter func(uint8) (bool, error), fMap func(uint8) (int32, error), list []uint8) ([]int32, error)

FilterMapUint8Int32Err 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 - uint8 and returns (bool, error).
  2. Function: takes uint8 as argument and returns (int32, error)
  3. List of type uint8

Returns: 

	New List of type int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int32Ptr 

func FilterMapUint8Int32Ptr(fFilter func(*uint8) bool, fMap func(*uint8) *int32, list []*uint8) []*int32

FilterMapUint8Int32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint8 and returns true/false.
  2. Function: takes *uint8 as argument and returns *int32
  3. List of type *[]uint8

Returns: 

	New List of type *int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int32PtrErr 

func FilterMapUint8Int32PtrErr(fFilter func(*uint8) (bool, error), fMap func(*uint8) (*int32, error), list []*uint8) ([]*int32, error)

FilterMapUint8Int32PtrErr 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 - *uint8 and returns (bool, error).
  2. Function: takes *uint8 as argument and returns (*int32, error)
  3. List of type *uint8

Returns: 

	New List of type *int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int64 

func FilterMapUint8Int64(fFilter func(uint8) bool, fMap func(uint8) int64, list []uint8) []int64

FilterMapUint8Int64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint8 and returns true/false.
  2. Function: takes uint8 as argument and returns int64
  3. List of type uint8

Returns: 

	New List of type int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int64Err 

func FilterMapUint8Int64Err(fFilter func(uint8) (bool, error), fMap func(uint8) (int64, error), list []uint8) ([]int64, error)

FilterMapUint8Int64Err 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 - uint8 and returns (bool, error).
  2. Function: takes uint8 as argument and returns (int64, error)
  3. List of type uint8

Returns: 

	New List of type int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int64Ptr 

func FilterMapUint8Int64Ptr(fFilter func(*uint8) bool, fMap func(*uint8) *int64, list []*uint8) []*int64

FilterMapUint8Int64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint8 and returns true/false.
  2. Function: takes *uint8 as argument and returns *int64
  3. List of type *[]uint8

Returns: 

	New List of type *int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int64PtrErr 

func FilterMapUint8Int64PtrErr(fFilter func(*uint8) (bool, error), fMap func(*uint8) (*int64, error), list []*uint8) ([]*int64, error)

FilterMapUint8Int64PtrErr 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 - *uint8 and returns (bool, error).
  2. Function: takes *uint8 as argument and returns (*int64, error)
  3. List of type *uint8

Returns: 

	New List of type *int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int8 

func FilterMapUint8Int8(fFilter func(uint8) bool, fMap func(uint8) int8, list []uint8) []int8

FilterMapUint8Int8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint8 and returns true/false.
  2. Function: takes uint8 as argument and returns int8
  3. List of type uint8

Returns: 

	New List of type int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int8Err 

func FilterMapUint8Int8Err(fFilter func(uint8) (bool, error), fMap func(uint8) (int8, error), list []uint8) ([]int8, error)

FilterMapUint8Int8Err 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 - uint8 and returns (bool, error).
  2. Function: takes uint8 as argument and returns (int8, error)
  3. List of type uint8

Returns: 

	New List of type int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int8Ptr 

func FilterMapUint8Int8Ptr(fFilter func(*uint8) bool, fMap func(*uint8) *int8, list []*uint8) []*int8

FilterMapUint8Int8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint8 and returns true/false.
  2. Function: takes *uint8 as argument and returns *int8
  3. List of type *[]uint8

Returns: 

	New List of type *int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Int8PtrErr 

func FilterMapUint8Int8PtrErr(fFilter func(*uint8) (bool, error), fMap func(*uint8) (*int8, error), list []*uint8) ([]*int8, error)

FilterMapUint8Int8PtrErr 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 - *uint8 and returns (bool, error).
  2. Function: takes *uint8 as argument and returns (*int8, error)
  3. List of type *uint8

Returns: 

	New List of type *int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8IntErr 

func FilterMapUint8IntErr(fFilter func(uint8) (bool, error), fMap func(uint8) (int, error), list []uint8) ([]int, error)

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

Returns: 

	New List of type int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8IntPtr 

func FilterMapUint8IntPtr(fFilter func(*uint8) bool, fMap func(*uint8) *int, list []*uint8) []*int

FilterMapUint8IntPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint8 and returns true/false.
  2. Function: takes *uint8 as argument and returns *int
  3. List of type *[]uint8

Returns: 

	New List of type *int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8IntPtrErr 

func FilterMapUint8IntPtrErr(fFilter func(*uint8) (bool, error), fMap func(*uint8) (*int, error), list []*uint8) ([]*int, error)

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

Returns: 

	New List of type *int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Ptr 

func FilterMapUint8Ptr(fFilter func(*uint8) bool, fMap func(*uint8) *uint8, list []*uint8) []*uint8

FilterMapUint8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns (bool).
  2. Function: takes uint8 as argument and returns (uint8)
  3. Slice of type []*uint8

Returns: 

	New List of type []*uint8.
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8PtrErr 

func FilterMapUint8PtrErr(fFilter func(*uint8) (bool, error), fMap func(*uint8) (*uint8, error), list []*uint8) ([]*uint8, error)

FilterMapUint8PtrErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(*uint8) and returns (bool, error).
  2. Function: takes *uint8 as argument and returns (*uint8, error)
  3. Slice of type []*uint8

Returns: 

	New List ([]*uint8, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Str 

func FilterMapUint8Str(fFilter func(uint8) bool, fMap func(uint8) string, list []uint8) []string

FilterMapUint8Str filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint8 and returns true/false.
  2. Function: takes uint8 as argument and returns string
  3. List of type uint8

Returns: 

	New List of type string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8StrErr 

func FilterMapUint8StrErr(fFilter func(uint8) (bool, error), fMap func(uint8) (string, error), list []uint8) ([]string, error)

FilterMapUint8StrErr 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 - uint8 and returns (bool, error).
  2. Function: takes uint8 as argument and returns (string, error)
  3. List of type uint8

Returns: 

	New List of type string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8StrPtr 

func FilterMapUint8StrPtr(fFilter func(*uint8) bool, fMap func(*uint8) *string, list []*uint8) []*string

FilterMapUint8StrPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint8 and returns true/false.
  2. Function: takes *uint8 as argument and returns *string
  3. List of type *[]uint8

Returns: 

	New List of type *string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8StrPtrErr 

func FilterMapUint8StrPtrErr(fFilter func(*uint8) (bool, error), fMap func(*uint8) (*string, error), list []*uint8) ([]*string, error)

FilterMapUint8StrPtrErr 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 - *uint8 and returns (bool, error).
  2. Function: takes *uint8 as argument and returns (*string, error)
  3. List of type *uint8

Returns: 

	New List of type *string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Uint 

func FilterMapUint8Uint(fFilter func(uint8) bool, fMap func(uint8) uint, list []uint8) []uint

FilterMapUint8Uint filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint8 and returns true/false.
  2. Function: takes uint8 as argument and returns uint
  3. List of type uint8

Returns: 

	New List of type uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Uint16 

func FilterMapUint8Uint16(fFilter func(uint8) bool, fMap func(uint8) uint16, list []uint8) []uint16

FilterMapUint8Uint16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint8 and returns true/false.
  2. Function: takes uint8 as argument and returns uint16
  3. List of type uint8

Returns: 

	New List of type uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Uint16Err 

func FilterMapUint8Uint16Err(fFilter func(uint8) (bool, error), fMap func(uint8) (uint16, error), list []uint8) ([]uint16, error)

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

Returns: 

	New List of type uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Uint16Ptr 

func FilterMapUint8Uint16Ptr(fFilter func(*uint8) bool, fMap func(*uint8) *uint16, list []*uint8) []*uint16

FilterMapUint8Uint16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint8 and returns true/false.
  2. Function: takes *uint8 as argument and returns *uint16
  3. List of type *[]uint8

Returns: 

	New List of type *uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Uint16PtrErr 

func FilterMapUint8Uint16PtrErr(fFilter func(*uint8) (bool, error), fMap func(*uint8) (*uint16, error), list []*uint8) ([]*uint16, error)

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

Returns: 

	New List of type *uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Uint32 

func FilterMapUint8Uint32(fFilter func(uint8) bool, fMap func(uint8) uint32, list []uint8) []uint32

FilterMapUint8Uint32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint8 and returns true/false.
  2. Function: takes uint8 as argument and returns uint32
  3. List of type uint8

Returns: 

	New List of type uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Uint32Err 

func FilterMapUint8Uint32Err(fFilter func(uint8) (bool, error), fMap func(uint8) (uint32, error), list []uint8) ([]uint32, error)

FilterMapUint8Uint32Err 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 - uint8 and returns (bool, error).
  2. Function: takes uint8 as argument and returns (uint32, error)
  3. List of type uint8

Returns: 

	New List of type uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Uint32Ptr 

func FilterMapUint8Uint32Ptr(fFilter func(*uint8) bool, fMap func(*uint8) *uint32, list []*uint8) []*uint32

FilterMapUint8Uint32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint8 and returns true/false.
  2. Function: takes *uint8 as argument and returns *uint32
  3. List of type *[]uint8

Returns: 

	New List of type *uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Uint32PtrErr 

func FilterMapUint8Uint32PtrErr(fFilter func(*uint8) (bool, error), fMap func(*uint8) (*uint32, error), list []*uint8) ([]*uint32, error)

FilterMapUint8Uint32PtrErr 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 - *uint8 and returns (bool, error).
  2. Function: takes *uint8 as argument and returns (*uint32, error)
  3. List of type *uint8

Returns: 

	New List of type *uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Uint64 

func FilterMapUint8Uint64(fFilter func(uint8) bool, fMap func(uint8) uint64, list []uint8) []uint64

FilterMapUint8Uint64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint8 and returns true/false.
  2. Function: takes uint8 as argument and returns uint64
  3. List of type uint8

Returns: 

	New List of type uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Uint64Err 

func FilterMapUint8Uint64Err(fFilter func(uint8) (bool, error), fMap func(uint8) (uint64, error), list []uint8) ([]uint64, error)

FilterMapUint8Uint64Err 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 - uint8 and returns (bool, error).
  2. Function: takes uint8 as argument and returns (uint64, error)
  3. List of type uint8

Returns: 

	New List of type uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Uint64Ptr 

func FilterMapUint8Uint64Ptr(fFilter func(*uint8) bool, fMap func(*uint8) *uint64, list []*uint8) []*uint64

FilterMapUint8Uint64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint8 and returns true/false.
  2. Function: takes *uint8 as argument and returns *uint64
  3. List of type *[]uint8

Returns: 

	New List of type *uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8Uint64PtrErr 

func FilterMapUint8Uint64PtrErr(fFilter func(*uint8) (bool, error), fMap func(*uint8) (*uint64, error), list []*uint8) ([]*uint64, error)

FilterMapUint8Uint64PtrErr 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 - *uint8 and returns (bool, error).
  2. Function: takes *uint8 as argument and returns (*uint64, error)
  3. List of type *uint8

Returns: 

	New List of type *uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8UintErr 

func FilterMapUint8UintErr(fFilter func(uint8) (bool, error), fMap func(uint8) (uint, error), list []uint8) ([]uint, error)

FilterMapUint8UintErr 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 - uint8 and returns (bool, error).
  2. Function: takes uint8 as argument and returns (uint, error)
  3. List of type uint8

Returns: 

	New List of type uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8UintPtr 

func FilterMapUint8UintPtr(fFilter func(*uint8) bool, fMap func(*uint8) *uint, list []*uint8) []*uint

FilterMapUint8UintPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint8 and returns true/false.
  2. Function: takes *uint8 as argument and returns *uint
  3. List of type *[]uint8

Returns: 

	New List of type *uint
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUint8UintPtrErr 

func FilterMapUint8UintPtrErr(fFilter func(*uint8) (bool, error), fMap func(*uint8) (*uint, error), list []*uint8) ([]*uint, error)

FilterMapUint8UintPtrErr 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 - *uint8 and returns (bool, error).
  2. Function: takes *uint8 as argument and returns (*uint, error)
  3. List of type *uint8

Returns: 

	New List of type *uint, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintBool 

func FilterMapUintBool(fFilter func(uint) bool, fMap func(uint) bool, list []uint) []bool

FilterMapUintBool filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint and returns true/false.
  2. Function: takes uint as argument and returns bool
  3. List of type uint

Returns: 

	New List of type bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintBoolErr 

func FilterMapUintBoolErr(fFilter func(uint) (bool, error), fMap func(uint) (bool, error), list []uint) ([]bool, error)

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

Returns: 

	New List of type bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintBoolPtr 

func FilterMapUintBoolPtr(fFilter func(*uint) bool, fMap func(*uint) *bool, list []*uint) []*bool

FilterMapUintBoolPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint and returns true/false.
  2. Function: takes *uint as argument and returns *bool
  3. List of type *[]uint

Returns: 

	New List of type *bool
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintBoolPtrErr 

func FilterMapUintBoolPtrErr(fFilter func(*uint) (bool, error), fMap func(*uint) (*bool, error), list []*uint) ([]*bool, error)

FilterMapUintBoolPtrErr 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 - *uint and returns (bool, error).
  2. Function: takes *uint as argument and returns (*bool, error)
  3. List of type *uint

Returns: 

	New List of type *bool, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintErr 

func FilterMapUintErr(fFilter func(uint) (bool, error), fMap func(uint) (uint, error), list []uint) ([]uint, error)

FilterMapUintErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(uint) and returns (bool, error).
  2. Function: takes uint as argument and returns (uint, error)
  3. Slice of type []uint

Returns: 

	New List ([]uint, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintFloat32 

func FilterMapUintFloat32(fFilter func(uint) bool, fMap func(uint) float32, list []uint) []float32

FilterMapUintFloat32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint and returns true/false.
  2. Function: takes uint as argument and returns float32
  3. List of type uint

Returns: 

	New List of type float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintFloat32Err 

func FilterMapUintFloat32Err(fFilter func(uint) (bool, error), fMap func(uint) (float32, error), list []uint) ([]float32, error)

FilterMapUintFloat32Err 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 - uint and returns (bool, error).
  2. Function: takes uint as argument and returns (float32, error)
  3. List of type uint

Returns: 

	New List of type float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintFloat32Ptr 

func FilterMapUintFloat32Ptr(fFilter func(*uint) bool, fMap func(*uint) *float32, list []*uint) []*float32

FilterMapUintFloat32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint and returns true/false.
  2. Function: takes *uint as argument and returns *float32
  3. List of type *[]uint

Returns: 

	New List of type *float32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintFloat32PtrErr 

func FilterMapUintFloat32PtrErr(fFilter func(*uint) (bool, error), fMap func(*uint) (*float32, error), list []*uint) ([]*float32, error)

FilterMapUintFloat32PtrErr 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 - *uint and returns (bool, error).
  2. Function: takes *uint as argument and returns (*float32, error)
  3. List of type *uint

Returns: 

	New List of type *float32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintFloat64 

func FilterMapUintFloat64(fFilter func(uint) bool, fMap func(uint) float64, list []uint) []float64

FilterMapUintFloat64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint and returns true/false.
  2. Function: takes uint as argument and returns float64
  3. List of type uint

Returns: 

	New List of type float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintFloat64Err 

func FilterMapUintFloat64Err(fFilter func(uint) (bool, error), fMap func(uint) (float64, error), list []uint) ([]float64, error)

FilterMapUintFloat64Err 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 - uint and returns (bool, error).
  2. Function: takes uint as argument and returns (float64, error)
  3. List of type uint

Returns: 

	New List of type float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintFloat64Ptr 

func FilterMapUintFloat64Ptr(fFilter func(*uint) bool, fMap func(*uint) *float64, list []*uint) []*float64

FilterMapUintFloat64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint and returns true/false.
  2. Function: takes *uint as argument and returns *float64
  3. List of type *[]uint

Returns: 

	New List of type *float64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintFloat64PtrErr 

func FilterMapUintFloat64PtrErr(fFilter func(*uint) (bool, error), fMap func(*uint) (*float64, error), list []*uint) ([]*float64, error)

FilterMapUintFloat64PtrErr 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 - *uint and returns (bool, error).
  2. Function: takes *uint as argument and returns (*float64, error)
  3. List of type *uint

Returns: 

	New List of type *float64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt 

func FilterMapUintInt(fFilter func(uint) bool, fMap func(uint) int, list []uint) []int

FilterMapUintInt filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint and returns true/false.
  2. Function: takes uint as argument and returns int
  3. List of type uint

Returns: 

	New List of type int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt16 

func FilterMapUintInt16(fFilter func(uint) bool, fMap func(uint) int16, list []uint) []int16

FilterMapUintInt16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint and returns true/false.
  2. Function: takes uint as argument and returns int16
  3. List of type uint

Returns: 

	New List of type int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt16Err 

func FilterMapUintInt16Err(fFilter func(uint) (bool, error), fMap func(uint) (int16, error), list []uint) ([]int16, error)

FilterMapUintInt16Err 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 - uint and returns (bool, error).
  2. Function: takes uint as argument and returns (int16, error)
  3. List of type uint

Returns: 

	New List of type int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt16Ptr 

func FilterMapUintInt16Ptr(fFilter func(*uint) bool, fMap func(*uint) *int16, list []*uint) []*int16

FilterMapUintInt16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint and returns true/false.
  2. Function: takes *uint as argument and returns *int16
  3. List of type *[]uint

Returns: 

	New List of type *int16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt16PtrErr 

func FilterMapUintInt16PtrErr(fFilter func(*uint) (bool, error), fMap func(*uint) (*int16, error), list []*uint) ([]*int16, error)

FilterMapUintInt16PtrErr 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 - *uint and returns (bool, error).
  2. Function: takes *uint as argument and returns (*int16, error)
  3. List of type *uint

Returns: 

	New List of type *int16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt32 

func FilterMapUintInt32(fFilter func(uint) bool, fMap func(uint) int32, list []uint) []int32

FilterMapUintInt32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint and returns true/false.
  2. Function: takes uint as argument and returns int32
  3. List of type uint

Returns: 

	New List of type int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt32Err 

func FilterMapUintInt32Err(fFilter func(uint) (bool, error), fMap func(uint) (int32, error), list []uint) ([]int32, error)

FilterMapUintInt32Err 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 - uint and returns (bool, error).
  2. Function: takes uint as argument and returns (int32, error)
  3. List of type uint

Returns: 

	New List of type int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt32Ptr 

func FilterMapUintInt32Ptr(fFilter func(*uint) bool, fMap func(*uint) *int32, list []*uint) []*int32

FilterMapUintInt32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint and returns true/false.
  2. Function: takes *uint as argument and returns *int32
  3. List of type *[]uint

Returns: 

	New List of type *int32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt32PtrErr 

func FilterMapUintInt32PtrErr(fFilter func(*uint) (bool, error), fMap func(*uint) (*int32, error), list []*uint) ([]*int32, error)

FilterMapUintInt32PtrErr 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 - *uint and returns (bool, error).
  2. Function: takes *uint as argument and returns (*int32, error)
  3. List of type *uint

Returns: 

	New List of type *int32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt64 

func FilterMapUintInt64(fFilter func(uint) bool, fMap func(uint) int64, list []uint) []int64

FilterMapUintInt64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint and returns true/false.
  2. Function: takes uint as argument and returns int64
  3. List of type uint

Returns: 

	New List of type int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt64Err 

func FilterMapUintInt64Err(fFilter func(uint) (bool, error), fMap func(uint) (int64, error), list []uint) ([]int64, error)

FilterMapUintInt64Err 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 - uint and returns (bool, error).
  2. Function: takes uint as argument and returns (int64, error)
  3. List of type uint

Returns: 

	New List of type int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt64Ptr 

func FilterMapUintInt64Ptr(fFilter func(*uint) bool, fMap func(*uint) *int64, list []*uint) []*int64

FilterMapUintInt64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint and returns true/false.
  2. Function: takes *uint as argument and returns *int64
  3. List of type *[]uint

Returns: 

	New List of type *int64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt64PtrErr 

func FilterMapUintInt64PtrErr(fFilter func(*uint) (bool, error), fMap func(*uint) (*int64, error), list []*uint) ([]*int64, error)

FilterMapUintInt64PtrErr 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 - *uint and returns (bool, error).
  2. Function: takes *uint as argument and returns (*int64, error)
  3. List of type *uint

Returns: 

	New List of type *int64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt8 

func FilterMapUintInt8(fFilter func(uint) bool, fMap func(uint) int8, list []uint) []int8

FilterMapUintInt8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint and returns true/false.
  2. Function: takes uint as argument and returns int8
  3. List of type uint

Returns: 

	New List of type int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt8Err 

func FilterMapUintInt8Err(fFilter func(uint) (bool, error), fMap func(uint) (int8, error), list []uint) ([]int8, error)

FilterMapUintInt8Err 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 - uint and returns (bool, error).
  2. Function: takes uint as argument and returns (int8, error)
  3. List of type uint

Returns: 

	New List of type int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt8Ptr 

func FilterMapUintInt8Ptr(fFilter func(*uint) bool, fMap func(*uint) *int8, list []*uint) []*int8

FilterMapUintInt8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint and returns true/false.
  2. Function: takes *uint as argument and returns *int8
  3. List of type *[]uint

Returns: 

	New List of type *int8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintInt8PtrErr 

func FilterMapUintInt8PtrErr(fFilter func(*uint) (bool, error), fMap func(*uint) (*int8, error), list []*uint) ([]*int8, error)

FilterMapUintInt8PtrErr 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 - *uint and returns (bool, error).
  2. Function: takes *uint as argument and returns (*int8, error)
  3. List of type *uint

Returns: 

	New List of type *int8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintIntErr 

func FilterMapUintIntErr(fFilter func(uint) (bool, error), fMap func(uint) (int, error), list []uint) ([]int, error)

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

Returns: 

	New List of type int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintIntPtr 

func FilterMapUintIntPtr(fFilter func(*uint) bool, fMap func(*uint) *int, list []*uint) []*int

FilterMapUintIntPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint and returns true/false.
  2. Function: takes *uint as argument and returns *int
  3. List of type *[]uint

Returns: 

	New List of type *int
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintIntPtrErr 

func FilterMapUintIntPtrErr(fFilter func(*uint) (bool, error), fMap func(*uint) (*int, error), list []*uint) ([]*int, error)

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

Returns: 

	New List of type *int, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintPtr 

func FilterMapUintPtr(fFilter func(*uint) bool, fMap func(*uint) *uint, list []*uint) []*uint

FilterMapUintPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input and returns (bool).
  2. Function: takes uint as argument and returns (uint)
  3. Slice of type []*uint

Returns: 

	New List of type []*uint.
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintPtrErr 

func FilterMapUintPtrErr(fFilter func(*uint) (bool, error), fMap func(*uint) (*uint, error), list []*uint) ([]*uint, error)

FilterMapUintPtrErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input(*uint) and returns (bool, error).
  2. Function: takes *uint as argument and returns (*uint, error)
  3. Slice of type []*uint

Returns: 

	New List ([]*uint, error).
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintStr 

func FilterMapUintStr(fFilter func(uint) bool, fMap func(uint) string, list []uint) []string

FilterMapUintStr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint and returns true/false.
  2. Function: takes uint as argument and returns string
  3. List of type uint

Returns: 

	New List of type string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintStrErr 

func FilterMapUintStrErr(fFilter func(uint) (bool, error), fMap func(uint) (string, error), list []uint) ([]string, error)

FilterMapUintStrErr 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 - uint and returns (bool, error).
  2. Function: takes uint as argument and returns (string, error)
  3. List of type uint

Returns: 

	New List of type string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintStrPtr 

func FilterMapUintStrPtr(fFilter func(*uint) bool, fMap func(*uint) *string, list []*uint) []*string

FilterMapUintStrPtr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint and returns true/false.
  2. Function: takes *uint as argument and returns *string
  3. List of type *[]uint

Returns: 

	New List of type *string
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintStrPtrErr 

func FilterMapUintStrPtrErr(fFilter func(*uint) (bool, error), fMap func(*uint) (*string, error), list []*uint) ([]*string, error)

FilterMapUintStrPtrErr 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 - *uint and returns (bool, error).
  2. Function: takes *uint as argument and returns (*string, error)
  3. List of type *uint

Returns: 

	New List of type *string, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintUint16 

func FilterMapUintUint16(fFilter func(uint) bool, fMap func(uint) uint16, list []uint) []uint16

FilterMapUintUint16 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint and returns true/false.
  2. Function: takes uint as argument and returns uint16
  3. List of type uint

Returns: 

	New List of type uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintUint16Err 

func FilterMapUintUint16Err(fFilter func(uint) (bool, error), fMap func(uint) (uint16, error), list []uint) ([]uint16, error)

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

Returns: 

	New List of type uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintUint16Ptr 

func FilterMapUintUint16Ptr(fFilter func(*uint) bool, fMap func(*uint) *uint16, list []*uint) []*uint16

FilterMapUintUint16Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint and returns true/false.
  2. Function: takes *uint as argument and returns *uint16
  3. List of type *[]uint

Returns: 

	New List of type *uint16
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintUint16PtrErr 

func FilterMapUintUint16PtrErr(fFilter func(*uint) (bool, error), fMap func(*uint) (*uint16, error), list []*uint) ([]*uint16, error)

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

Returns: 

	New List of type *uint16, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintUint32 

func FilterMapUintUint32(fFilter func(uint) bool, fMap func(uint) uint32, list []uint) []uint32

FilterMapUintUint32 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint and returns true/false.
  2. Function: takes uint as argument and returns uint32
  3. List of type uint

Returns: 

	New List of type uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintUint32Err 

func FilterMapUintUint32Err(fFilter func(uint) (bool, error), fMap func(uint) (uint32, error), list []uint) ([]uint32, error)

FilterMapUintUint32Err 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 - uint and returns (bool, error).
  2. Function: takes uint as argument and returns (uint32, error)
  3. List of type uint

Returns: 

	New List of type uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintUint32Ptr 

func FilterMapUintUint32Ptr(fFilter func(*uint) bool, fMap func(*uint) *uint32, list []*uint) []*uint32

FilterMapUintUint32Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint and returns true/false.
  2. Function: takes *uint as argument and returns *uint32
  3. List of type *[]uint

Returns: 

	New List of type *uint32
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintUint32PtrErr 

func FilterMapUintUint32PtrErr(fFilter func(*uint) (bool, error), fMap func(*uint) (*uint32, error), list []*uint) ([]*uint32, error)

FilterMapUintUint32PtrErr 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 - *uint and returns (bool, error).
  2. Function: takes *uint as argument and returns (*uint32, error)
  3. List of type *uint

Returns: 

	New List of type *uint32, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintUint64 

func FilterMapUintUint64(fFilter func(uint) bool, fMap func(uint) uint64, list []uint) []uint64

FilterMapUintUint64 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint and returns true/false.
  2. Function: takes uint as argument and returns uint64
  3. List of type uint

Returns: 

	New List of type uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintUint64Err 

func FilterMapUintUint64Err(fFilter func(uint) (bool, error), fMap func(uint) (uint64, error), list []uint) ([]uint64, error)

FilterMapUintUint64Err 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 - uint and returns (bool, error).
  2. Function: takes uint as argument and returns (uint64, error)
  3. List of type uint

Returns: 

	New List of type uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintUint64Ptr 

func FilterMapUintUint64Ptr(fFilter func(*uint) bool, fMap func(*uint) *uint64, list []*uint) []*uint64

FilterMapUintUint64Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint and returns true/false.
  2. Function: takes *uint as argument and returns *uint64
  3. List of type *[]uint

Returns: 

	New List of type *uint64
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintUint64PtrErr 

func FilterMapUintUint64PtrErr(fFilter func(*uint) (bool, error), fMap func(*uint) (*uint64, error), list []*uint) ([]*uint64, error)

FilterMapUintUint64PtrErr 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 - *uint and returns (bool, error).
  2. Function: takes *uint as argument and returns (*uint64, error)
  3. List of type *uint

Returns: 

	New List of type *uint64, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintUint8 

func FilterMapUintUint8(fFilter func(uint) bool, fMap func(uint) uint8, list []uint) []uint8

FilterMapUintUint8 filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - uint and returns true/false.
  2. Function: takes uint as argument and returns uint8
  3. List of type uint

Returns: 

	New List of type uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintUint8Err 

func FilterMapUintUint8Err(fFilter func(uint) (bool, error), fMap func(uint) (uint8, error), list []uint) ([]uint8, error)

FilterMapUintUint8Err 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 - uint and returns (bool, error).
  2. Function: takes uint as argument and returns (uint8, error)
  3. List of type uint

Returns: 

	New List of type uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintUint8Ptr 

func FilterMapUintUint8Ptr(fFilter func(*uint) bool, fMap func(*uint) *uint8, list []*uint) []*uint8

FilterMapUintUint8Ptr filters given list, then apply function(2nd argument) on each item in the list and returns a new list Takes 3 inputs

  1. Function: takes one input type - *uint and returns true/false.
  2. Function: takes *uint as argument and returns *uint8
  3. List of type *[]uint

Returns: 

	New List of type *uint8
 Empty list if all there parameters are nil or either of parameter is nil

func FilterMapUintUint8PtrErr 

func FilterMapUintUint8PtrErr(fFilter func(*uint) (bool, error), fMap func(*uint) (*uint8, error), list []*uint) ([]*uint8, error)

FilterMapUintUint8PtrErr 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 - *uint and returns (bool, error).
  2. Function: takes *uint as argument and returns (*uint8, error)
  3. List of type *uint

Returns: 

	New List of type *uint8, error
 Empty list if all there parameters are nil or either of parameter is nil

func FilterStr 

func FilterStr(f func(string) bool, list []string) []string

FilterStr filters list based on function passed as 1st argument

Takes two inputs

  1. function - Takes 1 input and returns bool
  2. list

Returns: 

New Filtered List.
Empty list if either of arguments or both of them are nil

Example: Filter all the name which length is less than 10 

fp.FilterStr(isStringLengthLessThan10, []string{"gopal", "govinda", "Dasananda Ravan"}) // Returns ["gopal", "govinda"]

func isStringLengthLessThan10(str string) bool {
	return len(str) < 10
}

func FilterStrErr 

func FilterStrErr(f func(string) (bool, error), list []string) ([]string, error)

FilterStrErr takes two arguments

  1. Function: takes 1 argument of type string and returns (bool, error)
  2. slice of type []string

Returns: 

new filtered list and error

func FilterStrPtr 

func FilterStrPtr(f func(*string) bool, list []*string) []*string

FilterStrPtr takes two arguments

  1. Function: takes 1 argument of type string and returns bool
  2. slice of type []*string

Returns: 

new filtered list

func FilterStrPtrErr 

func FilterStrPtrErr(f func(*string) (bool, error), list []*string) ([]*string, error)

FilterStrPtrErr takes two arguments

  1. Function: takes 1 argument of type string and returns (bool, error)
  2. slice of type []*string

Returns: 

new filtered list and error

func FilterUint 

func FilterUint(f func(uint) bool, list []uint) []uint

FilterUint filters list based on function passed as 1st argument

Takes two inputs

  1. function - Takes 1 input and returns bool
  2. list

Returns: 

New Filtered List.
Empty list if either of arguments or both of them are nil

Example: Filter all even numbers 

fp.FilterUint(isEven, []uint{1, 2, 3, 4}) // Returns [2, 4]

func isEven(num uint) bool {
	return num%2 == 0
}

func FilterUint16 

func FilterUint16(f func(uint16) bool, list []uint16) []uint16

FilterUint16 filters list based on function passed as 1st argument

Takes two inputs

  1. function - Takes 1 input and returns bool
  2. list

Returns: 

New Filtered List.
Empty list if either of arguments or both of them are nil

Example: Filter all even numbers 

fp.FilterUint16(isEven, []uint16{1, 2, 3, 4}) // Returns [2, 4]

func isEven(num uint16) bool {
	return num%2 == 0
}

func FilterUint16Err 

func FilterUint16Err(f func(uint16) (bool, error), list []uint16) ([]uint16, error)

FilterUint16Err takes two arguments

  1. Function: takes 1 argument of type uint16 and returns (bool, error)
  2. slice of type []uint16

Returns: 

new filtered list and error

func FilterUint16Ptr 

func FilterUint16Ptr(f func(*uint16) bool, list []*uint16) []*uint16

FilterUint16Ptr takes two arguments

  1. Function: takes 1 argument of type uint16 and returns bool
  2. slice of type []*uint16

Returns: 

new filtered list

func FilterUint16PtrErr 

func FilterUint16PtrErr(f func(*uint16) (bool, error), list []*uint16) ([]*uint16, error)

FilterUint16PtrErr takes two arguments

  1. Function: takes 1 argument of type uint16 and returns (bool, error)
  2. slice of type []*uint16

Returns: 

new filtered list and error

func FilterUint32 

func FilterUint32(f func(uint32) bool, list []uint32) []uint32

FilterUint32 filters list based on function passed as 1st argument

Takes two inputs

  1. function - Takes 1 input and returns bool
  2. list

Returns: 

New Filtered List.
Empty list if either of arguments or both of them are nil

Example: Filter all even numbers 

fp.FilterUint32(isEven, []uint32{1, 2, 3, 4}) // Returns [2, 4]

func isEven(num uint32) bool {
	return num%2 == 0
}

func FilterUint32Err 

func FilterUint32Err(f func(uint32) (bool, error), list []uint32) ([]uint32, error)

FilterUint32Err takes two arguments

  1. Function: takes 1 argument of type uint32 and returns (bool, error)
  2. slice of type []uint32

Returns: 

new filtered list and error

func FilterUint32Ptr 

func FilterUint32Ptr(f func(*uint32) bool, list []*uint32) []*uint32

FilterUint32Ptr takes two arguments

  1. Function: takes 1 argument of type uint32 and returns bool
  2. slice of type []*uint32

Returns: 

new filtered list

func FilterUint32PtrErr 

func FilterUint32PtrErr(f func(*uint32) (bool, error), list []*uint32) ([]*uint32, error)

FilterUint32PtrErr takes two arguments

  1. Function: takes 1 argument of type uint32 and returns (bool, error)
  2. slice of type []*uint32

Returns: 

new filtered list and error

func FilterUint64 

func FilterUint64(f func(uint64) bool, list []uint64) []uint64

FilterUint64 filters list based on function passed as 1st argument

Takes two inputs

  1. function - Takes 1 input and returns bool
  2. list

Returns: 

New Filtered List.
Empty list if either of arguments or both of them are nil

Example: Filter all even numbers 

fp.FilterUint64(isEven, []uint64{1, 2, 3, 4}) // Returns [2, 4]

func isEven(num uint64) bool {
	return num%2 == 0
}

func FilterUint64Err 

func FilterUint64Err(f func(uint64) (bool, error), list []uint64) ([]uint64, error)

FilterUint64Err takes two arguments

  1. Function: takes 1 argument of type uint64 and returns (bool, error)
  2. slice of type []uint64

Returns: 

new filtered list and error

func FilterUint64Ptr 

func FilterUint64Ptr(f func(*uint64) bool, list []*uint64) []*uint64

FilterUint64Ptr takes two arguments

  1. Function: takes 1 argument of type uint64 and returns bool
  2. slice of type []*uint64

Returns: 

new filtered list

func FilterUint64PtrErr 

func FilterUint64PtrErr(f func(*uint64) (bool, error), list []*uint64) ([]*uint64, error)

FilterUint64PtrErr takes two arguments

  1. Function: takes 1 argument of type uint64 and returns (bool, error)
  2. slice of type []*uint64

Returns: 

new filtered list and error

func FilterUint8 

func FilterUint8(f func(uint8) bool, list []uint8) []uint8

FilterUint8 filters list based on function passed as 1st argument

Takes two inputs

  1. function - Takes 1 input and returns bool
  2. list

Returns: 

New Filtered List.
Empty list if either of arguments or both of them are nil

Example: Filter all even numbers 

fp.FilterUint8(isEven, []uint8{1, 2, 3, 4}) // Returns [2, 4]

func isEven(num uint8) bool {
	return num%2 == 0
}

func FilterUint8Err 

func FilterUint8Err(f func(uint8) (bool, error), list []uint8) ([]uint8, error)

FilterUint8Err takes two arguments

  1. Function: takes 1 argument of type uint8 and returns (bool, error)
  2. slice of type []uint8

Returns: 

new filtered list and error

func FilterUint8Ptr 

func FilterUint8Ptr(f func(*uint8) bool, list []*uint8) []*uint8

FilterUint8Ptr takes two arguments

  1. Function: takes 1 argument of type uint8 and returns bool
  2. slice of type []*uint8

Returns: 

new filtered list

func FilterUint8PtrErr 

func FilterUint8PtrErr(f func(*uint8) (bool, error), list []*uint8) ([]*uint8, error)

FilterUint8PtrErr takes two arguments

  1. Function: takes 1 argument of type uint8 and returns (bool, error)
  2. slice of type []*uint8

Returns: 

new filtered list and error

func FilterUintErr 

func FilterUintErr(f func(uint) (bool, error), list []uint) ([]uint, error)

FilterUintErr takes two arguments

  1. Function: takes 1 argument of type uint and returns (bool, error)
  2. slice of type []uint

Returns: 

new filtered list and error

func FilterUintPtr 

func FilterUintPtr(f func(*uint) bool, list []*uint) []*uint

FilterUintPtr takes two arguments

  1. Function: takes 1 argument of type uint and returns bool
  2. slice of type []*uint

Returns: 

new filtered list

func FilterUintPtrErr 

func FilterUintPtrErr(f func(*uint) (bool, error), list []*uint) ([]*uint, error)

FilterUintPtrErr takes two arguments

  1. Function: takes 1 argument of type uint and returns (bool, error)
  2. slice of type []*uint

Returns: 

new filtered list and error

func IntersectionBool 

func IntersectionBool(arrList ...[]bool) []bool

IntersectionBool return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionBoolPtr 

func IntersectionBoolPtr(arrList ...[]*bool) []*bool

IntersectionBoolPtr return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionFloat32 

func IntersectionFloat32(arrList ...[]float32) []float32

IntersectionFloat32 return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionFloat32Ptr 

func IntersectionFloat32Ptr(arrList ...[]*float32) []*float32

IntersectionFloat32Ptr return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionFloat64 

func IntersectionFloat64(arrList ...[]float64) []float64

IntersectionFloat64 return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionFloat64Ptr 

func IntersectionFloat64Ptr(arrList ...[]*float64) []*float64

IntersectionFloat64Ptr return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionInt 

func IntersectionInt(arrList ...[]int) []int

IntersectionInt return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionInt16 

func IntersectionInt16(arrList ...[]int16) []int16

IntersectionInt16 return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionInt16Ptr 

func IntersectionInt16Ptr(arrList ...[]*int16) []*int16

IntersectionInt16Ptr return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionInt32 

func IntersectionInt32(arrList ...[]int32) []int32

IntersectionInt32 return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionInt32Ptr 

func IntersectionInt32Ptr(arrList ...[]*int32) []*int32

IntersectionInt32Ptr return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionInt64 

func IntersectionInt64(arrList ...[]int64) []int64

IntersectionInt64 return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionInt64Ptr 

func IntersectionInt64Ptr(arrList ...[]*int64) []*int64

IntersectionInt64Ptr return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionInt8 

func IntersectionInt8(arrList ...[]int8) []int8

IntersectionInt8 return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionInt8Ptr 

func IntersectionInt8Ptr(arrList ...[]*int8) []*int8

IntersectionInt8Ptr return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionIntPtr 

func IntersectionIntPtr(arrList ...[]*int) []*int

IntersectionIntPtr return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionStr 

func IntersectionStr(arrList ...[]string) []string

IntersectionStr return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionStrPtr 

func IntersectionStrPtr(arrList ...[]*string) []*string

IntersectionStrPtr return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionUint 

func IntersectionUint(arrList ...[]uint) []uint

IntersectionUint return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionUint16 

func IntersectionUint16(arrList ...[]uint16) []uint16

IntersectionUint16 return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionUint16Ptr 

func IntersectionUint16Ptr(arrList ...[]*uint16) []*uint16

IntersectionUint16Ptr return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionUint32 

func IntersectionUint32(arrList ...[]uint32) []uint32

IntersectionUint32 return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionUint32Ptr 

func IntersectionUint32Ptr(arrList ...[]*uint32) []*uint32

IntersectionUint32Ptr return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionUint64 

func IntersectionUint64(arrList ...[]uint64) []uint64

IntersectionUint64 return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionUint64Ptr 

func IntersectionUint64Ptr(arrList ...[]*uint64) []*uint64

IntersectionUint64Ptr return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionUint8 

func IntersectionUint8(arrList ...[]uint8) []uint8

IntersectionUint8 return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionUint8Ptr 

func IntersectionUint8Ptr(arrList ...[]*uint8) []*uint8

IntersectionUint8Ptr return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func IntersectionUintPtr 

func IntersectionUintPtr(arrList ...[]*uint) []*uint

IntersectionUintPtr return a set that is the intersection of the input sets repeated value within list parameter will be ignored

func KeysBool 

func KeysBool(m map[bool]bool) []bool

KeysBool returns a slice of map's keys

func KeysBoolFloat32 

func KeysBoolFloat32(m map[bool]float32) []bool

KeysBoolFloat32 returns a slice of map's keys

func KeysBoolFloat64 

func KeysBoolFloat64(m map[bool]float64) []bool

KeysBoolFloat64 returns a slice of map's keys

func KeysBoolInt 

func KeysBoolInt(m map[bool]int) []bool

KeysBoolInt returns a slice of map's keys

func KeysBoolInt16 

func KeysBoolInt16(m map[bool]int16) []bool

KeysBoolInt16 returns a slice of map's keys

func KeysBoolInt32 

func KeysBoolInt32(m map[bool]int32) []bool

KeysBoolInt32 returns a slice of map's keys

func KeysBoolInt64 

func KeysBoolInt64(m map[bool]int64) []bool

KeysBoolInt64 returns a slice of map's keys

func KeysBoolInt8 

func KeysBoolInt8(m map[bool]int8) []bool

KeysBoolInt8 returns a slice of map's keys

func KeysBoolStr 

func KeysBoolStr(m map[bool]string) []bool

KeysBoolStr returns a slice of map's keys

func KeysBoolUint 

func KeysBoolUint(m map[bool]uint) []bool

KeysBoolUint returns a slice of map's keys

func KeysBoolUint16 

func KeysBoolUint16(m map[bool]uint16) []bool

KeysBoolUint16 returns a slice of map's keys

func KeysBoolUint32 

func KeysBoolUint32(m map[bool]uint32) []bool

KeysBoolUint32 returns a slice of map's keys

func KeysBoolUint64 

func KeysBoolUint64(m map[bool]uint64) []bool

KeysBoolUint64 returns a slice of map's keys

func KeysBoolUint8 

func KeysBoolUint8(m map[bool]uint8) []bool

KeysBoolUint8 returns a slice of map's keys

func KeysFloat32 

func KeysFloat32(m map[float32]float32) []float32

KeysFloat32 returns a slice of map's keys

func KeysFloat32Bool 

func KeysFloat32Bool(m map[float32]bool) []float32

KeysFloat32Bool returns a slice of map's keys

func KeysFloat32Float64 

func KeysFloat32Float64(m map[float32]float64) []float32

KeysFloat32Float64 returns a slice of map's keys

func KeysFloat32Int 

func KeysFloat32Int(m map[float32]int) []float32

KeysFloat32Int returns a slice of map's keys

func KeysFloat32Int16 

func KeysFloat32Int16(m map[float32]int16) []float32

KeysFloat32Int16 returns a slice of map's keys

func KeysFloat32Int32 

func KeysFloat32Int32(m map[float32]int32) []float32

KeysFloat32Int32 returns a slice of map's keys

func KeysFloat32Int64 

func KeysFloat32Int64(m map[float32]int64) []float32

KeysFloat32Int64 returns a slice of map's keys

func KeysFloat32Int8 

func KeysFloat32Int8(m map[float32]int8) []float32

KeysFloat32Int8 returns a slice of map's keys

func KeysFloat32Str 

func KeysFloat32Str(m map[float32]string) []float32

KeysFloat32Str returns a slice of map's keys

func KeysFloat32Uint 

func KeysFloat32Uint(m map[float32]uint) []float32

KeysFloat32Uint returns a slice of map's keys

func KeysFloat32Uint16 

func KeysFloat32Uint16(m map[float32]uint16) []float32

KeysFloat32Uint16 returns a slice of map's keys

func KeysFloat32Uint32 

func KeysFloat32Uint32(m map[float32]uint32) []float32

KeysFloat32Uint32 returns a slice of map's keys

func KeysFloat32Uint64 

func KeysFloat32Uint64(m map[float32]uint64) []float32

KeysFloat32Uint64 returns a slice of map's keys

func KeysFloat32Uint8 

func KeysFloat32Uint8(m map[float32]uint8) []float32

KeysFloat32Uint8 returns a slice of map's keys

func KeysFloat64 

func KeysFloat64(m map[float64]float64) []float64

KeysFloat64 returns a slice of map's keys

func KeysFloat64Bool 

func KeysFloat64Bool(m map[float64]bool) []float64

KeysFloat64Bool returns a slice of map's keys

func KeysFloat64Float32 

func KeysFloat64Float32(m map[float64]float32) []float64

KeysFloat64Float32 returns a slice of map's keys

func KeysFloat64Int 

func KeysFloat64Int(m map[float64]int) []float64

KeysFloat64Int returns a slice of map's keys

func KeysFloat64Int16 

func KeysFloat64Int16(m map[float64]int16) []float64

KeysFloat64Int16 returns a slice of map's keys

func KeysFloat64Int32 

func KeysFloat64Int32(m map[float64]int32) []float64

KeysFloat64Int32 returns a slice of map's keys

func KeysFloat64Int64 

func KeysFloat64Int64(m map[float64]int64) []float64

KeysFloat64Int64 returns a slice of map's keys

func KeysFloat64Int8 

func KeysFloat64Int8(m map[float64]int8) []float64

KeysFloat64Int8 returns a slice of map's keys

func KeysFloat64Str 

func KeysFloat64Str(m map[float64]string) []float64

KeysFloat64Str returns a slice of map's keys

func KeysFloat64Uint 

func KeysFloat64Uint(m map[float64]uint) []float64

KeysFloat64Uint returns a slice of map's keys

func KeysFloat64Uint16 

func KeysFloat64Uint16(m map[float64]uint16) []float64

KeysFloat64Uint16 returns a slice of map's keys

func KeysFloat64Uint32 

func KeysFloat64Uint32(m map[float64]uint32) []float64

KeysFloat64Uint32 returns a slice of map's keys

func KeysFloat64Uint64 

func KeysFloat64Uint64(m map[float64]uint64) []float64

KeysFloat64Uint64 returns a slice of map's keys

func KeysFloat64Uint8 

func KeysFloat64Uint8(m map[float64]uint8) []float64

KeysFloat64Uint8 returns a slice of map's keys

func KeysInt 

func KeysInt(m map[int]int) []int

KeysInt returns a slice of map's keys

func KeysInt16 

func KeysInt16(m map[int16]int16) []int16

KeysInt16 returns a slice of map's keys

func KeysInt16Bool 

func KeysInt16Bool(m map[int16]bool) []int16

KeysInt16Bool returns a slice of map's keys

func KeysInt16Float32 

func KeysInt16Float32(m map[int16]float32) []int16

KeysInt16Float32 returns a slice of map's keys

func KeysInt16Float64 

func KeysInt16Float64(m map[int16]float64) []int16

KeysInt16Float64 returns a slice of map's keys

func KeysInt16Int 

func KeysInt16Int(m map[int16]int) []int16

KeysInt16Int returns a slice of map's keys

func KeysInt16Int32 

func KeysInt16Int32(m map[int16]int32) []int16

KeysInt16Int32 returns a slice of map's keys

func KeysInt16Int64 

func KeysInt16Int64(m map[int16]int64) []int16

KeysInt16Int64 returns a slice of map's keys

func KeysInt16Int8 

func KeysInt16Int8(m map[int16]int8) []int16

KeysInt16Int8 returns a slice of map's keys

func KeysInt16Str 

func KeysInt16Str(m map[int16]string) []int16

KeysInt16Str returns a slice of map's keys

func KeysInt16Uint 

func KeysInt16Uint(m map[int16]uint) []int16

KeysInt16Uint returns a slice of map's keys

func KeysInt16Uint16 

func KeysInt16Uint16(m map[int16]uint16) []int16

KeysInt16Uint16 returns a slice of map's keys

func KeysInt16Uint32 

func KeysInt16Uint32(m map[int16]uint32) []int16

KeysInt16Uint32 returns a slice of map's keys

func KeysInt16Uint64 

func KeysInt16Uint64(m map[int16]uint64) []int16

KeysInt16Uint64 returns a slice of map's keys

func KeysInt16Uint8 

func KeysInt16Uint8(m map[int16]uint8) []int16

KeysInt16Uint8 returns a slice of map's keys

func KeysInt32 

func KeysInt32(m map[int32]int32) []int32

KeysInt32 returns a slice of map's keys

func KeysInt32Bool 

func KeysInt32Bool(m map[int32]bool) []int32

KeysInt32Bool returns a slice of map's keys

func KeysInt32Float32 

func KeysInt32Float32(m map[int32]float32) []int32

KeysInt32Float32 returns a slice of map's keys

func KeysInt32Float64 

func KeysInt32Float64(m map[int32]float64) []int32

KeysInt32Float64 returns a slice of map's keys

func KeysInt32Int 

func KeysInt32Int(m map[int32]int) []int32

KeysInt32Int returns a slice of map's keys

func KeysInt32Int16 

func KeysInt32Int16(m map[int32]int16) []int32

KeysInt32Int16 returns a slice of map's keys

func KeysInt32Int64 

func KeysInt32Int64(m map[int32]int64) []int32

KeysInt32Int64 returns a slice of map's keys

func KeysInt32Int8 

func KeysInt32Int8(m map[int32]int8) []int32

KeysInt32Int8 returns a slice of map's keys

func KeysInt32Str 

func KeysInt32Str(m map[int32]string) []int32

KeysInt32Str returns a slice of map's keys

func KeysInt32Uint 

func KeysInt32Uint(m map[int32]uint) []int32

KeysInt32Uint returns a slice of map's keys

func KeysInt32Uint16 

func KeysInt32Uint16(m map[int32]uint16) []int32

KeysInt32Uint16 returns a slice of map's keys

func KeysInt32Uint32 

func KeysInt32Uint32(m map[int32]uint32) []int32

KeysInt32Uint32 returns a slice of map's keys

func KeysInt32Uint64 

func KeysInt32Uint64(m map[int32]uint64) []int32

KeysInt32Uint64 returns a slice of map's keys

func KeysInt32Uint8 

func KeysInt32Uint8(m map[int32]uint8) []int32

KeysInt32Uint8 returns a slice of map's keys

func KeysInt64 

func KeysInt64(m map[int64]int64) []int64

KeysInt64 returns a slice of map's keys

func KeysInt64Bool 

func KeysInt64Bool(m map[int64]bool) []int64

KeysInt64Bool returns a slice of map's keys

func KeysInt64Float32 

func KeysInt64Float32(m map[int64]float32) []int64

KeysInt64Float32 returns a slice of map's keys

func KeysInt64Float64 

func KeysInt64Float64(m map[int64]float64) []int64

KeysInt64Float64 returns a slice of map's keys

func KeysInt64Int 

func KeysInt64Int(m map[int64]int) []int64

KeysInt64Int returns a slice of map's keys

func KeysInt64Int16 

func KeysInt64Int16(m map[int64]int16) []int64

KeysInt64Int16 returns a slice of map's keys

func KeysInt64Int32 

func KeysInt64Int32(m map[int64]int32) []int64

KeysInt64Int32 returns a slice of map's keys

func KeysInt64Int8 

func KeysInt64Int8(m map[int64]int8) []int64

KeysInt64Int8 returns a slice of map's keys

func KeysInt64Str 

func KeysInt64Str(m map[int64]string) []int64

KeysInt64Str returns a slice of map's keys

func KeysInt64Uint 

func KeysInt64Uint(m map[int64]uint) []int64

KeysInt64Uint returns a slice of map's keys

func KeysInt64Uint16 

func KeysInt64Uint16(m map[int64]uint16) []int64

KeysInt64Uint16 returns a slice of map's keys

func KeysInt64Uint32 

func KeysInt64Uint32(m map[int64]uint32) []int64

KeysInt64Uint32 returns a slice of map's keys

func KeysInt64Uint64 

func KeysInt64Uint64(m map[int64]uint64) []int64

KeysInt64Uint64 returns a slice of map's keys

func KeysInt64Uint8 

func KeysInt64Uint8(m map[int64]uint8) []int64

KeysInt64Uint8 returns a slice of map's keys

func KeysInt8 

func KeysInt8(m map[int8]int8) []int8

KeysInt8 returns a slice of map's keys

func KeysInt8Bool 

func KeysInt8Bool(m map[int8]bool) []int8

KeysInt8Bool returns a slice of map's keys

func KeysInt8Float32 

func KeysInt8Float32(m map[int8]float32) []int8

KeysInt8Float32 returns a slice of map's keys

func KeysInt8Float64 

func KeysInt8Float64(m map[int8]float64) []int8

KeysInt8Float64 returns a slice of map's keys

func KeysInt8Int 

func KeysInt8Int(m map[int8]int) []int8

KeysInt8Int returns a slice of map's keys

func KeysInt8Int16 

func KeysInt8Int16(m map[int8]int16) []int8

KeysInt8Int16 returns a slice of map's keys

func KeysInt8Int32 

func KeysInt8Int32(m map[int8]int32) []int8

KeysInt8Int32 returns a slice of map's keys

func KeysInt8Int64 

func KeysInt8Int64(m map[int8]int64) []int8

KeysInt8Int64 returns a slice of map's keys

func KeysInt8Str 

func KeysInt8Str(m map[int8]string) []int8

KeysInt8Str returns a slice of map's keys

func KeysInt8Uint 

func KeysInt8Uint(m map[int8]uint) []int8

KeysInt8Uint returns a slice of map's keys

func KeysInt8Uint16 

func KeysInt8Uint16(m map[int8]uint16) []int8

KeysInt8Uint16 returns a slice of map's keys

func KeysInt8Uint32 

func KeysInt8Uint32(m map[int8]uint32) []int8

KeysInt8Uint32 returns a slice of map's keys

func KeysInt8Uint64 

func KeysInt8Uint64(m map[int8]uint64) []int8

KeysInt8Uint64 returns a slice of map's keys

func KeysInt8Uint8 

func KeysInt8Uint8(m map[int8]uint8) []int8

KeysInt8Uint8 returns a slice of map's keys

func KeysIntBool 

func KeysIntBool(m map[int]bool) []int

KeysIntBool returns a slice of map's keys

func KeysIntFloat32 

func KeysIntFloat32(m map[int]float32) []int

KeysIntFloat32 returns a slice of map's keys

func KeysIntFloat64 

func KeysIntFloat64(m map[int]float64) []int

KeysIntFloat64 returns a slice of map's keys

func KeysIntInt16 

func KeysIntInt16(m map[int]int16) []int

KeysIntInt16 returns a slice of map's keys

func KeysIntInt32 

func KeysIntInt32(m map[int]int32) []int

KeysIntInt32 returns a slice of map's keys

func KeysIntInt64 

func KeysIntInt64(m map[int]int64) []int

KeysIntInt64 returns a slice of map's keys

func KeysIntInt8 

func KeysIntInt8(m map[int]int8) []int

KeysIntInt8 returns a slice of map's keys

func KeysIntStr 

func KeysIntStr(m map[int]string) []int

KeysIntStr returns a slice of map's keys

func KeysIntUint 

func KeysIntUint(m map[int]uint) []int

KeysIntUint returns a slice of map's keys

func KeysIntUint16 

func KeysIntUint16(m map[int]uint16) []int

KeysIntUint16 returns a slice of map's keys

func KeysIntUint32 

func KeysIntUint32(m map[int]uint32) []int

KeysIntUint32 returns a slice of map's keys

func KeysIntUint64 

func KeysIntUint64(m map[int]uint64) []int

KeysIntUint64 returns a slice of map's keys

func KeysIntUint8 

func KeysIntUint8(m map[int]uint8) []int

KeysIntUint8 returns a slice of map's keys

func KeysStr 

func KeysStr(m map[string]string) []string

KeysStr returns a slice of map's keys

func KeysStrBool 

func KeysStrBool(m map[string]bool) []string

KeysStrBool returns a slice of map's keys

func KeysStrFloat32 

func KeysStrFloat32(m map[string]float32) []string

KeysStrFloat32 returns a slice of map's keys

func KeysStrFloat64 

func KeysStrFloat64(m map[string]float64) []string

KeysStrFloat64 returns a slice of map's keys

func KeysStrInt 

func KeysStrInt(m map[string]int) []string

KeysStrInt returns a slice of map's keys

func KeysStrInt16 

func KeysStrInt16(m map[string]int16) []string

KeysStrInt16 returns a slice of map's keys

func KeysStrInt32 

func KeysStrInt32(m map[string]int32) []string

KeysStrInt32 returns a slice of map's keys

func KeysStrInt64 

func KeysStrInt64(m map[string]int64) []string

KeysStrInt64 returns a slice of map's keys

func KeysStrInt8 

func KeysStrInt8(m map[string]int8) []string

KeysStrInt8 returns a slice of map's keys

func KeysStrUint 

func KeysStrUint(m map[string]uint) []string

KeysStrUint returns a slice of map's keys

func KeysStrUint16 

func KeysStrUint16(m map[string]uint16) []string

KeysStrUint16 returns a slice of map's keys

func KeysStrUint32 

func KeysStrUint32(m map[string]uint32) []string

KeysStrUint32 returns a slice of map's keys

func KeysStrUint64 

func KeysStrUint64(m map[string]uint64) []string

KeysStrUint64 returns a slice of map's keys

func KeysStrUint8 

func KeysStrUint8(m map[string]uint8) []string

KeysStrUint8 returns a slice of map's keys

func KeysUint 

func KeysUint(m map[uint]uint) []uint

KeysUint returns a slice of map's keys

func KeysUint16 

func KeysUint16(m map[uint16]uint16) []uint16

KeysUint16 returns a slice of map's keys

func KeysUint16Bool 

func KeysUint16Bool(m map[uint16]bool) []uint16

KeysUint16Bool returns a slice of map's keys

func KeysUint16Float32 

func KeysUint16Float32(m map[uint16]float32) []uint16

KeysUint16Float32 returns a slice of map's keys

func KeysUint16Float64 

func KeysUint16Float64(m map[uint16]float64) []uint16

KeysUint16Float64 returns a slice of map's keys

func KeysUint16Int 

func KeysUint16Int(m map[uint16]int) []uint16

KeysUint16Int returns a slice of map's keys

func KeysUint16Int16 

func KeysUint16Int16(m map[uint16]int16) []uint16

KeysUint16Int16 returns a slice of map's keys

func KeysUint16Int32 

func KeysUint16Int32(m map[uint16]int32) []uint16

KeysUint16Int32 returns a slice of map's keys

func KeysUint16Int64 

func KeysUint16Int64(m map[uint16]int64) []uint16

KeysUint16Int64 returns a slice of map's keys

func KeysUint16Int8 

func KeysUint16Int8(m map[uint16]int8) []uint16

KeysUint16Int8 returns a slice of map's keys

func KeysUint16Str 

func KeysUint16Str(m map[uint16]string) []uint16

KeysUint16Str returns a slice of map's keys

func KeysUint16Uint 

func KeysUint16Uint(m map[uint16]uint) []uint16

KeysUint16Uint returns a slice of map's keys

func KeysUint16Uint32 

func KeysUint16Uint32(m map[uint16]uint32) []uint16

KeysUint16Uint32 returns a slice of map's keys

func KeysUint16Uint64 

func KeysUint16Uint64(m map[uint16]uint64) []uint16

KeysUint16Uint64 returns a slice of map's keys

func KeysUint16Uint8 

func KeysUint16Uint8(m map[uint16]uint8) []uint16

KeysUint16Uint8 returns a slice of map's keys

func KeysUint32 

func KeysUint32(m map[uint32]uint32) []uint32

KeysUint32 returns a slice of map's keys

func KeysUint32Bool 

func KeysUint32Bool(m map[uint32]bool) []uint32

KeysUint32Bool returns a slice of map's keys

func KeysUint32Float32 

func KeysUint32Float32(m map[uint32]float32) []uint32

KeysUint32Float32 returns a slice of map's keys

func KeysUint32Float64 

func KeysUint32Float64(m map[uint32]float64) []uint32

KeysUint32Float64 returns a slice of map's keys

func KeysUint32Int 

func KeysUint32Int(m map[uint32]int) []uint32

KeysUint32Int returns a slice of map's keys

func KeysUint32Int16 

func KeysUint32Int16(m map[uint32]int16) []uint32

KeysUint32Int16 returns a slice of map's keys

func KeysUint32Int32 

func KeysUint32Int32(m map[uint32]int32) []uint32

KeysUint32Int32 returns a slice of map's keys

func KeysUint32Int64 

func KeysUint32Int64(m map[uint32]int64) []uint32

KeysUint32Int64 returns a slice of map's keys

func KeysUint32Int8 

func KeysUint32Int8(m map[uint32]int8) []uint32

KeysUint32Int8 returns a slice of map's keys

func KeysUint32Str 

func KeysUint32Str(m map[uint32]string) []uint32

KeysUint32Str returns a slice of map's keys

func KeysUint32Uint 

func KeysUint32Uint(m map[uint32]uint) []uint32

KeysUint32Uint returns a slice of map's keys

func KeysUint32Uint16 

func KeysUint32Uint16(m map[uint32]uint16) []uint32

KeysUint32Uint16 returns a slice of map's keys

func KeysUint32Uint64 

func KeysUint32Uint64(m map[uint32]uint64) []uint32

KeysUint32Uint64 returns a slice of map's keys

func KeysUint32Uint8 

func KeysUint32Uint8(m map[uint32]uint8) []uint32

KeysUint32Uint8 returns a slice of map's keys

func KeysUint64 

func KeysUint64(m map[uint64]uint64) []uint64

KeysUint64 returns a slice of map's keys

func KeysUint64Bool 

func KeysUint64Bool(m map[uint64]bool) []uint64

KeysUint64Bool returns a slice of map's keys

func KeysUint64Float32 

func KeysUint64Float32(m map[uint64]float32) []uint64

KeysUint64Float32 returns a slice of map's keys

func KeysUint64Float64 

func KeysUint64Float64(m map[uint64]float64) []uint64

KeysUint64Float64 returns a slice of map's keys

func KeysUint64Int 

func KeysUint64Int(m map[uint64]int) []uint64

KeysUint64Int returns a slice of map's keys

func KeysUint64Int16 

func KeysUint64Int16(m map[uint64]int16) []uint64

KeysUint64Int16 returns a slice of map's keys

func KeysUint64Int32 

func KeysUint64Int32(m map[uint64]int32) []uint64

KeysUint64Int32 returns a slice of map's keys

func KeysUint64Int64 

func KeysUint64Int64(m map[uint64]int64) []uint64

KeysUint64Int64 returns a slice of map's keys

func KeysUint64Int8 

func KeysUint64Int8(m map[uint64]int8) []uint64

KeysUint64Int8 returns a slice of map's keys

func KeysUint64Str 

func KeysUint64Str(m map[uint64]string) []uint64

KeysUint64Str returns a slice of map's keys

func KeysUint64Uint 

func KeysUint64Uint(m map[uint64]uint) []uint64

KeysUint64Uint returns a slice of map's keys

func KeysUint64Uint16 

func KeysUint64Uint16(m map[uint64]uint16) []uint64

KeysUint64Uint16 returns a slice of map's keys

func KeysUint64Uint32 

func KeysUint64Uint32(m map[uint64]uint32) []uint64

KeysUint64Uint32 returns a slice of map's keys

func KeysUint64Uint8 

func KeysUint64Uint8(m map[uint64]uint8) []uint64

KeysUint64Uint8 returns a slice of map's keys

func KeysUint8 

func KeysUint8(m map[uint8]uint8) []uint8

KeysUint8 returns a slice of map's keys

func KeysUint8Bool 

func KeysUint8Bool(m map[uint8]bool) []uint8

KeysUint8Bool returns a slice of map's keys

func KeysUint8Float32 

func KeysUint8Float32(m map[uint8]float32) []uint8

KeysUint8Float32 returns a slice of map's keys

func KeysUint8Float64 

func KeysUint8Float64(m map[uint8]float64) []uint8

KeysUint8Float64 returns a slice of map's keys

func KeysUint8Int 

func KeysUint8Int(m map[uint8]int) []uint8

KeysUint8Int returns a slice of map's keys

func KeysUint8Int16 

func KeysUint8Int16(m map[uint8]int16) []uint8

KeysUint8Int16 returns a slice of map's keys

func KeysUint8Int32 

func KeysUint8Int32(m map[uint8]int32) []uint8

KeysUint8Int32 returns a slice of map's keys

func KeysUint8Int64 

func KeysUint8Int64(m map[uint8]int64) []uint8

KeysUint8Int64 returns a slice of map's keys

func KeysUint8Int8 

func KeysUint8Int8(m map[uint8]int8) []uint8

KeysUint8Int8 returns a slice of map's keys

func KeysUint8Str 

func KeysUint8Str(m map[uint8]string) []uint8

KeysUint8Str returns a slice of map's keys

func KeysUint8Uint 

func KeysUint8Uint(m map[uint8]uint) []uint8

KeysUint8Uint returns a slice of map's keys

func KeysUint8Uint16 

func KeysUint8Uint16(m map[uint8]uint16) []uint8

KeysUint8Uint16 returns a slice of map's keys

func KeysUint8Uint32 

func KeysUint8Uint32(m map[uint8]uint32) []uint8

KeysUint8Uint32 returns a slice of map's keys

func KeysUint8Uint64 

func KeysUint8Uint64(m map[uint8]uint64) []uint8

KeysUint8Uint64 returns a slice of map's keys

func KeysUintBool 

func KeysUintBool(m map[uint]bool) []uint

KeysUintBool returns a slice of map's keys

func KeysUintFloat32 

func KeysUintFloat32(m map[uint]float32) []uint

KeysUintFloat32 returns a slice of map's keys

func KeysUintFloat64 

func KeysUintFloat64(m map[uint]float64) []uint

KeysUintFloat64 returns a slice of map's keys

func KeysUintInt 

func KeysUintInt(m map[uint]int) []uint

KeysUintInt returns a slice of map's keys

func KeysUintInt16 

func KeysUintInt16(m map[uint]int16) []uint

KeysUintInt16 returns a slice of map's keys

func KeysUintInt32 

func KeysUintInt32(m map[uint]int32) []uint

KeysUintInt32 returns a slice of map's keys

func KeysUintInt64 

func KeysUintInt64(m map[uint]int64) []uint

KeysUintInt64 returns a slice of map's keys

func KeysUintInt8 

func KeysUintInt8(m map[uint]int8) []uint

KeysUintInt8 returns a slice of map's keys

func KeysUintStr 

func KeysUintStr(m map[uint]string) []uint

KeysUintStr returns a slice of map's keys

func KeysUintUint16 

func KeysUintUint16(m map[uint]uint16) []uint

KeysUintUint16 returns a slice of map's keys

func KeysUintUint32 

func KeysUintUint32(m map[uint]uint32) []uint

KeysUintUint32 returns a slice of map's keys

func KeysUintUint64 

func KeysUintUint64(m map[uint]uint64) []uint

KeysUintUint64 returns a slice of map's keys

func KeysUintUint8 

func KeysUintUint8(m map[uint]uint8) []uint

KeysUintUint8 returns a slice of map's keys

func MakeBoolSlice 

func MakeBoolSlice(values ...bool) boolSlice

MakeBoolSlice - creates slice for the functional method such as map, filter

func MakeBoolSlicePtr 

func MakeBoolSlicePtr(values ...*bool) boolSlicePtr

MakeBoolSlicePtr - creates slice for the functional method such as map, filter

func MakeFloat32Slice 

func MakeFloat32Slice(values ...float32) float32Slice

MakeFloat32Slice - creates slice for the functional method such as map, filter

func MakeFloat32SlicePtr 

func MakeFloat32SlicePtr(values ...*float32) float32SlicePtr

MakeFloat32SlicePtr - creates slice for the functional method such as map, filter

func MakeFloat64Slice 

func MakeFloat64Slice(values ...float64) float64Slice

MakeFloat64Slice - creates slice for the functional method such as map, filter

func MakeFloat64SlicePtr 

func MakeFloat64SlicePtr(values ...*float64) float64SlicePtr

MakeFloat64SlicePtr - creates slice for the functional method such as map, filter

func MakeInt16Slice 

func MakeInt16Slice(values ...int16) int16Slice

MakeInt16Slice - creates slice for the functional method such as map, filter

func MakeInt16SlicePtr 

func MakeInt16SlicePtr(values ...*int16) int16SlicePtr

MakeInt16SlicePtr - creates slice for the functional method such as map, filter

func MakeInt32Slice 

func MakeInt32Slice(values ...int32) int32Slice

MakeInt32Slice - creates slice for the functional method such as map, filter

func MakeInt32SlicePtr 

func MakeInt32SlicePtr(values ...*int32) int32SlicePtr

MakeInt32SlicePtr - creates slice for the functional method such as map, filter

func MakeInt64Slice 

func MakeInt64Slice(values ...int64) int64Slice

MakeInt64Slice - creates slice for the functional method such as map, filter

func MakeInt64SlicePtr 

func MakeInt64SlicePtr(values ...*int64) int64SlicePtr

MakeInt64SlicePtr - creates slice for the functional method such as map, filter

func MakeInt8Slice 

func MakeInt8Slice(values ...int8) int8Slice

MakeInt8Slice - creates slice for the functional method such as map, filter

func MakeInt8SlicePtr 

func MakeInt8SlicePtr(values ...*int8) int8SlicePtr

MakeInt8SlicePtr - creates slice for the functional method such as map, filter

func MakeIntSlice 

func MakeIntSlice(values ...int) intSlice

MakeIntSlice - creates slice for the functional method such as map, filter

func MakeIntSlicePtr 

func MakeIntSlicePtr(values ...*int) intSlicePtr

MakeIntSlicePtr - creates slice for the functional method such as map, filter

func MakeStrSlice 

func MakeStrSlice(values ...string) stringSlice

MakeStrSlice - creates slice for the functional method such as map, filter

func MakeStrSlicePtr 

func MakeStrSlicePtr(values ...*string) stringSlicePtr

MakeStrSlicePtr - creates slice for the functional method such as map, filter

func MakeUint16Slice 

func MakeUint16Slice(values ...uint16) uint16Slice

MakeUint16Slice - creates slice for the functional method such as map, filter

func MakeUint16SlicePtr 

func MakeUint16SlicePtr(values ...*uint16) uint16SlicePtr

MakeUint16SlicePtr - creates slice for the functional method such as map, filter

func MakeUint32Slice 

func MakeUint32Slice(values ...uint32) uint32Slice

MakeUint32Slice - creates slice for the functional method such as map, filter

func MakeUint32SlicePtr 

func MakeUint32SlicePtr(values ...*uint32) uint32SlicePtr

MakeUint32SlicePtr - creates slice for the functional method such as map, filter

func MakeUint64Slice 

func MakeUint64Slice(values ...uint64) uint64Slice

MakeUint64Slice - creates slice for the functional method such as map, filter

func MakeUint64SlicePtr 

func MakeUint64SlicePtr(values ...*uint64) uint64SlicePtr

MakeUint64SlicePtr - creates slice for the functional method such as map, filter

func MakeUint8Slice 

func MakeUint8Slice(values ...uint8) uint8Slice

MakeUint8Slice - creates slice for the functional method such as map, filter

func MakeUint8SlicePtr 

func MakeUint8SlicePtr(values ...*uint8) uint8SlicePtr

MakeUint8SlicePtr - creates slice for the functional method such as map, filter

func MakeUintSlice 

func MakeUintSlice(values ...uint) uintSlice

MakeUintSlice - creates slice for the functional method such as map, filter

func MakeUintSlicePtr 

func MakeUintSlicePtr(values ...*uint) uintSlicePtr

MakeUintSlicePtr - creates slice for the functional method such as map, filter

func MapBool 

func MapBool(f func(bool) bool, list []bool) []bool

MapBool applies the function(1st argument) on each item of the list and returns new list

Takes 2 inputs

  1. Function - takes 1 input
  2. List

Returns 

New List.
Empty list if all arguments are nil or either one is nil

func MapBoolErr 

func MapBoolErr(f func(bool) (bool, error), list []bool) ([]bool, error)

MapBoolErr takes 2 arguments:

  1. A function input argument: bool and return types (bool, error)
  2. A list of type []bool

Returns: 

([]bool, error)

func MapBoolFloat32 

func MapBoolFloat32(f func(bool) float32, list []bool) []float32

MapBoolFloat32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolFloat32Err 

func MapBoolFloat32Err(f func(bool) (float32, error), list []bool) ([]float32, error)

MapBoolFloat32Err 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

func MapBoolFloat32Ptr 

func MapBoolFloat32Ptr(f func(*bool) *float32, list []*bool) []*float32

MapBoolFloat32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolFloat32PtrErr 

func MapBoolFloat32PtrErr(f func(*bool) (*float32, error), list []*bool) ([]*float32, error)

MapBoolFloat32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapBoolFloat64 

func MapBoolFloat64(f func(bool) float64, list []bool) []float64

MapBoolFloat64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolFloat64Err 

func MapBoolFloat64Err(f func(bool) (float64, error), list []bool) ([]float64, error)

MapBoolFloat64Err 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

func MapBoolFloat64Ptr 

func MapBoolFloat64Ptr(f func(*bool) *float64, list []*bool) []*float64

MapBoolFloat64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolFloat64PtrErr 

func MapBoolFloat64PtrErr(f func(*bool) (*float64, error), list []*bool) ([]*float64, error)

MapBoolFloat64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapBoolInt 

func MapBoolInt(f func(bool) int, list []bool) []int

MapBoolInt takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolInt16 

func MapBoolInt16(f func(bool) int16, list []bool) []int16

MapBoolInt16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolInt16Err 

func MapBoolInt16Err(f func(bool) (int16, error), list []bool) ([]int16, error)

MapBoolInt16Err 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

func MapBoolInt16Ptr 

func MapBoolInt16Ptr(f func(*bool) *int16, list []*bool) []*int16

MapBoolInt16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolInt16PtrErr 

func MapBoolInt16PtrErr(f func(*bool) (*int16, error), list []*bool) ([]*int16, error)

MapBoolInt16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapBoolInt32 

func MapBoolInt32(f func(bool) int32, list []bool) []int32

MapBoolInt32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolInt32Err 

func MapBoolInt32Err(f func(bool) (int32, error), list []bool) ([]int32, error)

MapBoolInt32Err 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

func MapBoolInt32Ptr 

func MapBoolInt32Ptr(f func(*bool) *int32, list []*bool) []*int32

MapBoolInt32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolInt32PtrErr 

func MapBoolInt32PtrErr(f func(*bool) (*int32, error), list []*bool) ([]*int32, error)

MapBoolInt32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapBoolInt64 

func MapBoolInt64(f func(bool) int64, list []bool) []int64

MapBoolInt64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolInt64Err 

func MapBoolInt64Err(f func(bool) (int64, error), list []bool) ([]int64, error)

MapBoolInt64Err 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

func MapBoolInt64Ptr 

func MapBoolInt64Ptr(f func(*bool) *int64, list []*bool) []*int64

MapBoolInt64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolInt64PtrErr 

func MapBoolInt64PtrErr(f func(*bool) (*int64, error), list []*bool) ([]*int64, error)

MapBoolInt64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapBoolInt8 

func MapBoolInt8(f func(bool) int8, list []bool) []int8

MapBoolInt8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolInt8Err 

func MapBoolInt8Err(f func(bool) (int8, error), list []bool) ([]int8, error)

MapBoolInt8Err 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

func MapBoolInt8Ptr 

func MapBoolInt8Ptr(f func(*bool) *int8, list []*bool) []*int8

MapBoolInt8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolInt8PtrErr 

func MapBoolInt8PtrErr(f func(*bool) (*int8, error), list []*bool) ([]*int8, error)

MapBoolInt8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapBoolIntErr 

func MapBoolIntErr(f func(bool) (int, error), list []bool) ([]int, error)

MapBoolIntErr 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

func MapBoolIntPtr 

func MapBoolIntPtr(f func(*bool) *int, list []*bool) []*int

MapBoolIntPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolIntPtrErr 

func MapBoolIntPtrErr(f func(*bool) (*int, error), list []*bool) ([]*int, error)

MapBoolIntPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapBoolPtr 

func MapBoolPtr(f func(*bool) *bool, list []*bool) []*bool

MapBoolPtr takes 2 arguments.

  1. A function input argument: bool and return type (bool)
  2. A list of type []*bool

Returns: 

([]*bool)

func MapBoolPtrErr 

func MapBoolPtrErr(f func(*bool) (*bool, error), list []*bool) ([]*bool, error)

MapBoolPtrErr takes 2 arguments:

  1. A function input argument: *bool and return types (*bool, error)
  2. A list of type []*bool

Returns: 

([]*bool, error)

func MapBoolStr 

func MapBoolStr(f func(bool) string, list []bool) []string

MapBoolStr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolStrErr 

func MapBoolStrErr(f func(bool) (string, error), list []bool) ([]string, error)

MapBoolStrErr 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

func MapBoolStrPtr 

func MapBoolStrPtr(f func(*bool) *string, list []*bool) []*string

MapBoolStrPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolStrPtrErr 

func MapBoolStrPtrErr(f func(*bool) (*string, error), list []*bool) ([]*string, error)

MapBoolStrPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapBoolUint 

func MapBoolUint(f func(bool) uint, list []bool) []uint

MapBoolUint takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolUint16 

func MapBoolUint16(f func(bool) uint16, list []bool) []uint16

MapBoolUint16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolUint16Err 

func MapBoolUint16Err(f func(bool) (uint16, error), list []bool) ([]uint16, error)

MapBoolUint16Err 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

func MapBoolUint16Ptr 

func MapBoolUint16Ptr(f func(*bool) *uint16, list []*bool) []*uint16

MapBoolUint16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolUint16PtrErr 

func MapBoolUint16PtrErr(f func(*bool) (*uint16, error), list []*bool) ([]*uint16, error)

MapBoolUint16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapBoolUint32 

func MapBoolUint32(f func(bool) uint32, list []bool) []uint32

MapBoolUint32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolUint32Err 

func MapBoolUint32Err(f func(bool) (uint32, error), list []bool) ([]uint32, error)

MapBoolUint32Err 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

func MapBoolUint32Ptr 

func MapBoolUint32Ptr(f func(*bool) *uint32, list []*bool) []*uint32

MapBoolUint32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolUint32PtrErr 

func MapBoolUint32PtrErr(f func(*bool) (*uint32, error), list []*bool) ([]*uint32, error)

MapBoolUint32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapBoolUint64 

func MapBoolUint64(f func(bool) uint64, list []bool) []uint64

MapBoolUint64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolUint64Err 

func MapBoolUint64Err(f func(bool) (uint64, error), list []bool) ([]uint64, error)

MapBoolUint64Err 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

func MapBoolUint64Ptr 

func MapBoolUint64Ptr(f func(*bool) *uint64, list []*bool) []*uint64

MapBoolUint64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolUint64PtrErr 

func MapBoolUint64PtrErr(f func(*bool) (*uint64, error), list []*bool) ([]*uint64, error)

MapBoolUint64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapBoolUint8 

func MapBoolUint8(f func(bool) uint8, list []bool) []uint8

MapBoolUint8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolUint8Err 

func MapBoolUint8Err(f func(bool) (uint8, error), list []bool) ([]uint8, error)

MapBoolUint8Err 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

func MapBoolUint8Ptr 

func MapBoolUint8Ptr(f func(*bool) *uint8, list []*bool) []*uint8

MapBoolUint8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolUint8PtrErr 

func MapBoolUint8PtrErr(f func(*bool) (*uint8, error), list []*bool) ([]*uint8, error)

MapBoolUint8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapBoolUintErr 

func MapBoolUintErr(f func(bool) (uint, error), list []bool) ([]uint, error)

MapBoolUintErr 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

func MapBoolUintPtr 

func MapBoolUintPtr(f func(*bool) *uint, list []*bool) []*uint

MapBoolUintPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapBoolUintPtrErr 

func MapBoolUintPtrErr(f func(*bool) (*uint, error), list []*bool) ([]*uint, error)

MapBoolUintPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat32 

func MapFloat32(f func(float32) float32, list []float32) []float32

MapFloat32 applies the function(1st argument) on each item of the list and returns new list

Takes 2 inputs

  1. Function - takes 1 input
  2. List

Returns 

New List.
Empty list if all arguments are nil or either one is nil

Example: add 1 to each item in the list 

MapFloat32(addOne, []float32{1, 2, 3}) // Returns [2, 3, 4]

func addOne(num float32) float32 {
	return num + 1
}

func MapFloat32Bool 

func MapFloat32Bool(f func(float32) bool, list []float32) []bool

MapFloat32Bool takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32BoolErr 

func MapFloat32BoolErr(f func(float32) (bool, error), list []float32) ([]bool, error)

MapFloat32BoolErr 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

func MapFloat32BoolPtr 

func MapFloat32BoolPtr(f func(*float32) *bool, list []*float32) []*bool

MapFloat32BoolPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32BoolPtrErr 

func MapFloat32BoolPtrErr(f func(*float32) (*bool, error), list []*float32) ([]*bool, error)

MapFloat32BoolPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat32Err 

func MapFloat32Err(f func(float32) (float32, error), list []float32) ([]float32, error)

MapFloat32Err takes 2 arguments:

  1. A function input argument: float32 and return types (float32, error)
  2. A list of type []float32

Returns: 

([]float32, error)

func MapFloat32Float64 

func MapFloat32Float64(f func(float32) float64, list []float32) []float64

MapFloat32Float64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Float64Err 

func MapFloat32Float64Err(f func(float32) (float64, error), list []float32) ([]float64, error)

MapFloat32Float64Err 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

func MapFloat32Float64Ptr 

func MapFloat32Float64Ptr(f func(*float32) *float64, list []*float32) []*float64

MapFloat32Float64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Float64PtrErr 

func MapFloat32Float64PtrErr(f func(*float32) (*float64, error), list []*float32) ([]*float64, error)

MapFloat32Float64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat32Int 

func MapFloat32Int(f func(float32) int, list []float32) []int

MapFloat32Int takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Int16 

func MapFloat32Int16(f func(float32) int16, list []float32) []int16

MapFloat32Int16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Int16Err 

func MapFloat32Int16Err(f func(float32) (int16, error), list []float32) ([]int16, error)

MapFloat32Int16Err 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

func MapFloat32Int16Ptr 

func MapFloat32Int16Ptr(f func(*float32) *int16, list []*float32) []*int16

MapFloat32Int16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Int16PtrErr 

func MapFloat32Int16PtrErr(f func(*float32) (*int16, error), list []*float32) ([]*int16, error)

MapFloat32Int16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat32Int32 

func MapFloat32Int32(f func(float32) int32, list []float32) []int32

MapFloat32Int32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Int32Err 

func MapFloat32Int32Err(f func(float32) (int32, error), list []float32) ([]int32, error)

MapFloat32Int32Err 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

func MapFloat32Int32Ptr 

func MapFloat32Int32Ptr(f func(*float32) *int32, list []*float32) []*int32

MapFloat32Int32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Int32PtrErr 

func MapFloat32Int32PtrErr(f func(*float32) (*int32, error), list []*float32) ([]*int32, error)

MapFloat32Int32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat32Int64 

func MapFloat32Int64(f func(float32) int64, list []float32) []int64

MapFloat32Int64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Int64Err 

func MapFloat32Int64Err(f func(float32) (int64, error), list []float32) ([]int64, error)

MapFloat32Int64Err 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

func MapFloat32Int64Ptr 

func MapFloat32Int64Ptr(f func(*float32) *int64, list []*float32) []*int64

MapFloat32Int64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Int64PtrErr 

func MapFloat32Int64PtrErr(f func(*float32) (*int64, error), list []*float32) ([]*int64, error)

MapFloat32Int64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat32Int8 

func MapFloat32Int8(f func(float32) int8, list []float32) []int8

MapFloat32Int8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Int8Err 

func MapFloat32Int8Err(f func(float32) (int8, error), list []float32) ([]int8, error)

MapFloat32Int8Err 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

func MapFloat32Int8Ptr 

func MapFloat32Int8Ptr(f func(*float32) *int8, list []*float32) []*int8

MapFloat32Int8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Int8PtrErr 

func MapFloat32Int8PtrErr(f func(*float32) (*int8, error), list []*float32) ([]*int8, error)

MapFloat32Int8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat32IntErr 

func MapFloat32IntErr(f func(float32) (int, error), list []float32) ([]int, error)

MapFloat32IntErr 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

func MapFloat32IntPtr 

func MapFloat32IntPtr(f func(*float32) *int, list []*float32) []*int

MapFloat32IntPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32IntPtrErr 

func MapFloat32IntPtrErr(f func(*float32) (*int, error), list []*float32) ([]*int, error)

MapFloat32IntPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat32Ptr 

func MapFloat32Ptr(f func(*float32) *float32, list []*float32) []*float32

MapFloat32Ptr takes 2 arguments.

  1. A function input argument: float32 and return type (float32)
  2. A list of type []*float32

Returns: 

([]*float32)

func MapFloat32PtrErr 

func MapFloat32PtrErr(f func(*float32) (*float32, error), list []*float32) ([]*float32, error)

MapFloat32PtrErr takes 2 arguments:

  1. A function input argument: *float32 and return types (*float32, error)
  2. A list of type []*float32

Returns: 

([]*float32, error)

func MapFloat32Str 

func MapFloat32Str(f func(float32) string, list []float32) []string

MapFloat32Str takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32StrErr 

func MapFloat32StrErr(f func(float32) (string, error), list []float32) ([]string, error)

MapFloat32StrErr 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

func MapFloat32StrPtr 

func MapFloat32StrPtr(f func(*float32) *string, list []*float32) []*string

MapFloat32StrPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32StrPtrErr 

func MapFloat32StrPtrErr(f func(*float32) (*string, error), list []*float32) ([]*string, error)

MapFloat32StrPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat32Uint 

func MapFloat32Uint(f func(float32) uint, list []float32) []uint

MapFloat32Uint takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Uint16 

func MapFloat32Uint16(f func(float32) uint16, list []float32) []uint16

MapFloat32Uint16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Uint16Err 

func MapFloat32Uint16Err(f func(float32) (uint16, error), list []float32) ([]uint16, error)

MapFloat32Uint16Err 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

func MapFloat32Uint16Ptr 

func MapFloat32Uint16Ptr(f func(*float32) *uint16, list []*float32) []*uint16

MapFloat32Uint16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Uint16PtrErr 

func MapFloat32Uint16PtrErr(f func(*float32) (*uint16, error), list []*float32) ([]*uint16, error)

MapFloat32Uint16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat32Uint32 

func MapFloat32Uint32(f func(float32) uint32, list []float32) []uint32

MapFloat32Uint32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Uint32Err 

func MapFloat32Uint32Err(f func(float32) (uint32, error), list []float32) ([]uint32, error)

MapFloat32Uint32Err 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

func MapFloat32Uint32Ptr 

func MapFloat32Uint32Ptr(f func(*float32) *uint32, list []*float32) []*uint32

MapFloat32Uint32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Uint32PtrErr 

func MapFloat32Uint32PtrErr(f func(*float32) (*uint32, error), list []*float32) ([]*uint32, error)

MapFloat32Uint32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat32Uint64 

func MapFloat32Uint64(f func(float32) uint64, list []float32) []uint64

MapFloat32Uint64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Uint64Err 

func MapFloat32Uint64Err(f func(float32) (uint64, error), list []float32) ([]uint64, error)

MapFloat32Uint64Err 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

func MapFloat32Uint64Ptr 

func MapFloat32Uint64Ptr(f func(*float32) *uint64, list []*float32) []*uint64

MapFloat32Uint64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Uint64PtrErr 

func MapFloat32Uint64PtrErr(f func(*float32) (*uint64, error), list []*float32) ([]*uint64, error)

MapFloat32Uint64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat32Uint8 

func MapFloat32Uint8(f func(float32) uint8, list []float32) []uint8

MapFloat32Uint8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Uint8Err 

func MapFloat32Uint8Err(f func(float32) (uint8, error), list []float32) ([]uint8, error)

MapFloat32Uint8Err 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

func MapFloat32Uint8Ptr 

func MapFloat32Uint8Ptr(f func(*float32) *uint8, list []*float32) []*uint8

MapFloat32Uint8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32Uint8PtrErr 

func MapFloat32Uint8PtrErr(f func(*float32) (*uint8, error), list []*float32) ([]*uint8, error)

MapFloat32Uint8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat32UintErr 

func MapFloat32UintErr(f func(float32) (uint, error), list []float32) ([]uint, error)

MapFloat32UintErr 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

func MapFloat32UintPtr 

func MapFloat32UintPtr(f func(*float32) *uint, list []*float32) []*uint

MapFloat32UintPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat32UintPtrErr 

func MapFloat32UintPtrErr(f func(*float32) (*uint, error), list []*float32) ([]*uint, error)

MapFloat32UintPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat64 

func MapFloat64(f func(float64) float64, list []float64) []float64

MapFloat64 applies the function(1st argument) on each item of the list and returns new list

Takes 2 inputs

  1. Function - takes 1 input
  2. List

Returns 

New List.
Empty list if all arguments are nil or either one is nil

Example: add 1 to each item in the list 

MapFloat64(addOne, []float64{1, 2, 3}) // Returns [2, 3, 4]

func addOne(num float64) float64 {
	return num + 1
}

func MapFloat64Bool 

func MapFloat64Bool(f func(float64) bool, list []float64) []bool

MapFloat64Bool takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64BoolErr 

func MapFloat64BoolErr(f func(float64) (bool, error), list []float64) ([]bool, error)

MapFloat64BoolErr 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

func MapFloat64BoolPtr 

func MapFloat64BoolPtr(f func(*float64) *bool, list []*float64) []*bool

MapFloat64BoolPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64BoolPtrErr 

func MapFloat64BoolPtrErr(f func(*float64) (*bool, error), list []*float64) ([]*bool, error)

MapFloat64BoolPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat64Err 

func MapFloat64Err(f func(float64) (float64, error), list []float64) ([]float64, error)

MapFloat64Err takes 2 arguments:

  1. A function input argument: float64 and return types (float64, error)
  2. A list of type []float64

Returns: 

([]float64, error)

func MapFloat64Float32 

func MapFloat64Float32(f func(float64) float32, list []float64) []float32

MapFloat64Float32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Float32Err 

func MapFloat64Float32Err(f func(float64) (float32, error), list []float64) ([]float32, error)

MapFloat64Float32Err 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

func MapFloat64Float32Ptr 

func MapFloat64Float32Ptr(f func(*float64) *float32, list []*float64) []*float32

MapFloat64Float32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Float32PtrErr 

func MapFloat64Float32PtrErr(f func(*float64) (*float32, error), list []*float64) ([]*float32, error)

MapFloat64Float32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat64Int 

func MapFloat64Int(f func(float64) int, list []float64) []int

MapFloat64Int takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Int16 

func MapFloat64Int16(f func(float64) int16, list []float64) []int16

MapFloat64Int16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Int16Err 

func MapFloat64Int16Err(f func(float64) (int16, error), list []float64) ([]int16, error)

MapFloat64Int16Err 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

func MapFloat64Int16Ptr 

func MapFloat64Int16Ptr(f func(*float64) *int16, list []*float64) []*int16

MapFloat64Int16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Int16PtrErr 

func MapFloat64Int16PtrErr(f func(*float64) (*int16, error), list []*float64) ([]*int16, error)

MapFloat64Int16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat64Int32 

func MapFloat64Int32(f func(float64) int32, list []float64) []int32

MapFloat64Int32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Int32Err 

func MapFloat64Int32Err(f func(float64) (int32, error), list []float64) ([]int32, error)

MapFloat64Int32Err 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

func MapFloat64Int32Ptr 

func MapFloat64Int32Ptr(f func(*float64) *int32, list []*float64) []*int32

MapFloat64Int32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Int32PtrErr 

func MapFloat64Int32PtrErr(f func(*float64) (*int32, error), list []*float64) ([]*int32, error)

MapFloat64Int32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat64Int64 

func MapFloat64Int64(f func(float64) int64, list []float64) []int64

MapFloat64Int64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Int64Err 

func MapFloat64Int64Err(f func(float64) (int64, error), list []float64) ([]int64, error)

MapFloat64Int64Err 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

func MapFloat64Int64Ptr 

func MapFloat64Int64Ptr(f func(*float64) *int64, list []*float64) []*int64

MapFloat64Int64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Int64PtrErr 

func MapFloat64Int64PtrErr(f func(*float64) (*int64, error), list []*float64) ([]*int64, error)

MapFloat64Int64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat64Int8 

func MapFloat64Int8(f func(float64) int8, list []float64) []int8

MapFloat64Int8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Int8Err 

func MapFloat64Int8Err(f func(float64) (int8, error), list []float64) ([]int8, error)

MapFloat64Int8Err 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

func MapFloat64Int8Ptr 

func MapFloat64Int8Ptr(f func(*float64) *int8, list []*float64) []*int8

MapFloat64Int8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Int8PtrErr 

func MapFloat64Int8PtrErr(f func(*float64) (*int8, error), list []*float64) ([]*int8, error)

MapFloat64Int8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat64IntErr 

func MapFloat64IntErr(f func(float64) (int, error), list []float64) ([]int, error)

MapFloat64IntErr 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

func MapFloat64IntPtr 

func MapFloat64IntPtr(f func(*float64) *int, list []*float64) []*int

MapFloat64IntPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64IntPtrErr 

func MapFloat64IntPtrErr(f func(*float64) (*int, error), list []*float64) ([]*int, error)

MapFloat64IntPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat64Ptr 

func MapFloat64Ptr(f func(*float64) *float64, list []*float64) []*float64

MapFloat64Ptr takes 2 arguments.

  1. A function input argument: float64 and return type (float64)
  2. A list of type []*float64

Returns: 

([]*float64)

func MapFloat64PtrErr 

func MapFloat64PtrErr(f func(*float64) (*float64, error), list []*float64) ([]*float64, error)

MapFloat64PtrErr takes 2 arguments:

  1. A function input argument: *float64 and return types (*float64, error)
  2. A list of type []*float64

Returns: 

([]*float64, error)

func MapFloat64Str 

func MapFloat64Str(f func(float64) string, list []float64) []string

MapFloat64Str takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64StrErr 

func MapFloat64StrErr(f func(float64) (string, error), list []float64) ([]string, error)

MapFloat64StrErr 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

func MapFloat64StrPtr 

func MapFloat64StrPtr(f func(*float64) *string, list []*float64) []*string

MapFloat64StrPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64StrPtrErr 

func MapFloat64StrPtrErr(f func(*float64) (*string, error), list []*float64) ([]*string, error)

MapFloat64StrPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat64Uint 

func MapFloat64Uint(f func(float64) uint, list []float64) []uint

MapFloat64Uint takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Uint16 

func MapFloat64Uint16(f func(float64) uint16, list []float64) []uint16

MapFloat64Uint16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Uint16Err 

func MapFloat64Uint16Err(f func(float64) (uint16, error), list []float64) ([]uint16, error)

MapFloat64Uint16Err 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

func MapFloat64Uint16Ptr 

func MapFloat64Uint16Ptr(f func(*float64) *uint16, list []*float64) []*uint16

MapFloat64Uint16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Uint16PtrErr 

func MapFloat64Uint16PtrErr(f func(*float64) (*uint16, error), list []*float64) ([]*uint16, error)

MapFloat64Uint16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat64Uint32 

func MapFloat64Uint32(f func(float64) uint32, list []float64) []uint32

MapFloat64Uint32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Uint32Err 

func MapFloat64Uint32Err(f func(float64) (uint32, error), list []float64) ([]uint32, error)

MapFloat64Uint32Err 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

func MapFloat64Uint32Ptr 

func MapFloat64Uint32Ptr(f func(*float64) *uint32, list []*float64) []*uint32

MapFloat64Uint32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Uint32PtrErr 

func MapFloat64Uint32PtrErr(f func(*float64) (*uint32, error), list []*float64) ([]*uint32, error)

MapFloat64Uint32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat64Uint64 

func MapFloat64Uint64(f func(float64) uint64, list []float64) []uint64

MapFloat64Uint64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Uint64Err 

func MapFloat64Uint64Err(f func(float64) (uint64, error), list []float64) ([]uint64, error)

MapFloat64Uint64Err 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

func MapFloat64Uint64Ptr 

func MapFloat64Uint64Ptr(f func(*float64) *uint64, list []*float64) []*uint64

MapFloat64Uint64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Uint64PtrErr 

func MapFloat64Uint64PtrErr(f func(*float64) (*uint64, error), list []*float64) ([]*uint64, error)

MapFloat64Uint64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat64Uint8 

func MapFloat64Uint8(f func(float64) uint8, list []float64) []uint8

MapFloat64Uint8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Uint8Err 

func MapFloat64Uint8Err(f func(float64) (uint8, error), list []float64) ([]uint8, error)

MapFloat64Uint8Err 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

func MapFloat64Uint8Ptr 

func MapFloat64Uint8Ptr(f func(*float64) *uint8, list []*float64) []*uint8

MapFloat64Uint8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64Uint8PtrErr 

func MapFloat64Uint8PtrErr(f func(*float64) (*uint8, error), list []*float64) ([]*uint8, error)

MapFloat64Uint8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapFloat64UintErr 

func MapFloat64UintErr(f func(float64) (uint, error), list []float64) ([]uint, error)

MapFloat64UintErr 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

func MapFloat64UintPtr 

func MapFloat64UintPtr(f func(*float64) *uint, list []*float64) []*uint

MapFloat64UintPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapFloat64UintPtrErr 

func MapFloat64UintPtrErr(f func(*float64) (*uint, error), list []*float64) ([]*uint, error)

MapFloat64UintPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt 

func MapInt(f func(int) int, list []int) []int

MapInt applies the function(1st argument) on each item of the list and returns new list

Takes 2 inputs

  1. Function - takes 1 input
  2. List

Returns 

New List.
Empty list if all arguments are nil or either one is nil

Example: Square each item in the list 

MapInt(squareInt, []int{1, 2, 3}) // Returns [1, 4, 9]

func squareInt(num int) int {
	return num * num
}

func MapInt16 

func MapInt16(f func(int16) int16, list []int16) []int16

MapInt16 applies the function(1st argument) on each item of the list and returns new list

Takes 2 inputs

  1. Function - takes 1 input
  2. List

Returns 

New List.
Empty list if all arguments are nil or either one is nil

Example: Square each item in the list 

MapInt16(squareInt, []int16{1, 2, 3}) // Returns [1, 4, 9]

func squareInt(num int16) int16 {
	return num * num
}

func MapInt16Bool 

func MapInt16Bool(f func(int16) bool, list []int16) []bool

MapInt16Bool takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16BoolErr 

func MapInt16BoolErr(f func(int16) (bool, error), list []int16) ([]bool, error)

MapInt16BoolErr 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

func MapInt16BoolPtr 

func MapInt16BoolPtr(f func(*int16) *bool, list []*int16) []*bool

MapInt16BoolPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16BoolPtrErr 

func MapInt16BoolPtrErr(f func(*int16) (*bool, error), list []*int16) ([]*bool, error)

MapInt16BoolPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt16Err 

func MapInt16Err(f func(int16) (int16, error), list []int16) ([]int16, error)

MapInt16Err takes 2 arguments:

  1. A function input argument: int16 and return types (int16, error)
  2. A list of type []int16

Returns: 

([]int16, error)

func MapInt16Float32 

func MapInt16Float32(f func(int16) float32, list []int16) []float32

MapInt16Float32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Float32Err 

func MapInt16Float32Err(f func(int16) (float32, error), list []int16) ([]float32, error)

MapInt16Float32Err 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

func MapInt16Float32Ptr 

func MapInt16Float32Ptr(f func(*int16) *float32, list []*int16) []*float32

MapInt16Float32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Float32PtrErr 

func MapInt16Float32PtrErr(f func(*int16) (*float32, error), list []*int16) ([]*float32, error)

MapInt16Float32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt16Float64 

func MapInt16Float64(f func(int16) float64, list []int16) []float64

MapInt16Float64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Float64Err 

func MapInt16Float64Err(f func(int16) (float64, error), list []int16) ([]float64, error)

MapInt16Float64Err 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

func MapInt16Float64Ptr 

func MapInt16Float64Ptr(f func(*int16) *float64, list []*int16) []*float64

MapInt16Float64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Float64PtrErr 

func MapInt16Float64PtrErr(f func(*int16) (*float64, error), list []*int16) ([]*float64, error)

MapInt16Float64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt16Int 

func MapInt16Int(f func(int16) int, list []int16) []int

MapInt16Int takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Int32 

func MapInt16Int32(f func(int16) int32, list []int16) []int32

MapInt16Int32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Int32Err 

func MapInt16Int32Err(f func(int16) (int32, error), list []int16) ([]int32, error)

MapInt16Int32Err 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

func MapInt16Int32Ptr 

func MapInt16Int32Ptr(f func(*int16) *int32, list []*int16) []*int32

MapInt16Int32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Int32PtrErr 

func MapInt16Int32PtrErr(f func(*int16) (*int32, error), list []*int16) ([]*int32, error)

MapInt16Int32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt16Int64 

func MapInt16Int64(f func(int16) int64, list []int16) []int64

MapInt16Int64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Int64Err 

func MapInt16Int64Err(f func(int16) (int64, error), list []int16) ([]int64, error)

MapInt16Int64Err 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

func MapInt16Int64Ptr 

func MapInt16Int64Ptr(f func(*int16) *int64, list []*int16) []*int64

MapInt16Int64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Int64PtrErr 

func MapInt16Int64PtrErr(f func(*int16) (*int64, error), list []*int16) ([]*int64, error)

MapInt16Int64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt16Int8 

func MapInt16Int8(f func(int16) int8, list []int16) []int8

MapInt16Int8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Int8Err 

func MapInt16Int8Err(f func(int16) (int8, error), list []int16) ([]int8, error)

MapInt16Int8Err 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

func MapInt16Int8Ptr 

func MapInt16Int8Ptr(f func(*int16) *int8, list []*int16) []*int8

MapInt16Int8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Int8PtrErr 

func MapInt16Int8PtrErr(f func(*int16) (*int8, error), list []*int16) ([]*int8, error)

MapInt16Int8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt16IntErr 

func MapInt16IntErr(f func(int16) (int, error), list []int16) ([]int, error)

MapInt16IntErr 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

func MapInt16IntPtr 

func MapInt16IntPtr(f func(*int16) *int, list []*int16) []*int

MapInt16IntPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16IntPtrErr 

func MapInt16IntPtrErr(f func(*int16) (*int, error), list []*int16) ([]*int, error)

MapInt16IntPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt16Ptr 

func MapInt16Ptr(f func(*int16) *int16, list []*int16) []*int16

MapInt16Ptr takes 2 arguments.

  1. A function input argument: int16 and return type (int16)
  2. A list of type []*int16

Returns: 

([]*int16)

func MapInt16PtrErr 

func MapInt16PtrErr(f func(*int16) (*int16, error), list []*int16) ([]*int16, error)

MapInt16PtrErr takes 2 arguments:

  1. A function input argument: *int16 and return types (*int16, error)
  2. A list of type []*int16

Returns: 

([]*int16, error)

func MapInt16Str 

func MapInt16Str(f func(int16) string, list []int16) []string

MapInt16Str takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16StrErr 

func MapInt16StrErr(f func(int16) (string, error), list []int16) ([]string, error)

MapInt16StrErr 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

func MapInt16StrPtr 

func MapInt16StrPtr(f func(*int16) *string, list []*int16) []*string

MapInt16StrPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16StrPtrErr 

func MapInt16StrPtrErr(f func(*int16) (*string, error), list []*int16) ([]*string, error)

MapInt16StrPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt16Uint 

func MapInt16Uint(f func(int16) uint, list []int16) []uint

MapInt16Uint takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Uint16 

func MapInt16Uint16(f func(int16) uint16, list []int16) []uint16

MapInt16Uint16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Uint16Err 

func MapInt16Uint16Err(f func(int16) (uint16, error), list []int16) ([]uint16, error)

MapInt16Uint16Err 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

func MapInt16Uint16Ptr 

func MapInt16Uint16Ptr(f func(*int16) *uint16, list []*int16) []*uint16

MapInt16Uint16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Uint16PtrErr 

func MapInt16Uint16PtrErr(f func(*int16) (*uint16, error), list []*int16) ([]*uint16, error)

MapInt16Uint16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt16Uint32 

func MapInt16Uint32(f func(int16) uint32, list []int16) []uint32

MapInt16Uint32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Uint32Err 

func MapInt16Uint32Err(f func(int16) (uint32, error), list []int16) ([]uint32, error)

MapInt16Uint32Err 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

func MapInt16Uint32Ptr 

func MapInt16Uint32Ptr(f func(*int16) *uint32, list []*int16) []*uint32

MapInt16Uint32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Uint32PtrErr 

func MapInt16Uint32PtrErr(f func(*int16) (*uint32, error), list []*int16) ([]*uint32, error)

MapInt16Uint32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt16Uint64 

func MapInt16Uint64(f func(int16) uint64, list []int16) []uint64

MapInt16Uint64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Uint64Err 

func MapInt16Uint64Err(f func(int16) (uint64, error), list []int16) ([]uint64, error)

MapInt16Uint64Err 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

func MapInt16Uint64Ptr 

func MapInt16Uint64Ptr(f func(*int16) *uint64, list []*int16) []*uint64

MapInt16Uint64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Uint64PtrErr 

func MapInt16Uint64PtrErr(f func(*int16) (*uint64, error), list []*int16) ([]*uint64, error)

MapInt16Uint64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt16Uint8 

func MapInt16Uint8(f func(int16) uint8, list []int16) []uint8

MapInt16Uint8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Uint8Err 

func MapInt16Uint8Err(f func(int16) (uint8, error), list []int16) ([]uint8, error)

MapInt16Uint8Err 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

func MapInt16Uint8Ptr 

func MapInt16Uint8Ptr(f func(*int16) *uint8, list []*int16) []*uint8

MapInt16Uint8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16Uint8PtrErr 

func MapInt16Uint8PtrErr(f func(*int16) (*uint8, error), list []*int16) ([]*uint8, error)

MapInt16Uint8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt16UintErr 

func MapInt16UintErr(f func(int16) (uint, error), list []int16) ([]uint, error)

MapInt16UintErr 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

func MapInt16UintPtr 

func MapInt16UintPtr(f func(*int16) *uint, list []*int16) []*uint

MapInt16UintPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt16UintPtrErr 

func MapInt16UintPtrErr(f func(*int16) (*uint, error), list []*int16) ([]*uint, error)

MapInt16UintPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt32 

func MapInt32(f func(int32) int32, list []int32) []int32

MapInt32 applies the function(1st argument) on each item of the list and returns new list

Takes 2 inputs

  1. Function - takes 1 input
  2. List

Returns 

New List.
Empty list if all arguments are nil or either one is nil

Example: Square each item in the list 

MapInt32(squareInt, []int32{1, 2, 3}) // Returns [1, 4, 9]

func squareInt(num int32) int32 {
	return num * num
}

func MapInt32Bool 

func MapInt32Bool(f func(int32) bool, list []int32) []bool

MapInt32Bool takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32BoolErr 

func MapInt32BoolErr(f func(int32) (bool, error), list []int32) ([]bool, error)

MapInt32BoolErr 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

func MapInt32BoolPtr 

func MapInt32BoolPtr(f func(*int32) *bool, list []*int32) []*bool

MapInt32BoolPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32BoolPtrErr 

func MapInt32BoolPtrErr(f func(*int32) (*bool, error), list []*int32) ([]*bool, error)

MapInt32BoolPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt32Err 

func MapInt32Err(f func(int32) (int32, error), list []int32) ([]int32, error)

MapInt32Err takes 2 arguments:

  1. A function input argument: int32 and return types (int32, error)
  2. A list of type []int32

Returns: 

([]int32, error)

func MapInt32Float32 

func MapInt32Float32(f func(int32) float32, list []int32) []float32

MapInt32Float32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Float32Err 

func MapInt32Float32Err(f func(int32) (float32, error), list []int32) ([]float32, error)

MapInt32Float32Err 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

func MapInt32Float32Ptr 

func MapInt32Float32Ptr(f func(*int32) *float32, list []*int32) []*float32

MapInt32Float32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Float32PtrErr 

func MapInt32Float32PtrErr(f func(*int32) (*float32, error), list []*int32) ([]*float32, error)

MapInt32Float32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt32Float64 

func MapInt32Float64(f func(int32) float64, list []int32) []float64

MapInt32Float64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Float64Err 

func MapInt32Float64Err(f func(int32) (float64, error), list []int32) ([]float64, error)

MapInt32Float64Err 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

func MapInt32Float64Ptr 

func MapInt32Float64Ptr(f func(*int32) *float64, list []*int32) []*float64

MapInt32Float64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Float64PtrErr 

func MapInt32Float64PtrErr(f func(*int32) (*float64, error), list []*int32) ([]*float64, error)

MapInt32Float64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt32Int 

func MapInt32Int(f func(int32) int, list []int32) []int

MapInt32Int takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Int16 

func MapInt32Int16(f func(int32) int16, list []int32) []int16

MapInt32Int16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Int16Err 

func MapInt32Int16Err(f func(int32) (int16, error), list []int32) ([]int16, error)

MapInt32Int16Err 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

func MapInt32Int16Ptr 

func MapInt32Int16Ptr(f func(*int32) *int16, list []*int32) []*int16

MapInt32Int16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Int16PtrErr 

func MapInt32Int16PtrErr(f func(*int32) (*int16, error), list []*int32) ([]*int16, error)

MapInt32Int16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt32Int64 

func MapInt32Int64(f func(int32) int64, list []int32) []int64

MapInt32Int64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Int64Err 

func MapInt32Int64Err(f func(int32) (int64, error), list []int32) ([]int64, error)

MapInt32Int64Err 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

func MapInt32Int64Ptr 

func MapInt32Int64Ptr(f func(*int32) *int64, list []*int32) []*int64

MapInt32Int64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Int64PtrErr 

func MapInt32Int64PtrErr(f func(*int32) (*int64, error), list []*int32) ([]*int64, error)

MapInt32Int64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt32Int8 

func MapInt32Int8(f func(int32) int8, list []int32) []int8

MapInt32Int8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Int8Err 

func MapInt32Int8Err(f func(int32) (int8, error), list []int32) ([]int8, error)

MapInt32Int8Err 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

func MapInt32Int8Ptr 

func MapInt32Int8Ptr(f func(*int32) *int8, list []*int32) []*int8

MapInt32Int8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Int8PtrErr 

func MapInt32Int8PtrErr(f func(*int32) (*int8, error), list []*int32) ([]*int8, error)

MapInt32Int8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt32IntErr 

func MapInt32IntErr(f func(int32) (int, error), list []int32) ([]int, error)

MapInt32IntErr 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

func MapInt32IntPtr 

func MapInt32IntPtr(f func(*int32) *int, list []*int32) []*int

MapInt32IntPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32IntPtrErr 

func MapInt32IntPtrErr(f func(*int32) (*int, error), list []*int32) ([]*int, error)

MapInt32IntPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt32Ptr 

func MapInt32Ptr(f func(*int32) *int32, list []*int32) []*int32

MapInt32Ptr takes 2 arguments.

  1. A function input argument: int32 and return type (int32)
  2. A list of type []*int32

Returns: 

([]*int32)

func MapInt32PtrErr 

func MapInt32PtrErr(f func(*int32) (*int32, error), list []*int32) ([]*int32, error)

MapInt32PtrErr takes 2 arguments:

  1. A function input argument: *int32 and return types (*int32, error)
  2. A list of type []*int32

Returns: 

([]*int32, error)

func MapInt32Str 

func MapInt32Str(f func(int32) string, list []int32) []string

MapInt32Str takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32StrErr 

func MapInt32StrErr(f func(int32) (string, error), list []int32) ([]string, error)

MapInt32StrErr 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

func MapInt32StrPtr 

func MapInt32StrPtr(f func(*int32) *string, list []*int32) []*string

MapInt32StrPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32StrPtrErr 

func MapInt32StrPtrErr(f func(*int32) (*string, error), list []*int32) ([]*string, error)

MapInt32StrPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt32Uint 

func MapInt32Uint(f func(int32) uint, list []int32) []uint

MapInt32Uint takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Uint16 

func MapInt32Uint16(f func(int32) uint16, list []int32) []uint16

MapInt32Uint16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Uint16Err 

func MapInt32Uint16Err(f func(int32) (uint16, error), list []int32) ([]uint16, error)

MapInt32Uint16Err 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

func MapInt32Uint16Ptr 

func MapInt32Uint16Ptr(f func(*int32) *uint16, list []*int32) []*uint16

MapInt32Uint16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Uint16PtrErr 

func MapInt32Uint16PtrErr(f func(*int32) (*uint16, error), list []*int32) ([]*uint16, error)

MapInt32Uint16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt32Uint32 

func MapInt32Uint32(f func(int32) uint32, list []int32) []uint32

MapInt32Uint32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Uint32Err 

func MapInt32Uint32Err(f func(int32) (uint32, error), list []int32) ([]uint32, error)

MapInt32Uint32Err 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

func MapInt32Uint32Ptr 

func MapInt32Uint32Ptr(f func(*int32) *uint32, list []*int32) []*uint32

MapInt32Uint32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Uint32PtrErr 

func MapInt32Uint32PtrErr(f func(*int32) (*uint32, error), list []*int32) ([]*uint32, error)

MapInt32Uint32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt32Uint64 

func MapInt32Uint64(f func(int32) uint64, list []int32) []uint64

MapInt32Uint64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Uint64Err 

func MapInt32Uint64Err(f func(int32) (uint64, error), list []int32) ([]uint64, error)

MapInt32Uint64Err 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

func MapInt32Uint64Ptr 

func MapInt32Uint64Ptr(f func(*int32) *uint64, list []*int32) []*uint64

MapInt32Uint64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Uint64PtrErr 

func MapInt32Uint64PtrErr(f func(*int32) (*uint64, error), list []*int32) ([]*uint64, error)

MapInt32Uint64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt32Uint8 

func MapInt32Uint8(f func(int32) uint8, list []int32) []uint8

MapInt32Uint8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Uint8Err 

func MapInt32Uint8Err(f func(int32) (uint8, error), list []int32) ([]uint8, error)

MapInt32Uint8Err 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

func MapInt32Uint8Ptr 

func MapInt32Uint8Ptr(f func(*int32) *uint8, list []*int32) []*uint8

MapInt32Uint8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32Uint8PtrErr 

func MapInt32Uint8PtrErr(f func(*int32) (*uint8, error), list []*int32) ([]*uint8, error)

MapInt32Uint8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt32UintErr 

func MapInt32UintErr(f func(int32) (uint, error), list []int32) ([]uint, error)

MapInt32UintErr 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

func MapInt32UintPtr 

func MapInt32UintPtr(f func(*int32) *uint, list []*int32) []*uint

MapInt32UintPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt32UintPtrErr 

func MapInt32UintPtrErr(f func(*int32) (*uint, error), list []*int32) ([]*uint, error)

MapInt32UintPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt64 

func MapInt64(f func(int64) int64, list []int64) []int64

MapInt64 applies the function(1st argument) on each item of the list and returns new list

Takes 2 inputs

  1. Function - takes 1 input
  2. List

Returns 

New List.
Empty list if all arguments are nil or either one is nil

Example: Square each item in the list 

MapInt64(squareInt, []int64{1, 2, 3}) // Returns [1, 4, 9]

func squareInt(num int64) int64 {
	return num * num
}

func MapInt64Bool 

func MapInt64Bool(f func(int64) bool, list []int64) []bool

MapInt64Bool takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64BoolErr 

func MapInt64BoolErr(f func(int64) (bool, error), list []int64) ([]bool, error)

MapInt64BoolErr 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

func MapInt64BoolPtr 

func MapInt64BoolPtr(f func(*int64) *bool, list []*int64) []*bool

MapInt64BoolPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64BoolPtrErr 

func MapInt64BoolPtrErr(f func(*int64) (*bool, error), list []*int64) ([]*bool, error)

MapInt64BoolPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt64Err 

func MapInt64Err(f func(int64) (int64, error), list []int64) ([]int64, error)

MapInt64Err takes 2 arguments:

  1. A function input argument: int64 and return types (int64, error)
  2. A list of type []int64

Returns: 

([]int64, error)

func MapInt64Float32 

func MapInt64Float32(f func(int64) float32, list []int64) []float32

MapInt64Float32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Float32Err 

func MapInt64Float32Err(f func(int64) (float32, error), list []int64) ([]float32, error)

MapInt64Float32Err 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

func MapInt64Float32Ptr 

func MapInt64Float32Ptr(f func(*int64) *float32, list []*int64) []*float32

MapInt64Float32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Float32PtrErr 

func MapInt64Float32PtrErr(f func(*int64) (*float32, error), list []*int64) ([]*float32, error)

MapInt64Float32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt64Float64 

func MapInt64Float64(f func(int64) float64, list []int64) []float64

MapInt64Float64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Float64Err 

func MapInt64Float64Err(f func(int64) (float64, error), list []int64) ([]float64, error)

MapInt64Float64Err 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

func MapInt64Float64Ptr 

func MapInt64Float64Ptr(f func(*int64) *float64, list []*int64) []*float64

MapInt64Float64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Float64PtrErr 

func MapInt64Float64PtrErr(f func(*int64) (*float64, error), list []*int64) ([]*float64, error)

MapInt64Float64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt64Int 

func MapInt64Int(f func(int64) int, list []int64) []int

MapInt64Int takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Int16 

func MapInt64Int16(f func(int64) int16, list []int64) []int16

MapInt64Int16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Int16Err 

func MapInt64Int16Err(f func(int64) (int16, error), list []int64) ([]int16, error)

MapInt64Int16Err 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

func MapInt64Int16Ptr 

func MapInt64Int16Ptr(f func(*int64) *int16, list []*int64) []*int16

MapInt64Int16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Int16PtrErr 

func MapInt64Int16PtrErr(f func(*int64) (*int16, error), list []*int64) ([]*int16, error)

MapInt64Int16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt64Int32 

func MapInt64Int32(f func(int64) int32, list []int64) []int32

MapInt64Int32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Int32Err 

func MapInt64Int32Err(f func(int64) (int32, error), list []int64) ([]int32, error)

MapInt64Int32Err 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

func MapInt64Int32Ptr 

func MapInt64Int32Ptr(f func(*int64) *int32, list []*int64) []*int32

MapInt64Int32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Int32PtrErr 

func MapInt64Int32PtrErr(f func(*int64) (*int32, error), list []*int64) ([]*int32, error)

MapInt64Int32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt64Int8 

func MapInt64Int8(f func(int64) int8, list []int64) []int8

MapInt64Int8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Int8Err 

func MapInt64Int8Err(f func(int64) (int8, error), list []int64) ([]int8, error)

MapInt64Int8Err 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

func MapInt64Int8Ptr 

func MapInt64Int8Ptr(f func(*int64) *int8, list []*int64) []*int8

MapInt64Int8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Int8PtrErr 

func MapInt64Int8PtrErr(f func(*int64) (*int8, error), list []*int64) ([]*int8, error)

MapInt64Int8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt64IntErr 

func MapInt64IntErr(f func(int64) (int, error), list []int64) ([]int, error)

MapInt64IntErr 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

func MapInt64IntPtr 

func MapInt64IntPtr(f func(*int64) *int, list []*int64) []*int

MapInt64IntPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64IntPtrErr 

func MapInt64IntPtrErr(f func(*int64) (*int, error), list []*int64) ([]*int, error)

MapInt64IntPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt64Ptr 

func MapInt64Ptr(f func(*int64) *int64, list []*int64) []*int64

MapInt64Ptr takes 2 arguments.

  1. A function input argument: int64 and return type (int64)
  2. A list of type []*int64

Returns: 

([]*int64)

func MapInt64PtrErr 

func MapInt64PtrErr(f func(*int64) (*int64, error), list []*int64) ([]*int64, error)

MapInt64PtrErr takes 2 arguments:

  1. A function input argument: *int64 and return types (*int64, error)
  2. A list of type []*int64

Returns: 

([]*int64, error)

func MapInt64Str 

func MapInt64Str(f func(int64) string, list []int64) []string

MapInt64Str takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64StrErr 

func MapInt64StrErr(f func(int64) (string, error), list []int64) ([]string, error)

MapInt64StrErr 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

func MapInt64StrPtr 

func MapInt64StrPtr(f func(*int64) *string, list []*int64) []*string

MapInt64StrPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64StrPtrErr 

func MapInt64StrPtrErr(f func(*int64) (*string, error), list []*int64) ([]*string, error)

MapInt64StrPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt64Uint 

func MapInt64Uint(f func(int64) uint, list []int64) []uint

MapInt64Uint takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Uint16 

func MapInt64Uint16(f func(int64) uint16, list []int64) []uint16

MapInt64Uint16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Uint16Err 

func MapInt64Uint16Err(f func(int64) (uint16, error), list []int64) ([]uint16, error)

MapInt64Uint16Err 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

func MapInt64Uint16Ptr 

func MapInt64Uint16Ptr(f func(*int64) *uint16, list []*int64) []*uint16

MapInt64Uint16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Uint16PtrErr 

func MapInt64Uint16PtrErr(f func(*int64) (*uint16, error), list []*int64) ([]*uint16, error)

MapInt64Uint16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt64Uint32 

func MapInt64Uint32(f func(int64) uint32, list []int64) []uint32

MapInt64Uint32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Uint32Err 

func MapInt64Uint32Err(f func(int64) (uint32, error), list []int64) ([]uint32, error)

MapInt64Uint32Err 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

func MapInt64Uint32Ptr 

func MapInt64Uint32Ptr(f func(*int64) *uint32, list []*int64) []*uint32

MapInt64Uint32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Uint32PtrErr 

func MapInt64Uint32PtrErr(f func(*int64) (*uint32, error), list []*int64) ([]*uint32, error)

MapInt64Uint32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt64Uint64 

func MapInt64Uint64(f func(int64) uint64, list []int64) []uint64

MapInt64Uint64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Uint64Err 

func MapInt64Uint64Err(f func(int64) (uint64, error), list []int64) ([]uint64, error)

MapInt64Uint64Err 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

func MapInt64Uint64Ptr 

func MapInt64Uint64Ptr(f func(*int64) *uint64, list []*int64) []*uint64

MapInt64Uint64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Uint64PtrErr 

func MapInt64Uint64PtrErr(f func(*int64) (*uint64, error), list []*int64) ([]*uint64, error)

MapInt64Uint64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt64Uint8 

func MapInt64Uint8(f func(int64) uint8, list []int64) []uint8

MapInt64Uint8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Uint8Err 

func MapInt64Uint8Err(f func(int64) (uint8, error), list []int64) ([]uint8, error)

MapInt64Uint8Err 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

func MapInt64Uint8Ptr 

func MapInt64Uint8Ptr(f func(*int64) *uint8, list []*int64) []*uint8

MapInt64Uint8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64Uint8PtrErr 

func MapInt64Uint8PtrErr(f func(*int64) (*uint8, error), list []*int64) ([]*uint8, error)

MapInt64Uint8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt64UintErr 

func MapInt64UintErr(f func(int64) (uint, error), list []int64) ([]uint, error)

MapInt64UintErr 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

func MapInt64UintPtr 

func MapInt64UintPtr(f func(*int64) *uint, list []*int64) []*uint

MapInt64UintPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt64UintPtrErr 

func MapInt64UintPtrErr(f func(*int64) (*uint, error), list []*int64) ([]*uint, error)

MapInt64UintPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt8 

func MapInt8(f func(int8) int8, list []int8) []int8

MapInt8 applies the function(1st argument) on each item of the list and returns new list

Takes 2 inputs

  1. Function - takes 1 input
  2. List

Returns 

New List.
Empty list if all arguments are nil or either one is nil

Example: Square each item in the list 

MapInt8(squareInt, []int8{1, 2, 3}) // Returns [1, 4, 9]

func squareInt(num int8) int8 {
	return num * num
}

func MapInt8Bool 

func MapInt8Bool(f func(int8) bool, list []int8) []bool

MapInt8Bool takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8BoolErr 

func MapInt8BoolErr(f func(int8) (bool, error), list []int8) ([]bool, error)

MapInt8BoolErr 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

func MapInt8BoolPtr 

func MapInt8BoolPtr(f func(*int8) *bool, list []*int8) []*bool

MapInt8BoolPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8BoolPtrErr 

func MapInt8BoolPtrErr(f func(*int8) (*bool, error), list []*int8) ([]*bool, error)

MapInt8BoolPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt8Err 

func MapInt8Err(f func(int8) (int8, error), list []int8) ([]int8, error)

MapInt8Err takes 2 arguments:

  1. A function input argument: int8 and return types (int8, error)
  2. A list of type []int8

Returns: 

([]int8, error)

func MapInt8Float32 

func MapInt8Float32(f func(int8) float32, list []int8) []float32

MapInt8Float32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Float32Err 

func MapInt8Float32Err(f func(int8) (float32, error), list []int8) ([]float32, error)

MapInt8Float32Err 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

func MapInt8Float32Ptr 

func MapInt8Float32Ptr(f func(*int8) *float32, list []*int8) []*float32

MapInt8Float32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Float32PtrErr 

func MapInt8Float32PtrErr(f func(*int8) (*float32, error), list []*int8) ([]*float32, error)

MapInt8Float32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt8Float64 

func MapInt8Float64(f func(int8) float64, list []int8) []float64

MapInt8Float64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Float64Err 

func MapInt8Float64Err(f func(int8) (float64, error), list []int8) ([]float64, error)

MapInt8Float64Err 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

func MapInt8Float64Ptr 

func MapInt8Float64Ptr(f func(*int8) *float64, list []*int8) []*float64

MapInt8Float64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Float64PtrErr 

func MapInt8Float64PtrErr(f func(*int8) (*float64, error), list []*int8) ([]*float64, error)

MapInt8Float64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt8Int 

func MapInt8Int(f func(int8) int, list []int8) []int

MapInt8Int takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Int16 

func MapInt8Int16(f func(int8) int16, list []int8) []int16

MapInt8Int16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Int16Err 

func MapInt8Int16Err(f func(int8) (int16, error), list []int8) ([]int16, error)

MapInt8Int16Err 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

func MapInt8Int16Ptr 

func MapInt8Int16Ptr(f func(*int8) *int16, list []*int8) []*int16

MapInt8Int16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Int16PtrErr 

func MapInt8Int16PtrErr(f func(*int8) (*int16, error), list []*int8) ([]*int16, error)

MapInt8Int16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt8Int32 

func MapInt8Int32(f func(int8) int32, list []int8) []int32

MapInt8Int32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Int32Err 

func MapInt8Int32Err(f func(int8) (int32, error), list []int8) ([]int32, error)

MapInt8Int32Err 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

func MapInt8Int32Ptr 

func MapInt8Int32Ptr(f func(*int8) *int32, list []*int8) []*int32

MapInt8Int32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Int32PtrErr 

func MapInt8Int32PtrErr(f func(*int8) (*int32, error), list []*int8) ([]*int32, error)

MapInt8Int32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt8Int64 

func MapInt8Int64(f func(int8) int64, list []int8) []int64

MapInt8Int64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Int64Err 

func MapInt8Int64Err(f func(int8) (int64, error), list []int8) ([]int64, error)

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

func MapInt8Int64Ptr 

func MapInt8Int64Ptr(f func(*int8) *int64, list []*int8) []*int64

MapInt8Int64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Int64PtrErr 

func MapInt8Int64PtrErr(f func(*int8) (*int64, error), list []*int8) ([]*int64, error)

MapInt8Int64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt8IntErr 

func MapInt8IntErr(f func(int8) (int, error), list []int8) ([]int, error)

MapInt8IntErr 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

func MapInt8IntPtr 

func MapInt8IntPtr(f func(*int8) *int, list []*int8) []*int

MapInt8IntPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8IntPtrErr 

func MapInt8IntPtrErr(f func(*int8) (*int, error), list []*int8) ([]*int, error)

MapInt8IntPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt8Ptr 

func MapInt8Ptr(f func(*int8) *int8, list []*int8) []*int8

MapInt8Ptr takes 2 arguments.

  1. A function input argument: int8 and return type (int8)
  2. A list of type []*int8

Returns: 

([]*int8)

func MapInt8PtrErr 

func MapInt8PtrErr(f func(*int8) (*int8, error), list []*int8) ([]*int8, error)

MapInt8PtrErr takes 2 arguments:

  1. A function input argument: *int8 and return types (*int8, error)
  2. A list of type []*int8

Returns: 

([]*int8, error)

func MapInt8Str 

func MapInt8Str(f func(int8) string, list []int8) []string

MapInt8Str takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8StrErr 

func MapInt8StrErr(f func(int8) (string, error), list []int8) ([]string, error)

MapInt8StrErr 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

func MapInt8StrPtr 

func MapInt8StrPtr(f func(*int8) *string, list []*int8) []*string

MapInt8StrPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8StrPtrErr 

func MapInt8StrPtrErr(f func(*int8) (*string, error), list []*int8) ([]*string, error)

MapInt8StrPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt8Uint 

func MapInt8Uint(f func(int8) uint, list []int8) []uint

MapInt8Uint takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Uint16 

func MapInt8Uint16(f func(int8) uint16, list []int8) []uint16

MapInt8Uint16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Uint16Err 

func MapInt8Uint16Err(f func(int8) (uint16, error), list []int8) ([]uint16, error)

MapInt8Uint16Err 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

func MapInt8Uint16Ptr 

func MapInt8Uint16Ptr(f func(*int8) *uint16, list []*int8) []*uint16

MapInt8Uint16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Uint16PtrErr 

func MapInt8Uint16PtrErr(f func(*int8) (*uint16, error), list []*int8) ([]*uint16, error)

MapInt8Uint16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt8Uint32 

func MapInt8Uint32(f func(int8) uint32, list []int8) []uint32

MapInt8Uint32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Uint32Err 

func MapInt8Uint32Err(f func(int8) (uint32, error), list []int8) ([]uint32, error)

MapInt8Uint32Err 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

func MapInt8Uint32Ptr 

func MapInt8Uint32Ptr(f func(*int8) *uint32, list []*int8) []*uint32

MapInt8Uint32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Uint32PtrErr 

func MapInt8Uint32PtrErr(f func(*int8) (*uint32, error), list []*int8) ([]*uint32, error)

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

func MapInt8Uint64 

func MapInt8Uint64(f func(int8) uint64, list []int8) []uint64

MapInt8Uint64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Uint64Err 

func MapInt8Uint64Err(f func(int8) (uint64, error), list []int8) ([]uint64, error)

MapInt8Uint64Err 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

func MapInt8Uint64Ptr 

func MapInt8Uint64Ptr(f func(*int8) *uint64, list []*int8) []*uint64

MapInt8Uint64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Uint64PtrErr 

func MapInt8Uint64PtrErr(f func(*int8) (*uint64, error), list []*int8) ([]*uint64, error)

MapInt8Uint64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt8Uint8 

func MapInt8Uint8(f func(int8) uint8, list []int8) []uint8

MapInt8Uint8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Uint8Err 

func MapInt8Uint8Err(f func(int8) (uint8, error), list []int8) ([]uint8, error)

MapInt8Uint8Err 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

func MapInt8Uint8Ptr 

func MapInt8Uint8Ptr(f func(*int8) *uint8, list []*int8) []*uint8

MapInt8Uint8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8Uint8PtrErr 

func MapInt8Uint8PtrErr(f func(*int8) (*uint8, error), list []*int8) ([]*uint8, error)

MapInt8Uint8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapInt8UintErr 

func MapInt8UintErr(f func(int8) (uint, error), list []int8) ([]uint, error)

MapInt8UintErr 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

func MapInt8UintPtr 

func MapInt8UintPtr(f func(*int8) *uint, list []*int8) []*uint

MapInt8UintPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapInt8UintPtrErr 

func MapInt8UintPtrErr(f func(*int8) (*uint, error), list []*int8) ([]*uint, error)

MapInt8UintPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapIntBool 

func MapIntBool(f func(int) bool, list []int) []bool

MapIntBool takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntBoolErr 

func MapIntBoolErr(f func(int) (bool, error), list []int) ([]bool, error)

MapIntBoolErr 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

func MapIntBoolPtr 

func MapIntBoolPtr(f func(*int) *bool, list []*int) []*bool

MapIntBoolPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntBoolPtrErr 

func MapIntBoolPtrErr(f func(*int) (*bool, error), list []*int) ([]*bool, error)

MapIntBoolPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapIntErr 

func MapIntErr(f func(int) (int, error), list []int) ([]int, error)

MapIntErr takes 2 arguments:

  1. A function input argument: int and return types (int, error)
  2. A list of type []int

Returns: 

([]int, error)

func MapIntFloat32 

func MapIntFloat32(f func(int) float32, list []int) []float32

MapIntFloat32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntFloat32Err 

func MapIntFloat32Err(f func(int) (float32, error), list []int) ([]float32, error)

MapIntFloat32Err 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

func MapIntFloat32Ptr 

func MapIntFloat32Ptr(f func(*int) *float32, list []*int) []*float32

MapIntFloat32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntFloat32PtrErr 

func MapIntFloat32PtrErr(f func(*int) (*float32, error), list []*int) ([]*float32, error)

MapIntFloat32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapIntFloat64 

func MapIntFloat64(f func(int) float64, list []int) []float64

MapIntFloat64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntFloat64Err 

func MapIntFloat64Err(f func(int) (float64, error), list []int) ([]float64, error)

MapIntFloat64Err 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

func MapIntFloat64Ptr 

func MapIntFloat64Ptr(f func(*int) *float64, list []*int) []*float64

MapIntFloat64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntFloat64PtrErr 

func MapIntFloat64PtrErr(f func(*int) (*float64, error), list []*int) ([]*float64, error)

MapIntFloat64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapIntInt16 

func MapIntInt16(f func(int) int16, list []int) []int16

MapIntInt16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntInt16Err 

func MapIntInt16Err(f func(int) (int16, error), list []int) ([]int16, error)

MapIntInt16Err 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

func MapIntInt16Ptr 

func MapIntInt16Ptr(f func(*int) *int16, list []*int) []*int16

MapIntInt16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntInt16PtrErr 

func MapIntInt16PtrErr(f func(*int) (*int16, error), list []*int) ([]*int16, error)

MapIntInt16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapIntInt32 

func MapIntInt32(f func(int) int32, list []int) []int32

MapIntInt32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntInt32Err 

func MapIntInt32Err(f func(int) (int32, error), list []int) ([]int32, error)

MapIntInt32Err 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

func MapIntInt32Ptr 

func MapIntInt32Ptr(f func(*int) *int32, list []*int) []*int32

MapIntInt32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntInt32PtrErr 

func MapIntInt32PtrErr(f func(*int) (*int32, error), list []*int) ([]*int32, error)

MapIntInt32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapIntInt64 

func MapIntInt64(f func(int) int64, list []int) []int64

MapIntInt64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntInt64Err 

func MapIntInt64Err(f func(int) (int64, error), list []int) ([]int64, error)

MapIntInt64Err 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

func MapIntInt64Ptr 

func MapIntInt64Ptr(f func(*int) *int64, list []*int) []*int64

MapIntInt64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntInt64PtrErr 

func MapIntInt64PtrErr(f func(*int) (*int64, error), list []*int) ([]*int64, error)

MapIntInt64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapIntInt8 

func MapIntInt8(f func(int) int8, list []int) []int8

MapIntInt8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntInt8Err 

func MapIntInt8Err(f func(int) (int8, error), list []int) ([]int8, error)

MapIntInt8Err 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

func MapIntInt8Ptr 

func MapIntInt8Ptr(f func(*int) *int8, list []*int) []*int8

MapIntInt8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntInt8PtrErr 

func MapIntInt8PtrErr(f func(*int) (*int8, error), list []*int) ([]*int8, error)

MapIntInt8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapIntPtr 

func MapIntPtr(f func(*int) *int, list []*int) []*int

MapIntPtr takes 2 arguments.

  1. A function input argument: int and return type (int)
  2. A list of type []*int

Returns: 

([]*int)

func MapIntPtrErr 

func MapIntPtrErr(f func(*int) (*int, error), list []*int) ([]*int, error)

MapIntPtrErr takes 2 arguments:

  1. A function input argument: *int and return types (*int, error)
  2. A list of type []*int

Returns: 

([]*int, error)

func MapIntStr 

func MapIntStr(f func(int) string, list []int) []string

MapIntStr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntStrErr 

func MapIntStrErr(f func(int) (string, error), list []int) ([]string, error)

MapIntStrErr 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

func MapIntStrPtr 

func MapIntStrPtr(f func(*int) *string, list []*int) []*string

MapIntStrPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntStrPtrErr 

func MapIntStrPtrErr(f func(*int) (*string, error), list []*int) ([]*string, error)

MapIntStrPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapIntUint 

func MapIntUint(f func(int) uint, list []int) []uint

MapIntUint takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntUint16 

func MapIntUint16(f func(int) uint16, list []int) []uint16

MapIntUint16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntUint16Err 

func MapIntUint16Err(f func(int) (uint16, error), list []int) ([]uint16, error)

MapIntUint16Err 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

func MapIntUint16Ptr 

func MapIntUint16Ptr(f func(*int) *uint16, list []*int) []*uint16

MapIntUint16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntUint16PtrErr 

func MapIntUint16PtrErr(f func(*int) (*uint16, error), list []*int) ([]*uint16, error)

MapIntUint16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapIntUint32 

func MapIntUint32(f func(int) uint32, list []int) []uint32

MapIntUint32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntUint32Err 

func MapIntUint32Err(f func(int) (uint32, error), list []int) ([]uint32, error)

MapIntUint32Err 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

func MapIntUint32Ptr 

func MapIntUint32Ptr(f func(*int) *uint32, list []*int) []*uint32

MapIntUint32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntUint32PtrErr 

func MapIntUint32PtrErr(f func(*int) (*uint32, error), list []*int) ([]*uint32, error)

MapIntUint32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapIntUint64 

func MapIntUint64(f func(int) uint64, list []int) []uint64

MapIntUint64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntUint64Err 

func MapIntUint64Err(f func(int) (uint64, error), list []int) ([]uint64, error)

MapIntUint64Err 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

func MapIntUint64Ptr 

func MapIntUint64Ptr(f func(*int) *uint64, list []*int) []*uint64

MapIntUint64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntUint64PtrErr 

func MapIntUint64PtrErr(f func(*int) (*uint64, error), list []*int) ([]*uint64, error)

MapIntUint64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapIntUint8 

func MapIntUint8(f func(int) uint8, list []int) []uint8

MapIntUint8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntUint8Err 

func MapIntUint8Err(f func(int) (uint8, error), list []int) ([]uint8, error)

MapIntUint8Err 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

func MapIntUint8Ptr 

func MapIntUint8Ptr(f func(*int) *uint8, list []*int) []*uint8

MapIntUint8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntUint8PtrErr 

func MapIntUint8PtrErr(f func(*int) (*uint8, error), list []*int) ([]*uint8, error)

MapIntUint8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapIntUintErr 

func MapIntUintErr(f func(int) (uint, error), list []int) ([]uint, error)

MapIntUintErr 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

func MapIntUintPtr 

func MapIntUintPtr(f func(*int) *uint, list []*int) []*uint

MapIntUintPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapIntUintPtrErr 

func MapIntUintPtrErr(f func(*int) (*uint, error), list []*int) ([]*uint, error)

MapIntUintPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapStr 

func MapStr(f func(string) string, list []string) []string

MapStr applies the function(1st argument) on each item of the list and returns new list

Takes 2 inputs

  1. Function - takes 1 input
  2. List

Returns 

New List.
Empty list if all arguments are nil or either one is nil

Example: change case to upper for each item in the list 

MapStr(strings.ToUpper, []string{"govinda", "gopal", "shyam"}) // Returns ["GOVINDA", "GOPAL", "SHYAM"]

func MapStrBool 

func MapStrBool(f func(string) bool, list []string) []bool

MapStrBool takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrBoolErr 

func MapStrBoolErr(f func(string) (bool, error), list []string) ([]bool, error)

MapStrBoolErr 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

func MapStrBoolPtr 

func MapStrBoolPtr(f func(*string) *bool, list []*string) []*bool

MapStrBoolPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrBoolPtrErr 

func MapStrBoolPtrErr(f func(*string) (*bool, error), list []*string) ([]*bool, error)

MapStrBoolPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapStrErr 

func MapStrErr(f func(string) (string, error), list []string) ([]string, error)

MapStrErr takes 2 arguments:

  1. A function input argument: string and return types (string, error)
  2. A list of type []string

Returns: 

([]string, error)

func MapStrFloat32 

func MapStrFloat32(f func(string) float32, list []string) []float32

MapStrFloat32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrFloat32Err 

func MapStrFloat32Err(f func(string) (float32, error), list []string) ([]float32, error)

MapStrFloat32Err 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

func MapStrFloat32Ptr 

func MapStrFloat32Ptr(f func(*string) *float32, list []*string) []*float32

MapStrFloat32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrFloat32PtrErr 

func MapStrFloat32PtrErr(f func(*string) (*float32, error), list []*string) ([]*float32, error)

MapStrFloat32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapStrFloat64 

func MapStrFloat64(f func(string) float64, list []string) []float64

MapStrFloat64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrFloat64Err 

func MapStrFloat64Err(f func(string) (float64, error), list []string) ([]float64, error)

MapStrFloat64Err 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

func MapStrFloat64Ptr 

func MapStrFloat64Ptr(f func(*string) *float64, list []*string) []*float64

MapStrFloat64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrFloat64PtrErr 

func MapStrFloat64PtrErr(f func(*string) (*float64, error), list []*string) ([]*float64, error)

MapStrFloat64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapStrInt 

func MapStrInt(f func(string) int, list []string) []int

MapStrInt takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrInt16 

func MapStrInt16(f func(string) int16, list []string) []int16

MapStrInt16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrInt16Err 

func MapStrInt16Err(f func(string) (int16, error), list []string) ([]int16, error)

MapStrInt16Err 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

func MapStrInt16Ptr 

func MapStrInt16Ptr(f func(*string) *int16, list []*string) []*int16

MapStrInt16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrInt16PtrErr 

func MapStrInt16PtrErr(f func(*string) (*int16, error), list []*string) ([]*int16, error)

MapStrInt16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapStrInt32 

func MapStrInt32(f func(string) int32, list []string) []int32

MapStrInt32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrInt32Err 

func MapStrInt32Err(f func(string) (int32, error), list []string) ([]int32, error)

MapStrInt32Err 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

func MapStrInt32Ptr 

func MapStrInt32Ptr(f func(*string) *int32, list []*string) []*int32

MapStrInt32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrInt32PtrErr 

func MapStrInt32PtrErr(f func(*string) (*int32, error), list []*string) ([]*int32, error)

MapStrInt32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapStrInt64 

func MapStrInt64(f func(string) int64, list []string) []int64

MapStrInt64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrInt64Err 

func MapStrInt64Err(f func(string) (int64, error), list []string) ([]int64, error)

MapStrInt64Err 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

func MapStrInt64Ptr 

func MapStrInt64Ptr(f func(*string) *int64, list []*string) []*int64

MapStrInt64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrInt64PtrErr 

func MapStrInt64PtrErr(f func(*string) (*int64, error), list []*string) ([]*int64, error)

MapStrInt64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapStrInt8 

func MapStrInt8(f func(string) int8, list []string) []int8

MapStrInt8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrInt8Err 

func MapStrInt8Err(f func(string) (int8, error), list []string) ([]int8, error)

MapStrInt8Err 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

func MapStrInt8Ptr 

func MapStrInt8Ptr(f func(*string) *int8, list []*string) []*int8

MapStrInt8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrInt8PtrErr 

func MapStrInt8PtrErr(f func(*string) (*int8, error), list []*string) ([]*int8, error)

MapStrInt8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapStrIntErr 

func MapStrIntErr(f func(string) (int, error), list []string) ([]int, error)

MapStrIntErr 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

func MapStrIntPtr 

func MapStrIntPtr(f func(*string) *int, list []*string) []*int

MapStrIntPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrIntPtrErr 

func MapStrIntPtrErr(f func(*string) (*int, error), list []*string) ([]*int, error)

MapStrIntPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapStrPtr 

func MapStrPtr(f func(*string) *string, list []*string) []*string

MapStrPtr takes 2 arguments.

  1. A function input argument: string and return type (string)
  2. A list of type []*string

Returns: 

([]*string)

func MapStrPtrErr 

func MapStrPtrErr(f func(*string) (*string, error), list []*string) ([]*string, error)

MapStrPtrErr takes 2 arguments:

  1. A function input argument: *string and return types (*string, error)
  2. A list of type []*string

Returns: 

([]*string, error)

func MapStrUint 

func MapStrUint(f func(string) uint, list []string) []uint

MapStrUint takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrUint16 

func MapStrUint16(f func(string) uint16, list []string) []uint16

MapStrUint16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrUint16Err 

func MapStrUint16Err(f func(string) (uint16, error), list []string) ([]uint16, error)

MapStrUint16Err 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

func MapStrUint16Ptr 

func MapStrUint16Ptr(f func(*string) *uint16, list []*string) []*uint16

MapStrUint16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrUint16PtrErr 

func MapStrUint16PtrErr(f func(*string) (*uint16, error), list []*string) ([]*uint16, error)

MapStrUint16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapStrUint32 

func MapStrUint32(f func(string) uint32, list []string) []uint32

MapStrUint32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrUint32Err 

func MapStrUint32Err(f func(string) (uint32, error), list []string) ([]uint32, error)

MapStrUint32Err 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

func MapStrUint32Ptr 

func MapStrUint32Ptr(f func(*string) *uint32, list []*string) []*uint32

MapStrUint32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrUint32PtrErr 

func MapStrUint32PtrErr(f func(*string) (*uint32, error), list []*string) ([]*uint32, error)

MapStrUint32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapStrUint64 

func MapStrUint64(f func(string) uint64, list []string) []uint64

MapStrUint64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrUint64Err 

func MapStrUint64Err(f func(string) (uint64, error), list []string) ([]uint64, error)

MapStrUint64Err 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

func MapStrUint64Ptr 

func MapStrUint64Ptr(f func(*string) *uint64, list []*string) []*uint64

MapStrUint64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrUint64PtrErr 

func MapStrUint64PtrErr(f func(*string) (*uint64, error), list []*string) ([]*uint64, error)

MapStrUint64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapStrUint8 

func MapStrUint8(f func(string) uint8, list []string) []uint8

MapStrUint8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrUint8Err 

func MapStrUint8Err(f func(string) (uint8, error), list []string) ([]uint8, error)

MapStrUint8Err 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

func MapStrUint8Ptr 

func MapStrUint8Ptr(f func(*string) *uint8, list []*string) []*uint8

MapStrUint8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrUint8PtrErr 

func MapStrUint8PtrErr(f func(*string) (*uint8, error), list []*string) ([]*uint8, error)

MapStrUint8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapStrUintErr 

func MapStrUintErr(f func(string) (uint, error), list []string) ([]uint, error)

MapStrUintErr 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

func MapStrUintPtr 

func MapStrUintPtr(f func(*string) *uint, list []*string) []*uint

MapStrUintPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapStrUintPtrErr 

func MapStrUintPtrErr(f func(*string) (*uint, error), list []*string) ([]*uint, error)

MapStrUintPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint 

func MapUint(f func(uint) uint, list []uint) []uint

MapUint applies the function(1st argument) on each item of the list and returns new list

Takes 2 inputs

  1. Function - takes 1 input
  2. List

Returns 

New List.
Empty list if all arguments are nil or either one is nil

Example: Square each item in the list 

MapUint(squareInt, []uint{1, 2, 3}) // Returns [1, 4, 9]

func squareInt(num uint) uint {
	return num * num
}

func MapUint16 

func MapUint16(f func(uint16) uint16, list []uint16) []uint16

MapUint16 applies the function(1st argument) on each item of the list and returns new list

Takes 2 inputs

  1. Function - takes 1 input
  2. List

Returns 

New List.
Empty list if all arguments are nil or either one is nil

Example: Square each item in the list 

MapUint16(squareInt, []uint16{1, 2, 3}) // Returns [1, 4, 9]

func squareInt(num uint16) uint16 {
	return num * num
}

func MapUint16Bool 

func MapUint16Bool(f func(uint16) bool, list []uint16) []bool

MapUint16Bool takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16BoolErr 

func MapUint16BoolErr(f func(uint16) (bool, error), list []uint16) ([]bool, error)

MapUint16BoolErr 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

func MapUint16BoolPtr 

func MapUint16BoolPtr(f func(*uint16) *bool, list []*uint16) []*bool

MapUint16BoolPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16BoolPtrErr 

func MapUint16BoolPtrErr(f func(*uint16) (*bool, error), list []*uint16) ([]*bool, error)

MapUint16BoolPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint16Err 

func MapUint16Err(f func(uint16) (uint16, error), list []uint16) ([]uint16, error)

MapUint16Err takes 2 arguments:

  1. A function input argument: uint16 and return types (uint16, error)
  2. A list of type []uint16

Returns: 

([]uint16, error)

func MapUint16Float32 

func MapUint16Float32(f func(uint16) float32, list []uint16) []float32

MapUint16Float32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Float32Err 

func MapUint16Float32Err(f func(uint16) (float32, error), list []uint16) ([]float32, error)

MapUint16Float32Err 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

func MapUint16Float32Ptr 

func MapUint16Float32Ptr(f func(*uint16) *float32, list []*uint16) []*float32

MapUint16Float32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Float32PtrErr 

func MapUint16Float32PtrErr(f func(*uint16) (*float32, error), list []*uint16) ([]*float32, error)

MapUint16Float32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint16Float64 

func MapUint16Float64(f func(uint16) float64, list []uint16) []float64

MapUint16Float64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Float64Err 

func MapUint16Float64Err(f func(uint16) (float64, error), list []uint16) ([]float64, error)

MapUint16Float64Err 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

func MapUint16Float64Ptr 

func MapUint16Float64Ptr(f func(*uint16) *float64, list []*uint16) []*float64

MapUint16Float64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Float64PtrErr 

func MapUint16Float64PtrErr(f func(*uint16) (*float64, error), list []*uint16) ([]*float64, error)

MapUint16Float64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint16Int 

func MapUint16Int(f func(uint16) int, list []uint16) []int

MapUint16Int takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Int16 

func MapUint16Int16(f func(uint16) int16, list []uint16) []int16

MapUint16Int16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Int16Err 

func MapUint16Int16Err(f func(uint16) (int16, error), list []uint16) ([]int16, error)

MapUint16Int16Err 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

func MapUint16Int16Ptr 

func MapUint16Int16Ptr(f func(*uint16) *int16, list []*uint16) []*int16

MapUint16Int16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Int16PtrErr 

func MapUint16Int16PtrErr(f func(*uint16) (*int16, error), list []*uint16) ([]*int16, error)

MapUint16Int16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint16Int32 

func MapUint16Int32(f func(uint16) int32, list []uint16) []int32

MapUint16Int32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Int32Err 

func MapUint16Int32Err(f func(uint16) (int32, error), list []uint16) ([]int32, error)

MapUint16Int32Err 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

func MapUint16Int32Ptr 

func MapUint16Int32Ptr(f func(*uint16) *int32, list []*uint16) []*int32

MapUint16Int32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Int32PtrErr 

func MapUint16Int32PtrErr(f func(*uint16) (*int32, error), list []*uint16) ([]*int32, error)

MapUint16Int32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint16Int64 

func MapUint16Int64(f func(uint16) int64, list []uint16) []int64

MapUint16Int64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Int64Err 

func MapUint16Int64Err(f func(uint16) (int64, error), list []uint16) ([]int64, error)

MapUint16Int64Err 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

func MapUint16Int64Ptr 

func MapUint16Int64Ptr(f func(*uint16) *int64, list []*uint16) []*int64

MapUint16Int64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Int64PtrErr 

func MapUint16Int64PtrErr(f func(*uint16) (*int64, error), list []*uint16) ([]*int64, error)

MapUint16Int64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint16Int8 

func MapUint16Int8(f func(uint16) int8, list []uint16) []int8

MapUint16Int8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Int8Err 

func MapUint16Int8Err(f func(uint16) (int8, error), list []uint16) ([]int8, error)

MapUint16Int8Err 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

func MapUint16Int8Ptr 

func MapUint16Int8Ptr(f func(*uint16) *int8, list []*uint16) []*int8

MapUint16Int8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Int8PtrErr 

func MapUint16Int8PtrErr(f func(*uint16) (*int8, error), list []*uint16) ([]*int8, error)

MapUint16Int8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint16IntErr 

func MapUint16IntErr(f func(uint16) (int, error), list []uint16) ([]int, error)

MapUint16IntErr 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

func MapUint16IntPtr 

func MapUint16IntPtr(f func(*uint16) *int, list []*uint16) []*int

MapUint16IntPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16IntPtrErr 

func MapUint16IntPtrErr(f func(*uint16) (*int, error), list []*uint16) ([]*int, error)

MapUint16IntPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint16Ptr 

func MapUint16Ptr(f func(*uint16) *uint16, list []*uint16) []*uint16

MapUint16Ptr takes 2 arguments.

  1. A function input argument: uint16 and return type (uint16)
  2. A list of type []*uint16

Returns: 

([]*uint16)

func MapUint16PtrErr 

func MapUint16PtrErr(f func(*uint16) (*uint16, error), list []*uint16) ([]*uint16, error)

MapUint16PtrErr takes 2 arguments:

  1. A function input argument: *uint16 and return types (*uint16, error)
  2. A list of type []*uint16

Returns: 

([]*uint16, error)

func MapUint16Str 

func MapUint16Str(f func(uint16) string, list []uint16) []string

MapUint16Str takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16StrErr 

func MapUint16StrErr(f func(uint16) (string, error), list []uint16) ([]string, error)

MapUint16StrErr 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

func MapUint16StrPtr 

func MapUint16StrPtr(f func(*uint16) *string, list []*uint16) []*string

MapUint16StrPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16StrPtrErr 

func MapUint16StrPtrErr(f func(*uint16) (*string, error), list []*uint16) ([]*string, error)

MapUint16StrPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint16Uint 

func MapUint16Uint(f func(uint16) uint, list []uint16) []uint

MapUint16Uint takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Uint32 

func MapUint16Uint32(f func(uint16) uint32, list []uint16) []uint32

MapUint16Uint32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Uint32Err 

func MapUint16Uint32Err(f func(uint16) (uint32, error), list []uint16) ([]uint32, error)

MapUint16Uint32Err 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

func MapUint16Uint32Ptr 

func MapUint16Uint32Ptr(f func(*uint16) *uint32, list []*uint16) []*uint32

MapUint16Uint32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Uint32PtrErr 

func MapUint16Uint32PtrErr(f func(*uint16) (*uint32, error), list []*uint16) ([]*uint32, error)

MapUint16Uint32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint16Uint64 

func MapUint16Uint64(f func(uint16) uint64, list []uint16) []uint64

MapUint16Uint64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Uint64Err 

func MapUint16Uint64Err(f func(uint16) (uint64, error), list []uint16) ([]uint64, error)

MapUint16Uint64Err 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

func MapUint16Uint64Ptr 

func MapUint16Uint64Ptr(f func(*uint16) *uint64, list []*uint16) []*uint64

MapUint16Uint64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Uint64PtrErr 

func MapUint16Uint64PtrErr(f func(*uint16) (*uint64, error), list []*uint16) ([]*uint64, error)

MapUint16Uint64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint16Uint8 

func MapUint16Uint8(f func(uint16) uint8, list []uint16) []uint8

MapUint16Uint8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Uint8Err 

func MapUint16Uint8Err(f func(uint16) (uint8, error), list []uint16) ([]uint8, error)

MapUint16Uint8Err 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

func MapUint16Uint8Ptr 

func MapUint16Uint8Ptr(f func(*uint16) *uint8, list []*uint16) []*uint8

MapUint16Uint8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16Uint8PtrErr 

func MapUint16Uint8PtrErr(f func(*uint16) (*uint8, error), list []*uint16) ([]*uint8, error)

MapUint16Uint8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint16UintErr 

func MapUint16UintErr(f func(uint16) (uint, error), list []uint16) ([]uint, error)

MapUint16UintErr 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

func MapUint16UintPtr 

func MapUint16UintPtr(f func(*uint16) *uint, list []*uint16) []*uint

MapUint16UintPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint16UintPtrErr 

func MapUint16UintPtrErr(f func(*uint16) (*uint, error), list []*uint16) ([]*uint, error)

MapUint16UintPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint32 

func MapUint32(f func(uint32) uint32, list []uint32) []uint32

MapUint32 applies the function(1st argument) on each item of the list and returns new list

Takes 2 inputs

  1. Function - takes 1 input
  2. List

Returns 

New List.
Empty list if all arguments are nil or either one is nil

Example: Square each item in the list 

MapUint32(squareInt, []uint32{1, 2, 3}) // Returns [1, 4, 9]

func squareInt(num uint32) uint32 {
	return num * num
}

func MapUint32Bool 

func MapUint32Bool(f func(uint32) bool, list []uint32) []bool

MapUint32Bool takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32BoolErr 

func MapUint32BoolErr(f func(uint32) (bool, error), list []uint32) ([]bool, error)

MapUint32BoolErr 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

func MapUint32BoolPtr 

func MapUint32BoolPtr(f func(*uint32) *bool, list []*uint32) []*bool

MapUint32BoolPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32BoolPtrErr 

func MapUint32BoolPtrErr(f func(*uint32) (*bool, error), list []*uint32) ([]*bool, error)

MapUint32BoolPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint32Err 

func MapUint32Err(f func(uint32) (uint32, error), list []uint32) ([]uint32, error)

MapUint32Err takes 2 arguments:

  1. A function input argument: uint32 and return types (uint32, error)
  2. A list of type []uint32

Returns: 

([]uint32, error)

func MapUint32Float32 

func MapUint32Float32(f func(uint32) float32, list []uint32) []float32

MapUint32Float32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Float32Err 

func MapUint32Float32Err(f func(uint32) (float32, error), list []uint32) ([]float32, error)

MapUint32Float32Err 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

func MapUint32Float32Ptr 

func MapUint32Float32Ptr(f func(*uint32) *float32, list []*uint32) []*float32

MapUint32Float32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Float32PtrErr 

func MapUint32Float32PtrErr(f func(*uint32) (*float32, error), list []*uint32) ([]*float32, error)

MapUint32Float32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint32Float64 

func MapUint32Float64(f func(uint32) float64, list []uint32) []float64

MapUint32Float64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Float64Err 

func MapUint32Float64Err(f func(uint32) (float64, error), list []uint32) ([]float64, error)

MapUint32Float64Err 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

func MapUint32Float64Ptr 

func MapUint32Float64Ptr(f func(*uint32) *float64, list []*uint32) []*float64

MapUint32Float64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Float64PtrErr 

func MapUint32Float64PtrErr(f func(*uint32) (*float64, error), list []*uint32) ([]*float64, error)

MapUint32Float64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint32Int 

func MapUint32Int(f func(uint32) int, list []uint32) []int

MapUint32Int takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Int16 

func MapUint32Int16(f func(uint32) int16, list []uint32) []int16

MapUint32Int16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Int16Err 

func MapUint32Int16Err(f func(uint32) (int16, error), list []uint32) ([]int16, error)

MapUint32Int16Err 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

func MapUint32Int16Ptr 

func MapUint32Int16Ptr(f func(*uint32) *int16, list []*uint32) []*int16

MapUint32Int16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Int16PtrErr 

func MapUint32Int16PtrErr(f func(*uint32) (*int16, error), list []*uint32) ([]*int16, error)

MapUint32Int16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint32Int32 

func MapUint32Int32(f func(uint32) int32, list []uint32) []int32

MapUint32Int32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Int32Err 

func MapUint32Int32Err(f func(uint32) (int32, error), list []uint32) ([]int32, error)

MapUint32Int32Err 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

func MapUint32Int32Ptr 

func MapUint32Int32Ptr(f func(*uint32) *int32, list []*uint32) []*int32

MapUint32Int32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Int32PtrErr 

func MapUint32Int32PtrErr(f func(*uint32) (*int32, error), list []*uint32) ([]*int32, error)

MapUint32Int32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint32Int64 

func MapUint32Int64(f func(uint32) int64, list []uint32) []int64

MapUint32Int64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Int64Err 

func MapUint32Int64Err(f func(uint32) (int64, error), list []uint32) ([]int64, error)

MapUint32Int64Err 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

func MapUint32Int64Ptr 

func MapUint32Int64Ptr(f func(*uint32) *int64, list []*uint32) []*int64

MapUint32Int64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Int64PtrErr 

func MapUint32Int64PtrErr(f func(*uint32) (*int64, error), list []*uint32) ([]*int64, error)

MapUint32Int64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint32Int8 

func MapUint32Int8(f func(uint32) int8, list []uint32) []int8

MapUint32Int8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Int8Err 

func MapUint32Int8Err(f func(uint32) (int8, error), list []uint32) ([]int8, error)

MapUint32Int8Err 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

func MapUint32Int8Ptr 

func MapUint32Int8Ptr(f func(*uint32) *int8, list []*uint32) []*int8

MapUint32Int8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Int8PtrErr 

func MapUint32Int8PtrErr(f func(*uint32) (*int8, error), list []*uint32) ([]*int8, error)

MapUint32Int8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint32IntErr 

func MapUint32IntErr(f func(uint32) (int, error), list []uint32) ([]int, error)

MapUint32IntErr 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

func MapUint32IntPtr 

func MapUint32IntPtr(f func(*uint32) *int, list []*uint32) []*int

MapUint32IntPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32IntPtrErr 

func MapUint32IntPtrErr(f func(*uint32) (*int, error), list []*uint32) ([]*int, error)

MapUint32IntPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint32Ptr 

func MapUint32Ptr(f func(*uint32) *uint32, list []*uint32) []*uint32

MapUint32Ptr takes 2 arguments.

  1. A function input argument: uint32 and return type (uint32)
  2. A list of type []*uint32

Returns: 

([]*uint32)

func MapUint32PtrErr 

func MapUint32PtrErr(f func(*uint32) (*uint32, error), list []*uint32) ([]*uint32, error)

MapUint32PtrErr takes 2 arguments:

  1. A function input argument: *uint32 and return types (*uint32, error)
  2. A list of type []*uint32

Returns: 

([]*uint32, error)

func MapUint32Str 

func MapUint32Str(f func(uint32) string, list []uint32) []string

MapUint32Str takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32StrErr 

func MapUint32StrErr(f func(uint32) (string, error), list []uint32) ([]string, error)

MapUint32StrErr 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

func MapUint32StrPtr 

func MapUint32StrPtr(f func(*uint32) *string, list []*uint32) []*string

MapUint32StrPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32StrPtrErr 

func MapUint32StrPtrErr(f func(*uint32) (*string, error), list []*uint32) ([]*string, error)

MapUint32StrPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint32Uint 

func MapUint32Uint(f func(uint32) uint, list []uint32) []uint

MapUint32Uint takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Uint16 

func MapUint32Uint16(f func(uint32) uint16, list []uint32) []uint16

MapUint32Uint16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Uint16Err 

func MapUint32Uint16Err(f func(uint32) (uint16, error), list []uint32) ([]uint16, error)

MapUint32Uint16Err 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

func MapUint32Uint16Ptr 

func MapUint32Uint16Ptr(f func(*uint32) *uint16, list []*uint32) []*uint16

MapUint32Uint16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Uint16PtrErr 

func MapUint32Uint16PtrErr(f func(*uint32) (*uint16, error), list []*uint32) ([]*uint16, error)

MapUint32Uint16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint32Uint64 

func MapUint32Uint64(f func(uint32) uint64, list []uint32) []uint64

MapUint32Uint64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Uint64Err 

func MapUint32Uint64Err(f func(uint32) (uint64, error), list []uint32) ([]uint64, error)

MapUint32Uint64Err 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

func MapUint32Uint64Ptr 

func MapUint32Uint64Ptr(f func(*uint32) *uint64, list []*uint32) []*uint64

MapUint32Uint64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Uint64PtrErr 

func MapUint32Uint64PtrErr(f func(*uint32) (*uint64, error), list []*uint32) ([]*uint64, error)

MapUint32Uint64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint32Uint8 

func MapUint32Uint8(f func(uint32) uint8, list []uint32) []uint8

MapUint32Uint8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Uint8Err 

func MapUint32Uint8Err(f func(uint32) (uint8, error), list []uint32) ([]uint8, error)

MapUint32Uint8Err 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

func MapUint32Uint8Ptr 

func MapUint32Uint8Ptr(f func(*uint32) *uint8, list []*uint32) []*uint8

MapUint32Uint8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32Uint8PtrErr 

func MapUint32Uint8PtrErr(f func(*uint32) (*uint8, error), list []*uint32) ([]*uint8, error)

MapUint32Uint8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint32UintErr 

func MapUint32UintErr(f func(uint32) (uint, error), list []uint32) ([]uint, error)

MapUint32UintErr 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

func MapUint32UintPtr 

func MapUint32UintPtr(f func(*uint32) *uint, list []*uint32) []*uint

MapUint32UintPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint32UintPtrErr 

func MapUint32UintPtrErr(f func(*uint32) (*uint, error), list []*uint32) ([]*uint, error)

MapUint32UintPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint64 

func MapUint64(f func(uint64) uint64, list []uint64) []uint64

MapUint64 applies the function(1st argument) on each item of the list and returns new list

Takes 2 inputs

  1. Function - takes 1 input
  2. List

Returns 

New List.
Empty list if all arguments are nil or either one is nil

Example: Square each item in the list 

MapUint64(squareInt, []uint64{1, 2, 3}) // Returns [1, 4, 9]

func squareInt(num uint64) uint64 {
	return num * num
}

func MapUint64Bool 

func MapUint64Bool(f func(uint64) bool, list []uint64) []bool

MapUint64Bool takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64BoolErr 

func MapUint64BoolErr(f func(uint64) (bool, error), list []uint64) ([]bool, error)

MapUint64BoolErr 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

func MapUint64BoolPtr 

func MapUint64BoolPtr(f func(*uint64) *bool, list []*uint64) []*bool

MapUint64BoolPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64BoolPtrErr 

func MapUint64BoolPtrErr(f func(*uint64) (*bool, error), list []*uint64) ([]*bool, error)

MapUint64BoolPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint64Err 

func MapUint64Err(f func(uint64) (uint64, error), list []uint64) ([]uint64, error)

MapUint64Err takes 2 arguments:

  1. A function input argument: uint64 and return types (uint64, error)
  2. A list of type []uint64

Returns: 

([]uint64, error)

func MapUint64Float32 

func MapUint64Float32(f func(uint64) float32, list []uint64) []float32

MapUint64Float32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Float32Err 

func MapUint64Float32Err(f func(uint64) (float32, error), list []uint64) ([]float32, error)

MapUint64Float32Err 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

func MapUint64Float32Ptr 

func MapUint64Float32Ptr(f func(*uint64) *float32, list []*uint64) []*float32

MapUint64Float32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Float32PtrErr 

func MapUint64Float32PtrErr(f func(*uint64) (*float32, error), list []*uint64) ([]*float32, error)

MapUint64Float32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint64Float64 

func MapUint64Float64(f func(uint64) float64, list []uint64) []float64

MapUint64Float64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Float64Err 

func MapUint64Float64Err(f func(uint64) (float64, error), list []uint64) ([]float64, error)

MapUint64Float64Err 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

func MapUint64Float64Ptr 

func MapUint64Float64Ptr(f func(*uint64) *float64, list []*uint64) []*float64

MapUint64Float64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Float64PtrErr 

func MapUint64Float64PtrErr(f func(*uint64) (*float64, error), list []*uint64) ([]*float64, error)

MapUint64Float64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint64Int 

func MapUint64Int(f func(uint64) int, list []uint64) []int

MapUint64Int takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Int16 

func MapUint64Int16(f func(uint64) int16, list []uint64) []int16

MapUint64Int16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Int16Err 

func MapUint64Int16Err(f func(uint64) (int16, error), list []uint64) ([]int16, error)

MapUint64Int16Err 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

func MapUint64Int16Ptr 

func MapUint64Int16Ptr(f func(*uint64) *int16, list []*uint64) []*int16

MapUint64Int16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Int16PtrErr 

func MapUint64Int16PtrErr(f func(*uint64) (*int16, error), list []*uint64) ([]*int16, error)

MapUint64Int16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint64Int32 

func MapUint64Int32(f func(uint64) int32, list []uint64) []int32

MapUint64Int32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Int32Err 

func MapUint64Int32Err(f func(uint64) (int32, error), list []uint64) ([]int32, error)

MapUint64Int32Err 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

func MapUint64Int32Ptr 

func MapUint64Int32Ptr(f func(*uint64) *int32, list []*uint64) []*int32

MapUint64Int32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Int32PtrErr 

func MapUint64Int32PtrErr(f func(*uint64) (*int32, error), list []*uint64) ([]*int32, error)

MapUint64Int32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint64Int64 

func MapUint64Int64(f func(uint64) int64, list []uint64) []int64

MapUint64Int64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Int64Err 

func MapUint64Int64Err(f func(uint64) (int64, error), list []uint64) ([]int64, error)

MapUint64Int64Err 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

func MapUint64Int64Ptr 

func MapUint64Int64Ptr(f func(*uint64) *int64, list []*uint64) []*int64

MapUint64Int64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Int64PtrErr 

func MapUint64Int64PtrErr(f func(*uint64) (*int64, error), list []*uint64) ([]*int64, error)

MapUint64Int64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint64Int8 

func MapUint64Int8(f func(uint64) int8, list []uint64) []int8

MapUint64Int8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Int8Err 

func MapUint64Int8Err(f func(uint64) (int8, error), list []uint64) ([]int8, error)

MapUint64Int8Err 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

func MapUint64Int8Ptr 

func MapUint64Int8Ptr(f func(*uint64) *int8, list []*uint64) []*int8

MapUint64Int8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Int8PtrErr 

func MapUint64Int8PtrErr(f func(*uint64) (*int8, error), list []*uint64) ([]*int8, error)

MapUint64Int8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint64IntErr 

func MapUint64IntErr(f func(uint64) (int, error), list []uint64) ([]int, error)

MapUint64IntErr 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

func MapUint64IntPtr 

func MapUint64IntPtr(f func(*uint64) *int, list []*uint64) []*int

MapUint64IntPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64IntPtrErr 

func MapUint64IntPtrErr(f func(*uint64) (*int, error), list []*uint64) ([]*int, error)

MapUint64IntPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint64Ptr 

func MapUint64Ptr(f func(*uint64) *uint64, list []*uint64) []*uint64

MapUint64Ptr takes 2 arguments.

  1. A function input argument: uint64 and return type (uint64)
  2. A list of type []*uint64

Returns: 

([]*uint64)

func MapUint64PtrErr 

func MapUint64PtrErr(f func(*uint64) (*uint64, error), list []*uint64) ([]*uint64, error)

MapUint64PtrErr takes 2 arguments:

  1. A function input argument: *uint64 and return types (*uint64, error)
  2. A list of type []*uint64

Returns: 

([]*uint64, error)

func MapUint64Str 

func MapUint64Str(f func(uint64) string, list []uint64) []string

MapUint64Str takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64StrErr 

func MapUint64StrErr(f func(uint64) (string, error), list []uint64) ([]string, error)

MapUint64StrErr 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

func MapUint64StrPtr 

func MapUint64StrPtr(f func(*uint64) *string, list []*uint64) []*string

MapUint64StrPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64StrPtrErr 

func MapUint64StrPtrErr(f func(*uint64) (*string, error), list []*uint64) ([]*string, error)

MapUint64StrPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint64Uint 

func MapUint64Uint(f func(uint64) uint, list []uint64) []uint

MapUint64Uint takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Uint16 

func MapUint64Uint16(f func(uint64) uint16, list []uint64) []uint16

MapUint64Uint16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Uint16Err 

func MapUint64Uint16Err(f func(uint64) (uint16, error), list []uint64) ([]uint16, error)

MapUint64Uint16Err 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

func MapUint64Uint16Ptr 

func MapUint64Uint16Ptr(f func(*uint64) *uint16, list []*uint64) []*uint16

MapUint64Uint16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Uint16PtrErr 

func MapUint64Uint16PtrErr(f func(*uint64) (*uint16, error), list []*uint64) ([]*uint16, error)

MapUint64Uint16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint64Uint32 

func MapUint64Uint32(f func(uint64) uint32, list []uint64) []uint32

MapUint64Uint32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Uint32Err 

func MapUint64Uint32Err(f func(uint64) (uint32, error), list []uint64) ([]uint32, error)

MapUint64Uint32Err 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

func MapUint64Uint32Ptr 

func MapUint64Uint32Ptr(f func(*uint64) *uint32, list []*uint64) []*uint32

MapUint64Uint32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Uint32PtrErr 

func MapUint64Uint32PtrErr(f func(*uint64) (*uint32, error), list []*uint64) ([]*uint32, error)

MapUint64Uint32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint64Uint8 

func MapUint64Uint8(f func(uint64) uint8, list []uint64) []uint8

MapUint64Uint8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Uint8Err 

func MapUint64Uint8Err(f func(uint64) (uint8, error), list []uint64) ([]uint8, error)

MapUint64Uint8Err 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

func MapUint64Uint8Ptr 

func MapUint64Uint8Ptr(f func(*uint64) *uint8, list []*uint64) []*uint8

MapUint64Uint8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64Uint8PtrErr 

func MapUint64Uint8PtrErr(f func(*uint64) (*uint8, error), list []*uint64) ([]*uint8, error)

MapUint64Uint8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint64UintErr 

func MapUint64UintErr(f func(uint64) (uint, error), list []uint64) ([]uint, error)

MapUint64UintErr 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

func MapUint64UintPtr 

func MapUint64UintPtr(f func(*uint64) *uint, list []*uint64) []*uint

MapUint64UintPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint64UintPtrErr 

func MapUint64UintPtrErr(f func(*uint64) (*uint, error), list []*uint64) ([]*uint, error)

MapUint64UintPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint8 

func MapUint8(f func(uint8) uint8, list []uint8) []uint8

MapUint8 applies the function(1st argument) on each item of the list and returns new list

Takes 2 inputs

  1. Function - takes 1 input
  2. List

Returns 

New List.
Empty list if all arguments are nil or either one is nil

Example: Square each item in the list 

MapUint8(squareInt, []uint8{1, 2, 3}) // Returns [1, 4, 9]

func squareInt(num uint8) uint8 {
	return num * num
}

func MapUint8Bool 

func MapUint8Bool(f func(uint8) bool, list []uint8) []bool

MapUint8Bool takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8BoolErr 

func MapUint8BoolErr(f func(uint8) (bool, error), list []uint8) ([]bool, error)

MapUint8BoolErr 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

func MapUint8BoolPtr 

func MapUint8BoolPtr(f func(*uint8) *bool, list []*uint8) []*bool

MapUint8BoolPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8BoolPtrErr 

func MapUint8BoolPtrErr(f func(*uint8) (*bool, error), list []*uint8) ([]*bool, error)

MapUint8BoolPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint8Err 

func MapUint8Err(f func(uint8) (uint8, error), list []uint8) ([]uint8, error)

MapUint8Err takes 2 arguments:

  1. A function input argument: uint8 and return types (uint8, error)
  2. A list of type []uint8

Returns: 

([]uint8, error)

func MapUint8Float32 

func MapUint8Float32(f func(uint8) float32, list []uint8) []float32

MapUint8Float32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Float32Err 

func MapUint8Float32Err(f func(uint8) (float32, error), list []uint8) ([]float32, error)

MapUint8Float32Err 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

func MapUint8Float32Ptr 

func MapUint8Float32Ptr(f func(*uint8) *float32, list []*uint8) []*float32

MapUint8Float32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Float32PtrErr 

func MapUint8Float32PtrErr(f func(*uint8) (*float32, error), list []*uint8) ([]*float32, error)

MapUint8Float32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint8Float64 

func MapUint8Float64(f func(uint8) float64, list []uint8) []float64

MapUint8Float64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Float64Err 

func MapUint8Float64Err(f func(uint8) (float64, error), list []uint8) ([]float64, error)

MapUint8Float64Err 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

func MapUint8Float64Ptr 

func MapUint8Float64Ptr(f func(*uint8) *float64, list []*uint8) []*float64

MapUint8Float64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Float64PtrErr 

func MapUint8Float64PtrErr(f func(*uint8) (*float64, error), list []*uint8) ([]*float64, error)

MapUint8Float64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint8Int 

func MapUint8Int(f func(uint8) int, list []uint8) []int

MapUint8Int takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Int16 

func MapUint8Int16(f func(uint8) int16, list []uint8) []int16

MapUint8Int16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Int16Err 

func MapUint8Int16Err(f func(uint8) (int16, error), list []uint8) ([]int16, error)

MapUint8Int16Err 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

func MapUint8Int16Ptr 

func MapUint8Int16Ptr(f func(*uint8) *int16, list []*uint8) []*int16

MapUint8Int16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Int16PtrErr 

func MapUint8Int16PtrErr(f func(*uint8) (*int16, error), list []*uint8) ([]*int16, error)

MapUint8Int16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint8Int32 

func MapUint8Int32(f func(uint8) int32, list []uint8) []int32

MapUint8Int32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Int32Err 

func MapUint8Int32Err(f func(uint8) (int32, error), list []uint8) ([]int32, error)

MapUint8Int32Err 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

func MapUint8Int32Ptr 

func MapUint8Int32Ptr(f func(*uint8) *int32, list []*uint8) []*int32

MapUint8Int32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Int32PtrErr 

func MapUint8Int32PtrErr(f func(*uint8) (*int32, error), list []*uint8) ([]*int32, error)

MapUint8Int32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint8Int64 

func MapUint8Int64(f func(uint8) int64, list []uint8) []int64

MapUint8Int64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Int64Err 

func MapUint8Int64Err(f func(uint8) (int64, error), list []uint8) ([]int64, error)

MapUint8Int64Err 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

func MapUint8Int64Ptr 

func MapUint8Int64Ptr(f func(*uint8) *int64, list []*uint8) []*int64

MapUint8Int64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Int64PtrErr 

func MapUint8Int64PtrErr(f func(*uint8) (*int64, error), list []*uint8) ([]*int64, error)

MapUint8Int64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint8Int8 

func MapUint8Int8(f func(uint8) int8, list []uint8) []int8

MapUint8Int8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Int8Err 

func MapUint8Int8Err(f func(uint8) (int8, error), list []uint8) ([]int8, error)

MapUint8Int8Err 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

func MapUint8Int8Ptr 

func MapUint8Int8Ptr(f func(*uint8) *int8, list []*uint8) []*int8

MapUint8Int8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Int8PtrErr 

func MapUint8Int8PtrErr(f func(*uint8) (*int8, error), list []*uint8) ([]*int8, error)

MapUint8Int8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint8IntErr 

func MapUint8IntErr(f func(uint8) (int, error), list []uint8) ([]int, error)

MapUint8IntErr 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

func MapUint8IntPtr 

func MapUint8IntPtr(f func(*uint8) *int, list []*uint8) []*int

MapUint8IntPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8IntPtrErr 

func MapUint8IntPtrErr(f func(*uint8) (*int, error), list []*uint8) ([]*int, error)

MapUint8IntPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint8Ptr 

func MapUint8Ptr(f func(*uint8) *uint8, list []*uint8) []*uint8

MapUint8Ptr takes 2 arguments.

  1. A function input argument: uint8 and return type (uint8)
  2. A list of type []*uint8

Returns: 

([]*uint8)

func MapUint8PtrErr 

func MapUint8PtrErr(f func(*uint8) (*uint8, error), list []*uint8) ([]*uint8, error)

MapUint8PtrErr takes 2 arguments:

  1. A function input argument: *uint8 and return types (*uint8, error)
  2. A list of type []*uint8

Returns: 

([]*uint8, error)

func MapUint8Str 

func MapUint8Str(f func(uint8) string, list []uint8) []string

MapUint8Str takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8StrErr 

func MapUint8StrErr(f func(uint8) (string, error), list []uint8) ([]string, error)

MapUint8StrErr 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

func MapUint8StrPtr 

func MapUint8StrPtr(f func(*uint8) *string, list []*uint8) []*string

MapUint8StrPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8StrPtrErr 

func MapUint8StrPtrErr(f func(*uint8) (*string, error), list []*uint8) ([]*string, error)

MapUint8StrPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint8Uint 

func MapUint8Uint(f func(uint8) uint, list []uint8) []uint

MapUint8Uint takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Uint16 

func MapUint8Uint16(f func(uint8) uint16, list []uint8) []uint16

MapUint8Uint16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Uint16Err 

func MapUint8Uint16Err(f func(uint8) (uint16, error), list []uint8) ([]uint16, error)

MapUint8Uint16Err 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

func MapUint8Uint16Ptr 

func MapUint8Uint16Ptr(f func(*uint8) *uint16, list []*uint8) []*uint16

MapUint8Uint16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Uint16PtrErr 

func MapUint8Uint16PtrErr(f func(*uint8) (*uint16, error), list []*uint8) ([]*uint16, error)

MapUint8Uint16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint8Uint32 

func MapUint8Uint32(f func(uint8) uint32, list []uint8) []uint32

MapUint8Uint32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Uint32Err 

func MapUint8Uint32Err(f func(uint8) (uint32, error), list []uint8) ([]uint32, error)

MapUint8Uint32Err 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

func MapUint8Uint32Ptr 

func MapUint8Uint32Ptr(f func(*uint8) *uint32, list []*uint8) []*uint32

MapUint8Uint32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Uint32PtrErr 

func MapUint8Uint32PtrErr(f func(*uint8) (*uint32, error), list []*uint8) ([]*uint32, error)

MapUint8Uint32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint8Uint64 

func MapUint8Uint64(f func(uint8) uint64, list []uint8) []uint64

MapUint8Uint64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Uint64Err 

func MapUint8Uint64Err(f func(uint8) (uint64, error), list []uint8) ([]uint64, error)

MapUint8Uint64Err 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

func MapUint8Uint64Ptr 

func MapUint8Uint64Ptr(f func(*uint8) *uint64, list []*uint8) []*uint64

MapUint8Uint64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8Uint64PtrErr 

func MapUint8Uint64PtrErr(f func(*uint8) (*uint64, error), list []*uint8) ([]*uint64, error)

MapUint8Uint64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUint8UintErr 

func MapUint8UintErr(f func(uint8) (uint, error), list []uint8) ([]uint, error)

MapUint8UintErr 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

func MapUint8UintPtr 

func MapUint8UintPtr(f func(*uint8) *uint, list []*uint8) []*uint

MapUint8UintPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUint8UintPtrErr 

func MapUint8UintPtrErr(f func(*uint8) (*uint, error), list []*uint8) ([]*uint, error)

MapUint8UintPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUintBool 

func MapUintBool(f func(uint) bool, list []uint) []bool

MapUintBool takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintBoolErr 

func MapUintBoolErr(f func(uint) (bool, error), list []uint) ([]bool, error)

MapUintBoolErr 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

func MapUintBoolPtr 

func MapUintBoolPtr(f func(*uint) *bool, list []*uint) []*bool

MapUintBoolPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintBoolPtrErr 

func MapUintBoolPtrErr(f func(*uint) (*bool, error), list []*uint) ([]*bool, error)

MapUintBoolPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUintErr 

func MapUintErr(f func(uint) (uint, error), list []uint) ([]uint, error)

MapUintErr takes 2 arguments:

  1. A function input argument: uint and return types (uint, error)
  2. A list of type []uint

Returns: 

([]uint, error)

func MapUintFloat32 

func MapUintFloat32(f func(uint) float32, list []uint) []float32

MapUintFloat32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintFloat32Err 

func MapUintFloat32Err(f func(uint) (float32, error), list []uint) ([]float32, error)

MapUintFloat32Err 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

func MapUintFloat32Ptr 

func MapUintFloat32Ptr(f func(*uint) *float32, list []*uint) []*float32

MapUintFloat32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintFloat32PtrErr 

func MapUintFloat32PtrErr(f func(*uint) (*float32, error), list []*uint) ([]*float32, error)

MapUintFloat32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUintFloat64 

func MapUintFloat64(f func(uint) float64, list []uint) []float64

MapUintFloat64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintFloat64Err 

func MapUintFloat64Err(f func(uint) (float64, error), list []uint) ([]float64, error)

MapUintFloat64Err 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

func MapUintFloat64Ptr 

func MapUintFloat64Ptr(f func(*uint) *float64, list []*uint) []*float64

MapUintFloat64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintFloat64PtrErr 

func MapUintFloat64PtrErr(f func(*uint) (*float64, error), list []*uint) ([]*float64, error)

MapUintFloat64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUintInt 

func MapUintInt(f func(uint) int, list []uint) []int

MapUintInt takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintInt16 

func MapUintInt16(f func(uint) int16, list []uint) []int16

MapUintInt16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintInt16Err 

func MapUintInt16Err(f func(uint) (int16, error), list []uint) ([]int16, error)

MapUintInt16Err 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

func MapUintInt16Ptr 

func MapUintInt16Ptr(f func(*uint) *int16, list []*uint) []*int16

MapUintInt16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintInt16PtrErr 

func MapUintInt16PtrErr(f func(*uint) (*int16, error), list []*uint) ([]*int16, error)

MapUintInt16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUintInt32 

func MapUintInt32(f func(uint) int32, list []uint) []int32

MapUintInt32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintInt32Err 

func MapUintInt32Err(f func(uint) (int32, error), list []uint) ([]int32, error)

MapUintInt32Err 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

func MapUintInt32Ptr 

func MapUintInt32Ptr(f func(*uint) *int32, list []*uint) []*int32

MapUintInt32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintInt32PtrErr 

func MapUintInt32PtrErr(f func(*uint) (*int32, error), list []*uint) ([]*int32, error)

MapUintInt32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUintInt64 

func MapUintInt64(f func(uint) int64, list []uint) []int64

MapUintInt64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintInt64Err 

func MapUintInt64Err(f func(uint) (int64, error), list []uint) ([]int64, error)

MapUintInt64Err 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

func MapUintInt64Ptr 

func MapUintInt64Ptr(f func(*uint) *int64, list []*uint) []*int64

MapUintInt64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintInt64PtrErr 

func MapUintInt64PtrErr(f func(*uint) (*int64, error), list []*uint) ([]*int64, error)

MapUintInt64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUintInt8 

func MapUintInt8(f func(uint) int8, list []uint) []int8

MapUintInt8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintInt8Err 

func MapUintInt8Err(f func(uint) (int8, error), list []uint) ([]int8, error)

MapUintInt8Err 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

func MapUintInt8Ptr 

func MapUintInt8Ptr(f func(*uint) *int8, list []*uint) []*int8

MapUintInt8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintInt8PtrErr 

func MapUintInt8PtrErr(f func(*uint) (*int8, error), list []*uint) ([]*int8, error)

MapUintInt8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUintIntErr 

func MapUintIntErr(f func(uint) (int, error), list []uint) ([]int, error)

MapUintIntErr 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

func MapUintIntPtr 

func MapUintIntPtr(f func(*uint) *int, list []*uint) []*int

MapUintIntPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintIntPtrErr 

func MapUintIntPtrErr(f func(*uint) (*int, error), list []*uint) ([]*int, error)

MapUintIntPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUintPtr 

func MapUintPtr(f func(*uint) *uint, list []*uint) []*uint

MapUintPtr takes 2 arguments.

  1. A function input argument: uint and return type (uint)
  2. A list of type []*uint

Returns: 

([]*uint)

func MapUintPtrErr 

func MapUintPtrErr(f func(*uint) (*uint, error), list []*uint) ([]*uint, error)

MapUintPtrErr takes 2 arguments:

  1. A function input argument: *uint and return types (*uint, error)
  2. A list of type []*uint

Returns: 

([]*uint, error)

func MapUintStr 

func MapUintStr(f func(uint) string, list []uint) []string

MapUintStr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintStrErr 

func MapUintStrErr(f func(uint) (string, error), list []uint) ([]string, error)

MapUintStrErr 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

func MapUintStrPtr 

func MapUintStrPtr(f func(*uint) *string, list []*uint) []*string

MapUintStrPtr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintStrPtrErr 

func MapUintStrPtrErr(f func(*uint) (*string, error), list []*uint) ([]*string, error)

MapUintStrPtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUintUint16 

func MapUintUint16(f func(uint) uint16, list []uint) []uint16

MapUintUint16 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintUint16Err 

func MapUintUint16Err(f func(uint) (uint16, error), list []uint) ([]uint16, error)

MapUintUint16Err 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

func MapUintUint16Ptr 

func MapUintUint16Ptr(f func(*uint) *uint16, list []*uint) []*uint16

MapUintUint16Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintUint16PtrErr 

func MapUintUint16PtrErr(f func(*uint) (*uint16, error), list []*uint) ([]*uint16, error)

MapUintUint16PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUintUint32 

func MapUintUint32(f func(uint) uint32, list []uint) []uint32

MapUintUint32 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintUint32Err 

func MapUintUint32Err(f func(uint) (uint32, error), list []uint) ([]uint32, error)

MapUintUint32Err 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

func MapUintUint32Ptr 

func MapUintUint32Ptr(f func(*uint) *uint32, list []*uint) []*uint32

MapUintUint32Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintUint32PtrErr 

func MapUintUint32PtrErr(f func(*uint) (*uint32, error), list []*uint) ([]*uint32, error)

MapUintUint32PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUintUint64 

func MapUintUint64(f func(uint) uint64, list []uint) []uint64

MapUintUint64 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintUint64Err 

func MapUintUint64Err(f func(uint) (uint64, error), list []uint) ([]uint64, error)

MapUintUint64Err 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

func MapUintUint64Ptr 

func MapUintUint64Ptr(f func(*uint) *uint64, list []*uint) []*uint64

MapUintUint64Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintUint64PtrErr 

func MapUintUint64PtrErr(f func(*uint) (*uint64, error), list []*uint) ([]*uint64, error)

MapUintUint64PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MapUintUint8 

func MapUintUint8(f func(uint) uint8, list []uint) []uint8

MapUintUint8 takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintUint8Err 

func MapUintUint8Err(f func(uint) (uint8, error), list []uint) ([]uint8, error)

MapUintUint8Err 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

func MapUintUint8Ptr 

func MapUintUint8Ptr(f func(*uint) *uint8, list []*uint) []*uint8

MapUintUint8Ptr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list

func MapUintUint8PtrErr 

func MapUintUint8PtrErr(f func(*uint) (*uint8, error), list []*uint) ([]*uint8, error)

MapUintUint8PtrErr takes two inputs - 1. Function 2. List. Then It returns a new list after applying the function on each item of the list, error

func MaxFloat32 

func MaxFloat32(list []float32) float32

MaxFloat32 returns max item from the list. Return 0 if the list is either empty or nil

func MaxFloat32Ptr 

func MaxFloat32Ptr(list []*float32) *float32

MaxFloat32Ptr Returns the greatest of the nums

func MaxFloat64 

func MaxFloat64(list []float64) float64

MaxFloat64 returns max item from the list. Return 0 if the list is either empty or nil

func MaxFloat64Ptr 

func MaxFloat64Ptr(list []*float64) *float64

MaxFloat64Ptr Returns the greatest of the nums

func MaxInt 

func MaxInt(list []int) int

MaxInt returns max item from the list. Return 0 if the list is either empty or nil

func MaxInt16 

func MaxInt16(list []int16) int16

MaxInt16 returns max item from the list. Return 0 if the list is either empty or nil

func MaxInt16Ptr 

func MaxInt16Ptr(list []*int16) *int16

MaxInt16Ptr Returns the greatest of the nums

func MaxInt32 

func MaxInt32(list []int32) int32

MaxInt32 returns max item from the list. Return 0 if the list is either empty or nil

func MaxInt32Ptr 

func MaxInt32Ptr(list []*int32) *int32

MaxInt32Ptr Returns the greatest of the nums

func MaxInt64 

func MaxInt64(list []int64) int64

MaxInt64 returns max item from the list. Return 0 if the list is either empty or nil

func MaxInt64Ptr 

func MaxInt64Ptr(list []*int64) *int64

MaxInt64Ptr Returns the greatest of the nums

func MaxInt8 

func MaxInt8(list []int8) int8

MaxInt8 returns max item from the list. Return 0 if the list is either empty or nil

func MaxInt8Ptr 

func MaxInt8Ptr(list []*int8) *int8

MaxInt8Ptr Returns the greatest of the nums

func MaxIntPtr 

func MaxIntPtr(list []*int) *int

MaxIntPtr Returns the greatest of the nums

func MaxUint 

func MaxUint(list []uint) uint

MaxUint returns max item from the list. Return 0 if the list is either empty or nil

func MaxUint16 

func MaxUint16(list []uint16) uint16

MaxUint16 returns max item from the list. Return 0 if the list is either empty or nil

func MaxUint16Ptr 

func MaxUint16Ptr(list []*uint16) *uint16

MaxUint16Ptr Returns the greatest of the nums

func MaxUint32 

func MaxUint32(list []uint32) uint32

MaxUint32 returns max item from the list. Return 0 if the list is either empty or nil

func MaxUint32Ptr 

func MaxUint32Ptr(list []*uint32) *uint32

MaxUint32Ptr Returns the greatest of the nums

func MaxUint64 

func MaxUint64(list []uint64) uint64

MaxUint64 returns max item from the list. Return 0 if the list is either empty or nil

func MaxUint64Ptr 

func MaxUint64Ptr(list []*uint64) *uint64

MaxUint64Ptr Returns the greatest of the nums

func MaxUint8 

func MaxUint8(list []uint8) uint8

MaxUint8 returns max item from the list. Return 0 if the list is either empty or nil

func MaxUint8Ptr 

func MaxUint8Ptr(list []*uint8) *uint8

MaxUint8Ptr Returns the greatest of the nums

func MaxUintPtr 

func MaxUintPtr(list []*uint) *uint

MaxUintPtr Returns the greatest of the nums

func MergeBool 

func MergeBool(map1, map2 map[bool]bool) map[bool]bool

MergeBool takes two inputs: map[bool]bool and map[bool]bool and merge two maps and returns a new map[bool]bool.

func MergeBoolFloat32 

func MergeBoolFloat32(map1, map2 map[bool]float32) map[bool]float32

MergeBoolFloat32 takes two inputs: map[bool]float32 and map[bool]float32 and merge two maps and returns a new map[bool]float32.

func MergeBoolFloat32Ptr 

func MergeBoolFloat32Ptr(map1, map2 map[*bool]*float32) map[*bool]*float32

MergeBoolFloat32Ptr takes two inputs: map[bool]float32 and map[bool]float32 and merge two maps and returns a new map[bool]float32.

func MergeBoolFloat64 

func MergeBoolFloat64(map1, map2 map[bool]float64) map[bool]float64

MergeBoolFloat64 takes two inputs: map[bool]float64 and map[bool]float64 and merge two maps and returns a new map[bool]float64.

func MergeBoolFloat64Ptr 

func MergeBoolFloat64Ptr(map1, map2 map[*bool]*float64) map[*bool]*float64

MergeBoolFloat64Ptr takes two inputs: map[bool]float64 and map[bool]float64 and merge two maps and returns a new map[bool]float64.

func MergeBoolInt 

func MergeBoolInt(map1, map2 map[bool]int) map[bool]int

MergeBoolInt takes two inputs: map[bool]int and map[bool]int and merge two maps and returns a new map[bool]int.

func MergeBoolInt16 

func MergeBoolInt16(map1, map2 map[bool]int16) map[bool]int16

MergeBoolInt16 takes two inputs: map[bool]int16 and map[bool]int16 and merge two maps and returns a new map[bool]int16.

func MergeBoolInt16Ptr 

func MergeBoolInt16Ptr(map1, map2 map[*bool]*int16) map[*bool]*int16

MergeBoolInt16Ptr takes two inputs: map[bool]int16 and map[bool]int16 and merge two maps and returns a new map[bool]int16.

func MergeBoolInt32 

func MergeBoolInt32(map1, map2 map[bool]int32) map[bool]int32

MergeBoolInt32 takes two inputs: map[bool]int32 and map[bool]int32 and merge two maps and returns a new map[bool]int32.

func MergeBoolInt32Ptr 

func MergeBoolInt32Ptr(map1, map2 map[*bool]*int32) map[*bool]*int32

MergeBoolInt32Ptr takes two inputs: map[bool]int32 and map[bool]int32 and merge two maps and returns a new map[bool]int32.

func MergeBoolInt64 

func MergeBoolInt64(map1, map2 map[bool]int64) map[bool]int64

MergeBoolInt64 takes two inputs: map[bool]int64 and map[bool]int64 and merge two maps and returns a new map[bool]int64.

func MergeBoolInt64Ptr 

func MergeBoolInt64Ptr(map1, map2 map[*bool]*int64) map[*bool]*int64

MergeBoolInt64Ptr takes two inputs: map[bool]int64 and map[bool]int64 and merge two maps and returns a new map[bool]int64.

func MergeBoolInt8 

func MergeBoolInt8(map1, map2 map[bool]int8) map[bool]int8

MergeBoolInt8 takes two inputs: map[bool]int8 and map[bool]int8 and merge two maps and returns a new map[bool]int8.

func MergeBoolInt8Ptr 

func MergeBoolInt8Ptr(map1, map2 map[*bool]*int8) map[*bool]*int8

MergeBoolInt8Ptr takes two inputs: map[bool]int8 and map[bool]int8 and merge two maps and returns a new map[bool]int8.

func MergeBoolIntPtr 

func MergeBoolIntPtr(map1, map2 map[*bool]*int) map[*bool]*int

MergeBoolIntPtr takes two inputs: map[bool]int and map[bool]int and merge two maps and returns a new map[bool]int.

func MergeBoolPtr 

func MergeBoolPtr(map1, map2 map[*bool]*bool) map[*bool]*bool

MergeBoolPtr takes two inputs: map[bool]bool and map[bool]bool and merge two maps and returns a new map[bool]bool.

func MergeBoolStr 

func MergeBoolStr(map1, map2 map[bool]string) map[bool]string

MergeBoolStr takes two inputs: map[bool]string and map[bool]string and merge two maps and returns a new map[bool]string.

func MergeBoolStrPtr 

func MergeBoolStrPtr(map1, map2 map[*bool]*string) map[*bool]*string

MergeBoolStrPtr takes two inputs: map[bool]string and map[bool]string and merge two maps and returns a new map[bool]string.

func MergeBoolUint 

func MergeBoolUint(map1, map2 map[bool]uint) map[bool]uint

MergeBoolUint takes two inputs: map[bool]uint and map[bool]uint and merge two maps and returns a new map[bool]uint.

func MergeBoolUint16 

func MergeBoolUint16(map1, map2 map[bool]uint16) map[bool]uint16

MergeBoolUint16 takes two inputs: map[bool]uint16 and map[bool]uint16 and merge two maps and returns a new map[bool]uint16.

func MergeBoolUint16Ptr 

func MergeBoolUint16Ptr(map1, map2 map[*bool]*uint16) map[*bool]*uint16

MergeBoolUint16Ptr takes two inputs: map[bool]uint16 and map[bool]uint16 and merge two maps and returns a new map[bool]uint16.

func MergeBoolUint32 

func MergeBoolUint32(map1, map2 map[bool]uint32) map[bool]uint32

MergeBoolUint32 takes two inputs: map[bool]uint32 and map[bool]uint32 and merge two maps and returns a new map[bool]uint32.

func MergeBoolUint32Ptr 

func MergeBoolUint32Ptr(map1, map2 map[*bool]*uint32) map[*bool]*uint32

MergeBoolUint32Ptr takes two inputs: map[bool]uint32 and map[bool]uint32 and merge two maps and returns a new map[bool]uint32.

func MergeBoolUint64 

func MergeBoolUint64(map1, map2 map[bool]uint64) map[bool]uint64

MergeBoolUint64 takes two inputs: map[bool]uint64 and map[bool]uint64 and merge two maps and returns a new map[bool]uint64.

func MergeBoolUint64Ptr 

func MergeBoolUint64Ptr(map1, map2 map[*bool]*uint64) map[*bool]*uint64

MergeBoolUint64Ptr takes two inputs: map[bool]uint64 and map[bool]uint64 and merge two maps and returns a new map[bool]uint64.

func MergeBoolUint8 

func MergeBoolUint8(map1, map2 map[bool]uint8) map[bool]uint8

MergeBoolUint8 takes two inputs: map[bool]uint8 and map[bool]uint8 and merge two maps and returns a new map[bool]uint8.

func MergeBoolUint8Ptr 

func MergeBoolUint8Ptr(map1, map2 map[*bool]*uint8) map[*bool]*uint8

MergeBoolUint8Ptr takes two inputs: map[bool]uint8 and map[bool]uint8 and merge two maps and returns a new map[bool]uint8.

func MergeBoolUintPtr 

func MergeBoolUintPtr(map1, map2 map[*bool]*uint) map[*bool]*uint

MergeBoolUintPtr takes two inputs: map[bool]uint and map[bool]uint and merge two maps and returns a new map[bool]uint.

func MergeFloat32 

func MergeFloat32(map1, map2 map[float32]float32) map[float32]float32

MergeFloat32 takes two inputs: map[float32]float32 and map[float32]float32 and merge two maps and returns a new map[float32]float32.

func MergeFloat32Bool 

func MergeFloat32Bool(map1, map2 map[float32]bool) map[float32]bool

MergeFloat32Bool takes two inputs: map[float32]bool and map[float32]bool and merge two maps and returns a new map[float32]bool.

func MergeFloat32BoolPtr 

func MergeFloat32BoolPtr(map1, map2 map[*float32]*bool) map[*float32]*bool

MergeFloat32BoolPtr takes two inputs: map[float32]bool and map[float32]bool and merge two maps and returns a new map[float32]bool.

func MergeFloat32Float64 

func MergeFloat32Float64(map1, map2 map[float32]float64) map[float32]float64

MergeFloat32Float64 takes two inputs: map[float32]float64 and map[float32]float64 and merge two maps and returns a new map[float32]float64.

func MergeFloat32Float64Ptr 

func MergeFloat32Float64Ptr(map1, map2 map[*float32]*float64) map[*float32]*float64

MergeFloat32Float64Ptr takes two inputs: map[float32]float64 and map[float32]float64 and merge two maps and returns a new map[float32]float64.

func MergeFloat32Int 

func MergeFloat32Int(map1, map2 map[float32]int) map[float32]int

MergeFloat32Int takes two inputs: map[float32]int and map[float32]int and merge two maps and returns a new map[float32]int.

func MergeFloat32Int16 

func MergeFloat32Int16(map1, map2 map[float32]int16) map[float32]int16

MergeFloat32Int16 takes two inputs: map[float32]int16 and map[float32]int16 and merge two maps and returns a new map[float32]int16.

func MergeFloat32Int16Ptr 

func MergeFloat32Int16Ptr(map1, map2 map[*float32]*int16) map[*float32]*int16

MergeFloat32Int16Ptr takes two inputs: map[float32]int16 and map[float32]int16 and merge two maps and returns a new map[float32]int16.

func MergeFloat32Int32 

func MergeFloat32Int32(map1, map2 map[float32]int32) map[float32]int32

MergeFloat32Int32 takes two inputs: map[float32]int32 and map[float32]int32 and merge two maps and returns a new map[float32]int32.

func MergeFloat32Int32Ptr 

func MergeFloat32Int32Ptr(map1, map2 map[*float32]*int32) map[*float32]*int32

MergeFloat32Int32Ptr takes two inputs: map[float32]int32 and map[float32]int32 and merge two maps and returns a new map[float32]int32.

func MergeFloat32Int64 

func MergeFloat32Int64(map1, map2 map[float32]int64) map[float32]int64

MergeFloat32Int64 takes two inputs: map[float32]int64 and map[float32]int64 and merge two maps and returns a new map[float32]int64.

func MergeFloat32Int64Ptr 

func MergeFloat32Int64Ptr(map1, map2 map[*float32]*int64) map[*float32]*int64

MergeFloat32Int64Ptr takes two inputs: map[float32]int64 and map[float32]int64 and merge two maps and returns a new map[float32]int64.

func MergeFloat32Int8 

func MergeFloat32Int8(map1, map2 map[float32]int8) map[float32]int8

MergeFloat32Int8 takes two inputs: map[float32]int8 and map[float32]int8 and merge two maps and returns a new map[float32]int8.

func MergeFloat32Int8Ptr 

func MergeFloat32Int8Ptr(map1, map2 map[*float32]*int8) map[*float32]*int8

MergeFloat32Int8Ptr takes two inputs: map[float32]int8 and map[float32]int8 and merge two maps and returns a new map[float32]int8.

func MergeFloat32IntPtr 

func MergeFloat32IntPtr(map1, map2 map[*float32]*int) map[*float32]*int

MergeFloat32IntPtr takes two inputs: map[float32]int and map[float32]int and merge two maps and returns a new map[float32]int.

func MergeFloat32Ptr 

func MergeFloat32Ptr(map1, map2 map[*float32]*float32) map[*float32]*float32

MergeFloat32Ptr takes two inputs: map[float32]float32 and map[float32]float32 and merge two maps and returns a new map[float32]float32.

func MergeFloat32Str 

func MergeFloat32Str(map1, map2 map[float32]string) map[float32]string

MergeFloat32Str takes two inputs: map[float32]string and map[float32]string and merge two maps and returns a new map[float32]string.

func MergeFloat32StrPtr 

func MergeFloat32StrPtr(map1, map2 map[*float32]*string) map[*float32]*string

MergeFloat32StrPtr takes two inputs: map[float32]string and map[float32]string and merge two maps and returns a new map[float32]string.

func MergeFloat32Uint 

func MergeFloat32Uint(map1, map2 map[float32]uint) map[float32]uint

MergeFloat32Uint takes two inputs: map[float32]uint and map[float32]uint and merge two maps and returns a new map[float32]uint.

func MergeFloat32Uint16 

func MergeFloat32Uint16(map1, map2 map[float32]uint16) map[float32]uint16

MergeFloat32Uint16 takes two inputs: map[float32]uint16 and map[float32]uint16 and merge two maps and returns a new map[float32]uint16.

func MergeFloat32Uint16Ptr 

func MergeFloat32Uint16Ptr(map1, map2 map[*float32]*uint16) map[*float32]*uint16

MergeFloat32Uint16Ptr takes two inputs: map[float32]uint16 and map[float32]uint16 and merge two maps and returns a new map[float32]uint16.

func MergeFloat32Uint32 

func MergeFloat32Uint32(map1, map2 map[float32]uint32) map[float32]uint32

MergeFloat32Uint32 takes two inputs: map[float32]uint32 and map[float32]uint32 and merge two maps and returns a new map[float32]uint32.

func MergeFloat32Uint32Ptr 

func MergeFloat32Uint32Ptr(map1, map2 map[*float32]*uint32) map[*float32]*uint32

MergeFloat32Uint32Ptr takes two inputs: map[float32]uint32 and map[float32]uint32 and merge two maps and returns a new map[float32]uint32.

func MergeFloat32Uint64 

func MergeFloat32Uint64(map1, map2 map[float32]uint64) map[float32]uint64

MergeFloat32Uint64 takes two inputs: map[float32]uint64 and map[float32]uint64 and merge two maps and returns a new map[float32]uint64.

func MergeFloat32Uint64Ptr 

func MergeFloat32Uint64Ptr(map1, map2 map[*float32]*uint64) map[*float32]*uint64

MergeFloat32Uint64Ptr takes two inputs: map[float32]uint64 and map[float32]uint64 and merge two maps and returns a new map[float32]uint64.

func MergeFloat32Uint8 

func MergeFloat32Uint8(map1, map2 map[float32]uint8) map[float32]uint8

MergeFloat32Uint8 takes two inputs: map[float32]uint8 and map[float32]uint8 and merge two maps and returns a new map[float32]uint8.

func MergeFloat32Uint8Ptr 

func MergeFloat32Uint8Ptr(map1, map2 map[*float32]*uint8) map[*float32]*uint8

MergeFloat32Uint8Ptr takes two inputs: map[float32]uint8 and map[float32]uint8 and merge two maps and returns a new map[float32]uint8.

func MergeFloat32UintPtr 

func MergeFloat32UintPtr(map1, map2 map[*float32]*uint) map[*float32]*uint

MergeFloat32UintPtr takes two inputs: map[float32]uint and map[float32]uint and merge two maps and returns a new map[float32]uint.

func MergeFloat64 

func MergeFloat64(map1, map2 map[float64]float64) map[float64]float64

MergeFloat64 takes two inputs: map[float64]float64 and map[float64]float64 and merge two maps and returns a new map[float64]float64.

func MergeFloat64Bool 

func MergeFloat64Bool(map1, map2 map[float64]bool) map[float64]bool

MergeFloat64Bool takes two inputs: map[float64]bool and map[float64]bool and merge two maps and returns a new map[float64]bool.

func MergeFloat64BoolPtr 

func MergeFloat64BoolPtr(map1, map2 map[*float64]*bool) map[*float64]*bool

MergeFloat64BoolPtr takes two inputs: map[float64]bool and map[float64]bool and merge two maps and returns a new map[float64]bool.

func MergeFloat64Float32 

func MergeFloat64Float32(map1, map2 map[float64]float32) map[float64]float32

MergeFloat64Float32 takes two inputs: map[float64]float32 and map[float64]float32 and merge two maps and returns a new map[float64]float32.

func MergeFloat64Float32Ptr 

func MergeFloat64Float32Ptr(map1, map2 map[*float64]*float32) map[*float64]*float32

MergeFloat64Float32Ptr takes two inputs: map[float64]float32 and map[float64]float32 and merge two maps and returns a new map[float64]float32.

func MergeFloat64Int 

func MergeFloat64Int(map1, map2 map[float64]int) map[float64]int

MergeFloat64Int takes two inputs: map[float64]int and map[float64]int and merge two maps and returns a new map[float64]int.

func MergeFloat64Int16 

func MergeFloat64Int16(map1, map2 map[float64]int16) map[float64]int16

MergeFloat64Int16 takes two inputs: map[float64]int16 and map[float64]int16 and merge two maps and returns a new map[float64]int16.

func MergeFloat64Int16Ptr 

func MergeFloat64Int16Ptr(map1, map2 map[*float64]*int16) map[*float64]*int16

MergeFloat64Int16Ptr takes two inputs: map[float64]int16 and map[float64]int16 and merge two maps and returns a new map[float64]int16.

func MergeFloat64Int32 

func MergeFloat64Int32(map1, map2 map[float64]int32) map[float64]int32

MergeFloat64Int32 takes two inputs: map[float64]int32 and map[float64]int32 and merge two maps and returns a new map[float64]int32.

func MergeFloat64Int32Ptr 

func MergeFloat64Int32Ptr(map1, map2 map[*float64]*int32) map[*float64]*int32

MergeFloat64Int32Ptr takes two inputs: map[float64]int32 and map[float64]int32 and merge two maps and returns a new map[float64]int32.

func MergeFloat64Int64 

func MergeFloat64Int64(map1, map2 map[float64]int64) map[float64]int64

MergeFloat64Int64 takes two inputs: map[float64]int64 and map[float64]int64 and merge two maps and returns a new map[float64]int64.

func MergeFloat64Int64Ptr 

func MergeFloat64Int64Ptr(map1, map2 map[*float64]*int64) map[*float64]*int64

MergeFloat64Int64Ptr takes two inputs: map[float64]int64 and map[float64]int64 and merge two maps and returns a new map[float64]int64.

func MergeFloat64Int8 

func MergeFloat64Int8(map1, map2 map[float64]int8) map[float64]int8

MergeFloat64Int8 takes two inputs: map[float64]int8 and map[float64]int8 and merge two maps and returns a new map[float64]int8.

func MergeFloat64Int8Ptr 

func MergeFloat64Int8Ptr(map1, map2 map[*float64]*int8) map[*float64]*int8

MergeFloat64Int8Ptr takes two inputs: map[float64]int8 and map[float64]int8 and merge two maps and returns a new map[float64]int8.

func MergeFloat64IntPtr 

func MergeFloat64IntPtr(map1, map2 map[*float64]*int) map[*float64]*int

MergeFloat64IntPtr takes two inputs: map[float64]int and map[float64]int and merge two maps and returns a new map[float64]int.

func MergeFloat64Ptr 

func MergeFloat64Ptr(map1, map2 map[*float64]*float64) map[*float64]*float64

MergeFloat64Ptr takes two inputs: map[float64]float64 and map[float64]float64 and merge two maps and returns a new map[float64]float64.

func MergeFloat64Str 

func MergeFloat64Str(map1, map2 map[float64]string) map[float64]string

MergeFloat64Str takes two inputs: map[float64]string and map[float64]string and merge two maps and returns a new map[float64]string.

func MergeFloat64StrPtr 

func MergeFloat64StrPtr(map1, map2 map[*float64]*string) map[*float64]*string

MergeFloat64StrPtr takes two inputs: map[float64]string and map[float64]string and merge two maps and returns a new map[float64]string.

func MergeFloat64Uint 

func MergeFloat64Uint(map1, map2 map[float64]uint) map[float64]uint

MergeFloat64Uint takes two inputs: map[float64]uint and map[float64]uint and merge two maps and returns a new map[float64]uint.

func MergeFloat64Uint16 

func MergeFloat64Uint16(map1, map2 map[float64]uint16) map[float64]uint16

MergeFloat64Uint16 takes two inputs: map[float64]uint16 and map[float64]uint16 and merge two maps and returns a new map[float64]uint16.

func MergeFloat64Uint16Ptr 

func MergeFloat64Uint16Ptr(map1, map2 map[*float64]*uint16) map[*float64]*uint16

MergeFloat64Uint16Ptr takes two inputs: map[float64]uint16 and map[float64]uint16 and merge two maps and returns a new map[float64]uint16.

func MergeFloat64Uint32 

func MergeFloat64Uint32(map1, map2 map[float64]uint32) map[float64]uint32

MergeFloat64Uint32 takes two inputs: map[float64]uint32 and map[float64]uint32 and merge two maps and returns a new map[float64]uint32.

func MergeFloat64Uint32Ptr 

func MergeFloat64Uint32Ptr(map1, map2 map[*float64]*uint32) map[*float64]*uint32

MergeFloat64Uint32Ptr takes two inputs: map[float64]uint32 and map[float64]uint32 and merge two maps and returns a new map[float64]uint32.

func MergeFloat64Uint64 

func MergeFloat64Uint64(map1, map2 map[float64]uint64) map[float64]uint64

MergeFloat64Uint64 takes two inputs: map[float64]uint64 and map[float64]uint64 and merge two maps and returns a new map[float64]uint64.

func MergeFloat64Uint64Ptr 

func MergeFloat64Uint64Ptr(map1, map2 map[*float64]*uint64) map[*float64]*uint64

MergeFloat64Uint64Ptr takes two inputs: map[float64]uint64 and map[float64]uint64 and merge two maps and returns a new map[float64]uint64.

func MergeFloat64Uint8 

func MergeFloat64Uint8(map1, map2 map[float64]uint8) map[float64]uint8

MergeFloat64Uint8 takes two inputs: map[float64]uint8 and map[float64]uint8 and merge two maps and returns a new map[float64]uint8.

func MergeFloat64Uint8Ptr 

func MergeFloat64Uint8Ptr(map1, map2 map[*float64]*uint8) map[*float64]*uint8

MergeFloat64Uint8Ptr takes two inputs: map[float64]uint8 and map[float64]uint8 and merge two maps and returns a new map[float64]uint8.

func MergeFloat64UintPtr 

func MergeFloat64UintPtr(map1, map2 map[*float64]*uint) map[*float64]*uint

MergeFloat64UintPtr takes two inputs: map[float64]uint and map[float64]uint and merge two maps and returns a new map[float64]uint.

func MergeInt 

func MergeInt(map1, map2 map[int]int) map[int]int

MergeInt takes two inputs: map[int]int and map[int]int and merge two maps and returns a new map[int]int.

func MergeInt16 

func MergeInt16(map1, map2 map[int16]int16) map[int16]int16

MergeInt16 takes two inputs: map[int16]int16 and map[int16]int16 and merge two maps and returns a new map[int16]int16.

func MergeInt16Bool 

func MergeInt16Bool(map1, map2 map[int16]bool) map[int16]bool

MergeInt16Bool takes two inputs: map[int16]bool and map[int16]bool and merge two maps and returns a new map[int16]bool.

func MergeInt16BoolPtr 

func MergeInt16BoolPtr(map1, map2 map[*int16]*bool) map[*int16]*bool

MergeInt16BoolPtr takes two inputs: map[int16]bool and map[int16]bool and merge two maps and returns a new map[int16]bool.

func MergeInt16Float32 

func MergeInt16Float32(map1, map2 map[int16]float32) map[int16]float32

MergeInt16Float32 takes two inputs: map[int16]float32 and map[int16]float32 and merge two maps and returns a new map[int16]float32.

func MergeInt16Float32Ptr 

func MergeInt16Float32Ptr(map1, map2 map[*int16]*float32) map[*int16]*float32

MergeInt16Float32Ptr takes two inputs: map[int16]float32 and map[int16]float32 and merge two maps and returns a new map[int16]float32.

func MergeInt16Float64 

func MergeInt16Float64(map1, map2 map[int16]float64) map[int16]float64

MergeInt16Float64 takes two inputs: map[int16]float64 and map[int16]float64 and merge two maps and returns a new map[int16]float64.

func MergeInt16Float64Ptr 

func MergeInt16Float64Ptr(map1, map2 map[*int16]*float64) map[*int16]*float64

MergeInt16Float64Ptr takes two inputs: map[int16]float64 and map[int16]float64 and merge two maps and returns a new map[int16]float64.

func MergeInt16Int 

func MergeInt16Int(map1, map2 map[int16]int) map[int16]int

MergeInt16Int takes two inputs: map[int16]int and map[int16]int and merge two maps and returns a new map[int16]int.

func MergeInt16Int32 

func MergeInt16Int32(map1, map2 map[int16]int32) map[int16]int32

MergeInt16Int32 takes two inputs: map[int16]int32 and map[int16]int32 and merge two maps and returns a new map[int16]int32.

func MergeInt16Int32Ptr 

func MergeInt16Int32Ptr(map1, map2 map[*int16]*int32) map[*int16]*int32

MergeInt16Int32Ptr takes two inputs: map[int16]int32 and map[int16]int32 and merge two maps and returns a new map[int16]int32.

func MergeInt16Int64 

func MergeInt16Int64(map1, map2 map[int16]int64) map[int16]int64

MergeInt16Int64 takes two inputs: map[int16]int64 and map[int16]int64 and merge two maps and returns a new map[int16]int64.

func MergeInt16Int64Ptr 

func MergeInt16Int64Ptr(map1, map2 map[*int16]*int64) map[*int16]*int64

MergeInt16Int64Ptr takes two inputs: map[int16]int64 and map[int16]int64 and merge two maps and returns a new map[int16]int64.

func MergeInt16Int8 

func MergeInt16Int8(map1, map2 map[int16]int8) map[int16]int8

MergeInt16Int8 takes two inputs: map[int16]int8 and map[int16]int8 and merge two maps and returns a new map[int16]int8.

func MergeInt16Int8Ptr 

func MergeInt16Int8Ptr(map1, map2 map[*int16]*int8) map[*int16]*int8

MergeInt16Int8Ptr takes two inputs: map[int16]int8 and map[int16]int8 and merge two maps and returns a new map[int16]int8.

func MergeInt16IntPtr 

func MergeInt16IntPtr(map1, map2 map[*int16]*int) map[*int16]*int

MergeInt16IntPtr takes two inputs: map[int16]int and map[int16]int and merge two maps and returns a new map[int16]int.

func MergeInt16Ptr 

func MergeInt16Ptr(map1, map2 map[*int16]*int16) map[*int16]*int16

MergeInt16Ptr takes two inputs: map[int16]int16 and map[int16]int16 and merge two maps and returns a new map[int16]int16.

func MergeInt16Str 

func MergeInt16Str(map1, map2 map[int16]string) map[int16]string

MergeInt16Str takes two inputs: map[int16]string and map[int16]string and merge two maps and returns a new map[int16]string.

func MergeInt16StrPtr 

func MergeInt16StrPtr(map1, map2 map[*int16]*string) map[*int16]*string

MergeInt16StrPtr takes two inputs: map[int16]string and map[int16]string and merge two maps and returns a new map[int16]string.

func MergeInt16Uint 

func MergeInt16Uint(map1, map2 map[int16]uint) map[int16]uint

MergeInt16Uint takes two inputs: map[int16]uint and map[int16]uint and merge two maps and returns a new map[int16]uint.

func MergeInt16Uint16 

func MergeInt16Uint16(map1, map2 map[int16]uint16) map[int16]uint16

MergeInt16Uint16 takes two inputs: map[int16]uint16 and map[int16]uint16 and merge two maps and returns a new map[int16]uint16.

func MergeInt16Uint16Ptr 

func MergeInt16Uint16Ptr(map1, map2 map[*int16]*uint16) map[*int16]*uint16

MergeInt16Uint16Ptr takes two inputs: map[int16]uint16 and map[int16]uint16 and merge two maps and returns a new map[int16]uint16.

func MergeInt16Uint32 

func MergeInt16Uint32(map1, map2 map[int16]uint32) map[int16]uint32

MergeInt16Uint32 takes two inputs: map[int16]uint32 and map[int16]uint32 and merge two maps and returns a new map[int16]uint32.

func MergeInt16Uint32Ptr 

func MergeInt16Uint32Ptr(map1, map2 map[*int16]*uint32) map[*int16]*uint32

MergeInt16Uint32Ptr takes two inputs: map[int16]uint32 and map[int16]uint32 and merge two maps and returns a new map[int16]uint32.

func MergeInt16Uint64 

func MergeInt16Uint64(map1, map2 map[int16]uint64) map[int16]uint64

MergeInt16Uint64 takes two inputs: map[int16]uint64 and map[int16]uint64 and merge two maps and returns a new map[int16]uint64.

func MergeInt16Uint64Ptr 

func MergeInt16Uint64Ptr(map1, map2 map[*int16]*uint64) map[*int16]*uint64

MergeInt16Uint64Ptr takes two inputs: map[int16]uint64 and map[int16]uint64 and merge two maps and returns a new map[int16]uint64.

func MergeInt16Uint8 

func MergeInt16Uint8(map1, map2 map[int16]uint8) map[int16]uint8

MergeInt16Uint8 takes two inputs: map[int16]uint8 and map[int16]uint8 and merge two maps and returns a new map[int16]uint8.

func MergeInt16Uint8Ptr 

func MergeInt16Uint8Ptr(map1, map2 map[*int16]*uint8) map[*int16]*uint8

MergeInt16Uint8Ptr takes two inputs: map[int16]uint8 and map[int16]uint8 and merge two maps and returns a new map[int16]uint8.

func MergeInt16UintPtr 

func MergeInt16UintPtr(map1, map2 map[*int16]*uint) map[*int16]*uint

MergeInt16UintPtr takes two inputs: map[int16]uint and map[int16]uint and merge two maps and returns a new map[int16]uint.

func MergeInt32 

func MergeInt32(map1, map2 map[int32]int32) map[int32]int32

MergeInt32 takes two inputs: map[int32]int32 and map[int32]int32 and merge two maps and returns a new map[int32]int32.

func MergeInt32Bool 

func MergeInt32Bool(map1, map2 map[int32]bool) map[int32]bool

MergeInt32Bool takes two inputs: map[int32]bool and map[int32]bool and merge two maps and returns a new map[int32]bool.

func MergeInt32BoolPtr 

func MergeInt32BoolPtr(map1, map2 map[*int32]*bool) map[*int32]*bool

MergeInt32BoolPtr takes two inputs: map[int32]bool and map[int32]bool and merge two maps and returns a new map[int32]bool.

func MergeInt32Float32 

func MergeInt32Float32(map1, map2 map[int32]float32) map[int32]float32

MergeInt32Float32 takes two inputs: map[int32]float32 and map[int32]float32 and merge two maps and returns a new map[int32]float32.

func MergeInt32Float32Ptr 

func MergeInt32Float32Ptr(map1, map2 map[*int32]*float32) map[*int32]*float32

MergeInt32Float32Ptr takes two inputs: map[int32]float32 and map[int32]float32 and merge two maps and returns a new map[int32]float32.

func MergeInt32Float64 

func MergeInt32Float64(map1, map2 map[int32]float64) map[int32]float64

MergeInt32Float64 takes two inputs: map[int32]float64 and map[int32]float64 and merge two maps and returns a new map[int32]float64.

func MergeInt32Float64Ptr 

func MergeInt32Float64Ptr(map1, map2 map[*int32]*float64) map[*int32]*float64

MergeInt32Float64Ptr takes two inputs: map[int32]float64 and map[int32]float64 and merge two maps and returns a new map[int32]float64.

func MergeInt32Int 

func MergeInt32Int(map1, map2 map[int32]int) map[int32]int

MergeInt32Int takes two inputs: map[int32]int and map[int32]int and merge two maps and returns a new map[int32]int.

func MergeInt32Int16 

func MergeInt32Int16(map1, map2 map[int32]int16) map[int32]int16

MergeInt32Int16 takes two inputs: map[int32]int16 and map[int32]int16 and merge two maps and returns a new map[int32]int16.

func MergeInt32Int16Ptr 

func MergeInt32Int16Ptr(map1, map2 map[*int32]*int16) map[*int32]*int16

MergeInt32Int16Ptr takes two inputs: map[int32]int16 and map[int32]int16 and merge two maps and returns a new map[int32]int16.

func MergeInt32Int64 

func MergeInt32Int64(map1, map2 map[int32]int64) map[int32]int64

MergeInt32Int64 takes two inputs: map[int32]int64 and map[int32]int64 and merge two maps and returns a new map[int32]int64.

func MergeInt32Int64Ptr 

func MergeInt32Int64Ptr(map1, map2 map[*int32]*int64) map[*int32]*int64

MergeInt32Int64Ptr takes two inputs: map[int32]int64 and map[int32]int64 and merge two maps and returns a new map[int32]int64.

func MergeInt32Int8 

func MergeInt32Int8(map1, map2 map[int32]int8) map[int32]int8

MergeInt32Int8 takes two inputs: map[int32]int8 and map[int32]int8 and merge two maps and returns a new map[int32]int8.

func MergeInt32Int8Ptr 

func MergeInt32Int8Ptr(map1, map2 map[*int32]*int8) map[*int32]*int8

MergeInt32Int8Ptr takes two inputs: map[int32]int8 and map[int32]int8 and merge two maps and returns a new map[int32]int8.

func MergeInt32IntPtr 

func MergeInt32IntPtr(map1, map2 map[*int32]*int) map[*int32]*int

MergeInt32IntPtr takes two inputs: map[int32]int and map[int32]int and merge two maps and returns a new map[int32]int.

func MergeInt32Ptr 

func MergeInt32Ptr(map1, map2 map[*int32]*int32) map[*int32]*int32

MergeInt32Ptr takes two inputs: map[int32]int32 and map[int32]int32 and merge two maps and returns a new map[int32]int32.

func MergeInt32Str 

func MergeInt32Str(map1, map2 map[int32]string) map[int32]string

MergeInt32Str takes two inputs: map[int32]string and map[int32]string and merge two maps and returns a new map[int32]string.

func MergeInt32StrPtr 

func MergeInt32StrPtr(map1, map2 map[*int32]*string) map[*int32]*string

MergeInt32StrPtr takes two inputs: map[int32]string and map[int32]string and merge two maps and returns a new map[int32]string.

func MergeInt32Uint 

func MergeInt32Uint(map1, map2 map[int32]uint) map[int32]uint

MergeInt32Uint takes two inputs: map[int32]uint and map[int32]uint and merge two maps and returns a new map[int32]uint.

func MergeInt32Uint16 

func MergeInt32Uint16(map1, map2 map[int32]uint16) map[int32]uint16

MergeInt32Uint16 takes two inputs: map[int32]uint16 and map[int32]uint16 and merge two maps and returns a new map[int32]uint16.

func MergeInt32Uint16Ptr 

func MergeInt32Uint16Ptr(map1, map2 map[*int32]*uint16) map[*int32]*uint16

MergeInt32Uint16Ptr takes two inputs: map[int32]uint16 and map[int32]uint16 and merge two maps and returns a new map[int32]uint16.

func MergeInt32Uint32 

func MergeInt32Uint32(map1, map2 map[int32]uint32) map[int32]uint32

MergeInt32Uint32 takes two inputs: map[int32]uint32 and map[int32]uint32 and merge two maps and returns a new map[int32]uint32.

func MergeInt32Uint32Ptr 

func MergeInt32Uint32Ptr(map1, map2 map[*int32]*uint32) map[*int32]*uint32

MergeInt32Uint32Ptr takes two inputs: map[int32]uint32 and map[int32]uint32 and merge two maps and returns a new map[int32]uint32.

func MergeInt32Uint64 

func MergeInt32Uint64(map1, map2 map[int32]uint64) map[int32]uint64

MergeInt32Uint64 takes two inputs: map[int32]uint64 and map[int32]uint64 and merge two maps and returns a new map[int32]uint64.

func MergeInt32Uint64Ptr 

func MergeInt32Uint64Ptr(map1, map2 map[*int32]*uint64) map[*int32]*uint64

MergeInt32Uint64Ptr takes two inputs: map[int32]uint64 and map[int32]uint64 and merge two maps and returns a new map[int32]uint64.

func MergeInt32Uint8 

func MergeInt32Uint8(map1, map2 map[int32]uint8) map[int32]uint8

MergeInt32Uint8 takes two inputs: map[int32]uint8 and map[int32]uint8 and merge two maps and returns a new map[int32]uint8.

func MergeInt32Uint8Ptr 

func MergeInt32Uint8Ptr(map1, map2 map[*int32]*uint8) map[*int32]*uint8

MergeInt32Uint8Ptr takes two inputs: map[int32]uint8 and map[int32]uint8 and merge two maps and returns a new map[int32]uint8.

func MergeInt32UintPtr 

func MergeInt32UintPtr(map1, map2 map[*int32]*uint) map[*int32]*uint

MergeInt32UintPtr takes two inputs: map[int32]uint and map[int32]uint and merge two maps and returns a new map[int32]uint.

func MergeInt64 

func MergeInt64(map1, map2 map[int64]int64) map[int64]int64

MergeInt64 takes two inputs: map[int64]int64 and map[int64]int64 and merge two maps and returns a new map[int64]int64.

func MergeInt64Bool 

func MergeInt64Bool(map1, map2 map[int64]bool) map[int64]bool

MergeInt64Bool takes two inputs: map[int64]bool and map[int64]bool and merge two maps and returns a new map[int64]bool.

func MergeInt64BoolPtr 

func MergeInt64BoolPtr(map1, map2 map[*int64]*bool) map[*int64]*bool

MergeInt64BoolPtr takes two inputs: map[int64]bool and map[int64]bool and merge two maps and returns a new map[int64]bool.

func MergeInt64Float32 

func MergeInt64Float32(map1, map2 map[int64]float32) map[int64]float32

MergeInt64Float32 takes two inputs: map[int64]float32 and map[int64]float32 and merge two maps and returns a new map[int64]float32.

func MergeInt64Float32Ptr 

func MergeInt64Float32Ptr(map1, map2 map[*int64]*float32) map[*int64]*float32

MergeInt64Float32Ptr takes two inputs: map[int64]float32 and map[int64]float32 and merge two maps and returns a new map[int64]float32.

func MergeInt64Float64 

func MergeInt64Float64(map1, map2 map[int64]float64) map[int64]float64

MergeInt64Float64 takes two inputs: map[int64]float64 and map[int64]float64 and merge two maps and returns a new map[int64]float64.

func MergeInt64Float64Ptr 

func MergeInt64Float64Ptr(map1, map2 map[*int64]*float64) map[*int64]*float64

MergeInt64Float64Ptr takes two inputs: map[int64]float64 and map[int64]float64 and merge two maps and returns a new map[int64]float64.

func MergeInt64Int 

func MergeInt64Int(map1, map2 map[int64]int) map[int64]int

MergeInt64Int takes two inputs: map[int64]int and map[int64]int and merge two maps and returns a new map[int64]int.

func MergeInt64Int16 

func MergeInt64Int16(map1, map2 map[int64]int16) map[int64]int16

MergeInt64Int16 takes two inputs: map[int64]int16 and map[int64]int16 and merge two maps and returns a new map[int64]int16.

func MergeInt64Int16Ptr 

func MergeInt64Int16Ptr(map1, map2 map[*int64]*int16) map[*int64]*int16

MergeInt64Int16Ptr takes two inputs: map[int64]int16 and map[int64]int16 and merge two maps and returns a new map[int64]int16.

func MergeInt64Int32 

func MergeInt64Int32(map1, map2 map[int64]int32) map[int64]int32

MergeInt64Int32 takes two inputs: map[int64]int32 and map[int64]int32 and merge two maps and returns a new map[int64]int32.

func MergeInt64Int32Ptr 

func MergeInt64Int32Ptr(map1, map2 map[*int64]*int32) map[*int64]*int32

MergeInt64Int32Ptr takes two inputs: map[int64]int32 and map[int64]int32 and merge two maps and returns a new map[int64]int32.

func MergeInt64Int8 

func MergeInt64Int8(map1, map2 map[int64]int8) map[int64]int8

MergeInt64Int8 takes two inputs: map[int64]int8 and map[int64]int8 and merge two maps and returns a new map[int64]int8.

func MergeInt64Int8Ptr 

func MergeInt64Int8Ptr(map1, map2 map[*int64]*int8) map[*int64]*int8

MergeInt64Int8Ptr takes two inputs: map[int64]int8 and map[int64]int8 and merge two maps and returns a new map[int64]int8.

func MergeInt64IntPtr 

func MergeInt64IntPtr(map1, map2 map[*int64]*int) map[*int64]*int

MergeInt64IntPtr takes two inputs: map[int64]int and map[int64]int and merge two maps and returns a new map[int64]int.

func MergeInt64Ptr 

func MergeInt64Ptr(map1, map2 map[*int64]*int64) map[*int64]*int64

MergeInt64Ptr takes two inputs: map[int64]int64 and map[int64]int64 and merge two maps and returns a new map[int64]int64.

func MergeInt64Str 

func MergeInt64Str(map1, map2 map[int64]string) map[int64]string

MergeInt64Str takes two inputs: map[int64]string and map[int64]string and merge two maps and returns a new map[int64]string.

func MergeInt64StrPtr 

func MergeInt64StrPtr(map1, map2 map[*int64]*string) map[*int64]*string

MergeInt64StrPtr takes two inputs: map[int64]string and map[int64]string and merge two maps and returns a new map[int64]string.

func MergeInt64Uint 

func MergeInt64Uint(map1, map2 map[int64]uint) map[int64]uint

MergeInt64Uint takes two inputs: map[int64]uint and map[int64]uint and merge two maps and returns a new map[int64]uint.

func MergeInt64Uint16 

func MergeInt64Uint16(map1, map2 map[int64]uint16) map[int64]uint16

MergeInt64Uint16 takes two inputs: map[int64]uint16 and map[int64]uint16 and merge two maps and returns a new map[int64]uint16.

func MergeInt64Uint16Ptr 

func MergeInt64Uint16Ptr(map1, map2 map[*int64]*uint16) map[*int64]*uint16

MergeInt64Uint16Ptr takes two inputs: map[int64]uint16 and map[int64]uint16 and merge two maps and returns a new map[int64]uint16.

func MergeInt64Uint32 

func MergeInt64Uint32(map1, map2 map[int64]uint32) map[int64]uint32

MergeInt64Uint32 takes two inputs: map[int64]uint32 and map[int64]uint32 and merge two maps and returns a new map[int64]uint32.

func MergeInt64Uint32Ptr 

func MergeInt64Uint32Ptr(map1, map2 map[*int64]*uint32) map[*int64]*uint32

MergeInt64Uint32Ptr takes two inputs: map[int64]uint32 and map[int64]uint32 and merge two maps and returns a new map[int64]uint32.

func MergeInt64Uint64 

func MergeInt64Uint64(map1, map2 map[int64]uint64) map[int64]uint64

MergeInt64Uint64 takes two inputs: map[int64]uint64 and map[int64]uint64 and merge two maps and returns a new map[int64]uint64.

func MergeInt64Uint64Ptr 

func MergeInt64Uint64Ptr(map1, map2 map[*int64]*uint64) map[*int64]*uint64

MergeInt64Uint64Ptr takes two inputs: map[int64]uint64 and map[int64]uint64 and merge two maps and returns a new map[int64]uint64.

func MergeInt64Uint8 

func MergeInt64Uint8(map1, map2 map[int64]uint8) map[int64]uint8

MergeInt64Uint8 takes two inputs: map[int64]uint8 and map[int64]uint8 and merge two maps and returns a new map[int64]uint8.

func MergeInt64Uint8Ptr 

func MergeInt64Uint8Ptr(map1, map2 map[*int64]*uint8) map[*int64]*uint8

MergeInt64Uint8Ptr takes two inputs: map[int64]uint8 and map[int64]uint8 and merge two maps and returns a new map[int64]uint8.

func MergeInt64UintPtr 

func MergeInt64UintPtr(map1, map2 map[*int64]*uint) map[*int64]*uint

MergeInt64UintPtr takes two inputs: map[int64]uint and map[int64]uint and merge two maps and returns a new map[int64]uint.

func MergeInt8 

func MergeInt8(map1, map2 map[int8]int8) map[int8]int8

MergeInt8 takes two inputs: map[int8]int8 and map[int8]int8 and merge two maps and returns a new map[int8]int8.

func MergeInt8Bool 

func MergeInt8Bool(map1, map2 map[int8]bool) map[int8]bool

MergeInt8Bool takes two inputs: map[int8]bool and map[int8]bool and merge two maps and returns a new map[int8]bool.

func MergeInt8BoolPtr 

func MergeInt8BoolPtr(map1, map2 map[*int8]*bool) map[*int8]*bool

MergeInt8BoolPtr takes two inputs: map[int8]bool and map[int8]bool and merge two maps and returns a new map[int8]bool.

func MergeInt8Float32 

func MergeInt8Float32(map1, map2 map[int8]float32) map[int8]float32

MergeInt8Float32 takes two inputs: map[int8]float32 and map[int8]float32 and merge two maps and returns a new map[int8]float32.

func MergeInt8Float32Ptr 

func MergeInt8Float32Ptr(map1, map2 map[*int8]*float32) map[*int8]*float32

MergeInt8Float32Ptr takes two inputs: map[int8]float32 and map[int8]float32 and merge two maps and returns a new map[int8]float32.

func MergeInt8Float64 

func MergeInt8Float64(map1, map2 map[int8]float64) map[int8]float64

MergeInt8Float64 takes two inputs: map[int8]float64 and map[int8]float64 and merge two maps and returns a new map[int8]float64.

func MergeInt8Float64Ptr 

func MergeInt8Float64Ptr(map1, map2 map[*int8]*float64) map[*int8]*float64

MergeInt8Float64Ptr takes two inputs: map[int8]float64 and map[int8]float64 and merge two maps and returns a new map[int8]float64.

func MergeInt8Int 

func MergeInt8Int(map1, map2 map[int8]int) map[int8]int

MergeInt8Int takes two inputs: map[int8]int and map[int8]int and merge two maps and returns a new map[int8]int.

func MergeInt8Int16 

func MergeInt8Int16(map1, map2 map[int8]int16) map[int8]int16

MergeInt8Int16 takes two inputs: map[int8]int16 and map[int8]int16 and merge two maps and returns a new map[int8]int16.

func MergeInt8Int16Ptr 

func MergeInt8Int16Ptr(map1, map2 map[*int8]*int16) map[*int8]*int16

MergeInt8Int16Ptr takes two inputs: map[int8]int16 and map[int8]int16 and merge two maps and returns a new map[int8]int16.

func MergeInt8Int32 

func MergeInt8Int32(map1, map2 map[int8]int32) map[int8]int32

MergeInt8Int32 takes two inputs: map[int8]int32 and map[int8]int32 and merge two maps and returns a new map[int8]int32.

func MergeInt8Int32Ptr 

func MergeInt8Int32Ptr(map1, map2 map[*int8]*int32) map[*int8]*int32

MergeInt8Int32Ptr takes two inputs: map[int8]int32 and map[int8]int32 and merge two maps and returns a new map[int8]int32.

func MergeInt8Int64 

func MergeInt8Int64(map1, map2 map[int8]int64) map[int8]int64

MergeInt8Int64 takes two inputs: map[int8]int64 and map[int8]int64 and merge two maps and returns a new map[int8]int64.

func MergeInt8Int64Ptr 

func MergeInt8Int64Ptr(map1, map2 map[*int8]*int64) map[*int8]*int64

MergeInt8Int64Ptr takes two inputs: map[int8]int64 and map[int8]int64 and merge two maps and returns a new map[int8]int64.

func MergeInt8IntPtr 

func MergeInt8IntPtr(map1, map2 map[*int8]*int) map[*int8]*int

MergeInt8IntPtr takes two inputs: map[int8]int and map[int8]int and merge two maps and returns a new map[int8]int.

func MergeInt8Ptr 

func MergeInt8Ptr(map1, map2 map[*int8]*int8) map[*int8]*int8

MergeInt8Ptr takes two inputs: map[int8]int8 and map[int8]int8 and merge two maps and returns a new map[int8]int8.

func MergeInt8Str 

func MergeInt8Str(map1, map2 map[int8]string) map[int8]string

MergeInt8Str takes two inputs: map[int8]string and map[int8]string and merge two maps and returns a new map[int8]string.

func MergeInt8StrPtr 

func MergeInt8StrPtr(map1, map2 map[*int8]*string) map[*int8]*string

MergeInt8StrPtr takes two inputs: map[int8]string and map[int8]string and merge two maps and returns a new map[int8]string.

func MergeInt8Uint 

func MergeInt8Uint(map1, map2 map[int8]uint) map[int8]uint

MergeInt8Uint takes two inputs: map[int8]uint and map[int8]uint and merge two maps and returns a new map[int8]uint.

func MergeInt8Uint16 

func MergeInt8Uint16(map1, map2 map[int8]uint16) map[int8]uint16

MergeInt8Uint16 takes two inputs: map[int8]uint16 and map[int8]uint16 and merge two maps and returns a new map[int8]uint16.

func MergeInt8Uint16Ptr 

func MergeInt8Uint16Ptr(map1, map2 map[*int8]*uint16) map[*int8]*uint16

MergeInt8Uint16Ptr takes two inputs: map[int8]uint16 and map[int8]uint16 and merge two maps and returns a new map[int8]uint16.

func MergeInt8Uint32 

func MergeInt8Uint32(map1, map2 map[int8]uint32) map[int8]uint32

MergeInt8Uint32 takes two inputs: map[int8]uint32 and map[int8]uint32 and merge two maps and returns a new map[int8]uint32.

func MergeInt8Uint32Ptr 

func MergeInt8Uint32Ptr(map1, map2 map[*int8]*uint32) map[*int8]*uint32

MergeInt8Uint32Ptr takes two inputs: map[int8]uint32 and map[int8]uint32 and merge two maps and returns a new map[int8]uint32.

func MergeInt8Uint64 

func MergeInt8Uint64(map1, map2 map[int8]uint64) map[int8]uint64

MergeInt8Uint64 takes two inputs: map[int8]uint64 and map[int8]uint64 and merge two maps and returns a new map[int8]uint64.

func MergeInt8Uint64Ptr 

func MergeInt8Uint64Ptr(map1, map2 map[*int8]*uint64) map[*int8]*uint64

MergeInt8Uint64Ptr takes two inputs: map[int8]uint64 and map[int8]uint64 and merge two maps and returns a new map[int8]uint64.

func MergeInt8Uint8 

func MergeInt8Uint8(map1, map2 map[int8]uint8) map[int8]uint8

MergeInt8Uint8 takes two inputs: map[int8]uint8 and map[int8]uint8 and merge two maps and returns a new map[int8]uint8.

func MergeInt8Uint8Ptr 

func MergeInt8Uint8Ptr(map1, map2 map[*int8]*uint8) map[*int8]*uint8

MergeInt8Uint8Ptr takes two inputs: map[int8]uint8 and map[int8]uint8 and merge two maps and returns a new map[int8]uint8.

func MergeInt8UintPtr 

func MergeInt8UintPtr(map1, map2 map[*int8]*uint) map[*int8]*uint

MergeInt8UintPtr takes two inputs: map[int8]uint and map[int8]uint and merge two maps and returns a new map[int8]uint.

func MergeIntBool 

func MergeIntBool(map1, map2 map[int]bool) map[int]bool

MergeIntBool takes two inputs: map[int]bool and map[int]bool and merge two maps and returns a new map[int]bool.

func MergeIntBoolPtr 

func MergeIntBoolPtr(map1, map2 map[*int]*bool) map[*int]*bool

MergeIntBoolPtr takes two inputs: map[int]bool and map[int]bool and merge two maps and returns a new map[int]bool.

func MergeIntFloat32 

func MergeIntFloat32(map1, map2 map[int]float32) map[int]float32

MergeIntFloat32 takes two inputs: map[int]float32 and map[int]float32 and merge two maps and returns a new map[int]float32.

func MergeIntFloat32Ptr 

func MergeIntFloat32Ptr(map1, map2 map[*int]*float32) map[*int]*float32

MergeIntFloat32Ptr takes two inputs: map[int]float32 and map[int]float32 and merge two maps and returns a new map[int]float32.

func MergeIntFloat64 

func MergeIntFloat64(map1, map2 map[int]float64) map[int]float64

MergeIntFloat64 takes two inputs: map[int]float64 and map[int]float64 and merge two maps and returns a new map[int]float64.

func MergeIntFloat64Ptr 

func MergeIntFloat64Ptr(map1, map2 map[*int]*float64) map[*int]*float64

MergeIntFloat64Ptr takes two inputs: map[int]float64 and map[int]float64 and merge two maps and returns a new map[int]float64.

func MergeIntInt16 

func MergeIntInt16(map1, map2 map[int]int16) map[int]int16

MergeIntInt16 takes two inputs: map[int]int16 and map[int]int16 and merge two maps and returns a new map[int]int16.

func MergeIntInt16Ptr 

func MergeIntInt16Ptr(map1, map2 map[*int]*int16) map[*int]*int16

MergeIntInt16Ptr takes two inputs: map[int]int16 and map[int]int16 and merge two maps and returns a new map[int]int16.

func MergeIntInt32 

func MergeIntInt32(map1, map2 map[int]int32) map[int]int32

MergeIntInt32 takes two inputs: map[int]int32 and map[int]int32 and merge two maps and returns a new map[int]int32.

func MergeIntInt32Ptr 

func MergeIntInt32Ptr(map1, map2 map[*int]*int32) map[*int]*int32

MergeIntInt32Ptr takes two inputs: map[int]int32 and map[int]int32 and merge two maps and returns a new map[int]int32.

func MergeIntInt64 

func MergeIntInt64(map1, map2 map[int]int64) map[int]int64

MergeIntInt64 takes two inputs: map[int]int64 and map[int]int64 and merge two maps and returns a new map[int]int64.

func MergeIntInt64Ptr 

func MergeIntInt64Ptr(map1, map2 map[*int]*int64) map[*int]*int64

MergeIntInt64Ptr takes two inputs: map[int]int64 and map[int]int64 and merge two maps and returns a new map[int]int64.

func MergeIntInt8 

func MergeIntInt8(map1, map2 map[int]int8) map[int]int8

MergeIntInt8 takes two inputs: map[int]int8 and map[int]int8 and merge two maps and returns a new map[int]int8.

func MergeIntInt8Ptr 

func MergeIntInt8Ptr(map1, map2 map[*int]*int8) map[*int]*int8

MergeIntInt8Ptr takes two inputs: map[int]int8 and map[int]int8 and merge two maps and returns a new map[int]int8.

func MergeIntPtr 

func MergeIntPtr(map1, map2 map[*int]*int) map[*int]*int

MergeIntPtr takes two inputs: map[int]int and map[int]int and merge two maps and returns a new map[int]int.

func MergeIntStr 

func MergeIntStr(map1, map2 map[int]string) map[int]string

MergeIntStr takes two inputs: map[int]string and map[int]string and merge two maps and returns a new map[int]string.

func MergeIntStrPtr 

func MergeIntStrPtr(map1, map2 map[*int]*string) map[*int]*string

MergeIntStrPtr takes two inputs: map[int]string and map[int]string and merge two maps and returns a new map[int]string.

func MergeIntUint 

func MergeIntUint(map1, map2 map[int]uint) map[int]uint

MergeIntUint takes two inputs: map[int]uint and map[int]uint and merge two maps and returns a new map[int]uint.

func MergeIntUint16 

func MergeIntUint16(map1, map2 map[int]uint16) map[int]uint16

MergeIntUint16 takes two inputs: map[int]uint16 and map[int]uint16 and merge two maps and returns a new map[int]uint16.

func MergeIntUint16Ptr 

func MergeIntUint16Ptr(map1, map2 map[*int]*uint16) map[*int]*uint16

MergeIntUint16Ptr takes two inputs: map[int]uint16 and map[int]uint16 and merge two maps and returns a new map[int]uint16.

func MergeIntUint32 

func MergeIntUint32(map1, map2 map[int]uint32) map[int]uint32

MergeIntUint32 takes two inputs: map[int]uint32 and map[int]uint32 and merge two maps and returns a new map[int]uint32.

func MergeIntUint32Ptr 

func MergeIntUint32Ptr(map1, map2 map[*int]*uint32) map[*int]*uint32

MergeIntUint32Ptr takes two inputs: map[int]uint32 and map[int]uint32 and merge two maps and returns a new map[int]uint32.

func MergeIntUint64 

func MergeIntUint64(map1, map2 map[int]uint64) map[int]uint64

MergeIntUint64 takes two inputs: map[int]uint64 and map[int]uint64 and merge two maps and returns a new map[int]uint64.

func MergeIntUint64Ptr 

func MergeIntUint64Ptr(map1, map2 map[*int]*uint64) map[*int]*uint64

MergeIntUint64Ptr takes two inputs: map[int]uint64 and map[int]uint64 and merge two maps and returns a new map[int]uint64.

func MergeIntUint8 

func MergeIntUint8(map1, map2 map[int]uint8) map[int]uint8

MergeIntUint8 takes two inputs: map[int]uint8 and map[int]uint8 and merge two maps and returns a new map[int]uint8.

func MergeIntUint8Ptr 

func MergeIntUint8Ptr(map1, map2 map[*int]*uint8) map[*int]*uint8

MergeIntUint8Ptr takes two inputs: map[int]uint8 and map[int]uint8 and merge two maps and returns a new map[int]uint8.

func MergeIntUintPtr 

func MergeIntUintPtr(map1, map2 map[*int]*uint) map[*int]*uint

MergeIntUintPtr takes two inputs: map[int]uint and map[int]uint and merge two maps and returns a new map[int]uint.

func MergeStr 

func MergeStr(map1, map2 map[string]string) map[string]string

MergeStr takes two inputs: map[string]string and map[string]string and merge two maps and returns a new map[string]string.

func MergeStrBool 

func MergeStrBool(map1, map2 map[string]bool) map[string]bool

MergeStrBool takes two inputs: map[string]bool and map[string]bool and merge two maps and returns a new map[string]bool.

func MergeStrBoolPtr 

func MergeStrBoolPtr(map1, map2 map[*string]*bool) map[*string]*bool

MergeStrBoolPtr takes two inputs: map[string]bool and map[string]bool and merge two maps and returns a new map[string]bool.

func MergeStrFloat32 

func MergeStrFloat32(map1, map2 map[string]float32) map[string]float32

MergeStrFloat32 takes two inputs: map[string]float32 and map[string]float32 and merge two maps and returns a new map[string]float32.

func MergeStrFloat32Ptr 

func MergeStrFloat32Ptr(map1, map2 map[*string]*float32) map[*string]*float32

MergeStrFloat32Ptr takes two inputs: map[string]float32 and map[string]float32 and merge two maps and returns a new map[string]float32.

func MergeStrFloat64 

func MergeStrFloat64(map1, map2 map[string]float64) map[string]float64

MergeStrFloat64 takes two inputs: map[string]float64 and map[string]float64 and merge two maps and returns a new map[string]float64.

func MergeStrFloat64Ptr 

func MergeStrFloat64Ptr(map1, map2 map[*string]*float64) map[*string]*float64

MergeStrFloat64Ptr takes two inputs: map[string]float64 and map[string]float64 and merge two maps and returns a new map[string]float64.

func MergeStrInt 

func MergeStrInt(map1, map2 map[string]int) map[string]int

MergeStrInt takes two inputs: map[string]int and map[string]int and merge two maps and returns a new map[string]int.

func MergeStrInt16 

func MergeStrInt16(map1, map2 map[string]int16) map[string]int16

MergeStrInt16 takes two inputs: map[string]int16 and map[string]int16 and merge two maps and returns a new map[string]int16.

func MergeStrInt16Ptr 

func MergeStrInt16Ptr(map1, map2 map[*string]*int16) map[*string]*int16

MergeStrInt16Ptr takes two inputs: map[string]int16 and map[string]int16 and merge two maps and returns a new map[string]int16.

func MergeStrInt32 

func MergeStrInt32(map1, map2 map[string]int32) map[string]int32

MergeStrInt32 takes two inputs: map[string]int32 and map[string]int32 and merge two maps and returns a new map[string]int32.

func MergeStrInt32Ptr 

func MergeStrInt32Ptr(map1, map2 map[*string]*int32) map[*string]*int32

MergeStrInt32Ptr takes two inputs: map[string]int32 and map[string]int32 and merge two maps and returns a new map[string]int32.

func MergeStrInt64 

func MergeStrInt64(map1, map2 map[string]int64) map[string]int64

MergeStrInt64 takes two inputs: map[string]int64 and map[string]int64 and merge two maps and returns a new map[string]int64.

func MergeStrInt64Ptr 

func MergeStrInt64Ptr(map1, map2 map[*string]*int64) map[*string]*int64

MergeStrInt64Ptr takes two inputs: map[string]int64 and map[string]int64 and merge two maps and returns a new map[string]int64.

func MergeStrInt8 

func MergeStrInt8(map1, map2 map[string]int8) map[string]int8

MergeStrInt8 takes two inputs: map[string]int8 and map[string]int8 and merge two maps and returns a new map[string]int8.

func MergeStrInt8Ptr 

func MergeStrInt8Ptr(map1, map2 map[*string]*int8) map[*string]*int8

MergeStrInt8Ptr takes two inputs: map[string]int8 and map[string]int8 and merge two maps and returns a new map[string]int8.

func MergeStrIntPtr 

func MergeStrIntPtr(map1, map2 map[*string]*int) map[*string]*int

MergeStrIntPtr takes two inputs: map[string]int and map[string]int and merge two maps and returns a new map[string]int.

func MergeStrPtr 

func MergeStrPtr(map1, map2 map[*string]*string) map[*string]*string

MergeStrPtr takes two inputs: map[string]string and map[string]string and merge two maps and returns a new map[string]string.

func MergeStrUint 

func MergeStrUint(map1, map2 map[string]uint) map[string]uint

MergeStrUint takes two inputs: map[string]uint and map[string]uint and merge two maps and returns a new map[string]uint.

func MergeStrUint16 

func MergeStrUint16(map1, map2 map[string]uint16) map[string]uint16

MergeStrUint16 takes two inputs: map[string]uint16 and map[string]uint16 and merge two maps and returns a new map[string]uint16.

func MergeStrUint16Ptr 

func MergeStrUint16Ptr(map1, map2 map[*string]*uint16) map[*string]*uint16

MergeStrUint16Ptr takes two inputs: map[string]uint16 and map[string]uint16 and merge two maps and returns a new map[string]uint16.

func MergeStrUint32 

func MergeStrUint32(map1, map2 map[string]uint32) map[string]uint32

MergeStrUint32 takes two inputs: map[string]uint32 and map[string]uint32 and merge two maps and returns a new map[string]uint32.

func MergeStrUint32Ptr 

func MergeStrUint32Ptr(map1, map2 map[*string]*uint32) map[*string]*uint32

MergeStrUint32Ptr takes two inputs: map[string]uint32 and map[string]uint32 and merge two maps and returns a new map[string]uint32.

func MergeStrUint64 

func MergeStrUint64(map1, map2 map[string]uint64) map[string]uint64

MergeStrUint64 takes two inputs: map[string]uint64 and map[string]uint64 and merge two maps and returns a new map[string]uint64.

func MergeStrUint64Ptr 

func MergeStrUint64Ptr(map1, map2 map[*string]*uint64) map[*string]*uint64

MergeStrUint64Ptr takes two inputs: map[string]uint64 and map[string]uint64 and merge two maps and returns a new map[string]uint64.

func MergeStrUint8 

func MergeStrUint8(map1, map2 map[string]uint8) map[string]uint8

MergeStrUint8 takes two inputs: map[string]uint8 and map[string]uint8 and merge two maps and returns a new map[string]uint8.

func MergeStrUint8Ptr 

func MergeStrUint8Ptr(map1, map2 map[*string]*uint8) map[*string]*uint8

MergeStrUint8Ptr takes two inputs: map[string]uint8 and map[string]uint8 and merge two maps and returns a new map[string]uint8.

func MergeStrUintPtr 

func MergeStrUintPtr(map1, map2 map[*string]*uint) map[*string]*uint

MergeStrUintPtr takes two inputs: map[string]uint and map[string]uint and merge two maps and returns a new map[string]uint.

func MergeUint 

func MergeUint(map1, map2 map[uint]uint) map[uint]uint

MergeUint takes two inputs: map[uint]uint and map[uint]uint and merge two maps and returns a new map[uint]uint.

func MergeUint16 

func MergeUint16(map1, map2 map[uint16]uint16) map[uint16]uint16

MergeUint16 takes two inputs: map[uint16]uint16 and map[uint16]uint16 and merge two maps and returns a new map[uint16]uint16.

func MergeUint16Bool 

func MergeUint16Bool(map1, map2 map[uint16]bool) map[uint16]bool

MergeUint16Bool takes two inputs: map[uint16]bool and map[uint16]bool and merge two maps and returns a new map[uint16]bool.

func MergeUint16BoolPtr 

func MergeUint16BoolPtr(map1, map2 map[*uint16]*bool) map[*uint16]*bool

MergeUint16BoolPtr takes two inputs: map[uint16]bool and map[uint16]bool and merge two maps and returns a new map[uint16]bool.

func MergeUint16Float32 

func MergeUint16Float32(map1, map2 map[uint16]float32) map[uint16]float32

MergeUint16Float32 takes two inputs: map[uint16]float32 and map[uint16]float32 and merge two maps and returns a new map[uint16]float32.

func MergeUint16Float32Ptr 

func MergeUint16Float32Ptr(map1, map2 map[*uint16]*float32) map[*uint16]*float32

MergeUint16Float32Ptr takes two inputs: map[uint16]float32 and map[uint16]float32 and merge two maps and returns a new map[uint16]float32.

func MergeUint16Float64 

func MergeUint16Float64(map1, map2 map[uint16]float64) map[uint16]float64

MergeUint16Float64 takes two inputs: map[uint16]float64 and map[uint16]float64 and merge two maps and returns a new map[uint16]float64.

func MergeUint16Float64Ptr 

func MergeUint16Float64Ptr(map1, map2 map[*uint16]*float64) map[*uint16]*float64

MergeUint16Float64Ptr takes two inputs: map[uint16]float64 and map[uint16]float64 and merge two maps and returns a new map[uint16]float64.

func MergeUint16Int 

func MergeUint16Int(map1, map2 map[uint16]int) map[uint16]int

MergeUint16Int takes two inputs: map[uint16]int and map[uint16]int and merge two maps and returns a new map[uint16]int.

func MergeUint16Int16 

func MergeUint16Int16(map1, map2 map[uint16]int16) map[uint16]int16

MergeUint16Int16 takes two inputs: map[uint16]int16 and map[uint16]int16 and merge two maps and returns a new map[uint16]int16.

func MergeUint16Int16Ptr 

func MergeUint16Int16Ptr(map1, map2 map[*uint16]*int16) map[*uint16]*int16

MergeUint16Int16Ptr takes two inputs: map[uint16]int16 and map[uint16]int16 and merge two maps and returns a new map[uint16]int16.

func MergeUint16Int32 

func MergeUint16Int32(map1, map2 map[uint16]int32) map[uint16]int32

MergeUint16Int32 takes two inputs: map[uint16]int32 and map[uint16]int32 and merge two maps and returns a new map[uint16]int32.

func MergeUint16Int32Ptr 

func MergeUint16Int32Ptr(map1, map2 map[*uint16]*int32) map[*uint16]*int32

MergeUint16Int32Ptr takes two inputs: map[uint16]int32 and map[uint16]int32 and merge two maps and returns a new map[uint16]int32.

func MergeUint16Int64 

func MergeUint16Int64(map1, map2 map[uint16]int64) map[uint16]int64

MergeUint16Int64 takes two inputs: map[uint16]int64 and map[uint16]int64 and merge two maps and returns a new map[uint16]int64.

func MergeUint16Int64Ptr 

func MergeUint16Int64Ptr(map1, map2 map[*uint16]*int64) map[*uint16]*int64

MergeUint16Int64Ptr takes two inputs: map[uint16]int64 and map[uint16]int64 and merge two maps and returns a new map[uint16]int64.

func MergeUint16Int8 

func MergeUint16Int8(map1, map2 map[uint16]int8) map[uint16]int8

MergeUint16Int8 takes two inputs: map[uint16]int8 and map[uint16]int8 and merge two maps and returns a new map[uint16]int8.

func MergeUint16Int8Ptr 

func MergeUint16Int8Ptr(map1, map2 map[*uint16]*int8) map[*uint16]*int8

MergeUint16Int8Ptr takes two inputs: map[uint16]int8 and map[uint16]int8 and merge two maps and returns a new map[uint16]int8.

func MergeUint16IntPtr 

func MergeUint16IntPtr(map1, map2 map[*uint16]*int) map[*uint16]*int

MergeUint16IntPtr takes two inputs: map[uint16]int and map[uint16]int and merge two maps and returns a new map[uint16]int.

func MergeUint16Ptr 

func MergeUint16Ptr(map1, map2 map[*uint16]*uint16) map[*uint16]*uint16

MergeUint16Ptr takes two inputs: map[uint16]uint16 and map[uint16]uint16 and merge two maps and returns a new map[uint16]uint16.

func MergeUint16Str 

func MergeUint16Str(map1, map2 map[uint16]string) map[uint16]string

MergeUint16Str takes two inputs: map[uint16]string and map[uint16]string and merge two maps and returns a new map[uint16]string.

func MergeUint16StrPtr 

func MergeUint16StrPtr(map1, map2 map[*uint16]*string) map[*uint16]*string

MergeUint16StrPtr takes two inputs: map[uint16]string and map[uint16]string and merge two maps and returns a new map[uint16]string.

func MergeUint16Uint 

func MergeUint16Uint(map1, map2 map[uint16]uint) map[uint16]uint

MergeUint16Uint takes two inputs: map[uint16]uint and map[uint16]uint and merge two maps and returns a new map[uint16]uint.

func MergeUint16Uint32 

func MergeUint16Uint32(map1, map2 map[uint16]uint32) map[uint16]uint32

MergeUint16Uint32 takes two inputs: map[uint16]uint32 and map[uint16]uint32 and merge two maps and returns a new map[uint16]uint32.

func MergeUint16Uint32Ptr 

func MergeUint16Uint32Ptr(map1, map2 map[*uint16]*uint32) map[*uint16]*uint32

MergeUint16Uint32Ptr takes two inputs: map[uint16]uint32 and map[uint16]uint32 and merge two maps and returns a new map[uint16]uint32.

func MergeUint16Uint64 

func MergeUint16Uint64(map1, map2 map[uint16]uint64) map[uint16]uint64

MergeUint16Uint64 takes two inputs: map[uint16]uint64 and map[uint16]uint64 and merge two maps and returns a new map[uint16]uint64.

func MergeUint16Uint64Ptr 

func MergeUint16Uint64Ptr(map1, map2 map[*uint16]*uint64) map[*uint16]*uint64

MergeUint16Uint64Ptr takes two inputs: map[uint16]uint64 and map[uint16]uint64 and merge two maps and returns a new map[uint16]uint64.

func MergeUint16Uint8 

func MergeUint16Uint8(map1, map2 map[uint16]uint8) map[uint16]uint8

MergeUint16Uint8 takes two inputs: map[uint16]uint8 and map[uint16]uint8 and merge two maps and returns a new map[uint16]uint8.

func MergeUint16Uint8Ptr 

func MergeUint16Uint8Ptr(map1, map2 map[*uint16]*uint8) map[*uint16]*uint8

MergeUint16Uint8Ptr takes two inputs: map[uint16]uint8 and map[uint16]uint8 and merge two maps and returns a new map[uint16]uint8.

func MergeUint16UintPtr 

func MergeUint16UintPtr(map1, map2 map[*uint16]*uint) map[*uint16]*uint

MergeUint16UintPtr takes two inputs: map[uint16]uint and map[uint16]uint and merge two maps and returns a new map[uint16]uint.

func MergeUint32 

func MergeUint32(map1, map2 map[uint32]uint32) map[uint32]uint32

MergeUint32 takes two inputs: map[uint32]uint32 and map[uint32]uint32 and merge two maps and returns a new map[uint32]uint32.

func MergeUint32Bool 

func MergeUint32Bool(map1, map2 map[uint32]bool) map[uint32]bool

MergeUint32Bool takes two inputs: map[uint32]bool and map[uint32]bool and merge two maps and returns a new map[uint32]bool.

func MergeUint32BoolPtr 

func MergeUint32BoolPtr(map1, map2 map[*uint32]*bool) map[*uint32]*bool

MergeUint32BoolPtr takes two inputs: map[uint32]bool and map[uint32]bool and merge two maps and returns a new map[uint32]bool.

func MergeUint32Float32 

func MergeUint32Float32(map1, map2 map[uint32]float32) map[uint32]float32

MergeUint32Float32 takes two inputs: map[uint32]float32 and map[uint32]float32 and merge two maps and returns a new map[uint32]float32.

func MergeUint32Float32Ptr 

func MergeUint32Float32Ptr(map1, map2 map[*uint32]*float32) map[*uint32]*float32

MergeUint32Float32Ptr takes two inputs: map[uint32]float32 and map[uint32]float32 and merge two maps and returns a new map[uint32]float32.

func MergeUint32Float64 

func MergeUint32Float64(map1, map2 map[uint32]float64) map[uint32]float64

MergeUint32Float64 takes two inputs: map[uint32]float64 and map[uint32]float64 and merge two maps and returns a new map[uint32]float64.

func MergeUint32Float64Ptr 

func MergeUint32Float64Ptr(map1, map2 map[*uint32]*float64) map[*uint32]*float64

MergeUint32Float64Ptr takes two inputs: map[uint32]float64 and map[uint32]float64 and merge two maps and returns a new map[uint32]float64.

func MergeUint32Int 

func MergeUint32Int(map1, map2 map[uint32]int) map[uint32]int

MergeUint32Int takes two inputs: map[uint32]int and map[uint32]int and merge two maps and returns a new map[uint32]int.

func MergeUint32Int16 

func MergeUint32Int16(map1, map2 map[uint32]int16) map[uint32]int16

MergeUint32Int16 takes two inputs: map[uint32]int16 and map[uint32]int16 and merge two maps and returns a new map[uint32]int16.

func MergeUint32Int16Ptr 

func MergeUint32Int16Ptr(map1, map2 map[*uint32]*int16) map[*uint32]*int16

MergeUint32Int16Ptr takes two inputs: map[uint32]int16 and map[uint32]int16 and merge two maps and returns a new map[uint32]int16.

func MergeUint32Int32 

func MergeUint32Int32(map1, map2 map[uint32]int32) map[uint32]int32

MergeUint32Int32 takes two inputs: map[uint32]int32 and map[uint32]int32 and merge two maps and returns a new map[uint32]int32.

func MergeUint32Int32Ptr 

func MergeUint32Int32Ptr(map1, map2 map[*uint32]*int32) map[*uint32]*int32

MergeUint32Int32Ptr takes two inputs: map[uint32]int32 and map[uint32]int32 and merge two maps and returns a new map[uint32]int32.

func MergeUint32Int64 

func MergeUint32Int64(map1, map2 map[uint32]int64) map[uint32]int64

MergeUint32Int64 takes two inputs: map[uint32]int64 and map[uint32]int64 and merge two maps and returns a new map[uint32]int64.

func MergeUint32Int64Ptr 

func MergeUint32Int64Ptr(map1, map2 map[*uint32]*int64) map[*uint32]*int64

MergeUint32Int64Ptr takes two inputs: map[uint32]int64 and map[uint32]int64 and merge two maps and returns a new map[uint32]int64.

func MergeUint32Int8 

func MergeUint32Int8(map1, map2 map[uint32]int8) map[uint32]int8

MergeUint32Int8 takes two inputs: map[uint32]int8 and map[uint32]int8 and merge two maps and returns a new map[uint32]int8.

func MergeUint32Int8Ptr 

func MergeUint32Int8Ptr(map1, map2 map[*uint32]*int8) map[*uint32]*int8

MergeUint32Int8Ptr takes two inputs: map[uint32]int8 and map[uint32]int8 and merge two maps and returns a new map[uint32]int8.

func MergeUint32IntPtr 

func MergeUint32IntPtr(map1, map2 map[*uint32]*int) map[*uint32]*int

MergeUint32IntPtr takes two inputs: map[uint32]int and map[uint32]int and merge two maps and returns a new map[uint32]int.

func MergeUint32Ptr 

func MergeUint32Ptr(map1, map2 map[*uint32]*uint32) map[*uint32]*uint32

MergeUint32Ptr takes two inputs: map[uint32]uint32 and map[uint32]uint32 and merge two maps and returns a new map[uint32]uint32.

func MergeUint32Str 

func MergeUint32Str(map1, map2 map[uint32]string) map[uint32]string

MergeUint32Str takes two inputs: map[uint32]string and map[uint32]string and merge two maps and returns a new map[uint32]string.

func MergeUint32StrPtr 

func MergeUint32StrPtr(map1, map2 map[*uint32]*string) map[*uint32]*string

MergeUint32StrPtr takes two inputs: map[uint32]string and map[uint32]string and merge two maps and returns a new map[uint32]string.

func MergeUint32Uint 

func MergeUint32Uint(map1, map2 map[uint32]uint) map[uint32]uint

MergeUint32Uint takes two inputs: map[uint32]uint and map[uint32]uint and merge two maps and returns a new map[uint32]uint.

func MergeUint32Uint16 

func MergeUint32Uint16(map1, map2 map[uint32]uint16) map[uint32]uint16

MergeUint32Uint16 takes two inputs: map[uint32]uint16 and map[uint32]uint16 and merge two maps and returns a new map[uint32]uint16.

func MergeUint32Uint16Ptr 

func MergeUint32Uint16Ptr(map1, map2 map[*uint32]*uint16) map[*uint32]*uint16

MergeUint32Uint16Ptr takes two inputs: map[uint32]uint16 and map[uint32]uint16 and merge two maps and returns a new map[uint32]uint16.

func MergeUint32Uint64 

func MergeUint32Uint64(map1, map2 map[uint32]uint64) map[uint32]uint64

MergeUint32Uint64 takes two inputs: map[uint32]uint64 and map[uint32]uint64 and merge two maps and returns a new map[uint32]uint64.

func MergeUint32Uint64Ptr 

func MergeUint32Uint64Ptr(map1, map2 map[*uint32]*uint64) map[*uint32]*uint64

MergeUint32Uint64Ptr takes two inputs: map[uint32]uint64 and map[uint32]uint64 and merge two maps and returns a new map[uint32]uint64.

func MergeUint32Uint8 

func MergeUint32Uint8(map1, map2 map[uint32]uint8) map[uint32]uint8

MergeUint32Uint8 takes two inputs: map[uint32]uint8 and map[uint32]uint8 and merge two maps and returns a new map[uint32]uint8.

func MergeUint32Uint8Ptr 

func MergeUint32Uint8Ptr(map1, map2 map[*uint32]*uint8) map[*uint32]*uint8

MergeUint32Uint8Ptr takes two inputs: map[uint32]uint8 and map[uint32]uint8 and merge two maps and returns a new map[uint32]uint8.

func MergeUint32UintPtr 

func MergeUint32UintPtr(map1, map2 map[*uint32]*uint) map[*uint32]*uint

MergeUint32UintPtr takes two inputs: map[uint32]uint and map[uint32]uint and merge two maps and returns a new map[uint32]uint.

func MergeUint64 

func MergeUint64(map1, map2 map[uint64]uint64) map[uint64]uint64

MergeUint64 takes two inputs: map[uint64]uint64 and map[uint64]uint64 and merge two maps and returns a new map[uint64]uint64.

func MergeUint64Bool 

func MergeUint64Bool(map1, map2 map[uint64]bool) map[uint64]bool

MergeUint64Bool takes two inputs: map[uint64]bool and map[uint64]bool and merge two maps and returns a new map[uint64]bool.

func MergeUint64BoolPtr 

func MergeUint64BoolPtr(map1, map2 map[*uint64]*bool) map[*uint64]*bool

MergeUint64BoolPtr takes two inputs: map[uint64]bool and map[uint64]bool and merge two maps and returns a new map[uint64]bool.

func MergeUint64Float32 

func MergeUint64Float32(map1, map2 map[uint64]float32) map[uint64]float32

MergeUint64Float32 takes two inputs: map[uint64]float32 and map[uint64]float32 and merge two maps and returns a new map[uint64]float32.

func MergeUint64Float32Ptr 

func MergeUint64Float32Ptr(map1, map2 map[*uint64]*float32) map[*uint64]*float32

MergeUint64Float32Ptr takes two inputs: map[uint64]float32 and map[uint64]float32 and merge two maps and returns a new map[uint64]float32.

func MergeUint64Float64 

func MergeUint64Float64(map1, map2 map[uint64]float64) map[uint64]float64

MergeUint64Float64 takes two inputs: map[uint64]float64 and map[uint64]float64 and merge two maps and returns a new map[uint64]float64.

func MergeUint64Float64Ptr 

func MergeUint64Float64Ptr(map1, map2 map[*uint64]*float64) map[*uint64]*float64

MergeUint64Float64Ptr takes two inputs: map[uint64]float64 and map[uint64]float64 and merge two maps and returns a new map[uint64]float64.

func MergeUint64Int 

func MergeUint64Int(map1, map2 map[uint64]int) map[uint64]int

MergeUint64Int takes two inputs: map[uint64]int and map[uint64]int and merge two maps and returns a new map[uint64]int.

func MergeUint64Int16 

func MergeUint64Int16(map1, map2 map[uint64]int16) map[uint64]int16

MergeUint64Int16 takes two inputs: map[uint64]int16 and map[uint64]int16 and merge two maps and returns a new map[uint64]int16.

func MergeUint64Int16Ptr 

func MergeUint64Int16Ptr(map1, map2 map[*uint64]*int16) map[*uint64]*int16

MergeUint64Int16Ptr takes two inputs: map[uint64]int16 and map[uint64]int16 and merge two maps and returns a new map[uint64]int16.

func MergeUint64Int32 

func MergeUint64Int32(map1, map2 map[uint64]int32) map[uint64]int32

MergeUint64Int32 takes two inputs: map[uint64]int32 and map[uint64]int32 and merge two maps and returns a new map[uint64]int32.

func MergeUint64Int32Ptr 

func MergeUint64Int32Ptr(map1, map2 map[*uint64]*int32) map[*uint64]*int32

MergeUint64Int32Ptr takes two inputs: map[uint64]int32 and map[uint64]int32 and merge two maps and returns a new map[uint64]int32.

func MergeUint64Int64 

func MergeUint64Int64(map1, map2 map[uint64]int64) map[uint64]int64

MergeUint64Int64 takes two inputs: map[uint64]int64 and map[uint64]int64 and merge two maps and returns a new map[uint64]int64.

func MergeUint64Int64Ptr 

func MergeUint64Int64Ptr(map1, map2 map[*uint64]*int64) map[*uint64]*int64

MergeUint64Int64Ptr takes two inputs: map[uint64]int64 and map[uint64]int64 and merge two maps and returns a new map[uint64]int64.

func MergeUint64Int8 

func MergeUint64Int8(map1, map2 map[uint64]int8) map[uint64]int8

MergeUint64Int8 takes two inputs: map[uint64]int8 and map[uint64]int8 and merge two maps and returns a new map[uint64]int8.

func MergeUint64Int8Ptr 

func MergeUint64Int8Ptr(map1, map2 map[*uint64]*int8) map[*uint64]*int8

MergeUint64Int8Ptr takes two inputs: map[uint64]int8 and map[uint64]int8 and merge two maps and returns a new map[uint64]int8.

func MergeUint64IntPtr 

func MergeUint64IntPtr(map1, map2 map[*uint64]*int) map[*uint64]*int

MergeUint64IntPtr takes two inputs: map[uint64]int and map[uint64]int and merge two maps and returns a new map[uint64]int.

func MergeUint64Ptr 

func MergeUint64Ptr(map1, map2 map[*uint64]*uint64) map[*uint64]*uint64

MergeUint64Ptr takes two inputs: map[uint64]uint64 and map[uint64]uint64 and merge two maps and returns a new map[uint64]uint64.

func MergeUint64Str 

func MergeUint64Str(map1, map2 map[uint64]string) map[uint64]string

MergeUint64Str takes two inputs: map[uint64]string and map[uint64]string and merge two maps and returns a new map[uint64]string.

func MergeUint64StrPtr 

func MergeUint64StrPtr(map1, map2 map[*uint64]*string) map[*uint64]*string

MergeUint64StrPtr takes two inputs: map[uint64]string and map[uint64]string and merge two maps and returns a new map[uint64]string.

func MergeUint64Uint 

func MergeUint64Uint(map1, map2 map[uint64]uint) map[uint64]uint

MergeUint64Uint takes two inputs: map[uint64]uint and map[uint64]uint and merge two maps and returns a new map[uint64]uint.

func MergeUint64Uint16 

func MergeUint64Uint16(map1, map2 map[uint64]uint16) map[uint64]uint16

MergeUint64Uint16 takes two inputs: map[uint64]uint16 and map[uint64]uint16 and merge two maps and returns a new map[uint64]uint16.

func MergeUint64Uint16Ptr 

func MergeUint64Uint16Ptr(map1, map2 map[*uint64]*uint16) map[*uint64]*uint16

MergeUint64Uint16Ptr takes two inputs: map[uint64]uint16 and map[uint64]uint16 and merge two maps and returns a new map[uint64]uint16.

func MergeUint64Uint32 

func MergeUint64Uint32(map1, map2 map[uint64]uint32) map[uint64]uint32

MergeUint64Uint32 takes two inputs: map[uint64]uint32 and map[uint64]uint32 and merge two maps and returns a new map[uint64]uint32.

func MergeUint64Uint32Ptr 

func MergeUint64Uint32Ptr(map1, map2 map[*uint64]*uint32) map[*uint64]*uint32

MergeUint64Uint32Ptr takes two inputs: map[uint64]uint32 and map[uint64]uint32 and merge two maps and returns a new map[uint64]uint32.

func MergeUint64Uint8 

func MergeUint64Uint8(map1, map2 map[uint64]uint8) map[uint64]uint8

MergeUint64Uint8 takes two inputs: map[uint64]uint8 and map[uint64]uint8 and merge two maps and returns a new map[uint64]uint8.

func MergeUint64Uint8Ptr 

func MergeUint64Uint8Ptr(map1, map2 map[*uint64]*uint8) map[*uint64]*uint8

MergeUint64Uint8Ptr takes two inputs: map[uint64]uint8 and map[uint64]uint8 and merge two maps and returns a new map[uint64]uint8.

func MergeUint64UintPtr 

func MergeUint64UintPtr(map1, map2 map[*uint64]*uint) map[*uint64]*uint

MergeUint64UintPtr takes two inputs: map[uint64]uint and map[uint64]uint and merge two maps and returns a new map[uint64]uint.

func MergeUint8 

func MergeUint8(map1, map2 map[uint8]uint8) map[uint8]uint8

MergeUint8 takes two inputs: map[uint8]uint8 and map[uint8]uint8 and merge two maps and returns a new map[uint8]uint8.

func MergeUint8Bool 

func MergeUint8Bool(map1, map2 map[uint8]bool) map[uint8]bool

MergeUint8Bool takes two inputs: map[uint8]bool and map[uint8]bool and merge two maps and returns a new map[uint8]bool.

func MergeUint8BoolPtr 

func MergeUint8BoolPtr(map1, map2 map[*uint8]*bool) map[*uint8]*bool

MergeUint8BoolPtr takes two inputs: map[uint8]bool and map[uint8]bool and merge two maps and returns a new map[uint8]bool.

func MergeUint8Float32 

func MergeUint8Float32(map1, map2 map[uint8]float32) map[uint8]float32

MergeUint8Float32 takes two inputs: map[uint8]float32 and map[uint8]float32 and merge two maps and returns a new map[uint8]float32.

func MergeUint8Float32Ptr 

func MergeUint8Float32Ptr(map1, map2 map[*uint8]*float32) map[*uint8]*float32

MergeUint8Float32Ptr takes two inputs: map[uint8]float32 and map[uint8]float32 and merge two maps and returns a new map[uint8]float32.

func MergeUint8Float64 

func MergeUint8Float64(map1, map2 map[uint8]float64) map[uint8]float64

MergeUint8Float64 takes two inputs: map[uint8]float64 and map[uint8]float64 and merge two maps and returns a new map[uint8]float64.

func MergeUint8Float64Ptr 

func MergeUint8Float64Ptr(map1, map2 map[*uint8]*float64) map[*uint8]*float64

MergeUint8Float64Ptr takes two inputs: map[uint8]float64 and map[uint8]float64 and merge two maps and returns a new map[uint8]float64.

func MergeUint8Int 

func MergeUint8Int(map1, map2 map[uint8]int) map[uint8]int

MergeUint8Int takes two inputs: map[uint8]int and map[uint8]int and merge two maps and returns a new map[uint8]int.

func MergeUint8Int16 

func MergeUint8Int16(map1, map2 map[uint8]int16) map[uint8]int16

MergeUint8Int16 takes two inputs: map[uint8]int16 and map[uint8]int16 and merge two maps and returns a new map[uint8]int16.

func MergeUint8Int16Ptr 

func MergeUint8Int16Ptr(map1, map2 map[*uint8]*int16) map[*uint8]*int16

MergeUint8Int16Ptr takes two inputs: map[uint8]int16 and map[uint8]int16 and merge two maps and returns a new map[uint8]int16.

func MergeUint8Int32 

func MergeUint8Int32(map1, map2 map[uint8]int32) map[uint8]int32

MergeUint8Int32 takes two inputs: map[uint8]int32 and map[uint8]int32 and merge two maps and returns a new map[uint8]int32.

func MergeUint8Int32Ptr 

func MergeUint8Int32Ptr(map1, map2 map[*uint8]*int32) map[*uint8]*int32

MergeUint8Int32Ptr takes two inputs: map[uint8]int32 and map[uint8]int32 and merge two maps and returns a new map[uint8]int32.

func MergeUint8Int64 

func MergeUint8Int64(map1, map2 map[uint8]int64) map[uint8]int64

MergeUint8Int64 takes two inputs: map[uint8]int64 and map[uint8]int64 and merge two maps and returns a new map[uint8]int64.

func MergeUint8Int64Ptr 

func MergeUint8Int64Ptr(map1, map2 map[*uint8]*int64) map[*uint8]*int64

MergeUint8Int64Ptr takes two inputs: map[uint8]int64 and map[uint8]int64 and merge two maps and returns a new map[uint8]int64.

func MergeUint8Int8 

func MergeUint8Int8(map1, map2 map[uint8]int8) map[uint8]int8

MergeUint8Int8 takes two inputs: map[uint8]int8 and map[uint8]int8 and merge two maps and returns a new map[uint8]int8.

func MergeUint8Int8Ptr 

func MergeUint8Int8Ptr(map1, map2 map[*uint8]*int8) map[*uint8]*int8

MergeUint8Int8Ptr takes two inputs: map[uint8]int8 and map[uint8]int8 and merge two maps and returns a new map[uint8]int8.

func MergeUint8IntPtr 

func MergeUint8IntPtr(map1, map2 map[*uint8]*int) map[*uint8]*int

MergeUint8IntPtr takes two inputs: map[uint8]int and map[uint8]int and merge two maps and returns a new map[uint8]int.

func MergeUint8Ptr 

func MergeUint8Ptr(map1, map2 map[*uint8]*uint8) map[*uint8]*uint8

MergeUint8Ptr takes two inputs: map[uint8]uint8 and map[uint8]uint8 and merge two maps and returns a new map[uint8]uint8.

func MergeUint8Str 

func MergeUint8Str(map1, map2 map[uint8]string) map[uint8]string

MergeUint8Str takes two inputs: map[uint8]string and map[uint8]string and merge two maps and returns a new map[uint8]string.

func MergeUint8StrPtr 

func MergeUint8StrPtr(map1, map2 map[*uint8]*string) map[*uint8]*string

MergeUint8StrPtr takes two inputs: map[uint8]string and map[uint8]string and merge two maps and returns a new map[uint8]string.

func MergeUint8Uint 

func MergeUint8Uint(map1, map2 map[uint8]uint) map[uint8]uint

MergeUint8Uint takes two inputs: map[uint8]uint and map[uint8]uint and merge two maps and returns a new map[uint8]uint.

func MergeUint8Uint16 

func MergeUint8Uint16(map1, map2 map[uint8]uint16) map[uint8]uint16

MergeUint8Uint16 takes two inputs: map[uint8]uint16 and map[uint8]uint16 and merge two maps and returns a new map[uint8]uint16.

func MergeUint8Uint16Ptr 

func MergeUint8Uint16Ptr(map1, map2 map[*uint8]*uint16) map[*uint8]*uint16

MergeUint8Uint16Ptr takes two inputs: map[uint8]uint16 and map[uint8]uint16 and merge two maps and returns a new map[uint8]uint16.

func MergeUint8Uint32 

func MergeUint8Uint32(map1, map2 map[uint8]uint32) map[uint8]uint32

MergeUint8Uint32 takes two inputs: map[uint8]uint32 and map[uint8]uint32 and merge two maps and returns a new map[uint8]uint32.

func MergeUint8Uint32Ptr 

func MergeUint8Uint32Ptr(map1, map2 map[*uint8]*uint32) map[*uint8]*uint32

MergeUint8Uint32Ptr takes two inputs: map[uint8]uint32 and map[uint8]uint32 and merge two maps and returns a new map[uint8]uint32.

func MergeUint8Uint64 

func MergeUint8Uint64(map1, map2 map[uint8]uint64) map[uint8]uint64

MergeUint8Uint64 takes two inputs: map[uint8]uint64 and map[uint8]uint64 and merge two maps and returns a new map[uint8]uint64.

func MergeUint8Uint64Ptr 

func MergeUint8Uint64Ptr(map1, map2 map[*uint8]*uint64) map[*uint8]*uint64

MergeUint8Uint64Ptr takes two inputs: map[uint8]uint64 and map[uint8]uint64 and merge two maps and returns a new map[uint8]uint64.

func MergeUint8UintPtr 

func MergeUint8UintPtr(map1, map2 map[*uint8]*uint) map[*uint8]*uint

MergeUint8UintPtr takes two inputs: map[uint8]uint and map[uint8]uint and merge two maps and returns a new map[uint8]uint.

func MergeUintBool 

func MergeUintBool(map1, map2 map[uint]bool) map[uint]bool

MergeUintBool takes two inputs: map[uint]bool and map[uint]bool and merge two maps and returns a new map[uint]bool.

func MergeUintBoolPtr 

func MergeUintBoolPtr(map1, map2 map[*uint]*bool) map[*uint]*bool

MergeUintBoolPtr takes two inputs: map[uint]bool and map[uint]bool and merge two maps and returns a new map[uint]bool.

func MergeUintFloat32 

func MergeUintFloat32(map1, map2 map[uint]float32) map[uint]float32

MergeUintFloat32 takes two inputs: map[uint]float32 and map[uint]float32 and merge two maps and returns a new map[uint]float32.

func MergeUintFloat32Ptr 

func MergeUintFloat32Ptr(map1, map2 map[*uint]*float32) map[*uint]*float32

MergeUintFloat32Ptr takes two inputs: map[uint]float32 and map[uint]float32 and merge two maps and returns a new map[uint]float32.

func MergeUintFloat64 

func MergeUintFloat64(map1, map2 map[uint]float64) map[uint]float64

MergeUintFloat64 takes two inputs: map[uint]float64 and map[uint]float64 and merge two maps and returns a new map[uint]float64.

func MergeUintFloat64Ptr 

func MergeUintFloat64Ptr(map1, map2 map[*uint]*float64) map[*uint]*float64

MergeUintFloat64Ptr takes two inputs: map[uint]float64 and map[uint]float64 and merge two maps and returns a new map[uint]float64.

func MergeUintInt 

func MergeUintInt(map1, map2 map[uint]int) map[uint]int

MergeUintInt takes two inputs: map[uint]int and map[uint]int and merge two maps and returns a new map[uint]int.

func MergeUintInt16 

func MergeUintInt16(map1, map2 map[uint]int16) map[uint]int16

MergeUintInt16 takes two inputs: map[uint]int16 and map[uint]int16 and merge two maps and returns a new map[uint]int16.

func MergeUintInt16Ptr 

func MergeUintInt16Ptr(map1, map2 map[*uint]*int16) map[*uint]*int16

MergeUintInt16Ptr takes two inputs: map[uint]int16 and map[uint]int16 and merge two maps and returns a new map[uint]int16.

func MergeUintInt32 

func MergeUintInt32(map1, map2 map[uint]int32) map[uint]int32

MergeUintInt32 takes two inputs: map[uint]int32 and map[uint]int32 and merge two maps and returns a new map[uint]int32.

func MergeUintInt32Ptr 

func MergeUintInt32Ptr(map1, map2 map[*uint]*int32) map[*uint]*int32

MergeUintInt32Ptr takes two inputs: map[uint]int32 and map[uint]int32 and merge two maps and returns a new map[uint]int32.

func MergeUintInt64 

func MergeUintInt64(map1, map2 map[uint]int64) map[uint]int64

MergeUintInt64 takes two inputs: map[uint]int64 and map[uint]int64 and merge two maps and returns a new map[uint]int64.

func MergeUintInt64Ptr 

func MergeUintInt64Ptr(map1, map2 map[*uint]*int64) map[*uint]*int64

MergeUintInt64Ptr takes two inputs: map[uint]int64 and map[uint]int64 and merge two maps and returns a new map[uint]int64.

func MergeUintInt8 

func MergeUintInt8(map1, map2 map[uint]int8) map[uint]int8

MergeUintInt8 takes two inputs: map[uint]int8 and map[uint]int8 and merge two maps and returns a new map[uint]int8.

func MergeUintInt8Ptr 

func MergeUintInt8Ptr(map1, map2 map[*uint]*int8) map[*uint]*int8

MergeUintInt8Ptr takes two inputs: map[uint]int8 and map[uint]int8 and merge two maps and returns a new map[uint]int8.

func MergeUintIntPtr 

func MergeUintIntPtr(map1, map2 map[*uint]*int) map[*uint]*int

MergeUintIntPtr takes two inputs: map[uint]int and map[uint]int and merge two maps and returns a new map[uint]int.

func MergeUintPtr 

func MergeUintPtr(map1, map2 map[*uint]*uint) map[*uint]*uint

MergeUintPtr takes two inputs: map[uint]uint and map[uint]uint and merge two maps and returns a new map[uint]uint.

func MergeUintStr 

func MergeUintStr(map1, map2 map[uint]string) map[uint]string

MergeUintStr takes two inputs: map[uint]string and map[uint]string and merge two maps and returns a new map[uint]string.

func MergeUintStrPtr 

func MergeUintStrPtr(map1, map2 map[*uint]*string) map[*uint]*string

MergeUintStrPtr takes two inputs: map[uint]string and map[uint]string and merge two maps and returns a new map[uint]string.

func MergeUintUint16 

func MergeUintUint16(map1, map2 map[uint]uint16) map[uint]uint16

MergeUintUint16 takes two inputs: map[uint]uint16 and map[uint]uint16 and merge two maps and returns a new map[uint]uint16.

func MergeUintUint16Ptr 

func MergeUintUint16Ptr(map1, map2 map[*uint]*uint16) map[*uint]*uint16

MergeUintUint16Ptr takes two inputs: map[uint]uint16 and map[uint]uint16 and merge two maps and returns a new map[uint]uint16.

func MergeUintUint32 

func MergeUintUint32(map1, map2 map[uint]uint32) map[uint]uint32

MergeUintUint32 takes two inputs: map[uint]uint32 and map[uint]uint32 and merge two maps and returns a new map[uint]uint32.

func MergeUintUint32Ptr 

func MergeUintUint32Ptr(map1, map2 map[*uint]*uint32) map[*uint]*uint32

MergeUintUint32Ptr takes two inputs: map[uint]uint32 and map[uint]uint32 and merge two maps and returns a new map[uint]uint32.

func MergeUintUint64 

func MergeUintUint64(map1, map2 map[uint]uint64) map[uint]uint64

MergeUintUint64 takes two inputs: map[uint]uint64 and map[uint]uint64 and merge two maps and returns a new map[uint]uint64.

func MergeUintUint64Ptr 

func MergeUintUint64Ptr(map1, map2 map[*uint]*uint64) map[*uint]*uint64

MergeUintUint64Ptr takes two inputs: map[uint]uint64 and map[uint]uint64 and merge two maps and returns a new map[uint]uint64.

func MergeUintUint8 

func MergeUintUint8(map1, map2 map[uint]uint8) map[uint]uint8

MergeUintUint8 takes two inputs: map[uint]uint8 and map[uint]uint8 and merge two maps and returns a new map[uint]uint8.

func MergeUintUint8Ptr 

func MergeUintUint8Ptr(map1, map2 map[*uint]*uint8) map[*uint]*uint8

MergeUintUint8Ptr takes two inputs: map[uint]uint8 and map[uint]uint8 and merge two maps and returns a new map[uint]uint8.

func MinFloat32 

func MinFloat32(list []float32) float32

MinFloat32 returns min item from the list. Return 0 if the list is either empty or nil

func MinFloat32Ptr 

func MinFloat32Ptr(list []*float32) *float32

MinFloat32Ptr returns min item from the list. Return 0 if the list is either empty or nil

func MinFloat64 

func MinFloat64(list []float64) float64

MinFloat64 returns min item from the list. Return 0 if the list is either empty or nil

func MinFloat64Ptr 

func MinFloat64Ptr(list []*float64) *float64

MinFloat64Ptr returns min item from the list. Return 0 if the list is either empty or nil

func MinInt 

func MinInt(list []int) int

MinInt returns min item from the list. Return 0 if the list is either empty or nil

func MinInt16 

func MinInt16(list []int16) int16

MinInt16 returns min item from the list. Return 0 if the list is either empty or nil

func MinInt16Ptr 

func MinInt16Ptr(list []*int16) *int16

MinInt16Ptr returns min item from the list. Return 0 if the list is either empty or nil

func MinInt32 

func MinInt32(list []int32) int32

MinInt32 returns min item from the list. Return 0 if the list is either empty or nil

func MinInt32Ptr 

func MinInt32Ptr(list []*int32) *int32

MinInt32Ptr returns min item from the list. Return 0 if the list is either empty or nil

func MinInt64 

func MinInt64(list []int64) int64

MinInt64 returns min item from the list. Return 0 if the list is either empty or nil

func MinInt64Ptr 

func MinInt64Ptr(list []*int64) *int64

MinInt64Ptr returns min item from the list. Return 0 if the list is either empty or nil

func MinInt8 

func MinInt8(list []int8) int8

MinInt8 returns min item from the list. Return 0 if the list is either empty or nil

func MinInt8Ptr 

func MinInt8Ptr(list []*int8) *int8

MinInt8Ptr returns min item from the list. Return 0 if the list is either empty or nil

func MinIntPtr 

func MinIntPtr(list []*int) *int

MinIntPtr returns min item from the list. Return 0 if the list is either empty or nil

func MinMaxFloat32 

func MinMaxFloat32(list []float32) (float32, float32)

MinMaxFloat32 returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxFloat32Ptr 

func MinMaxFloat32Ptr(list []*float32) (*float32, *float32)

MinMaxFloat32Ptr returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxFloat64 

func MinMaxFloat64(list []float64) (float64, float64)

MinMaxFloat64 returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxFloat64Ptr 

func MinMaxFloat64Ptr(list []*float64) (*float64, *float64)

MinMaxFloat64Ptr returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxInt 

func MinMaxInt(list []int) (int, int)

MinMaxInt returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxInt16 

func MinMaxInt16(list []int16) (int16, int16)

MinMaxInt16 returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxInt16Ptr 

func MinMaxInt16Ptr(list []*int16) (*int16, *int16)

MinMaxInt16Ptr returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxInt32 

func MinMaxInt32(list []int32) (int32, int32)

MinMaxInt32 returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxInt32Ptr 

func MinMaxInt32Ptr(list []*int32) (*int32, *int32)

MinMaxInt32Ptr returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxInt64 

func MinMaxInt64(list []int64) (int64, int64)

MinMaxInt64 returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxInt64Ptr 

func MinMaxInt64Ptr(list []*int64) (*int64, *int64)

MinMaxInt64Ptr returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxInt8 

func MinMaxInt8(list []int8) (int8, int8)

MinMaxInt8 returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxInt8Ptr 

func MinMaxInt8Ptr(list []*int8) (*int8, *int8)

MinMaxInt8Ptr returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxIntPtr 

func MinMaxIntPtr(list []*int) (*int, *int)

MinMaxIntPtr returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxUint 

func MinMaxUint(list []uint) (uint, uint)

MinMaxUint returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxUint16 

func MinMaxUint16(list []uint16) (uint16, uint16)

MinMaxUint16 returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxUint16Ptr 

func MinMaxUint16Ptr(list []*uint16) (*uint16, *uint16)

MinMaxUint16Ptr returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxUint32 

func MinMaxUint32(list []uint32) (uint32, uint32)

MinMaxUint32 returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxUint32Ptr 

func MinMaxUint32Ptr(list []*uint32) (*uint32, *uint32)

MinMaxUint32Ptr returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxUint64 

func MinMaxUint64(list []uint64) (uint64, uint64)

MinMaxUint64 returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxUint64Ptr 

func MinMaxUint64Ptr(list []*uint64) (*uint64, *uint64)

MinMaxUint64Ptr returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxUint8 

func MinMaxUint8(list []uint8) (uint8, uint8)

MinMaxUint8 returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxUint8Ptr 

func MinMaxUint8Ptr(list []*uint8) (*uint8, *uint8)

MinMaxUint8Ptr returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinMaxUintPtr 

func MinMaxUintPtr(list []*uint) (*uint, *uint)

MinMaxUintPtr returns min and max items from the list. Return 0,0 if the list is either empty or nil

func MinUint 

func MinUint(list []uint) uint

MinUint returns min item from the list. Return 0 if the list is either empty or nil

func MinUint16 

func MinUint16(list []uint16) uint16

MinUint16 returns min item from the list. Return 0 if the list is either empty or nil

func MinUint16Ptr 

func MinUint16Ptr(list []*uint16) *uint16

MinUint16Ptr returns min item from the list. Return 0 if the list is either empty or nil

func MinUint32 

func MinUint32(list []uint32) uint32

MinUint32 returns min item from the list. Return 0 if the list is either empty or nil

func MinUint32Ptr 

func MinUint32Ptr(list []*uint32) *uint32

MinUint32Ptr returns min item from the list. Return 0 if the list is either empty or nil

func MinUint64 

func MinUint64(list []uint64) uint64

MinUint64 returns min item from the list. Return 0 if the list is either empty or nil

func MinUint64Ptr 

func MinUint64Ptr(list []*uint64) *uint64

MinUint64Ptr returns min item from the list. Return 0 if the list is either empty or nil

func MinUint8 

func MinUint8(list []uint8) uint8

MinUint8 returns min item from the list. Return 0 if the list is either empty or nil

func MinUint8Ptr 

func MinUint8Ptr(list []*uint8) *uint8

MinUint8Ptr returns min item from the list. Return 0 if the list is either empty or nil

func MinUintPtr 

func MinUintPtr(list []*uint) *uint

MinUintPtr returns min item from the list. Return 0 if the list is either empty or nil

func NegFloat32P 

func NegFloat32P(v float32) bool

NegFloat32P Returns true if num is less than zero, else false

func NegFloat32PPtr 

func NegFloat32PPtr(v *float32) bool

NegFloat32PPtr Returns true if num is less than zero, else false

func NegFloat64P 

func NegFloat64P(v float64) bool

NegFloat64P Returns true if num is less than zero, else false

func NegFloat64PPtr 

func NegFloat64PPtr(v *float64) bool

NegFloat64PPtr Returns true if num is less than zero, else false

func NegInt16P 

func NegInt16P(v int16) bool

NegInt16P Returns true if num is less than zero, else false

func NegInt16PPtr 

func NegInt16PPtr(v *int16) bool

NegInt16PPtr Returns true if num is less than zero, else false

func NegInt32P 

func NegInt32P(v int32) bool

NegInt32P Returns true if num is less than zero, else false

func NegInt32PPtr 

func NegInt32PPtr(v *int32) bool

NegInt32PPtr Returns true if num is less than zero, else false

func NegInt64P 

func NegInt64P(v int64) bool

NegInt64P Returns true if num is less than zero, else false

func NegInt64PPtr 

func NegInt64PPtr(v *int64) bool

NegInt64PPtr Returns true if num is less than zero, else false

func NegInt8P 

func NegInt8P(v int8) bool

NegInt8P Returns true if num is less than zero, else false

func NegInt8PPtr 

func NegInt8PPtr(v *int8) bool

NegInt8PPtr Returns true if num is less than zero, else false

func NegIntP 

func NegIntP(v int) bool

NegIntP Returns true if num is less than zero, else false

func NegIntPPtr 

func NegIntPPtr(v *int) bool

NegIntPPtr Returns true if num is less than zero, else false

func OddInt16P 

func OddInt16P(v int16) bool

OddInt16P Returns true if n is odd

func OddInt16PPtr 

func OddInt16PPtr(v *int16) bool

OddInt16PPtr Returns true if n is odd

func OddInt32P 

func OddInt32P(v int32) bool

OddInt32P Returns true if n is odd

func OddInt32PPtr 

func OddInt32PPtr(v *int32) bool

OddInt32PPtr Returns true if n is odd

func OddInt64P 

func OddInt64P(v int64) bool

OddInt64P Returns true if n is odd

func OddInt64PPtr 

func OddInt64PPtr(v *int64) bool

OddInt64PPtr Returns true if n is odd

func OddInt8P 

func OddInt8P(v int8) bool

OddInt8P Returns true if n is odd

func OddInt8PPtr 

func OddInt8PPtr(v *int8) bool

OddInt8PPtr Returns true if n is odd

func OddIntP 

func OddIntP(v int) bool

OddIntP Returns true if n is odd

func OddIntPPtr 

func OddIntPPtr(v *int) bool

OddIntPPtr Returns true if n is odd

func OddUint16P 

func OddUint16P(v uint16) bool

OddUint16P Returns true if n is odd

func OddUint16PPtr 

func OddUint16PPtr(v *uint16) bool

OddUint16PPtr Returns true if n is odd

func OddUint32P 

func OddUint32P(v uint32) bool

OddUint32P Returns true if n is odd

func OddUint32PPtr 

func OddUint32PPtr(v *uint32) bool

OddUint32PPtr Returns true if n is odd

func OddUint64P 

func OddUint64P(v uint64) bool

OddUint64P Returns true if n is odd

func OddUint64PPtr 

func OddUint64PPtr(v *uint64) bool

OddUint64PPtr Returns true if n is odd

func OddUint8P 

func OddUint8P(v uint8) bool

OddUint8P Returns true if n is odd

func OddUint8PPtr 

func OddUint8PPtr(v *uint8) bool

OddUint8PPtr Returns true if n is odd

func OddUintP 

func OddUintP(v uint) bool

OddUintP Returns true if n is odd

func OddUintPPtr 

func OddUintPPtr(v *uint) bool

OddUintPPtr Returns true if n is odd

func PMapBool 

func PMapBool(f func(bool) bool, list []bool, optional ...Optional) []bool

PMapBool applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolErr 

func PMapBoolErr(f func(bool) (bool, error), list []bool, optional ...Optional) ([]bool, error)

PMapBoolErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolFloat32 

func PMapBoolFloat32(f func(bool) float32, list []bool, optional ...Optional) []float32

PMapBoolFloat32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolFloat32Err 

func PMapBoolFloat32Err(f func(bool) (float32, error), list []bool, optional ...Optional) ([]float32, error)

PMapBoolFloat32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolFloat32Ptr 

func PMapBoolFloat32Ptr(f func(*bool) *float32, list []*bool, optional ...Optional) []*float32

PMapBoolFloat32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolFloat32PtrErr 

func PMapBoolFloat32PtrErr(f func(*bool) (*float32, error), list []*bool, optional ...Optional) ([]*float32, error)

PMapBoolFloat32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolFloat64 

func PMapBoolFloat64(f func(bool) float64, list []bool, optional ...Optional) []float64

PMapBoolFloat64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolFloat64Err 

func PMapBoolFloat64Err(f func(bool) (float64, error), list []bool, optional ...Optional) ([]float64, error)

PMapBoolFloat64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolFloat64Ptr 

func PMapBoolFloat64Ptr(f func(*bool) *float64, list []*bool, optional ...Optional) []*float64

PMapBoolFloat64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolFloat64PtrErr 

func PMapBoolFloat64PtrErr(f func(*bool) (*float64, error), list []*bool, optional ...Optional) ([]*float64, error)

PMapBoolFloat64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt 

func PMapBoolInt(f func(bool) int, list []bool, optional ...Optional) []int

PMapBoolInt applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt16 

func PMapBoolInt16(f func(bool) int16, list []bool, optional ...Optional) []int16

PMapBoolInt16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt16Err 

func PMapBoolInt16Err(f func(bool) (int16, error), list []bool, optional ...Optional) ([]int16, error)

PMapBoolInt16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt16Ptr 

func PMapBoolInt16Ptr(f func(*bool) *int16, list []*bool, optional ...Optional) []*int16

PMapBoolInt16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt16PtrErr 

func PMapBoolInt16PtrErr(f func(*bool) (*int16, error), list []*bool, optional ...Optional) ([]*int16, error)

PMapBoolInt16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt32 

func PMapBoolInt32(f func(bool) int32, list []bool, optional ...Optional) []int32

PMapBoolInt32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt32Err 

func PMapBoolInt32Err(f func(bool) (int32, error), list []bool, optional ...Optional) ([]int32, error)

PMapBoolInt32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt32Ptr 

func PMapBoolInt32Ptr(f func(*bool) *int32, list []*bool, optional ...Optional) []*int32

PMapBoolInt32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt32PtrErr 

func PMapBoolInt32PtrErr(f func(*bool) (*int32, error), list []*bool, optional ...Optional) ([]*int32, error)

PMapBoolInt32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt64 

func PMapBoolInt64(f func(bool) int64, list []bool, optional ...Optional) []int64

PMapBoolInt64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt64Err 

func PMapBoolInt64Err(f func(bool) (int64, error), list []bool, optional ...Optional) ([]int64, error)

PMapBoolInt64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt64Ptr 

func PMapBoolInt64Ptr(f func(*bool) *int64, list []*bool, optional ...Optional) []*int64

PMapBoolInt64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt64PtrErr 

func PMapBoolInt64PtrErr(f func(*bool) (*int64, error), list []*bool, optional ...Optional) ([]*int64, error)

PMapBoolInt64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt8 

func PMapBoolInt8(f func(bool) int8, list []bool, optional ...Optional) []int8

PMapBoolInt8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt8Err 

func PMapBoolInt8Err(f func(bool) (int8, error), list []bool, optional ...Optional) ([]int8, error)

PMapBoolInt8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt8Ptr 

func PMapBoolInt8Ptr(f func(*bool) *int8, list []*bool, optional ...Optional) []*int8

PMapBoolInt8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolInt8PtrErr 

func PMapBoolInt8PtrErr(f func(*bool) (*int8, error), list []*bool, optional ...Optional) ([]*int8, error)

PMapBoolInt8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolIntErr 

func PMapBoolIntErr(f func(bool) (int, error), list []bool, optional ...Optional) ([]int, error)

PMapBoolIntErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolIntPtr 

func PMapBoolIntPtr(f func(*bool) *int, list []*bool, optional ...Optional) []*int

PMapBoolIntPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolIntPtrErr 

func PMapBoolIntPtrErr(f func(*bool) (*int, error), list []*bool, optional ...Optional) ([]*int, error)

PMapBoolIntPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolPtr 

func PMapBoolPtr(f func(*bool) *bool, list []*bool, optional ...Optional) []*bool

PMapBoolPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolPtrErr 

func PMapBoolPtrErr(f func(*bool) (*bool, error), list []*bool, optional ...Optional) ([]*bool, error)

PMapBoolPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolStr 

func PMapBoolStr(f func(bool) string, list []bool, optional ...Optional) []string

PMapBoolStr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolStrErr 

func PMapBoolStrErr(f func(bool) (string, error), list []bool, optional ...Optional) ([]string, error)

PMapBoolStrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolStrPtr 

func PMapBoolStrPtr(f func(*bool) *string, list []*bool, optional ...Optional) []*string

PMapBoolStrPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolStrPtrErr 

func PMapBoolStrPtrErr(f func(*bool) (*string, error), list []*bool, optional ...Optional) ([]*string, error)

PMapBoolStrPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint 

func PMapBoolUint(f func(bool) uint, list []bool, optional ...Optional) []uint

PMapBoolUint applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint16 

func PMapBoolUint16(f func(bool) uint16, list []bool, optional ...Optional) []uint16

PMapBoolUint16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint16Err 

func PMapBoolUint16Err(f func(bool) (uint16, error), list []bool, optional ...Optional) ([]uint16, error)

PMapBoolUint16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint16Ptr 

func PMapBoolUint16Ptr(f func(*bool) *uint16, list []*bool, optional ...Optional) []*uint16

PMapBoolUint16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint16PtrErr 

func PMapBoolUint16PtrErr(f func(*bool) (*uint16, error), list []*bool, optional ...Optional) ([]*uint16, error)

PMapBoolUint16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint32 

func PMapBoolUint32(f func(bool) uint32, list []bool, optional ...Optional) []uint32

PMapBoolUint32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint32Err 

func PMapBoolUint32Err(f func(bool) (uint32, error), list []bool, optional ...Optional) ([]uint32, error)

PMapBoolUint32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint32Ptr 

func PMapBoolUint32Ptr(f func(*bool) *uint32, list []*bool, optional ...Optional) []*uint32

PMapBoolUint32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint32PtrErr 

func PMapBoolUint32PtrErr(f func(*bool) (*uint32, error), list []*bool, optional ...Optional) ([]*uint32, error)

PMapBoolUint32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint64 

func PMapBoolUint64(f func(bool) uint64, list []bool, optional ...Optional) []uint64

PMapBoolUint64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint64Err 

func PMapBoolUint64Err(f func(bool) (uint64, error), list []bool, optional ...Optional) ([]uint64, error)

PMapBoolUint64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint64Ptr 

func PMapBoolUint64Ptr(f func(*bool) *uint64, list []*bool, optional ...Optional) []*uint64

PMapBoolUint64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint64PtrErr 

func PMapBoolUint64PtrErr(f func(*bool) (*uint64, error), list []*bool, optional ...Optional) ([]*uint64, error)

PMapBoolUint64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint8 

func PMapBoolUint8(f func(bool) uint8, list []bool, optional ...Optional) []uint8

PMapBoolUint8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint8Err 

func PMapBoolUint8Err(f func(bool) (uint8, error), list []bool, optional ...Optional) ([]uint8, error)

PMapBoolUint8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint8Ptr 

func PMapBoolUint8Ptr(f func(*bool) *uint8, list []*bool, optional ...Optional) []*uint8

PMapBoolUint8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUint8PtrErr 

func PMapBoolUint8PtrErr(f func(*bool) (*uint8, error), list []*bool, optional ...Optional) ([]*uint8, error)

PMapBoolUint8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUintErr 

func PMapBoolUintErr(f func(bool) (uint, error), list []bool, optional ...Optional) ([]uint, error)

PMapBoolUintErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUintPtr 

func PMapBoolUintPtr(f func(*bool) *uint, list []*bool, optional ...Optional) []*uint

PMapBoolUintPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapBoolUintPtrErr 

func PMapBoolUintPtrErr(f func(*bool) (*uint, error), list []*bool, optional ...Optional) ([]*uint, error)

PMapBoolUintPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32 

func PMapFloat32(f func(float32) float32, list []float32, optional ...Optional) []float32

PMapFloat32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Bool 

func PMapFloat32Bool(f func(float32) bool, list []float32, optional ...Optional) []bool

PMapFloat32Bool applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32BoolErr 

func PMapFloat32BoolErr(f func(float32) (bool, error), list []float32, optional ...Optional) ([]bool, error)

PMapFloat32BoolErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32BoolPtr 

func PMapFloat32BoolPtr(f func(*float32) *bool, list []*float32, optional ...Optional) []*bool

PMapFloat32BoolPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32BoolPtrErr 

func PMapFloat32BoolPtrErr(f func(*float32) (*bool, error), list []*float32, optional ...Optional) ([]*bool, error)

PMapFloat32BoolPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Err 

func PMapFloat32Err(f func(float32) (float32, error), list []float32, optional ...Optional) ([]float32, error)

PMapFloat32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Float64 

func PMapFloat32Float64(f func(float32) float64, list []float32, optional ...Optional) []float64

PMapFloat32Float64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Float64Err 

func PMapFloat32Float64Err(f func(float32) (float64, error), list []float32, optional ...Optional) ([]float64, error)

PMapFloat32Float64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Float64Ptr 

func PMapFloat32Float64Ptr(f func(*float32) *float64, list []*float32, optional ...Optional) []*float64

PMapFloat32Float64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Float64PtrErr 

func PMapFloat32Float64PtrErr(f func(*float32) (*float64, error), list []*float32, optional ...Optional) ([]*float64, error)

PMapFloat32Float64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int 

func PMapFloat32Int(f func(float32) int, list []float32, optional ...Optional) []int

PMapFloat32Int applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int16 

func PMapFloat32Int16(f func(float32) int16, list []float32, optional ...Optional) []int16

PMapFloat32Int16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int16Err 

func PMapFloat32Int16Err(f func(float32) (int16, error), list []float32, optional ...Optional) ([]int16, error)

PMapFloat32Int16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int16Ptr 

func PMapFloat32Int16Ptr(f func(*float32) *int16, list []*float32, optional ...Optional) []*int16

PMapFloat32Int16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int16PtrErr 

func PMapFloat32Int16PtrErr(f func(*float32) (*int16, error), list []*float32, optional ...Optional) ([]*int16, error)

PMapFloat32Int16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int32 

func PMapFloat32Int32(f func(float32) int32, list []float32, optional ...Optional) []int32

PMapFloat32Int32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int32Err 

func PMapFloat32Int32Err(f func(float32) (int32, error), list []float32, optional ...Optional) ([]int32, error)

PMapFloat32Int32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int32Ptr 

func PMapFloat32Int32Ptr(f func(*float32) *int32, list []*float32, optional ...Optional) []*int32

PMapFloat32Int32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int32PtrErr 

func PMapFloat32Int32PtrErr(f func(*float32) (*int32, error), list []*float32, optional ...Optional) ([]*int32, error)

PMapFloat32Int32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int64 

func PMapFloat32Int64(f func(float32) int64, list []float32, optional ...Optional) []int64

PMapFloat32Int64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int64Err 

func PMapFloat32Int64Err(f func(float32) (int64, error), list []float32, optional ...Optional) ([]int64, error)

PMapFloat32Int64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int64Ptr 

func PMapFloat32Int64Ptr(f func(*float32) *int64, list []*float32, optional ...Optional) []*int64

PMapFloat32Int64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int64PtrErr 

func PMapFloat32Int64PtrErr(f func(*float32) (*int64, error), list []*float32, optional ...Optional) ([]*int64, error)

PMapFloat32Int64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int8 

func PMapFloat32Int8(f func(float32) int8, list []float32, optional ...Optional) []int8

PMapFloat32Int8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int8Err 

func PMapFloat32Int8Err(f func(float32) (int8, error), list []float32, optional ...Optional) ([]int8, error)

PMapFloat32Int8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int8Ptr 

func PMapFloat32Int8Ptr(f func(*float32) *int8, list []*float32, optional ...Optional) []*int8

PMapFloat32Int8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Int8PtrErr 

func PMapFloat32Int8PtrErr(f func(*float32) (*int8, error), list []*float32, optional ...Optional) ([]*int8, error)

PMapFloat32Int8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32IntErr 

func PMapFloat32IntErr(f func(float32) (int, error), list []float32, optional ...Optional) ([]int, error)

PMapFloat32IntErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32IntPtr 

func PMapFloat32IntPtr(f func(*float32) *int, list []*float32, optional ...Optional) []*int

PMapFloat32IntPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32IntPtrErr 

func PMapFloat32IntPtrErr(f func(*float32) (*int, error), list []*float32, optional ...Optional) ([]*int, error)

PMapFloat32IntPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Ptr 

func PMapFloat32Ptr(f func(*float32) *float32, list []*float32, optional ...Optional) []*float32

PMapFloat32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32PtrErr 

func PMapFloat32PtrErr(f func(*float32) (*float32, error), list []*float32, optional ...Optional) ([]*float32, error)

PMapFloat32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Str 

func PMapFloat32Str(f func(float32) string, list []float32, optional ...Optional) []string

PMapFloat32Str applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32StrErr 

func PMapFloat32StrErr(f func(float32) (string, error), list []float32, optional ...Optional) ([]string, error)

PMapFloat32StrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32StrPtr 

func PMapFloat32StrPtr(f func(*float32) *string, list []*float32, optional ...Optional) []*string

PMapFloat32StrPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32StrPtrErr 

func PMapFloat32StrPtrErr(f func(*float32) (*string, error), list []*float32, optional ...Optional) ([]*string, error)

PMapFloat32StrPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint 

func PMapFloat32Uint(f func(float32) uint, list []float32, optional ...Optional) []uint

PMapFloat32Uint applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint16 

func PMapFloat32Uint16(f func(float32) uint16, list []float32, optional ...Optional) []uint16

PMapFloat32Uint16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint16Err 

func PMapFloat32Uint16Err(f func(float32) (uint16, error), list []float32, optional ...Optional) ([]uint16, error)

PMapFloat32Uint16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint16Ptr 

func PMapFloat32Uint16Ptr(f func(*float32) *uint16, list []*float32, optional ...Optional) []*uint16

PMapFloat32Uint16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint16PtrErr 

func PMapFloat32Uint16PtrErr(f func(*float32) (*uint16, error), list []*float32, optional ...Optional) ([]*uint16, error)

PMapFloat32Uint16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint32 

func PMapFloat32Uint32(f func(float32) uint32, list []float32, optional ...Optional) []uint32

PMapFloat32Uint32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint32Err 

func PMapFloat32Uint32Err(f func(float32) (uint32, error), list []float32, optional ...Optional) ([]uint32, error)

PMapFloat32Uint32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint32Ptr 

func PMapFloat32Uint32Ptr(f func(*float32) *uint32, list []*float32, optional ...Optional) []*uint32

PMapFloat32Uint32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint32PtrErr 

func PMapFloat32Uint32PtrErr(f func(*float32) (*uint32, error), list []*float32, optional ...Optional) ([]*uint32, error)

PMapFloat32Uint32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint64 

func PMapFloat32Uint64(f func(float32) uint64, list []float32, optional ...Optional) []uint64

PMapFloat32Uint64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint64Err 

func PMapFloat32Uint64Err(f func(float32) (uint64, error), list []float32, optional ...Optional) ([]uint64, error)

PMapFloat32Uint64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint64Ptr 

func PMapFloat32Uint64Ptr(f func(*float32) *uint64, list []*float32, optional ...Optional) []*uint64

PMapFloat32Uint64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint64PtrErr 

func PMapFloat32Uint64PtrErr(f func(*float32) (*uint64, error), list []*float32, optional ...Optional) ([]*uint64, error)

PMapFloat32Uint64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint8 

func PMapFloat32Uint8(f func(float32) uint8, list []float32, optional ...Optional) []uint8

PMapFloat32Uint8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint8Err 

func PMapFloat32Uint8Err(f func(float32) (uint8, error), list []float32, optional ...Optional) ([]uint8, error)

PMapFloat32Uint8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint8Ptr 

func PMapFloat32Uint8Ptr(f func(*float32) *uint8, list []*float32, optional ...Optional) []*uint8

PMapFloat32Uint8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32Uint8PtrErr 

func PMapFloat32Uint8PtrErr(f func(*float32) (*uint8, error), list []*float32, optional ...Optional) ([]*uint8, error)

PMapFloat32Uint8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32UintErr 

func PMapFloat32UintErr(f func(float32) (uint, error), list []float32, optional ...Optional) ([]uint, error)

PMapFloat32UintErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32UintPtr 

func PMapFloat32UintPtr(f func(*float32) *uint, list []*float32, optional ...Optional) []*uint

PMapFloat32UintPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat32UintPtrErr 

func PMapFloat32UintPtrErr(f func(*float32) (*uint, error), list []*float32, optional ...Optional) ([]*uint, error)

PMapFloat32UintPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64 

func PMapFloat64(f func(float64) float64, list []float64, optional ...Optional) []float64

PMapFloat64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Bool 

func PMapFloat64Bool(f func(float64) bool, list []float64, optional ...Optional) []bool

PMapFloat64Bool applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64BoolErr 

func PMapFloat64BoolErr(f func(float64) (bool, error), list []float64, optional ...Optional) ([]bool, error)

PMapFloat64BoolErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64BoolPtr 

func PMapFloat64BoolPtr(f func(*float64) *bool, list []*float64, optional ...Optional) []*bool

PMapFloat64BoolPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64BoolPtrErr 

func PMapFloat64BoolPtrErr(f func(*float64) (*bool, error), list []*float64, optional ...Optional) ([]*bool, error)

PMapFloat64BoolPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Err 

func PMapFloat64Err(f func(float64) (float64, error), list []float64, optional ...Optional) ([]float64, error)

PMapFloat64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Float32 

func PMapFloat64Float32(f func(float64) float32, list []float64, optional ...Optional) []float32

PMapFloat64Float32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Float32Err 

func PMapFloat64Float32Err(f func(float64) (float32, error), list []float64, optional ...Optional) ([]float32, error)

PMapFloat64Float32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Float32Ptr 

func PMapFloat64Float32Ptr(f func(*float64) *float32, list []*float64, optional ...Optional) []*float32

PMapFloat64Float32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Float32PtrErr 

func PMapFloat64Float32PtrErr(f func(*float64) (*float32, error), list []*float64, optional ...Optional) ([]*float32, error)

PMapFloat64Float32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int 

func PMapFloat64Int(f func(float64) int, list []float64, optional ...Optional) []int

PMapFloat64Int applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int16 

func PMapFloat64Int16(f func(float64) int16, list []float64, optional ...Optional) []int16

PMapFloat64Int16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int16Err 

func PMapFloat64Int16Err(f func(float64) (int16, error), list []float64, optional ...Optional) ([]int16, error)

PMapFloat64Int16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int16Ptr 

func PMapFloat64Int16Ptr(f func(*float64) *int16, list []*float64, optional ...Optional) []*int16

PMapFloat64Int16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int16PtrErr 

func PMapFloat64Int16PtrErr(f func(*float64) (*int16, error), list []*float64, optional ...Optional) ([]*int16, error)

PMapFloat64Int16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int32 

func PMapFloat64Int32(f func(float64) int32, list []float64, optional ...Optional) []int32

PMapFloat64Int32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int32Err 

func PMapFloat64Int32Err(f func(float64) (int32, error), list []float64, optional ...Optional) ([]int32, error)

PMapFloat64Int32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int32Ptr 

func PMapFloat64Int32Ptr(f func(*float64) *int32, list []*float64, optional ...Optional) []*int32

PMapFloat64Int32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int32PtrErr 

func PMapFloat64Int32PtrErr(f func(*float64) (*int32, error), list []*float64, optional ...Optional) ([]*int32, error)

PMapFloat64Int32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int64 

func PMapFloat64Int64(f func(float64) int64, list []float64, optional ...Optional) []int64

PMapFloat64Int64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int64Err 

func PMapFloat64Int64Err(f func(float64) (int64, error), list []float64, optional ...Optional) ([]int64, error)

PMapFloat64Int64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int64Ptr 

func PMapFloat64Int64Ptr(f func(*float64) *int64, list []*float64, optional ...Optional) []*int64

PMapFloat64Int64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int64PtrErr 

func PMapFloat64Int64PtrErr(f func(*float64) (*int64, error), list []*float64, optional ...Optional) ([]*int64, error)

PMapFloat64Int64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int8 

func PMapFloat64Int8(f func(float64) int8, list []float64, optional ...Optional) []int8

PMapFloat64Int8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int8Err 

func PMapFloat64Int8Err(f func(float64) (int8, error), list []float64, optional ...Optional) ([]int8, error)

PMapFloat64Int8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int8Ptr 

func PMapFloat64Int8Ptr(f func(*float64) *int8, list []*float64, optional ...Optional) []*int8

PMapFloat64Int8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Int8PtrErr 

func PMapFloat64Int8PtrErr(f func(*float64) (*int8, error), list []*float64, optional ...Optional) ([]*int8, error)

PMapFloat64Int8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64IntErr 

func PMapFloat64IntErr(f func(float64) (int, error), list []float64, optional ...Optional) ([]int, error)

PMapFloat64IntErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64IntPtr 

func PMapFloat64IntPtr(f func(*float64) *int, list []*float64, optional ...Optional) []*int

PMapFloat64IntPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64IntPtrErr 

func PMapFloat64IntPtrErr(f func(*float64) (*int, error), list []*float64, optional ...Optional) ([]*int, error)

PMapFloat64IntPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Ptr 

func PMapFloat64Ptr(f func(*float64) *float64, list []*float64, optional ...Optional) []*float64

PMapFloat64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64PtrErr 

func PMapFloat64PtrErr(f func(*float64) (*float64, error), list []*float64, optional ...Optional) ([]*float64, error)

PMapFloat64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Str 

func PMapFloat64Str(f func(float64) string, list []float64, optional ...Optional) []string

PMapFloat64Str applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64StrErr 

func PMapFloat64StrErr(f func(float64) (string, error), list []float64, optional ...Optional) ([]string, error)

PMapFloat64StrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64StrPtr 

func PMapFloat64StrPtr(f func(*float64) *string, list []*float64, optional ...Optional) []*string

PMapFloat64StrPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64StrPtrErr 

func PMapFloat64StrPtrErr(f func(*float64) (*string, error), list []*float64, optional ...Optional) ([]*string, error)

PMapFloat64StrPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint 

func PMapFloat64Uint(f func(float64) uint, list []float64, optional ...Optional) []uint

PMapFloat64Uint applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint16 

func PMapFloat64Uint16(f func(float64) uint16, list []float64, optional ...Optional) []uint16

PMapFloat64Uint16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint16Err 

func PMapFloat64Uint16Err(f func(float64) (uint16, error), list []float64, optional ...Optional) ([]uint16, error)

PMapFloat64Uint16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint16Ptr 

func PMapFloat64Uint16Ptr(f func(*float64) *uint16, list []*float64, optional ...Optional) []*uint16

PMapFloat64Uint16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint16PtrErr 

func PMapFloat64Uint16PtrErr(f func(*float64) (*uint16, error), list []*float64, optional ...Optional) ([]*uint16, error)

PMapFloat64Uint16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint32 

func PMapFloat64Uint32(f func(float64) uint32, list []float64, optional ...Optional) []uint32

PMapFloat64Uint32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint32Err 

func PMapFloat64Uint32Err(f func(float64) (uint32, error), list []float64, optional ...Optional) ([]uint32, error)

PMapFloat64Uint32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint32Ptr 

func PMapFloat64Uint32Ptr(f func(*float64) *uint32, list []*float64, optional ...Optional) []*uint32

PMapFloat64Uint32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint32PtrErr 

func PMapFloat64Uint32PtrErr(f func(*float64) (*uint32, error), list []*float64, optional ...Optional) ([]*uint32, error)

PMapFloat64Uint32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint64 

func PMapFloat64Uint64(f func(float64) uint64, list []float64, optional ...Optional) []uint64

PMapFloat64Uint64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint64Err 

func PMapFloat64Uint64Err(f func(float64) (uint64, error), list []float64, optional ...Optional) ([]uint64, error)

PMapFloat64Uint64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint64Ptr 

func PMapFloat64Uint64Ptr(f func(*float64) *uint64, list []*float64, optional ...Optional) []*uint64

PMapFloat64Uint64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint64PtrErr 

func PMapFloat64Uint64PtrErr(f func(*float64) (*uint64, error), list []*float64, optional ...Optional) ([]*uint64, error)

PMapFloat64Uint64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint8 

func PMapFloat64Uint8(f func(float64) uint8, list []float64, optional ...Optional) []uint8

PMapFloat64Uint8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint8Err 

func PMapFloat64Uint8Err(f func(float64) (uint8, error), list []float64, optional ...Optional) ([]uint8, error)

PMapFloat64Uint8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint8Ptr 

func PMapFloat64Uint8Ptr(f func(*float64) *uint8, list []*float64, optional ...Optional) []*uint8

PMapFloat64Uint8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64Uint8PtrErr 

func PMapFloat64Uint8PtrErr(f func(*float64) (*uint8, error), list []*float64, optional ...Optional) ([]*uint8, error)

PMapFloat64Uint8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64UintErr 

func PMapFloat64UintErr(f func(float64) (uint, error), list []float64, optional ...Optional) ([]uint, error)

PMapFloat64UintErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64UintPtr 

func PMapFloat64UintPtr(f func(*float64) *uint, list []*float64, optional ...Optional) []*uint

PMapFloat64UintPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapFloat64UintPtrErr 

func PMapFloat64UintPtrErr(f func(*float64) (*uint, error), list []*float64, optional ...Optional) ([]*uint, error)

PMapFloat64UintPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt 

func PMapInt(f func(int) int, list []int, optional ...Optional) []int

PMapInt applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16 

func PMapInt16(f func(int16) int16, list []int16, optional ...Optional) []int16

PMapInt16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Bool 

func PMapInt16Bool(f func(int16) bool, list []int16, optional ...Optional) []bool

PMapInt16Bool applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16BoolErr 

func PMapInt16BoolErr(f func(int16) (bool, error), list []int16, optional ...Optional) ([]bool, error)

PMapInt16BoolErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16BoolPtr 

func PMapInt16BoolPtr(f func(*int16) *bool, list []*int16, optional ...Optional) []*bool

PMapInt16BoolPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16BoolPtrErr 

func PMapInt16BoolPtrErr(f func(*int16) (*bool, error), list []*int16, optional ...Optional) ([]*bool, error)

PMapInt16BoolPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Err 

func PMapInt16Err(f func(int16) (int16, error), list []int16, optional ...Optional) ([]int16, error)

PMapInt16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Float32 

func PMapInt16Float32(f func(int16) float32, list []int16, optional ...Optional) []float32

PMapInt16Float32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Float32Err 

func PMapInt16Float32Err(f func(int16) (float32, error), list []int16, optional ...Optional) ([]float32, error)

PMapInt16Float32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Float32Ptr 

func PMapInt16Float32Ptr(f func(*int16) *float32, list []*int16, optional ...Optional) []*float32

PMapInt16Float32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Float32PtrErr 

func PMapInt16Float32PtrErr(f func(*int16) (*float32, error), list []*int16, optional ...Optional) ([]*float32, error)

PMapInt16Float32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Float64 

func PMapInt16Float64(f func(int16) float64, list []int16, optional ...Optional) []float64

PMapInt16Float64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Float64Err 

func PMapInt16Float64Err(f func(int16) (float64, error), list []int16, optional ...Optional) ([]float64, error)

PMapInt16Float64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Float64Ptr 

func PMapInt16Float64Ptr(f func(*int16) *float64, list []*int16, optional ...Optional) []*float64

PMapInt16Float64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Float64PtrErr 

func PMapInt16Float64PtrErr(f func(*int16) (*float64, error), list []*int16, optional ...Optional) ([]*float64, error)

PMapInt16Float64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Int 

func PMapInt16Int(f func(int16) int, list []int16, optional ...Optional) []int

PMapInt16Int applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Int32 

func PMapInt16Int32(f func(int16) int32, list []int16, optional ...Optional) []int32

PMapInt16Int32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Int32Err 

func PMapInt16Int32Err(f func(int16) (int32, error), list []int16, optional ...Optional) ([]int32, error)

PMapInt16Int32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Int32Ptr 

func PMapInt16Int32Ptr(f func(*int16) *int32, list []*int16, optional ...Optional) []*int32

PMapInt16Int32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Int32PtrErr 

func PMapInt16Int32PtrErr(f func(*int16) (*int32, error), list []*int16, optional ...Optional) ([]*int32, error)

PMapInt16Int32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Int64 

func PMapInt16Int64(f func(int16) int64, list []int16, optional ...Optional) []int64

PMapInt16Int64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Int64Err 

func PMapInt16Int64Err(f func(int16) (int64, error), list []int16, optional ...Optional) ([]int64, error)

PMapInt16Int64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Int64Ptr 

func PMapInt16Int64Ptr(f func(*int16) *int64, list []*int16, optional ...Optional) []*int64

PMapInt16Int64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Int64PtrErr 

func PMapInt16Int64PtrErr(f func(*int16) (*int64, error), list []*int16, optional ...Optional) ([]*int64, error)

PMapInt16Int64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Int8 

func PMapInt16Int8(f func(int16) int8, list []int16, optional ...Optional) []int8

PMapInt16Int8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Int8Err 

func PMapInt16Int8Err(f func(int16) (int8, error), list []int16, optional ...Optional) ([]int8, error)

PMapInt16Int8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Int8Ptr 

func PMapInt16Int8Ptr(f func(*int16) *int8, list []*int16, optional ...Optional) []*int8

PMapInt16Int8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Int8PtrErr 

func PMapInt16Int8PtrErr(f func(*int16) (*int8, error), list []*int16, optional ...Optional) ([]*int8, error)

PMapInt16Int8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16IntErr 

func PMapInt16IntErr(f func(int16) (int, error), list []int16, optional ...Optional) ([]int, error)

PMapInt16IntErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16IntPtr 

func PMapInt16IntPtr(f func(*int16) *int, list []*int16, optional ...Optional) []*int

PMapInt16IntPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16IntPtrErr 

func PMapInt16IntPtrErr(f func(*int16) (*int, error), list []*int16, optional ...Optional) ([]*int, error)

PMapInt16IntPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Ptr 

func PMapInt16Ptr(f func(*int16) *int16, list []*int16, optional ...Optional) []*int16

PMapInt16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16PtrErr 

func PMapInt16PtrErr(f func(*int16) (*int16, error), list []*int16, optional ...Optional) ([]*int16, error)

PMapInt16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Str 

func PMapInt16Str(f func(int16) string, list []int16, optional ...Optional) []string

PMapInt16Str applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16StrErr 

func PMapInt16StrErr(f func(int16) (string, error), list []int16, optional ...Optional) ([]string, error)

PMapInt16StrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16StrPtr 

func PMapInt16StrPtr(f func(*int16) *string, list []*int16, optional ...Optional) []*string

PMapInt16StrPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16StrPtrErr 

func PMapInt16StrPtrErr(f func(*int16) (*string, error), list []*int16, optional ...Optional) ([]*string, error)

PMapInt16StrPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint 

func PMapInt16Uint(f func(int16) uint, list []int16, optional ...Optional) []uint

PMapInt16Uint applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint16 

func PMapInt16Uint16(f func(int16) uint16, list []int16, optional ...Optional) []uint16

PMapInt16Uint16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint16Err 

func PMapInt16Uint16Err(f func(int16) (uint16, error), list []int16, optional ...Optional) ([]uint16, error)

PMapInt16Uint16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint16Ptr 

func PMapInt16Uint16Ptr(f func(*int16) *uint16, list []*int16, optional ...Optional) []*uint16

PMapInt16Uint16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint16PtrErr 

func PMapInt16Uint16PtrErr(f func(*int16) (*uint16, error), list []*int16, optional ...Optional) ([]*uint16, error)

PMapInt16Uint16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint32 

func PMapInt16Uint32(f func(int16) uint32, list []int16, optional ...Optional) []uint32

PMapInt16Uint32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint32Err 

func PMapInt16Uint32Err(f func(int16) (uint32, error), list []int16, optional ...Optional) ([]uint32, error)

PMapInt16Uint32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint32Ptr 

func PMapInt16Uint32Ptr(f func(*int16) *uint32, list []*int16, optional ...Optional) []*uint32

PMapInt16Uint32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint32PtrErr 

func PMapInt16Uint32PtrErr(f func(*int16) (*uint32, error), list []*int16, optional ...Optional) ([]*uint32, error)

PMapInt16Uint32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint64 

func PMapInt16Uint64(f func(int16) uint64, list []int16, optional ...Optional) []uint64

PMapInt16Uint64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint64Err 

func PMapInt16Uint64Err(f func(int16) (uint64, error), list []int16, optional ...Optional) ([]uint64, error)

PMapInt16Uint64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint64Ptr 

func PMapInt16Uint64Ptr(f func(*int16) *uint64, list []*int16, optional ...Optional) []*uint64

PMapInt16Uint64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint64PtrErr 

func PMapInt16Uint64PtrErr(f func(*int16) (*uint64, error), list []*int16, optional ...Optional) ([]*uint64, error)

PMapInt16Uint64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint8 

func PMapInt16Uint8(f func(int16) uint8, list []int16, optional ...Optional) []uint8

PMapInt16Uint8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint8Err 

func PMapInt16Uint8Err(f func(int16) (uint8, error), list []int16, optional ...Optional) ([]uint8, error)

PMapInt16Uint8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint8Ptr 

func PMapInt16Uint8Ptr(f func(*int16) *uint8, list []*int16, optional ...Optional) []*uint8

PMapInt16Uint8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16Uint8PtrErr 

func PMapInt16Uint8PtrErr(f func(*int16) (*uint8, error), list []*int16, optional ...Optional) ([]*uint8, error)

PMapInt16Uint8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16UintErr 

func PMapInt16UintErr(f func(int16) (uint, error), list []int16, optional ...Optional) ([]uint, error)

PMapInt16UintErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16UintPtr 

func PMapInt16UintPtr(f func(*int16) *uint, list []*int16, optional ...Optional) []*uint

PMapInt16UintPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt16UintPtrErr 

func PMapInt16UintPtrErr(f func(*int16) (*uint, error), list []*int16, optional ...Optional) ([]*uint, error)

PMapInt16UintPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32 

func PMapInt32(f func(int32) int32, list []int32, optional ...Optional) []int32

PMapInt32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Bool 

func PMapInt32Bool(f func(int32) bool, list []int32, optional ...Optional) []bool

PMapInt32Bool applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32BoolErr 

func PMapInt32BoolErr(f func(int32) (bool, error), list []int32, optional ...Optional) ([]bool, error)

PMapInt32BoolErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32BoolPtr 

func PMapInt32BoolPtr(f func(*int32) *bool, list []*int32, optional ...Optional) []*bool

PMapInt32BoolPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32BoolPtrErr 

func PMapInt32BoolPtrErr(f func(*int32) (*bool, error), list []*int32, optional ...Optional) ([]*bool, error)

PMapInt32BoolPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Err 

func PMapInt32Err(f func(int32) (int32, error), list []int32, optional ...Optional) ([]int32, error)

PMapInt32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Float32 

func PMapInt32Float32(f func(int32) float32, list []int32, optional ...Optional) []float32

PMapInt32Float32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Float32Err 

func PMapInt32Float32Err(f func(int32) (float32, error), list []int32, optional ...Optional) ([]float32, error)

PMapInt32Float32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Float32Ptr 

func PMapInt32Float32Ptr(f func(*int32) *float32, list []*int32, optional ...Optional) []*float32

PMapInt32Float32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Float32PtrErr 

func PMapInt32Float32PtrErr(f func(*int32) (*float32, error), list []*int32, optional ...Optional) ([]*float32, error)

PMapInt32Float32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Float64 

func PMapInt32Float64(f func(int32) float64, list []int32, optional ...Optional) []float64

PMapInt32Float64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Float64Err 

func PMapInt32Float64Err(f func(int32) (float64, error), list []int32, optional ...Optional) ([]float64, error)

PMapInt32Float64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Float64Ptr 

func PMapInt32Float64Ptr(f func(*int32) *float64, list []*int32, optional ...Optional) []*float64

PMapInt32Float64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Float64PtrErr 

func PMapInt32Float64PtrErr(f func(*int32) (*float64, error), list []*int32, optional ...Optional) ([]*float64, error)

PMapInt32Float64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Int 

func PMapInt32Int(f func(int32) int, list []int32, optional ...Optional) []int

PMapInt32Int applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Int16 

func PMapInt32Int16(f func(int32) int16, list []int32, optional ...Optional) []int16

PMapInt32Int16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Int16Err 

func PMapInt32Int16Err(f func(int32) (int16, error), list []int32, optional ...Optional) ([]int16, error)

PMapInt32Int16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Int16Ptr 

func PMapInt32Int16Ptr(f func(*int32) *int16, list []*int32, optional ...Optional) []*int16

PMapInt32Int16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Int16PtrErr 

func PMapInt32Int16PtrErr(f func(*int32) (*int16, error), list []*int32, optional ...Optional) ([]*int16, error)

PMapInt32Int16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Int64 

func PMapInt32Int64(f func(int32) int64, list []int32, optional ...Optional) []int64

PMapInt32Int64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Int64Err 

func PMapInt32Int64Err(f func(int32) (int64, error), list []int32, optional ...Optional) ([]int64, error)

PMapInt32Int64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Int64Ptr 

func PMapInt32Int64Ptr(f func(*int32) *int64, list []*int32, optional ...Optional) []*int64

PMapInt32Int64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Int64PtrErr 

func PMapInt32Int64PtrErr(f func(*int32) (*int64, error), list []*int32, optional ...Optional) ([]*int64, error)

PMapInt32Int64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Int8 

func PMapInt32Int8(f func(int32) int8, list []int32, optional ...Optional) []int8

PMapInt32Int8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Int8Err 

func PMapInt32Int8Err(f func(int32) (int8, error), list []int32, optional ...Optional) ([]int8, error)

PMapInt32Int8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Int8Ptr 

func PMapInt32Int8Ptr(f func(*int32) *int8, list []*int32, optional ...Optional) []*int8

PMapInt32Int8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Int8PtrErr 

func PMapInt32Int8PtrErr(f func(*int32) (*int8, error), list []*int32, optional ...Optional) ([]*int8, error)

PMapInt32Int8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32IntErr 

func PMapInt32IntErr(f func(int32) (int, error), list []int32, optional ...Optional) ([]int, error)

PMapInt32IntErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32IntPtr 

func PMapInt32IntPtr(f func(*int32) *int, list []*int32, optional ...Optional) []*int

PMapInt32IntPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32IntPtrErr 

func PMapInt32IntPtrErr(f func(*int32) (*int, error), list []*int32, optional ...Optional) ([]*int, error)

PMapInt32IntPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Ptr 

func PMapInt32Ptr(f func(*int32) *int32, list []*int32, optional ...Optional) []*int32

PMapInt32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32PtrErr 

func PMapInt32PtrErr(f func(*int32) (*int32, error), list []*int32, optional ...Optional) ([]*int32, error)

PMapInt32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Str 

func PMapInt32Str(f func(int32) string, list []int32, optional ...Optional) []string

PMapInt32Str applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32StrErr 

func PMapInt32StrErr(f func(int32) (string, error), list []int32, optional ...Optional) ([]string, error)

PMapInt32StrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32StrPtr 

func PMapInt32StrPtr(f func(*int32) *string, list []*int32, optional ...Optional) []*string

PMapInt32StrPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32StrPtrErr 

func PMapInt32StrPtrErr(f func(*int32) (*string, error), list []*int32, optional ...Optional) ([]*string, error)

PMapInt32StrPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint 

func PMapInt32Uint(f func(int32) uint, list []int32, optional ...Optional) []uint

PMapInt32Uint applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint16 

func PMapInt32Uint16(f func(int32) uint16, list []int32, optional ...Optional) []uint16

PMapInt32Uint16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint16Err 

func PMapInt32Uint16Err(f func(int32) (uint16, error), list []int32, optional ...Optional) ([]uint16, error)

PMapInt32Uint16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint16Ptr 

func PMapInt32Uint16Ptr(f func(*int32) *uint16, list []*int32, optional ...Optional) []*uint16

PMapInt32Uint16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint16PtrErr 

func PMapInt32Uint16PtrErr(f func(*int32) (*uint16, error), list []*int32, optional ...Optional) ([]*uint16, error)

PMapInt32Uint16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint32 

func PMapInt32Uint32(f func(int32) uint32, list []int32, optional ...Optional) []uint32

PMapInt32Uint32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint32Err 

func PMapInt32Uint32Err(f func(int32) (uint32, error), list []int32, optional ...Optional) ([]uint32, error)

PMapInt32Uint32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint32Ptr 

func PMapInt32Uint32Ptr(f func(*int32) *uint32, list []*int32, optional ...Optional) []*uint32

PMapInt32Uint32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint32PtrErr 

func PMapInt32Uint32PtrErr(f func(*int32) (*uint32, error), list []*int32, optional ...Optional) ([]*uint32, error)

PMapInt32Uint32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint64 

func PMapInt32Uint64(f func(int32) uint64, list []int32, optional ...Optional) []uint64

PMapInt32Uint64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint64Err 

func PMapInt32Uint64Err(f func(int32) (uint64, error), list []int32, optional ...Optional) ([]uint64, error)

PMapInt32Uint64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint64Ptr 

func PMapInt32Uint64Ptr(f func(*int32) *uint64, list []*int32, optional ...Optional) []*uint64

PMapInt32Uint64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint64PtrErr 

func PMapInt32Uint64PtrErr(f func(*int32) (*uint64, error), list []*int32, optional ...Optional) ([]*uint64, error)

PMapInt32Uint64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint8 

func PMapInt32Uint8(f func(int32) uint8, list []int32, optional ...Optional) []uint8

PMapInt32Uint8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint8Err 

func PMapInt32Uint8Err(f func(int32) (uint8, error), list []int32, optional ...Optional) ([]uint8, error)

PMapInt32Uint8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint8Ptr 

func PMapInt32Uint8Ptr(f func(*int32) *uint8, list []*int32, optional ...Optional) []*uint8

PMapInt32Uint8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32Uint8PtrErr 

func PMapInt32Uint8PtrErr(f func(*int32) (*uint8, error), list []*int32, optional ...Optional) ([]*uint8, error)

PMapInt32Uint8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32UintErr 

func PMapInt32UintErr(f func(int32) (uint, error), list []int32, optional ...Optional) ([]uint, error)

PMapInt32UintErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32UintPtr 

func PMapInt32UintPtr(f func(*int32) *uint, list []*int32, optional ...Optional) []*uint

PMapInt32UintPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt32UintPtrErr 

func PMapInt32UintPtrErr(f func(*int32) (*uint, error), list []*int32, optional ...Optional) ([]*uint, error)

PMapInt32UintPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64 

func PMapInt64(f func(int64) int64, list []int64, optional ...Optional) []int64

PMapInt64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Bool 

func PMapInt64Bool(f func(int64) bool, list []int64, optional ...Optional) []bool

PMapInt64Bool applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64BoolErr 

func PMapInt64BoolErr(f func(int64) (bool, error), list []int64, optional ...Optional) ([]bool, error)

PMapInt64BoolErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64BoolPtr 

func PMapInt64BoolPtr(f func(*int64) *bool, list []*int64, optional ...Optional) []*bool

PMapInt64BoolPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64BoolPtrErr 

func PMapInt64BoolPtrErr(f func(*int64) (*bool, error), list []*int64, optional ...Optional) ([]*bool, error)

PMapInt64BoolPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Err 

func PMapInt64Err(f func(int64) (int64, error), list []int64, optional ...Optional) ([]int64, error)

PMapInt64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Float32 

func PMapInt64Float32(f func(int64) float32, list []int64, optional ...Optional) []float32

PMapInt64Float32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Float32Err 

func PMapInt64Float32Err(f func(int64) (float32, error), list []int64, optional ...Optional) ([]float32, error)

PMapInt64Float32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Float32Ptr 

func PMapInt64Float32Ptr(f func(*int64) *float32, list []*int64, optional ...Optional) []*float32

PMapInt64Float32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Float32PtrErr 

func PMapInt64Float32PtrErr(f func(*int64) (*float32, error), list []*int64, optional ...Optional) ([]*float32, error)

PMapInt64Float32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Float64 

func PMapInt64Float64(f func(int64) float64, list []int64, optional ...Optional) []float64

PMapInt64Float64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Float64Err 

func PMapInt64Float64Err(f func(int64) (float64, error), list []int64, optional ...Optional) ([]float64, error)

PMapInt64Float64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Float64Ptr 

func PMapInt64Float64Ptr(f func(*int64) *float64, list []*int64, optional ...Optional) []*float64

PMapInt64Float64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Float64PtrErr 

func PMapInt64Float64PtrErr(f func(*int64) (*float64, error), list []*int64, optional ...Optional) ([]*float64, error)

PMapInt64Float64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Int 

func PMapInt64Int(f func(int64) int, list []int64, optional ...Optional) []int

PMapInt64Int applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Int16 

func PMapInt64Int16(f func(int64) int16, list []int64, optional ...Optional) []int16

PMapInt64Int16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Int16Err 

func PMapInt64Int16Err(f func(int64) (int16, error), list []int64, optional ...Optional) ([]int16, error)

PMapInt64Int16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Int16Ptr 

func PMapInt64Int16Ptr(f func(*int64) *int16, list []*int64, optional ...Optional) []*int16

PMapInt64Int16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Int16PtrErr 

func PMapInt64Int16PtrErr(f func(*int64) (*int16, error), list []*int64, optional ...Optional) ([]*int16, error)

PMapInt64Int16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Int32 

func PMapInt64Int32(f func(int64) int32, list []int64, optional ...Optional) []int32

PMapInt64Int32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Int32Err 

func PMapInt64Int32Err(f func(int64) (int32, error), list []int64, optional ...Optional) ([]int32, error)

PMapInt64Int32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Int32Ptr 

func PMapInt64Int32Ptr(f func(*int64) *int32, list []*int64, optional ...Optional) []*int32

PMapInt64Int32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Int32PtrErr 

func PMapInt64Int32PtrErr(f func(*int64) (*int32, error), list []*int64, optional ...Optional) ([]*int32, error)

PMapInt64Int32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Int8 

func PMapInt64Int8(f func(int64) int8, list []int64, optional ...Optional) []int8

PMapInt64Int8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Int8Err 

func PMapInt64Int8Err(f func(int64) (int8, error), list []int64, optional ...Optional) ([]int8, error)

PMapInt64Int8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Int8Ptr 

func PMapInt64Int8Ptr(f func(*int64) *int8, list []*int64, optional ...Optional) []*int8

PMapInt64Int8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Int8PtrErr 

func PMapInt64Int8PtrErr(f func(*int64) (*int8, error), list []*int64, optional ...Optional) ([]*int8, error)

PMapInt64Int8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64IntErr 

func PMapInt64IntErr(f func(int64) (int, error), list []int64, optional ...Optional) ([]int, error)

PMapInt64IntErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64IntPtr 

func PMapInt64IntPtr(f func(*int64) *int, list []*int64, optional ...Optional) []*int

PMapInt64IntPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64IntPtrErr 

func PMapInt64IntPtrErr(f func(*int64) (*int, error), list []*int64, optional ...Optional) ([]*int, error)

PMapInt64IntPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Ptr 

func PMapInt64Ptr(f func(*int64) *int64, list []*int64, optional ...Optional) []*int64

PMapInt64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64PtrErr 

func PMapInt64PtrErr(f func(*int64) (*int64, error), list []*int64, optional ...Optional) ([]*int64, error)

PMapInt64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Str 

func PMapInt64Str(f func(int64) string, list []int64, optional ...Optional) []string

PMapInt64Str applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64StrErr 

func PMapInt64StrErr(f func(int64) (string, error), list []int64, optional ...Optional) ([]string, error)

PMapInt64StrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64StrPtr 

func PMapInt64StrPtr(f func(*int64) *string, list []*int64, optional ...Optional) []*string

PMapInt64StrPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64StrPtrErr 

func PMapInt64StrPtrErr(f func(*int64) (*string, error), list []*int64, optional ...Optional) ([]*string, error)

PMapInt64StrPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint 

func PMapInt64Uint(f func(int64) uint, list []int64, optional ...Optional) []uint

PMapInt64Uint applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint16 

func PMapInt64Uint16(f func(int64) uint16, list []int64, optional ...Optional) []uint16

PMapInt64Uint16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint16Err 

func PMapInt64Uint16Err(f func(int64) (uint16, error), list []int64, optional ...Optional) ([]uint16, error)

PMapInt64Uint16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint16Ptr 

func PMapInt64Uint16Ptr(f func(*int64) *uint16, list []*int64, optional ...Optional) []*uint16

PMapInt64Uint16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint16PtrErr 

func PMapInt64Uint16PtrErr(f func(*int64) (*uint16, error), list []*int64, optional ...Optional) ([]*uint16, error)

PMapInt64Uint16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint32 

func PMapInt64Uint32(f func(int64) uint32, list []int64, optional ...Optional) []uint32

PMapInt64Uint32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint32Err 

func PMapInt64Uint32Err(f func(int64) (uint32, error), list []int64, optional ...Optional) ([]uint32, error)

PMapInt64Uint32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint32Ptr 

func PMapInt64Uint32Ptr(f func(*int64) *uint32, list []*int64, optional ...Optional) []*uint32

PMapInt64Uint32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint32PtrErr 

func PMapInt64Uint32PtrErr(f func(*int64) (*uint32, error), list []*int64, optional ...Optional) ([]*uint32, error)

PMapInt64Uint32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint64 

func PMapInt64Uint64(f func(int64) uint64, list []int64, optional ...Optional) []uint64

PMapInt64Uint64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint64Err 

func PMapInt64Uint64Err(f func(int64) (uint64, error), list []int64, optional ...Optional) ([]uint64, error)

PMapInt64Uint64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint64Ptr 

func PMapInt64Uint64Ptr(f func(*int64) *uint64, list []*int64, optional ...Optional) []*uint64

PMapInt64Uint64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint64PtrErr 

func PMapInt64Uint64PtrErr(f func(*int64) (*uint64, error), list []*int64, optional ...Optional) ([]*uint64, error)

PMapInt64Uint64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint8 

func PMapInt64Uint8(f func(int64) uint8, list []int64, optional ...Optional) []uint8

PMapInt64Uint8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint8Err 

func PMapInt64Uint8Err(f func(int64) (uint8, error), list []int64, optional ...Optional) ([]uint8, error)

PMapInt64Uint8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint8Ptr 

func PMapInt64Uint8Ptr(f func(*int64) *uint8, list []*int64, optional ...Optional) []*uint8

PMapInt64Uint8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64Uint8PtrErr 

func PMapInt64Uint8PtrErr(f func(*int64) (*uint8, error), list []*int64, optional ...Optional) ([]*uint8, error)

PMapInt64Uint8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64UintErr 

func PMapInt64UintErr(f func(int64) (uint, error), list []int64, optional ...Optional) ([]uint, error)

PMapInt64UintErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64UintPtr 

func PMapInt64UintPtr(f func(*int64) *uint, list []*int64, optional ...Optional) []*uint

PMapInt64UintPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt64UintPtrErr 

func PMapInt64UintPtrErr(f func(*int64) (*uint, error), list []*int64, optional ...Optional) ([]*uint, error)

PMapInt64UintPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8 

func PMapInt8(f func(int8) int8, list []int8, optional ...Optional) []int8

PMapInt8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Bool 

func PMapInt8Bool(f func(int8) bool, list []int8, optional ...Optional) []bool

PMapInt8Bool applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8BoolErr 

func PMapInt8BoolErr(f func(int8) (bool, error), list []int8, optional ...Optional) ([]bool, error)

PMapInt8BoolErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8BoolPtr 

func PMapInt8BoolPtr(f func(*int8) *bool, list []*int8, optional ...Optional) []*bool

PMapInt8BoolPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8BoolPtrErr 

func PMapInt8BoolPtrErr(f func(*int8) (*bool, error), list []*int8, optional ...Optional) ([]*bool, error)

PMapInt8BoolPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Err 

func PMapInt8Err(f func(int8) (int8, error), list []int8, optional ...Optional) ([]int8, error)

PMapInt8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Float32 

func PMapInt8Float32(f func(int8) float32, list []int8, optional ...Optional) []float32

PMapInt8Float32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Float32Err 

func PMapInt8Float32Err(f func(int8) (float32, error), list []int8, optional ...Optional) ([]float32, error)

PMapInt8Float32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Float32Ptr 

func PMapInt8Float32Ptr(f func(*int8) *float32, list []*int8, optional ...Optional) []*float32

PMapInt8Float32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Float32PtrErr 

func PMapInt8Float32PtrErr(f func(*int8) (*float32, error), list []*int8, optional ...Optional) ([]*float32, error)

PMapInt8Float32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Float64 

func PMapInt8Float64(f func(int8) float64, list []int8, optional ...Optional) []float64

PMapInt8Float64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Float64Err 

func PMapInt8Float64Err(f func(int8) (float64, error), list []int8, optional ...Optional) ([]float64, error)

PMapInt8Float64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Float64Ptr 

func PMapInt8Float64Ptr(f func(*int8) *float64, list []*int8, optional ...Optional) []*float64

PMapInt8Float64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Float64PtrErr 

func PMapInt8Float64PtrErr(f func(*int8) (*float64, error), list []*int8, optional ...Optional) ([]*float64, error)

PMapInt8Float64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Int 

func PMapInt8Int(f func(int8) int, list []int8, optional ...Optional) []int

PMapInt8Int applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Int16 

func PMapInt8Int16(f func(int8) int16, list []int8, optional ...Optional) []int16

PMapInt8Int16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Int16Err 

func PMapInt8Int16Err(f func(int8) (int16, error), list []int8, optional ...Optional) ([]int16, error)

PMapInt8Int16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Int16Ptr 

func PMapInt8Int16Ptr(f func(*int8) *int16, list []*int8, optional ...Optional) []*int16

PMapInt8Int16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Int16PtrErr 

func PMapInt8Int16PtrErr(f func(*int8) (*int16, error), list []*int8, optional ...Optional) ([]*int16, error)

PMapInt8Int16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Int32 

func PMapInt8Int32(f func(int8) int32, list []int8, optional ...Optional) []int32

PMapInt8Int32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Int32Err 

func PMapInt8Int32Err(f func(int8) (int32, error), list []int8, optional ...Optional) ([]int32, error)

PMapInt8Int32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Int32Ptr 

func PMapInt8Int32Ptr(f func(*int8) *int32, list []*int8, optional ...Optional) []*int32

PMapInt8Int32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Int32PtrErr 

func PMapInt8Int32PtrErr(f func(*int8) (*int32, error), list []*int8, optional ...Optional) ([]*int32, error)

PMapInt8Int32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Int64 

func PMapInt8Int64(f func(int8) int64, list []int8, optional ...Optional) []int64

PMapInt8Int64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Int64Err 

func PMapInt8Int64Err(f func(int8) (int64, error), list []int8, optional ...Optional) ([]int64, error)

PMapInt8Int64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Int64Ptr 

func PMapInt8Int64Ptr(f func(*int8) *int64, list []*int8, optional ...Optional) []*int64

PMapInt8Int64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Int64PtrErr 

func PMapInt8Int64PtrErr(f func(*int8) (*int64, error), list []*int8, optional ...Optional) ([]*int64, error)

PMapInt8Int64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8IntErr 

func PMapInt8IntErr(f func(int8) (int, error), list []int8, optional ...Optional) ([]int, error)

PMapInt8IntErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8IntPtr 

func PMapInt8IntPtr(f func(*int8) *int, list []*int8, optional ...Optional) []*int

PMapInt8IntPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8IntPtrErr 

func PMapInt8IntPtrErr(f func(*int8) (*int, error), list []*int8, optional ...Optional) ([]*int, error)

PMapInt8IntPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Ptr 

func PMapInt8Ptr(f func(*int8) *int8, list []*int8, optional ...Optional) []*int8

PMapInt8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8PtrErr 

func PMapInt8PtrErr(f func(*int8) (*int8, error), list []*int8, optional ...Optional) ([]*int8, error)

PMapInt8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Str 

func PMapInt8Str(f func(int8) string, list []int8, optional ...Optional) []string

PMapInt8Str applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8StrErr 

func PMapInt8StrErr(f func(int8) (string, error), list []int8, optional ...Optional) ([]string, error)

PMapInt8StrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8StrPtr 

func PMapInt8StrPtr(f func(*int8) *string, list []*int8, optional ...Optional) []*string

PMapInt8StrPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8StrPtrErr 

func PMapInt8StrPtrErr(f func(*int8) (*string, error), list []*int8, optional ...Optional) ([]*string, error)

PMapInt8StrPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint 

func PMapInt8Uint(f func(int8) uint, list []int8, optional ...Optional) []uint

PMapInt8Uint applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint16 

func PMapInt8Uint16(f func(int8) uint16, list []int8, optional ...Optional) []uint16

PMapInt8Uint16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint16Err 

func PMapInt8Uint16Err(f func(int8) (uint16, error), list []int8, optional ...Optional) ([]uint16, error)

PMapInt8Uint16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint16Ptr 

func PMapInt8Uint16Ptr(f func(*int8) *uint16, list []*int8, optional ...Optional) []*uint16

PMapInt8Uint16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint16PtrErr 

func PMapInt8Uint16PtrErr(f func(*int8) (*uint16, error), list []*int8, optional ...Optional) ([]*uint16, error)

PMapInt8Uint16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint32 

func PMapInt8Uint32(f func(int8) uint32, list []int8, optional ...Optional) []uint32

PMapInt8Uint32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint32Err 

func PMapInt8Uint32Err(f func(int8) (uint32, error), list []int8, optional ...Optional) ([]uint32, error)

PMapInt8Uint32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint32Ptr 

func PMapInt8Uint32Ptr(f func(*int8) *uint32, list []*int8, optional ...Optional) []*uint32

PMapInt8Uint32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint32PtrErr 

func PMapInt8Uint32PtrErr(f func(*int8) (*uint32, error), list []*int8, optional ...Optional) ([]*uint32, error)

PMapInt8Uint32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint64 

func PMapInt8Uint64(f func(int8) uint64, list []int8, optional ...Optional) []uint64

PMapInt8Uint64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint64Err 

func PMapInt8Uint64Err(f func(int8) (uint64, error), list []int8, optional ...Optional) ([]uint64, error)

PMapInt8Uint64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint64Ptr 

func PMapInt8Uint64Ptr(f func(*int8) *uint64, list []*int8, optional ...Optional) []*uint64

PMapInt8Uint64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint64PtrErr 

func PMapInt8Uint64PtrErr(f func(*int8) (*uint64, error), list []*int8, optional ...Optional) ([]*uint64, error)

PMapInt8Uint64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint8 

func PMapInt8Uint8(f func(int8) uint8, list []int8, optional ...Optional) []uint8

PMapInt8Uint8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint8Err 

func PMapInt8Uint8Err(f func(int8) (uint8, error), list []int8, optional ...Optional) ([]uint8, error)

PMapInt8Uint8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint8Ptr 

func PMapInt8Uint8Ptr(f func(*int8) *uint8, list []*int8, optional ...Optional) []*uint8

PMapInt8Uint8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8Uint8PtrErr 

func PMapInt8Uint8PtrErr(f func(*int8) (*uint8, error), list []*int8, optional ...Optional) ([]*uint8, error)

PMapInt8Uint8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8UintErr 

func PMapInt8UintErr(f func(int8) (uint, error), list []int8, optional ...Optional) ([]uint, error)

PMapInt8UintErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8UintPtr 

func PMapInt8UintPtr(f func(*int8) *uint, list []*int8, optional ...Optional) []*uint

PMapInt8UintPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapInt8UintPtrErr 

func PMapInt8UintPtrErr(f func(*int8) (*uint, error), list []*int8, optional ...Optional) ([]*uint, error)

PMapInt8UintPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntBool 

func PMapIntBool(f func(int) bool, list []int, optional ...Optional) []bool

PMapIntBool applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntBoolErr 

func PMapIntBoolErr(f func(int) (bool, error), list []int, optional ...Optional) ([]bool, error)

PMapIntBoolErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntBoolPtr 

func PMapIntBoolPtr(f func(*int) *bool, list []*int, optional ...Optional) []*bool

PMapIntBoolPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntBoolPtrErr 

func PMapIntBoolPtrErr(f func(*int) (*bool, error), list []*int, optional ...Optional) ([]*bool, error)

PMapIntBoolPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntErr 

func PMapIntErr(f func(int) (int, error), list []int, optional ...Optional) ([]int, error)

PMapIntErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntFloat32 

func PMapIntFloat32(f func(int) float32, list []int, optional ...Optional) []float32

PMapIntFloat32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntFloat32Err 

func PMapIntFloat32Err(f func(int) (float32, error), list []int, optional ...Optional) ([]float32, error)

PMapIntFloat32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntFloat32Ptr 

func PMapIntFloat32Ptr(f func(*int) *float32, list []*int, optional ...Optional) []*float32

PMapIntFloat32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntFloat32PtrErr 

func PMapIntFloat32PtrErr(f func(*int) (*float32, error), list []*int, optional ...Optional) ([]*float32, error)

PMapIntFloat32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntFloat64 

func PMapIntFloat64(f func(int) float64, list []int, optional ...Optional) []float64

PMapIntFloat64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntFloat64Err 

func PMapIntFloat64Err(f func(int) (float64, error), list []int, optional ...Optional) ([]float64, error)

PMapIntFloat64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntFloat64Ptr 

func PMapIntFloat64Ptr(f func(*int) *float64, list []*int, optional ...Optional) []*float64

PMapIntFloat64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntFloat64PtrErr 

func PMapIntFloat64PtrErr(f func(*int) (*float64, error), list []*int, optional ...Optional) ([]*float64, error)

PMapIntFloat64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntInt16 

func PMapIntInt16(f func(int) int16, list []int, optional ...Optional) []int16

PMapIntInt16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntInt16Err 

func PMapIntInt16Err(f func(int) (int16, error), list []int, optional ...Optional) ([]int16, error)

PMapIntInt16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntInt16Ptr 

func PMapIntInt16Ptr(f func(*int) *int16, list []*int, optional ...Optional) []*int16

PMapIntInt16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntInt16PtrErr 

func PMapIntInt16PtrErr(f func(*int) (*int16, error), list []*int, optional ...Optional) ([]*int16, error)

PMapIntInt16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntInt32 

func PMapIntInt32(f func(int) int32, list []int, optional ...Optional) []int32

PMapIntInt32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntInt32Err 

func PMapIntInt32Err(f func(int) (int32, error), list []int, optional ...Optional) ([]int32, error)

PMapIntInt32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntInt32Ptr 

func PMapIntInt32Ptr(f func(*int) *int32, list []*int, optional ...Optional) []*int32

PMapIntInt32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntInt32PtrErr 

func PMapIntInt32PtrErr(f func(*int) (*int32, error), list []*int, optional ...Optional) ([]*int32, error)

PMapIntInt32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntInt64 

func PMapIntInt64(f func(int) int64, list []int, optional ...Optional) []int64

PMapIntInt64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntInt64Err 

func PMapIntInt64Err(f func(int) (int64, error), list []int, optional ...Optional) ([]int64, error)

PMapIntInt64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntInt64Ptr 

func PMapIntInt64Ptr(f func(*int) *int64, list []*int, optional ...Optional) []*int64

PMapIntInt64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntInt64PtrErr 

func PMapIntInt64PtrErr(f func(*int) (*int64, error), list []*int, optional ...Optional) ([]*int64, error)

PMapIntInt64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntInt8 

func PMapIntInt8(f func(int) int8, list []int, optional ...Optional) []int8

PMapIntInt8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntInt8Err 

func PMapIntInt8Err(f func(int) (int8, error), list []int, optional ...Optional) ([]int8, error)

PMapIntInt8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntInt8Ptr 

func PMapIntInt8Ptr(f func(*int) *int8, list []*int, optional ...Optional) []*int8

PMapIntInt8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntInt8PtrErr 

func PMapIntInt8PtrErr(f func(*int) (*int8, error), list []*int, optional ...Optional) ([]*int8, error)

PMapIntInt8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntPtr 

func PMapIntPtr(f func(*int) *int, list []*int, optional ...Optional) []*int

PMapIntPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntPtrErr 

func PMapIntPtrErr(f func(*int) (*int, error), list []*int, optional ...Optional) ([]*int, error)

PMapIntPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntStr 

func PMapIntStr(f func(int) string, list []int, optional ...Optional) []string

PMapIntStr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntStrErr 

func PMapIntStrErr(f func(int) (string, error), list []int, optional ...Optional) ([]string, error)

PMapIntStrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntStrPtr 

func PMapIntStrPtr(f func(*int) *string, list []*int, optional ...Optional) []*string

PMapIntStrPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntStrPtrErr 

func PMapIntStrPtrErr(f func(*int) (*string, error), list []*int, optional ...Optional) ([]*string, error)

PMapIntStrPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint 

func PMapIntUint(f func(int) uint, list []int, optional ...Optional) []uint

PMapIntUint applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint16 

func PMapIntUint16(f func(int) uint16, list []int, optional ...Optional) []uint16

PMapIntUint16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint16Err 

func PMapIntUint16Err(f func(int) (uint16, error), list []int, optional ...Optional) ([]uint16, error)

PMapIntUint16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint16Ptr 

func PMapIntUint16Ptr(f func(*int) *uint16, list []*int, optional ...Optional) []*uint16

PMapIntUint16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint16PtrErr 

func PMapIntUint16PtrErr(f func(*int) (*uint16, error), list []*int, optional ...Optional) ([]*uint16, error)

PMapIntUint16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint32 

func PMapIntUint32(f func(int) uint32, list []int, optional ...Optional) []uint32

PMapIntUint32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint32Err 

func PMapIntUint32Err(f func(int) (uint32, error), list []int, optional ...Optional) ([]uint32, error)

PMapIntUint32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint32Ptr 

func PMapIntUint32Ptr(f func(*int) *uint32, list []*int, optional ...Optional) []*uint32

PMapIntUint32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint32PtrErr 

func PMapIntUint32PtrErr(f func(*int) (*uint32, error), list []*int, optional ...Optional) ([]*uint32, error)

PMapIntUint32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint64 

func PMapIntUint64(f func(int) uint64, list []int, optional ...Optional) []uint64

PMapIntUint64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint64Err 

func PMapIntUint64Err(f func(int) (uint64, error), list []int, optional ...Optional) ([]uint64, error)

PMapIntUint64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint64Ptr 

func PMapIntUint64Ptr(f func(*int) *uint64, list []*int, optional ...Optional) []*uint64

PMapIntUint64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint64PtrErr 

func PMapIntUint64PtrErr(f func(*int) (*uint64, error), list []*int, optional ...Optional) ([]*uint64, error)

PMapIntUint64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint8 

func PMapIntUint8(f func(int) uint8, list []int, optional ...Optional) []uint8

PMapIntUint8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint8Err 

func PMapIntUint8Err(f func(int) (uint8, error), list []int, optional ...Optional) ([]uint8, error)

PMapIntUint8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint8Ptr 

func PMapIntUint8Ptr(f func(*int) *uint8, list []*int, optional ...Optional) []*uint8

PMapIntUint8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUint8PtrErr 

func PMapIntUint8PtrErr(f func(*int) (*uint8, error), list []*int, optional ...Optional) ([]*uint8, error)

PMapIntUint8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUintErr 

func PMapIntUintErr(f func(int) (uint, error), list []int, optional ...Optional) ([]uint, error)

PMapIntUintErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUintPtr 

func PMapIntUintPtr(f func(*int) *uint, list []*int, optional ...Optional) []*uint

PMapIntUintPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapIntUintPtrErr 

func PMapIntUintPtrErr(f func(*int) (*uint, error), list []*int, optional ...Optional) ([]*uint, error)

PMapIntUintPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStr 

func PMapStr(f func(string) string, list []string, optional ...Optional) []string

PMapStr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrBool 

func PMapStrBool(f func(string) bool, list []string, optional ...Optional) []bool

PMapStrBool applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrBoolErr 

func PMapStrBoolErr(f func(string) (bool, error), list []string, optional ...Optional) ([]bool, error)

PMapStrBoolErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrBoolPtr 

func PMapStrBoolPtr(f func(*string) *bool, list []*string, optional ...Optional) []*bool

PMapStrBoolPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrBoolPtrErr 

func PMapStrBoolPtrErr(f func(*string) (*bool, error), list []*string, optional ...Optional) ([]*bool, error)

PMapStrBoolPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrErr 

func PMapStrErr(f func(string) (string, error), list []string, optional ...Optional) ([]string, error)

PMapStrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrFloat32 

func PMapStrFloat32(f func(string) float32, list []string, optional ...Optional) []float32

PMapStrFloat32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrFloat32Err 

func PMapStrFloat32Err(f func(string) (float32, error), list []string, optional ...Optional) ([]float32, error)

PMapStrFloat32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrFloat32Ptr 

func PMapStrFloat32Ptr(f func(*string) *float32, list []*string, optional ...Optional) []*float32

PMapStrFloat32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrFloat32PtrErr 

func PMapStrFloat32PtrErr(f func(*string) (*float32, error), list []*string, optional ...Optional) ([]*float32, error)

PMapStrFloat32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrFloat64 

func PMapStrFloat64(f func(string) float64, list []string, optional ...Optional) []float64

PMapStrFloat64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrFloat64Err 

func PMapStrFloat64Err(f func(string) (float64, error), list []string, optional ...Optional) ([]float64, error)

PMapStrFloat64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrFloat64Ptr 

func PMapStrFloat64Ptr(f func(*string) *float64, list []*string, optional ...Optional) []*float64

PMapStrFloat64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrFloat64PtrErr 

func PMapStrFloat64PtrErr(f func(*string) (*float64, error), list []*string, optional ...Optional) ([]*float64, error)

PMapStrFloat64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt 

func PMapStrInt(f func(string) int, list []string, optional ...Optional) []int

PMapStrInt applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt16 

func PMapStrInt16(f func(string) int16, list []string, optional ...Optional) []int16

PMapStrInt16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt16Err 

func PMapStrInt16Err(f func(string) (int16, error), list []string, optional ...Optional) ([]int16, error)

PMapStrInt16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt16Ptr 

func PMapStrInt16Ptr(f func(*string) *int16, list []*string, optional ...Optional) []*int16

PMapStrInt16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt16PtrErr 

func PMapStrInt16PtrErr(f func(*string) (*int16, error), list []*string, optional ...Optional) ([]*int16, error)

PMapStrInt16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt32 

func PMapStrInt32(f func(string) int32, list []string, optional ...Optional) []int32

PMapStrInt32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt32Err 

func PMapStrInt32Err(f func(string) (int32, error), list []string, optional ...Optional) ([]int32, error)

PMapStrInt32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt32Ptr 

func PMapStrInt32Ptr(f func(*string) *int32, list []*string, optional ...Optional) []*int32

PMapStrInt32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt32PtrErr 

func PMapStrInt32PtrErr(f func(*string) (*int32, error), list []*string, optional ...Optional) ([]*int32, error)

PMapStrInt32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt64 

func PMapStrInt64(f func(string) int64, list []string, optional ...Optional) []int64

PMapStrInt64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt64Err 

func PMapStrInt64Err(f func(string) (int64, error), list []string, optional ...Optional) ([]int64, error)

PMapStrInt64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt64Ptr 

func PMapStrInt64Ptr(f func(*string) *int64, list []*string, optional ...Optional) []*int64

PMapStrInt64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt64PtrErr 

func PMapStrInt64PtrErr(f func(*string) (*int64, error), list []*string, optional ...Optional) ([]*int64, error)

PMapStrInt64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt8 

func PMapStrInt8(f func(string) int8, list []string, optional ...Optional) []int8

PMapStrInt8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt8Err 

func PMapStrInt8Err(f func(string) (int8, error), list []string, optional ...Optional) ([]int8, error)

PMapStrInt8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt8Ptr 

func PMapStrInt8Ptr(f func(*string) *int8, list []*string, optional ...Optional) []*int8

PMapStrInt8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrInt8PtrErr 

func PMapStrInt8PtrErr(f func(*string) (*int8, error), list []*string, optional ...Optional) ([]*int8, error)

PMapStrInt8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrIntErr 

func PMapStrIntErr(f func(string) (int, error), list []string, optional ...Optional) ([]int, error)

PMapStrIntErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrIntPtr 

func PMapStrIntPtr(f func(*string) *int, list []*string, optional ...Optional) []*int

PMapStrIntPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrIntPtrErr 

func PMapStrIntPtrErr(f func(*string) (*int, error), list []*string, optional ...Optional) ([]*int, error)

PMapStrIntPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrPtr 

func PMapStrPtr(f func(*string) *string, list []*string, optional ...Optional) []*string

PMapStrPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrPtrErr 

func PMapStrPtrErr(f func(*string) (*string, error), list []*string, optional ...Optional) ([]*string, error)

PMapStrPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint 

func PMapStrUint(f func(string) uint, list []string, optional ...Optional) []uint

PMapStrUint applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint16 

func PMapStrUint16(f func(string) uint16, list []string, optional ...Optional) []uint16

PMapStrUint16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint16Err 

func PMapStrUint16Err(f func(string) (uint16, error), list []string, optional ...Optional) ([]uint16, error)

PMapStrUint16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint16Ptr 

func PMapStrUint16Ptr(f func(*string) *uint16, list []*string, optional ...Optional) []*uint16

PMapStrUint16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint16PtrErr 

func PMapStrUint16PtrErr(f func(*string) (*uint16, error), list []*string, optional ...Optional) ([]*uint16, error)

PMapStrUint16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint32 

func PMapStrUint32(f func(string) uint32, list []string, optional ...Optional) []uint32

PMapStrUint32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint32Err 

func PMapStrUint32Err(f func(string) (uint32, error), list []string, optional ...Optional) ([]uint32, error)

PMapStrUint32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint32Ptr 

func PMapStrUint32Ptr(f func(*string) *uint32, list []*string, optional ...Optional) []*uint32

PMapStrUint32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint32PtrErr 

func PMapStrUint32PtrErr(f func(*string) (*uint32, error), list []*string, optional ...Optional) ([]*uint32, error)

PMapStrUint32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint64 

func PMapStrUint64(f func(string) uint64, list []string, optional ...Optional) []uint64

PMapStrUint64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint64Err 

func PMapStrUint64Err(f func(string) (uint64, error), list []string, optional ...Optional) ([]uint64, error)

PMapStrUint64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint64Ptr 

func PMapStrUint64Ptr(f func(*string) *uint64, list []*string, optional ...Optional) []*uint64

PMapStrUint64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint64PtrErr 

func PMapStrUint64PtrErr(f func(*string) (*uint64, error), list []*string, optional ...Optional) ([]*uint64, error)

PMapStrUint64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint8 

func PMapStrUint8(f func(string) uint8, list []string, optional ...Optional) []uint8

PMapStrUint8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint8Err 

func PMapStrUint8Err(f func(string) (uint8, error), list []string, optional ...Optional) ([]uint8, error)

PMapStrUint8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint8Ptr 

func PMapStrUint8Ptr(f func(*string) *uint8, list []*string, optional ...Optional) []*uint8

PMapStrUint8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUint8PtrErr 

func PMapStrUint8PtrErr(f func(*string) (*uint8, error), list []*string, optional ...Optional) ([]*uint8, error)

PMapStrUint8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUintErr 

func PMapStrUintErr(f func(string) (uint, error), list []string, optional ...Optional) ([]uint, error)

PMapStrUintErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUintPtr 

func PMapStrUintPtr(f func(*string) *uint, list []*string, optional ...Optional) []*uint

PMapStrUintPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapStrUintPtrErr 

func PMapStrUintPtrErr(f func(*string) (*uint, error), list []*string, optional ...Optional) ([]*uint, error)

PMapStrUintPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint 

func PMapUint(f func(uint) uint, list []uint, optional ...Optional) []uint

PMapUint applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16 

func PMapUint16(f func(uint16) uint16, list []uint16, optional ...Optional) []uint16

PMapUint16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Bool 

func PMapUint16Bool(f func(uint16) bool, list []uint16, optional ...Optional) []bool

PMapUint16Bool applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16BoolErr 

func PMapUint16BoolErr(f func(uint16) (bool, error), list []uint16, optional ...Optional) ([]bool, error)

PMapUint16BoolErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16BoolPtr 

func PMapUint16BoolPtr(f func(*uint16) *bool, list []*uint16, optional ...Optional) []*bool

PMapUint16BoolPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16BoolPtrErr 

func PMapUint16BoolPtrErr(f func(*uint16) (*bool, error), list []*uint16, optional ...Optional) ([]*bool, error)

PMapUint16BoolPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Err 

func PMapUint16Err(f func(uint16) (uint16, error), list []uint16, optional ...Optional) ([]uint16, error)

PMapUint16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Float32 

func PMapUint16Float32(f func(uint16) float32, list []uint16, optional ...Optional) []float32

PMapUint16Float32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Float32Err 

func PMapUint16Float32Err(f func(uint16) (float32, error), list []uint16, optional ...Optional) ([]float32, error)

PMapUint16Float32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Float32Ptr 

func PMapUint16Float32Ptr(f func(*uint16) *float32, list []*uint16, optional ...Optional) []*float32

PMapUint16Float32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Float32PtrErr 

func PMapUint16Float32PtrErr(f func(*uint16) (*float32, error), list []*uint16, optional ...Optional) ([]*float32, error)

PMapUint16Float32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Float64 

func PMapUint16Float64(f func(uint16) float64, list []uint16, optional ...Optional) []float64

PMapUint16Float64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Float64Err 

func PMapUint16Float64Err(f func(uint16) (float64, error), list []uint16, optional ...Optional) ([]float64, error)

PMapUint16Float64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Float64Ptr 

func PMapUint16Float64Ptr(f func(*uint16) *float64, list []*uint16, optional ...Optional) []*float64

PMapUint16Float64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Float64PtrErr 

func PMapUint16Float64PtrErr(f func(*uint16) (*float64, error), list []*uint16, optional ...Optional) ([]*float64, error)

PMapUint16Float64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int 

func PMapUint16Int(f func(uint16) int, list []uint16, optional ...Optional) []int

PMapUint16Int applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int16 

func PMapUint16Int16(f func(uint16) int16, list []uint16, optional ...Optional) []int16

PMapUint16Int16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int16Err 

func PMapUint16Int16Err(f func(uint16) (int16, error), list []uint16, optional ...Optional) ([]int16, error)

PMapUint16Int16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int16Ptr 

func PMapUint16Int16Ptr(f func(*uint16) *int16, list []*uint16, optional ...Optional) []*int16

PMapUint16Int16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int16PtrErr 

func PMapUint16Int16PtrErr(f func(*uint16) (*int16, error), list []*uint16, optional ...Optional) ([]*int16, error)

PMapUint16Int16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int32 

func PMapUint16Int32(f func(uint16) int32, list []uint16, optional ...Optional) []int32

PMapUint16Int32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int32Err 

func PMapUint16Int32Err(f func(uint16) (int32, error), list []uint16, optional ...Optional) ([]int32, error)

PMapUint16Int32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int32Ptr 

func PMapUint16Int32Ptr(f func(*uint16) *int32, list []*uint16, optional ...Optional) []*int32

PMapUint16Int32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int32PtrErr 

func PMapUint16Int32PtrErr(f func(*uint16) (*int32, error), list []*uint16, optional ...Optional) ([]*int32, error)

PMapUint16Int32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int64 

func PMapUint16Int64(f func(uint16) int64, list []uint16, optional ...Optional) []int64

PMapUint16Int64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int64Err 

func PMapUint16Int64Err(f func(uint16) (int64, error), list []uint16, optional ...Optional) ([]int64, error)

PMapUint16Int64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int64Ptr 

func PMapUint16Int64Ptr(f func(*uint16) *int64, list []*uint16, optional ...Optional) []*int64

PMapUint16Int64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int64PtrErr 

func PMapUint16Int64PtrErr(f func(*uint16) (*int64, error), list []*uint16, optional ...Optional) ([]*int64, error)

PMapUint16Int64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int8 

func PMapUint16Int8(f func(uint16) int8, list []uint16, optional ...Optional) []int8

PMapUint16Int8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int8Err 

func PMapUint16Int8Err(f func(uint16) (int8, error), list []uint16, optional ...Optional) ([]int8, error)

PMapUint16Int8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int8Ptr 

func PMapUint16Int8Ptr(f func(*uint16) *int8, list []*uint16, optional ...Optional) []*int8

PMapUint16Int8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Int8PtrErr 

func PMapUint16Int8PtrErr(f func(*uint16) (*int8, error), list []*uint16, optional ...Optional) ([]*int8, error)

PMapUint16Int8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16IntErr 

func PMapUint16IntErr(f func(uint16) (int, error), list []uint16, optional ...Optional) ([]int, error)

PMapUint16IntErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16IntPtr 

func PMapUint16IntPtr(f func(*uint16) *int, list []*uint16, optional ...Optional) []*int

PMapUint16IntPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16IntPtrErr 

func PMapUint16IntPtrErr(f func(*uint16) (*int, error), list []*uint16, optional ...Optional) ([]*int, error)

PMapUint16IntPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Ptr 

func PMapUint16Ptr(f func(*uint16) *uint16, list []*uint16, optional ...Optional) []*uint16

PMapUint16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16PtrErr 

func PMapUint16PtrErr(f func(*uint16) (*uint16, error), list []*uint16, optional ...Optional) ([]*uint16, error)

PMapUint16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Str 

func PMapUint16Str(f func(uint16) string, list []uint16, optional ...Optional) []string

PMapUint16Str applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16StrErr 

func PMapUint16StrErr(f func(uint16) (string, error), list []uint16, optional ...Optional) ([]string, error)

PMapUint16StrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16StrPtr 

func PMapUint16StrPtr(f func(*uint16) *string, list []*uint16, optional ...Optional) []*string

PMapUint16StrPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16StrPtrErr 

func PMapUint16StrPtrErr(f func(*uint16) (*string, error), list []*uint16, optional ...Optional) ([]*string, error)

PMapUint16StrPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Uint 

func PMapUint16Uint(f func(uint16) uint, list []uint16, optional ...Optional) []uint

PMapUint16Uint applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Uint32 

func PMapUint16Uint32(f func(uint16) uint32, list []uint16, optional ...Optional) []uint32

PMapUint16Uint32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Uint32Err 

func PMapUint16Uint32Err(f func(uint16) (uint32, error), list []uint16, optional ...Optional) ([]uint32, error)

PMapUint16Uint32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Uint32Ptr 

func PMapUint16Uint32Ptr(f func(*uint16) *uint32, list []*uint16, optional ...Optional) []*uint32

PMapUint16Uint32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Uint32PtrErr 

func PMapUint16Uint32PtrErr(f func(*uint16) (*uint32, error), list []*uint16, optional ...Optional) ([]*uint32, error)

PMapUint16Uint32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Uint64 

func PMapUint16Uint64(f func(uint16) uint64, list []uint16, optional ...Optional) []uint64

PMapUint16Uint64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Uint64Err 

func PMapUint16Uint64Err(f func(uint16) (uint64, error), list []uint16, optional ...Optional) ([]uint64, error)

PMapUint16Uint64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Uint64Ptr 

func PMapUint16Uint64Ptr(f func(*uint16) *uint64, list []*uint16, optional ...Optional) []*uint64

PMapUint16Uint64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Uint64PtrErr 

func PMapUint16Uint64PtrErr(f func(*uint16) (*uint64, error), list []*uint16, optional ...Optional) ([]*uint64, error)

PMapUint16Uint64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Uint8 

func PMapUint16Uint8(f func(uint16) uint8, list []uint16, optional ...Optional) []uint8

PMapUint16Uint8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Uint8Err 

func PMapUint16Uint8Err(f func(uint16) (uint8, error), list []uint16, optional ...Optional) ([]uint8, error)

PMapUint16Uint8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Uint8Ptr 

func PMapUint16Uint8Ptr(f func(*uint16) *uint8, list []*uint16, optional ...Optional) []*uint8

PMapUint16Uint8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16Uint8PtrErr 

func PMapUint16Uint8PtrErr(f func(*uint16) (*uint8, error), list []*uint16, optional ...Optional) ([]*uint8, error)

PMapUint16Uint8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16UintErr 

func PMapUint16UintErr(f func(uint16) (uint, error), list []uint16, optional ...Optional) ([]uint, error)

PMapUint16UintErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16UintPtr 

func PMapUint16UintPtr(f func(*uint16) *uint, list []*uint16, optional ...Optional) []*uint

PMapUint16UintPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint16UintPtrErr 

func PMapUint16UintPtrErr(f func(*uint16) (*uint, error), list []*uint16, optional ...Optional) ([]*uint, error)

PMapUint16UintPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32 

func PMapUint32(f func(uint32) uint32, list []uint32, optional ...Optional) []uint32

PMapUint32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Bool 

func PMapUint32Bool(f func(uint32) bool, list []uint32, optional ...Optional) []bool

PMapUint32Bool applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32BoolErr 

func PMapUint32BoolErr(f func(uint32) (bool, error), list []uint32, optional ...Optional) ([]bool, error)

PMapUint32BoolErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32BoolPtr 

func PMapUint32BoolPtr(f func(*uint32) *bool, list []*uint32, optional ...Optional) []*bool

PMapUint32BoolPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32BoolPtrErr 

func PMapUint32BoolPtrErr(f func(*uint32) (*bool, error), list []*uint32, optional ...Optional) ([]*bool, error)

PMapUint32BoolPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Err 

func PMapUint32Err(f func(uint32) (uint32, error), list []uint32, optional ...Optional) ([]uint32, error)

PMapUint32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Float32 

func PMapUint32Float32(f func(uint32) float32, list []uint32, optional ...Optional) []float32

PMapUint32Float32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Float32Err 

func PMapUint32Float32Err(f func(uint32) (float32, error), list []uint32, optional ...Optional) ([]float32, error)

PMapUint32Float32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Float32Ptr 

func PMapUint32Float32Ptr(f func(*uint32) *float32, list []*uint32, optional ...Optional) []*float32

PMapUint32Float32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Float32PtrErr 

func PMapUint32Float32PtrErr(f func(*uint32) (*float32, error), list []*uint32, optional ...Optional) ([]*float32, error)

PMapUint32Float32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Float64 

func PMapUint32Float64(f func(uint32) float64, list []uint32, optional ...Optional) []float64

PMapUint32Float64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Float64Err 

func PMapUint32Float64Err(f func(uint32) (float64, error), list []uint32, optional ...Optional) ([]float64, error)

PMapUint32Float64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Float64Ptr 

func PMapUint32Float64Ptr(f func(*uint32) *float64, list []*uint32, optional ...Optional) []*float64

PMapUint32Float64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Float64PtrErr 

func PMapUint32Float64PtrErr(f func(*uint32) (*float64, error), list []*uint32, optional ...Optional) ([]*float64, error)

PMapUint32Float64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int 

func PMapUint32Int(f func(uint32) int, list []uint32, optional ...Optional) []int

PMapUint32Int applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int16 

func PMapUint32Int16(f func(uint32) int16, list []uint32, optional ...Optional) []int16

PMapUint32Int16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int16Err 

func PMapUint32Int16Err(f func(uint32) (int16, error), list []uint32, optional ...Optional) ([]int16, error)

PMapUint32Int16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int16Ptr 

func PMapUint32Int16Ptr(f func(*uint32) *int16, list []*uint32, optional ...Optional) []*int16

PMapUint32Int16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int16PtrErr 

func PMapUint32Int16PtrErr(f func(*uint32) (*int16, error), list []*uint32, optional ...Optional) ([]*int16, error)

PMapUint32Int16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int32 

func PMapUint32Int32(f func(uint32) int32, list []uint32, optional ...Optional) []int32

PMapUint32Int32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int32Err 

func PMapUint32Int32Err(f func(uint32) (int32, error), list []uint32, optional ...Optional) ([]int32, error)

PMapUint32Int32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int32Ptr 

func PMapUint32Int32Ptr(f func(*uint32) *int32, list []*uint32, optional ...Optional) []*int32

PMapUint32Int32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int32PtrErr 

func PMapUint32Int32PtrErr(f func(*uint32) (*int32, error), list []*uint32, optional ...Optional) ([]*int32, error)

PMapUint32Int32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int64 

func PMapUint32Int64(f func(uint32) int64, list []uint32, optional ...Optional) []int64

PMapUint32Int64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int64Err 

func PMapUint32Int64Err(f func(uint32) (int64, error), list []uint32, optional ...Optional) ([]int64, error)

PMapUint32Int64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int64Ptr 

func PMapUint32Int64Ptr(f func(*uint32) *int64, list []*uint32, optional ...Optional) []*int64

PMapUint32Int64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int64PtrErr 

func PMapUint32Int64PtrErr(f func(*uint32) (*int64, error), list []*uint32, optional ...Optional) ([]*int64, error)

PMapUint32Int64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int8 

func PMapUint32Int8(f func(uint32) int8, list []uint32, optional ...Optional) []int8

PMapUint32Int8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int8Err 

func PMapUint32Int8Err(f func(uint32) (int8, error), list []uint32, optional ...Optional) ([]int8, error)

PMapUint32Int8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int8Ptr 

func PMapUint32Int8Ptr(f func(*uint32) *int8, list []*uint32, optional ...Optional) []*int8

PMapUint32Int8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Int8PtrErr 

func PMapUint32Int8PtrErr(f func(*uint32) (*int8, error), list []*uint32, optional ...Optional) ([]*int8, error)

PMapUint32Int8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32IntErr 

func PMapUint32IntErr(f func(uint32) (int, error), list []uint32, optional ...Optional) ([]int, error)

PMapUint32IntErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32IntPtr 

func PMapUint32IntPtr(f func(*uint32) *int, list []*uint32, optional ...Optional) []*int

PMapUint32IntPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32IntPtrErr 

func PMapUint32IntPtrErr(f func(*uint32) (*int, error), list []*uint32, optional ...Optional) ([]*int, error)

PMapUint32IntPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Ptr 

func PMapUint32Ptr(f func(*uint32) *uint32, list []*uint32, optional ...Optional) []*uint32

PMapUint32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32PtrErr 

func PMapUint32PtrErr(f func(*uint32) (*uint32, error), list []*uint32, optional ...Optional) ([]*uint32, error)

PMapUint32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Str 

func PMapUint32Str(f func(uint32) string, list []uint32, optional ...Optional) []string

PMapUint32Str applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32StrErr 

func PMapUint32StrErr(f func(uint32) (string, error), list []uint32, optional ...Optional) ([]string, error)

PMapUint32StrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32StrPtr 

func PMapUint32StrPtr(f func(*uint32) *string, list []*uint32, optional ...Optional) []*string

PMapUint32StrPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32StrPtrErr 

func PMapUint32StrPtrErr(f func(*uint32) (*string, error), list []*uint32, optional ...Optional) ([]*string, error)

PMapUint32StrPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Uint 

func PMapUint32Uint(f func(uint32) uint, list []uint32, optional ...Optional) []uint

PMapUint32Uint applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Uint16 

func PMapUint32Uint16(f func(uint32) uint16, list []uint32, optional ...Optional) []uint16

PMapUint32Uint16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Uint16Err 

func PMapUint32Uint16Err(f func(uint32) (uint16, error), list []uint32, optional ...Optional) ([]uint16, error)

PMapUint32Uint16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Uint16Ptr 

func PMapUint32Uint16Ptr(f func(*uint32) *uint16, list []*uint32, optional ...Optional) []*uint16

PMapUint32Uint16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Uint16PtrErr 

func PMapUint32Uint16PtrErr(f func(*uint32) (*uint16, error), list []*uint32, optional ...Optional) ([]*uint16, error)

PMapUint32Uint16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Uint64 

func PMapUint32Uint64(f func(uint32) uint64, list []uint32, optional ...Optional) []uint64

PMapUint32Uint64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Uint64Err 

func PMapUint32Uint64Err(f func(uint32) (uint64, error), list []uint32, optional ...Optional) ([]uint64, error)

PMapUint32Uint64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Uint64Ptr 

func PMapUint32Uint64Ptr(f func(*uint32) *uint64, list []*uint32, optional ...Optional) []*uint64

PMapUint32Uint64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Uint64PtrErr 

func PMapUint32Uint64PtrErr(f func(*uint32) (*uint64, error), list []*uint32, optional ...Optional) ([]*uint64, error)

PMapUint32Uint64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Uint8 

func PMapUint32Uint8(f func(uint32) uint8, list []uint32, optional ...Optional) []uint8

PMapUint32Uint8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Uint8Err 

func PMapUint32Uint8Err(f func(uint32) (uint8, error), list []uint32, optional ...Optional) ([]uint8, error)

PMapUint32Uint8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Uint8Ptr 

func PMapUint32Uint8Ptr(f func(*uint32) *uint8, list []*uint32, optional ...Optional) []*uint8

PMapUint32Uint8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32Uint8PtrErr 

func PMapUint32Uint8PtrErr(f func(*uint32) (*uint8, error), list []*uint32, optional ...Optional) ([]*uint8, error)

PMapUint32Uint8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32UintErr 

func PMapUint32UintErr(f func(uint32) (uint, error), list []uint32, optional ...Optional) ([]uint, error)

PMapUint32UintErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32UintPtr 

func PMapUint32UintPtr(f func(*uint32) *uint, list []*uint32, optional ...Optional) []*uint

PMapUint32UintPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint32UintPtrErr 

func PMapUint32UintPtrErr(f func(*uint32) (*uint, error), list []*uint32, optional ...Optional) ([]*uint, error)

PMapUint32UintPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64 

func PMapUint64(f func(uint64) uint64, list []uint64, optional ...Optional) []uint64

PMapUint64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Bool 

func PMapUint64Bool(f func(uint64) bool, list []uint64, optional ...Optional) []bool

PMapUint64Bool applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64BoolErr 

func PMapUint64BoolErr(f func(uint64) (bool, error), list []uint64, optional ...Optional) ([]bool, error)

PMapUint64BoolErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64BoolPtr 

func PMapUint64BoolPtr(f func(*uint64) *bool, list []*uint64, optional ...Optional) []*bool

PMapUint64BoolPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64BoolPtrErr 

func PMapUint64BoolPtrErr(f func(*uint64) (*bool, error), list []*uint64, optional ...Optional) ([]*bool, error)

PMapUint64BoolPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Err 

func PMapUint64Err(f func(uint64) (uint64, error), list []uint64, optional ...Optional) ([]uint64, error)

PMapUint64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Float32 

func PMapUint64Float32(f func(uint64) float32, list []uint64, optional ...Optional) []float32

PMapUint64Float32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Float32Err 

func PMapUint64Float32Err(f func(uint64) (float32, error), list []uint64, optional ...Optional) ([]float32, error)

PMapUint64Float32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Float32Ptr 

func PMapUint64Float32Ptr(f func(*uint64) *float32, list []*uint64, optional ...Optional) []*float32

PMapUint64Float32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Float32PtrErr 

func PMapUint64Float32PtrErr(f func(*uint64) (*float32, error), list []*uint64, optional ...Optional) ([]*float32, error)

PMapUint64Float32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Float64 

func PMapUint64Float64(f func(uint64) float64, list []uint64, optional ...Optional) []float64

PMapUint64Float64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Float64Err 

func PMapUint64Float64Err(f func(uint64) (float64, error), list []uint64, optional ...Optional) ([]float64, error)

PMapUint64Float64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Float64Ptr 

func PMapUint64Float64Ptr(f func(*uint64) *float64, list []*uint64, optional ...Optional) []*float64

PMapUint64Float64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Float64PtrErr 

func PMapUint64Float64PtrErr(f func(*uint64) (*float64, error), list []*uint64, optional ...Optional) ([]*float64, error)

PMapUint64Float64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int 

func PMapUint64Int(f func(uint64) int, list []uint64, optional ...Optional) []int

PMapUint64Int applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int16 

func PMapUint64Int16(f func(uint64) int16, list []uint64, optional ...Optional) []int16

PMapUint64Int16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int16Err 

func PMapUint64Int16Err(f func(uint64) (int16, error), list []uint64, optional ...Optional) ([]int16, error)

PMapUint64Int16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int16Ptr 

func PMapUint64Int16Ptr(f func(*uint64) *int16, list []*uint64, optional ...Optional) []*int16

PMapUint64Int16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int16PtrErr 

func PMapUint64Int16PtrErr(f func(*uint64) (*int16, error), list []*uint64, optional ...Optional) ([]*int16, error)

PMapUint64Int16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int32 

func PMapUint64Int32(f func(uint64) int32, list []uint64, optional ...Optional) []int32

PMapUint64Int32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int32Err 

func PMapUint64Int32Err(f func(uint64) (int32, error), list []uint64, optional ...Optional) ([]int32, error)

PMapUint64Int32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int32Ptr 

func PMapUint64Int32Ptr(f func(*uint64) *int32, list []*uint64, optional ...Optional) []*int32

PMapUint64Int32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int32PtrErr 

func PMapUint64Int32PtrErr(f func(*uint64) (*int32, error), list []*uint64, optional ...Optional) ([]*int32, error)

PMapUint64Int32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int64 

func PMapUint64Int64(f func(uint64) int64, list []uint64, optional ...Optional) []int64

PMapUint64Int64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int64Err 

func PMapUint64Int64Err(f func(uint64) (int64, error), list []uint64, optional ...Optional) ([]int64, error)

PMapUint64Int64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int64Ptr 

func PMapUint64Int64Ptr(f func(*uint64) *int64, list []*uint64, optional ...Optional) []*int64

PMapUint64Int64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int64PtrErr 

func PMapUint64Int64PtrErr(f func(*uint64) (*int64, error), list []*uint64, optional ...Optional) ([]*int64, error)

PMapUint64Int64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int8 

func PMapUint64Int8(f func(uint64) int8, list []uint64, optional ...Optional) []int8

PMapUint64Int8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int8Err 

func PMapUint64Int8Err(f func(uint64) (int8, error), list []uint64, optional ...Optional) ([]int8, error)

PMapUint64Int8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int8Ptr 

func PMapUint64Int8Ptr(f func(*uint64) *int8, list []*uint64, optional ...Optional) []*int8

PMapUint64Int8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Int8PtrErr 

func PMapUint64Int8PtrErr(f func(*uint64) (*int8, error), list []*uint64, optional ...Optional) ([]*int8, error)

PMapUint64Int8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64IntErr 

func PMapUint64IntErr(f func(uint64) (int, error), list []uint64, optional ...Optional) ([]int, error)

PMapUint64IntErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64IntPtr 

func PMapUint64IntPtr(f func(*uint64) *int, list []*uint64, optional ...Optional) []*int

PMapUint64IntPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64IntPtrErr 

func PMapUint64IntPtrErr(f func(*uint64) (*int, error), list []*uint64, optional ...Optional) ([]*int, error)

PMapUint64IntPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Ptr 

func PMapUint64Ptr(f func(*uint64) *uint64, list []*uint64, optional ...Optional) []*uint64

PMapUint64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64PtrErr 

func PMapUint64PtrErr(f func(*uint64) (*uint64, error), list []*uint64, optional ...Optional) ([]*uint64, error)

PMapUint64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Str 

func PMapUint64Str(f func(uint64) string, list []uint64, optional ...Optional) []string

PMapUint64Str applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64StrErr 

func PMapUint64StrErr(f func(uint64) (string, error), list []uint64, optional ...Optional) ([]string, error)

PMapUint64StrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64StrPtr 

func PMapUint64StrPtr(f func(*uint64) *string, list []*uint64, optional ...Optional) []*string

PMapUint64StrPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64StrPtrErr 

func PMapUint64StrPtrErr(f func(*uint64) (*string, error), list []*uint64, optional ...Optional) ([]*string, error)

PMapUint64StrPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Uint 

func PMapUint64Uint(f func(uint64) uint, list []uint64, optional ...Optional) []uint

PMapUint64Uint applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Uint16 

func PMapUint64Uint16(f func(uint64) uint16, list []uint64, optional ...Optional) []uint16

PMapUint64Uint16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Uint16Err 

func PMapUint64Uint16Err(f func(uint64) (uint16, error), list []uint64, optional ...Optional) ([]uint16, error)

PMapUint64Uint16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Uint16Ptr 

func PMapUint64Uint16Ptr(f func(*uint64) *uint16, list []*uint64, optional ...Optional) []*uint16

PMapUint64Uint16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Uint16PtrErr 

func PMapUint64Uint16PtrErr(f func(*uint64) (*uint16, error), list []*uint64, optional ...Optional) ([]*uint16, error)

PMapUint64Uint16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Uint32 

func PMapUint64Uint32(f func(uint64) uint32, list []uint64, optional ...Optional) []uint32

PMapUint64Uint32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Uint32Err 

func PMapUint64Uint32Err(f func(uint64) (uint32, error), list []uint64, optional ...Optional) ([]uint32, error)

PMapUint64Uint32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Uint32Ptr 

func PMapUint64Uint32Ptr(f func(*uint64) *uint32, list []*uint64, optional ...Optional) []*uint32

PMapUint64Uint32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Uint32PtrErr 

func PMapUint64Uint32PtrErr(f func(*uint64) (*uint32, error), list []*uint64, optional ...Optional) ([]*uint32, error)

PMapUint64Uint32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Uint8 

func PMapUint64Uint8(f func(uint64) uint8, list []uint64, optional ...Optional) []uint8

PMapUint64Uint8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Uint8Err 

func PMapUint64Uint8Err(f func(uint64) (uint8, error), list []uint64, optional ...Optional) ([]uint8, error)

PMapUint64Uint8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Uint8Ptr 

func PMapUint64Uint8Ptr(f func(*uint64) *uint8, list []*uint64, optional ...Optional) []*uint8

PMapUint64Uint8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64Uint8PtrErr 

func PMapUint64Uint8PtrErr(f func(*uint64) (*uint8, error), list []*uint64, optional ...Optional) ([]*uint8, error)

PMapUint64Uint8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64UintErr 

func PMapUint64UintErr(f func(uint64) (uint, error), list []uint64, optional ...Optional) ([]uint, error)

PMapUint64UintErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64UintPtr 

func PMapUint64UintPtr(f func(*uint64) *uint, list []*uint64, optional ...Optional) []*uint

PMapUint64UintPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint64UintPtrErr 

func PMapUint64UintPtrErr(f func(*uint64) (*uint, error), list []*uint64, optional ...Optional) ([]*uint, error)

PMapUint64UintPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8 

func PMapUint8(f func(uint8) uint8, list []uint8, optional ...Optional) []uint8

PMapUint8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Bool 

func PMapUint8Bool(f func(uint8) bool, list []uint8, optional ...Optional) []bool

PMapUint8Bool applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8BoolErr 

func PMapUint8BoolErr(f func(uint8) (bool, error), list []uint8, optional ...Optional) ([]bool, error)

PMapUint8BoolErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8BoolPtr 

func PMapUint8BoolPtr(f func(*uint8) *bool, list []*uint8, optional ...Optional) []*bool

PMapUint8BoolPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8BoolPtrErr 

func PMapUint8BoolPtrErr(f func(*uint8) (*bool, error), list []*uint8, optional ...Optional) ([]*bool, error)

PMapUint8BoolPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Err 

func PMapUint8Err(f func(uint8) (uint8, error), list []uint8, optional ...Optional) ([]uint8, error)

PMapUint8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Float32 

func PMapUint8Float32(f func(uint8) float32, list []uint8, optional ...Optional) []float32

PMapUint8Float32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Float32Err 

func PMapUint8Float32Err(f func(uint8) (float32, error), list []uint8, optional ...Optional) ([]float32, error)

PMapUint8Float32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Float32Ptr 

func PMapUint8Float32Ptr(f func(*uint8) *float32, list []*uint8, optional ...Optional) []*float32

PMapUint8Float32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Float32PtrErr 

func PMapUint8Float32PtrErr(f func(*uint8) (*float32, error), list []*uint8, optional ...Optional) ([]*float32, error)

PMapUint8Float32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Float64 

func PMapUint8Float64(f func(uint8) float64, list []uint8, optional ...Optional) []float64

PMapUint8Float64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Float64Err 

func PMapUint8Float64Err(f func(uint8) (float64, error), list []uint8, optional ...Optional) ([]float64, error)

PMapUint8Float64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Float64Ptr 

func PMapUint8Float64Ptr(f func(*uint8) *float64, list []*uint8, optional ...Optional) []*float64

PMapUint8Float64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Float64PtrErr 

func PMapUint8Float64PtrErr(f func(*uint8) (*float64, error), list []*uint8, optional ...Optional) ([]*float64, error)

PMapUint8Float64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int 

func PMapUint8Int(f func(uint8) int, list []uint8, optional ...Optional) []int

PMapUint8Int applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int16 

func PMapUint8Int16(f func(uint8) int16, list []uint8, optional ...Optional) []int16

PMapUint8Int16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int16Err 

func PMapUint8Int16Err(f func(uint8) (int16, error), list []uint8, optional ...Optional) ([]int16, error)

PMapUint8Int16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int16Ptr 

func PMapUint8Int16Ptr(f func(*uint8) *int16, list []*uint8, optional ...Optional) []*int16

PMapUint8Int16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int16PtrErr 

func PMapUint8Int16PtrErr(f func(*uint8) (*int16, error), list []*uint8, optional ...Optional) ([]*int16, error)

PMapUint8Int16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int32 

func PMapUint8Int32(f func(uint8) int32, list []uint8, optional ...Optional) []int32

PMapUint8Int32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int32Err 

func PMapUint8Int32Err(f func(uint8) (int32, error), list []uint8, optional ...Optional) ([]int32, error)

PMapUint8Int32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int32Ptr 

func PMapUint8Int32Ptr(f func(*uint8) *int32, list []*uint8, optional ...Optional) []*int32

PMapUint8Int32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int32PtrErr 

func PMapUint8Int32PtrErr(f func(*uint8) (*int32, error), list []*uint8, optional ...Optional) ([]*int32, error)

PMapUint8Int32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int64 

func PMapUint8Int64(f func(uint8) int64, list []uint8, optional ...Optional) []int64

PMapUint8Int64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int64Err 

func PMapUint8Int64Err(f func(uint8) (int64, error), list []uint8, optional ...Optional) ([]int64, error)

PMapUint8Int64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int64Ptr 

func PMapUint8Int64Ptr(f func(*uint8) *int64, list []*uint8, optional ...Optional) []*int64

PMapUint8Int64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int64PtrErr 

func PMapUint8Int64PtrErr(f func(*uint8) (*int64, error), list []*uint8, optional ...Optional) ([]*int64, error)

PMapUint8Int64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int8 

func PMapUint8Int8(f func(uint8) int8, list []uint8, optional ...Optional) []int8

PMapUint8Int8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int8Err 

func PMapUint8Int8Err(f func(uint8) (int8, error), list []uint8, optional ...Optional) ([]int8, error)

PMapUint8Int8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int8Ptr 

func PMapUint8Int8Ptr(f func(*uint8) *int8, list []*uint8, optional ...Optional) []*int8

PMapUint8Int8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Int8PtrErr 

func PMapUint8Int8PtrErr(f func(*uint8) (*int8, error), list []*uint8, optional ...Optional) ([]*int8, error)

PMapUint8Int8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8IntErr 

func PMapUint8IntErr(f func(uint8) (int, error), list []uint8, optional ...Optional) ([]int, error)

PMapUint8IntErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8IntPtr 

func PMapUint8IntPtr(f func(*uint8) *int, list []*uint8, optional ...Optional) []*int

PMapUint8IntPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8IntPtrErr 

func PMapUint8IntPtrErr(f func(*uint8) (*int, error), list []*uint8, optional ...Optional) ([]*int, error)

PMapUint8IntPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Ptr 

func PMapUint8Ptr(f func(*uint8) *uint8, list []*uint8, optional ...Optional) []*uint8

PMapUint8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8PtrErr 

func PMapUint8PtrErr(f func(*uint8) (*uint8, error), list []*uint8, optional ...Optional) ([]*uint8, error)

PMapUint8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Str 

func PMapUint8Str(f func(uint8) string, list []uint8, optional ...Optional) []string

PMapUint8Str applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8StrErr 

func PMapUint8StrErr(f func(uint8) (string, error), list []uint8, optional ...Optional) ([]string, error)

PMapUint8StrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8StrPtr 

func PMapUint8StrPtr(f func(*uint8) *string, list []*uint8, optional ...Optional) []*string

PMapUint8StrPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8StrPtrErr 

func PMapUint8StrPtrErr(f func(*uint8) (*string, error), list []*uint8, optional ...Optional) ([]*string, error)

PMapUint8StrPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Uint 

func PMapUint8Uint(f func(uint8) uint, list []uint8, optional ...Optional) []uint

PMapUint8Uint applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Uint16 

func PMapUint8Uint16(f func(uint8) uint16, list []uint8, optional ...Optional) []uint16

PMapUint8Uint16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Uint16Err 

func PMapUint8Uint16Err(f func(uint8) (uint16, error), list []uint8, optional ...Optional) ([]uint16, error)

PMapUint8Uint16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Uint16Ptr 

func PMapUint8Uint16Ptr(f func(*uint8) *uint16, list []*uint8, optional ...Optional) []*uint16

PMapUint8Uint16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Uint16PtrErr 

func PMapUint8Uint16PtrErr(f func(*uint8) (*uint16, error), list []*uint8, optional ...Optional) ([]*uint16, error)

PMapUint8Uint16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Uint32 

func PMapUint8Uint32(f func(uint8) uint32, list []uint8, optional ...Optional) []uint32

PMapUint8Uint32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Uint32Err 

func PMapUint8Uint32Err(f func(uint8) (uint32, error), list []uint8, optional ...Optional) ([]uint32, error)

PMapUint8Uint32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Uint32Ptr 

func PMapUint8Uint32Ptr(f func(*uint8) *uint32, list []*uint8, optional ...Optional) []*uint32

PMapUint8Uint32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Uint32PtrErr 

func PMapUint8Uint32PtrErr(f func(*uint8) (*uint32, error), list []*uint8, optional ...Optional) ([]*uint32, error)

PMapUint8Uint32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Uint64 

func PMapUint8Uint64(f func(uint8) uint64, list []uint8, optional ...Optional) []uint64

PMapUint8Uint64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Uint64Err 

func PMapUint8Uint64Err(f func(uint8) (uint64, error), list []uint8, optional ...Optional) ([]uint64, error)

PMapUint8Uint64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Uint64Ptr 

func PMapUint8Uint64Ptr(f func(*uint8) *uint64, list []*uint8, optional ...Optional) []*uint64

PMapUint8Uint64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8Uint64PtrErr 

func PMapUint8Uint64PtrErr(f func(*uint8) (*uint64, error), list []*uint8, optional ...Optional) ([]*uint64, error)

PMapUint8Uint64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8UintErr 

func PMapUint8UintErr(f func(uint8) (uint, error), list []uint8, optional ...Optional) ([]uint, error)

PMapUint8UintErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8UintPtr 

func PMapUint8UintPtr(f func(*uint8) *uint, list []*uint8, optional ...Optional) []*uint

PMapUint8UintPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUint8UintPtrErr 

func PMapUint8UintPtrErr(f func(*uint8) (*uint, error), list []*uint8, optional ...Optional) ([]*uint, error)

PMapUint8UintPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintBool 

func PMapUintBool(f func(uint) bool, list []uint, optional ...Optional) []bool

PMapUintBool applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintBoolErr 

func PMapUintBoolErr(f func(uint) (bool, error), list []uint, optional ...Optional) ([]bool, error)

PMapUintBoolErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintBoolPtr 

func PMapUintBoolPtr(f func(*uint) *bool, list []*uint, optional ...Optional) []*bool

PMapUintBoolPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintBoolPtrErr 

func PMapUintBoolPtrErr(f func(*uint) (*bool, error), list []*uint, optional ...Optional) ([]*bool, error)

PMapUintBoolPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintErr 

func PMapUintErr(f func(uint) (uint, error), list []uint, optional ...Optional) ([]uint, error)

PMapUintErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintFloat32 

func PMapUintFloat32(f func(uint) float32, list []uint, optional ...Optional) []float32

PMapUintFloat32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintFloat32Err 

func PMapUintFloat32Err(f func(uint) (float32, error), list []uint, optional ...Optional) ([]float32, error)

PMapUintFloat32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintFloat32Ptr 

func PMapUintFloat32Ptr(f func(*uint) *float32, list []*uint, optional ...Optional) []*float32

PMapUintFloat32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintFloat32PtrErr 

func PMapUintFloat32PtrErr(f func(*uint) (*float32, error), list []*uint, optional ...Optional) ([]*float32, error)

PMapUintFloat32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintFloat64 

func PMapUintFloat64(f func(uint) float64, list []uint, optional ...Optional) []float64

PMapUintFloat64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintFloat64Err 

func PMapUintFloat64Err(f func(uint) (float64, error), list []uint, optional ...Optional) ([]float64, error)

PMapUintFloat64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintFloat64Ptr 

func PMapUintFloat64Ptr(f func(*uint) *float64, list []*uint, optional ...Optional) []*float64

PMapUintFloat64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintFloat64PtrErr 

func PMapUintFloat64PtrErr(f func(*uint) (*float64, error), list []*uint, optional ...Optional) ([]*float64, error)

PMapUintFloat64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt 

func PMapUintInt(f func(uint) int, list []uint, optional ...Optional) []int

PMapUintInt applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt16 

func PMapUintInt16(f func(uint) int16, list []uint, optional ...Optional) []int16

PMapUintInt16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt16Err 

func PMapUintInt16Err(f func(uint) (int16, error), list []uint, optional ...Optional) ([]int16, error)

PMapUintInt16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt16Ptr 

func PMapUintInt16Ptr(f func(*uint) *int16, list []*uint, optional ...Optional) []*int16

PMapUintInt16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt16PtrErr 

func PMapUintInt16PtrErr(f func(*uint) (*int16, error), list []*uint, optional ...Optional) ([]*int16, error)

PMapUintInt16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt32 

func PMapUintInt32(f func(uint) int32, list []uint, optional ...Optional) []int32

PMapUintInt32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt32Err 

func PMapUintInt32Err(f func(uint) (int32, error), list []uint, optional ...Optional) ([]int32, error)

PMapUintInt32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt32Ptr 

func PMapUintInt32Ptr(f func(*uint) *int32, list []*uint, optional ...Optional) []*int32

PMapUintInt32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt32PtrErr 

func PMapUintInt32PtrErr(f func(*uint) (*int32, error), list []*uint, optional ...Optional) ([]*int32, error)

PMapUintInt32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt64 

func PMapUintInt64(f func(uint) int64, list []uint, optional ...Optional) []int64

PMapUintInt64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt64Err 

func PMapUintInt64Err(f func(uint) (int64, error), list []uint, optional ...Optional) ([]int64, error)

PMapUintInt64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt64Ptr 

func PMapUintInt64Ptr(f func(*uint) *int64, list []*uint, optional ...Optional) []*int64

PMapUintInt64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt64PtrErr 

func PMapUintInt64PtrErr(f func(*uint) (*int64, error), list []*uint, optional ...Optional) ([]*int64, error)

PMapUintInt64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt8 

func PMapUintInt8(f func(uint) int8, list []uint, optional ...Optional) []int8

PMapUintInt8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt8Err 

func PMapUintInt8Err(f func(uint) (int8, error), list []uint, optional ...Optional) ([]int8, error)

PMapUintInt8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt8Ptr 

func PMapUintInt8Ptr(f func(*uint) *int8, list []*uint, optional ...Optional) []*int8

PMapUintInt8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintInt8PtrErr 

func PMapUintInt8PtrErr(f func(*uint) (*int8, error), list []*uint, optional ...Optional) ([]*int8, error)

PMapUintInt8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintIntErr 

func PMapUintIntErr(f func(uint) (int, error), list []uint, optional ...Optional) ([]int, error)

PMapUintIntErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintIntPtr 

func PMapUintIntPtr(f func(*uint) *int, list []*uint, optional ...Optional) []*int

PMapUintIntPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintIntPtrErr 

func PMapUintIntPtrErr(f func(*uint) (*int, error), list []*uint, optional ...Optional) ([]*int, error)

PMapUintIntPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintPtr 

func PMapUintPtr(f func(*uint) *uint, list []*uint, optional ...Optional) []*uint

PMapUintPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintPtrErr 

func PMapUintPtrErr(f func(*uint) (*uint, error), list []*uint, optional ...Optional) ([]*uint, error)

PMapUintPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintStr 

func PMapUintStr(f func(uint) string, list []uint, optional ...Optional) []string

PMapUintStr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintStrErr 

func PMapUintStrErr(f func(uint) (string, error), list []uint, optional ...Optional) ([]string, error)

PMapUintStrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintStrPtr 

func PMapUintStrPtr(f func(*uint) *string, list []*uint, optional ...Optional) []*string

PMapUintStrPtr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintStrPtrErr 

func PMapUintStrPtrErr(f func(*uint) (*string, error), list []*uint, optional ...Optional) ([]*string, error)

PMapUintStrPtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintUint16 

func PMapUintUint16(f func(uint) uint16, list []uint, optional ...Optional) []uint16

PMapUintUint16 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintUint16Err 

func PMapUintUint16Err(f func(uint) (uint16, error), list []uint, optional ...Optional) ([]uint16, error)

PMapUintUint16Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintUint16Ptr 

func PMapUintUint16Ptr(f func(*uint) *uint16, list []*uint, optional ...Optional) []*uint16

PMapUintUint16Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintUint16PtrErr 

func PMapUintUint16PtrErr(f func(*uint) (*uint16, error), list []*uint, optional ...Optional) ([]*uint16, error)

PMapUintUint16PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintUint32 

func PMapUintUint32(f func(uint) uint32, list []uint, optional ...Optional) []uint32

PMapUintUint32 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintUint32Err 

func PMapUintUint32Err(f func(uint) (uint32, error), list []uint, optional ...Optional) ([]uint32, error)

PMapUintUint32Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintUint32Ptr 

func PMapUintUint32Ptr(f func(*uint) *uint32, list []*uint, optional ...Optional) []*uint32

PMapUintUint32Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintUint32PtrErr 

func PMapUintUint32PtrErr(f func(*uint) (*uint32, error), list []*uint, optional ...Optional) ([]*uint32, error)

PMapUintUint32PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintUint64 

func PMapUintUint64(f func(uint) uint64, list []uint, optional ...Optional) []uint64

PMapUintUint64 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintUint64Err 

func PMapUintUint64Err(f func(uint) (uint64, error), list []uint, optional ...Optional) ([]uint64, error)

PMapUintUint64Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintUint64Ptr 

func PMapUintUint64Ptr(f func(*uint) *uint64, list []*uint, optional ...Optional) []*uint64

PMapUintUint64Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintUint64PtrErr 

func PMapUintUint64PtrErr(f func(*uint) (*uint64, error), list []*uint, optional ...Optional) ([]*uint64, error)

PMapUintUint64PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintUint8 

func PMapUintUint8(f func(uint) uint8, list []uint, optional ...Optional) []uint8

PMapUintUint8 applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintUint8Err 

func PMapUintUint8Err(f func(uint) (uint8, error), list []uint, optional ...Optional) ([]uint8, error)

PMapUintUint8Err applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintUint8Ptr 

func PMapUintUint8Ptr(f func(*uint) *uint8, list []*uint, optional ...Optional) []*uint8

PMapUintUint8Ptr applies the function(1st argument) on each item in the list and returns a new list. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PMapUintUint8PtrErr 

func PMapUintUint8PtrErr(f func(*uint) (*uint8, error), list []*uint, optional ...Optional) ([]*uint8, error)

PMapUintUint8PtrErr applies the function(1st argument) on each item in the list and returns a new list and error. 

Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional

  1. Function - takes 1 input
  2. List
  3. optional argument - fp.Optional{FixedPool: <some_number>}

func PosFloat32P 

func PosFloat32P(v float32) bool

PosFloat32P Returns true if num is greater than zero, else false

func PosFloat32PPtr 

func PosFloat32PPtr(v *float32) bool

PosFloat32PPtr Returns true if num is greater than zero, else false

func PosFloat64P 

func PosFloat64P(v float64) bool

PosFloat64P Returns true if num is greater than zero, else false

func PosFloat64PPtr 

func PosFloat64PPtr(v *float64) bool

PosFloat64PPtr Returns true if num is greater than zero, else false

func PosInt16P 

func PosInt16P(v int16) bool

PosInt16P Returns true if num is greater than zero, else false

func PosInt16PPtr 

func PosInt16PPtr(v *int16) bool

PosInt16PPtr Returns true if num is greater than zero, else false

func PosInt32P 

func PosInt32P(v int32) bool

PosInt32P Returns true if num is greater than zero, else false

func PosInt32PPtr 

func PosInt32PPtr(v *int32) bool

PosInt32PPtr Returns true if num is greater than zero, else false

func PosInt64P 

func PosInt64P(v int64) bool

PosInt64P Returns true if num is greater than zero, else false

func PosInt64PPtr 

func PosInt64PPtr(v *int64) bool

PosInt64PPtr Returns true if num is greater than zero, else false

func PosInt8P 

func PosInt8P(v int8) bool

PosInt8P Returns true if num is greater than zero, else false

func PosInt8PPtr 

func PosInt8PPtr(v *int8) bool

PosInt8PPtr Returns true if num is greater than zero, else false

func PosIntP 

func PosIntP(v int) bool

PosIntP Returns true if num is greater than zero, else false

func PosIntPPtr 

func PosIntPPtr(v *int) bool

PosIntPPtr Returns true if num is greater than zero, else false

func RangeInt 

func RangeInt(lower, higher int, hops ...int) []int

RangeInt returns a list of range between lower and upper value

Takes 3 inputs

  1. lower limit
  2. Upper limit
  3. Hops (optional)

Returns 

List of range between lower and upper value
Empty list if 3rd argument is either 0 or negative number

Example: 

RangeInt(-2, 2) // Returns: [-2, -1, 0, 1]
RangeInt(0, 2) // Returns: [0, 1]
RangeInt(3, 7, 2) // Returns: [3, 5]

func RangeInt16 

func RangeInt16(lower, higher int16, hops ...int16) []int16

RangeInt16 returns a list of range between lower and upper value

Takes 3 inputs

  1. lower limit
  2. Upper limit
  3. Hops (optional)

Returns 

List of range between lower and upper value
Empty list if 3rd argument is either 0 or negative number

Example: 

RangeInt16(-2, 2) // Returns: [-2, -1, 0, 1]
RangeInt16(0, 2) // Returns: [0, 1]
RangeInt16(3, 7, 2) // Returns: [3, 5]

func RangeInt32 

func RangeInt32(lower, higher int32, hops ...int32) []int32

RangeInt32 returns a list of range between lower and upper value

Takes 3 inputs

  1. lower limit
  2. Upper limit
  3. Hops (optional)

Returns 

List of range between lower and upper value
Empty list if 3rd argument is either 0 or negative number

Example: 

RangeInt32(-2, 2) // Returns: [-2, -1, 0, 1]
RangeInt32(0, 2) // Returns: [0, 1]
RangeInt32(3, 7, 2) // Returns: [3, 5]

func RangeInt64 

func RangeInt64(lower, higher int64, hops ...int64) []int64

RangeInt64 returns a list of range between lower and upper value

Takes 3 inputs

  1. lower limit
  2. Upper limit
  3. Hops (optional)

Returns 

List of range between lower and upper value
Empty list if 3rd argument is either 0 or negative number

Example: 

RangeInt64(-2, 2) // Returns: [-2, -1, 0, 1]
RangeInt64(0, 2) // Returns: [0, 1]
RangeInt64(3, 7, 2) // Returns: [3, 5]

func RangeInt8 

func RangeInt8(lower, higher int8, hops ...int8) []int8

RangeInt8 returns a list of range between lower and upper value

Takes 3 inputs

  1. lower limit
  2. Upper limit
  3. Hops (optional)

Returns 

List of range between lower and upper value
Empty list if 3rd argument is either 0 or negative number

Example: 

RangeInt8(-2, 2) // Returns: [-2, -1, 0, 1]
RangeInt8(0, 2) // Returns: [0, 1]
RangeInt8(3, 7, 2) // Returns: [3, 5]

func RangeUint 

func RangeUint(lower, higher uint, hops ...uint) []uint

RangeUint returns a list of range between lower and upper value

Takes 3 inputs

  1. lower limit
  2. Upper limit
  3. Hops (optional)

Returns 

List of range between lower and upper value
Empty list if 3rd argument is either 0 or negative number

Example: 

RangeUint(-2, 2) // Returns: [-2, -1, 0, 1]
RangeUint(0, 2) // Returns: [0, 1]
RangeUint(3, 7, 2) // Returns: [3, 5]

func RangeUint16 

func RangeUint16(lower, higher uint16, hops ...uint16) []uint16

RangeUint16 returns a list of range between lower and upper value

Takes 3 inputs

  1. lower limit
  2. Upper limit
  3. Hops (optional)

Returns 

List of range between lower and upper value
Empty list if 3rd argument is either 0 or negative number

Example: 

RangeUint16(-2, 2) // Returns: [-2, -1, 0, 1]
RangeUint16(0, 2) // Returns: [0, 1]
RangeUint16(3, 7, 2) // Returns: [3, 5]

func RangeUint32 

func RangeUint32(lower, higher uint32, hops ...uint32) []uint32

RangeUint32 returns a list of range between lower and upper value

Takes 3 inputs

  1. lower limit
  2. Upper limit
  3. Hops (optional)

Returns 

List of range between lower and upper value
Empty list if 3rd argument is either 0 or negative number

Example: 

RangeUint32(-2, 2) // Returns: [-2, -1, 0, 1]
RangeUint32(0, 2) // Returns: [0, 1]
RangeUint32(3, 7, 2) // Returns: [3, 5]

func RangeUint64 

func RangeUint64(lower, higher uint64, hops ...uint64) []uint64

RangeUint64 returns a list of range between lower and upper value

Takes 3 inputs

  1. lower limit
  2. Upper limit
  3. Hops (optional)

Returns 

List of range between lower and upper value
Empty list if 3rd argument is either 0 or negative number

Example: 

RangeUint64(-2, 2) // Returns: [-2, -1, 0, 1]
RangeUint64(0, 2) // Returns: [0, 1]
RangeUint64(3, 7, 2) // Returns: [3, 5]

func RangeUint8 

func RangeUint8(lower, higher uint8, hops ...uint8) []uint8

RangeUint8 returns a list of range between lower and upper value

Takes 3 inputs

  1. lower limit
  2. Upper limit
  3. Hops (optional)

Returns 

List of range between lower and upper value
Empty list if 3rd argument is either 0 or negative number

Example: 

RangeUint8(-2, 2) // Returns: [-2, -1, 0, 1]
RangeUint8(0, 2) // Returns: [0, 1]
RangeUint8(3, 7, 2) // Returns: [3, 5]

func ReduceFloat32 

func ReduceFloat32(f func(float32, float32) float32, list []float32, initializer ...float32) float32

ReduceFloat32 reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

Example 

list := []float32{1, 2, 3, 4, 5}
ReduceFloat32(plusInt, list) // returns: 15
ReduceFloat32(plusInt, list, 3) // returns: 18

func plusInt(num1, num2 float32) float32 {
	return num1 + num2
}

func ReduceFloat32Err 

func ReduceFloat32Err(f func(float32, float32) (float32, error), list []float32, initializer ...float32) (float32, error)

ReduceFloat32Err reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (float32, float32)
B. list of type []float32
C. initializer (optional of type float32)

Returns: 

single value, error: (float32, error)

func ReduceFloat32Ptr 

func ReduceFloat32Ptr(f func(*float32, *float32) *float32, list []*float32, initializer ...float32) *float32

ReduceFloat32Ptr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

func ReduceFloat32PtrErr 

func ReduceFloat32PtrErr(f func(*float32, *float32) (*float32, error), list []*float32, initializer ...float32) (*float32, error)

ReduceFloat32PtrErr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (*float32, *float32)
B. list of type []*float32
C. initializer (optional of type float32)

Returns: 

single value, error: (*float32, error)

func ReduceFloat64 

func ReduceFloat64(f func(float64, float64) float64, list []float64, initializer ...float64) float64

ReduceFloat64 reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

Example 

list := []float64{1, 2, 3, 4, 5}
ReduceFloat64(plusInt, list) // returns: 15
ReduceFloat64(plusInt, list, 3) // returns: 18

func plusInt(num1, num2 float64) float64 {
	return num1 + num2
}

func ReduceFloat64Err 

func ReduceFloat64Err(f func(float64, float64) (float64, error), list []float64, initializer ...float64) (float64, error)

ReduceFloat64Err reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (float64, float64)
B. list of type []float64
C. initializer (optional of type float64)

Returns: 

single value, error: (float64, error)

func ReduceFloat64Ptr 

func ReduceFloat64Ptr(f func(*float64, *float64) *float64, list []*float64, initializer ...float64) *float64

ReduceFloat64Ptr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

func ReduceFloat64PtrErr 

func ReduceFloat64PtrErr(f func(*float64, *float64) (*float64, error), list []*float64, initializer ...float64) (*float64, error)

ReduceFloat64PtrErr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (*float64, *float64)
B. list of type []*float64
C. initializer (optional of type float64)

Returns: 

single value, error: (*float64, error)

func ReduceInt 

func ReduceInt(f func(int, int) int, list []int, initializer ...int) int

ReduceInt reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

Example 

list := []int{1, 2, 3, 4, 5}
ReduceInt(plusInt, list) // returns: 15
ReduceInt(plusInt, list, 3) // returns: 18

func plusInt(num1, num2 int) int {
	return num1 + num2
}

func ReduceInt16 

func ReduceInt16(f func(int16, int16) int16, list []int16, initializer ...int16) int16

ReduceInt16 reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

Example 

list := []int16{1, 2, 3, 4, 5}
ReduceInt16(plusInt, list) // returns: 15
ReduceInt16(plusInt, list, 3) // returns: 18

func plusInt(num1, num2 int16) int16 {
	return num1 + num2
}

func ReduceInt16Err 

func ReduceInt16Err(f func(int16, int16) (int16, error), list []int16, initializer ...int16) (int16, error)

ReduceInt16Err reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (int16, int16)
B. list of type []int16
C. initializer (optional of type int16)

Returns: 

single value, error: (int16, error)

func ReduceInt16Ptr 

func ReduceInt16Ptr(f func(*int16, *int16) *int16, list []*int16, initializer ...int16) *int16

ReduceInt16Ptr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

func ReduceInt16PtrErr 

func ReduceInt16PtrErr(f func(*int16, *int16) (*int16, error), list []*int16, initializer ...int16) (*int16, error)

ReduceInt16PtrErr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (*int16, *int16)
B. list of type []*int16
C. initializer (optional of type int16)

Returns: 

single value, error: (*int16, error)

func ReduceInt32 

func ReduceInt32(f func(int32, int32) int32, list []int32, initializer ...int32) int32

ReduceInt32 reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

Example 

list := []int32{1, 2, 3, 4, 5}
ReduceInt32(plusInt, list) // returns: 15
ReduceInt32(plusInt, list, 3) // returns: 18

func plusInt(num1, num2 int32) int32 {
	return num1 + num2
}

func ReduceInt32Err 

func ReduceInt32Err(f func(int32, int32) (int32, error), list []int32, initializer ...int32) (int32, error)

ReduceInt32Err reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (int32, int32)
B. list of type []int32
C. initializer (optional of type int32)

Returns: 

single value, error: (int32, error)

func ReduceInt32Ptr 

func ReduceInt32Ptr(f func(*int32, *int32) *int32, list []*int32, initializer ...int32) *int32

ReduceInt32Ptr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

func ReduceInt32PtrErr 

func ReduceInt32PtrErr(f func(*int32, *int32) (*int32, error), list []*int32, initializer ...int32) (*int32, error)

ReduceInt32PtrErr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (*int32, *int32)
B. list of type []*int32
C. initializer (optional of type int32)

Returns: 

single value, error: (*int32, error)

func ReduceInt64 

func ReduceInt64(f func(int64, int64) int64, list []int64, initializer ...int64) int64

ReduceInt64 reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

Example 

list := []int64{1, 2, 3, 4, 5}
ReduceInt64(plusInt, list) // returns: 15
ReduceInt64(plusInt, list, 3) // returns: 18

func plusInt(num1, num2 int64) int64 {
	return num1 + num2
}

func ReduceInt64Err 

func ReduceInt64Err(f func(int64, int64) (int64, error), list []int64, initializer ...int64) (int64, error)

ReduceInt64Err reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (int64, int64)
B. list of type []int64
C. initializer (optional of type int64)

Returns: 

single value, error: (int64, error)

func ReduceInt64Ptr 

func ReduceInt64Ptr(f func(*int64, *int64) *int64, list []*int64, initializer ...int64) *int64

ReduceInt64Ptr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

func ReduceInt64PtrErr 

func ReduceInt64PtrErr(f func(*int64, *int64) (*int64, error), list []*int64, initializer ...int64) (*int64, error)

ReduceInt64PtrErr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (*int64, *int64)
B. list of type []*int64
C. initializer (optional of type int64)

Returns: 

single value, error: (*int64, error)

func ReduceInt8 

func ReduceInt8(f func(int8, int8) int8, list []int8, initializer ...int8) int8

ReduceInt8 reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

Example 

list := []int8{1, 2, 3, 4, 5}
ReduceInt8(plusInt, list) // returns: 15
ReduceInt8(plusInt, list, 3) // returns: 18

func plusInt(num1, num2 int8) int8 {
	return num1 + num2
}

func ReduceInt8Err 

func ReduceInt8Err(f func(int8, int8) (int8, error), list []int8, initializer ...int8) (int8, error)

ReduceInt8Err reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (int8, int8)
B. list of type []int8
C. initializer (optional of type int8)

Returns: 

single value, error: (int8, error)

func ReduceInt8Ptr 

func ReduceInt8Ptr(f func(*int8, *int8) *int8, list []*int8, initializer ...int8) *int8

ReduceInt8Ptr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

func ReduceInt8PtrErr 

func ReduceInt8PtrErr(f func(*int8, *int8) (*int8, error), list []*int8, initializer ...int8) (*int8, error)

ReduceInt8PtrErr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (*int8, *int8)
B. list of type []*int8
C. initializer (optional of type int8)

Returns: 

single value, error: (*int8, error)

func ReduceIntErr 

func ReduceIntErr(f func(int, int) (int, error), list []int, initializer ...int) (int, error)

ReduceIntErr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (int, int)
B. list of type []int
C. initializer (optional of type int)

Returns: 

single value, error: (int, error)

func ReduceIntPtr 

func ReduceIntPtr(f func(*int, *int) *int, list []*int, initializer ...int) *int

ReduceIntPtr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

func ReduceIntPtrErr 

func ReduceIntPtrErr(f func(*int, *int) (*int, error), list []*int, initializer ...int) (*int, error)

ReduceIntPtrErr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (*int, *int)
B. list of type []*int
C. initializer (optional of type int)

Returns: 

single value, error: (*int, error)

func ReduceStr 

func ReduceStr(f func(string, string) string, list []string, initializer ...string) string

ReduceStr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

Example 

list := []string{"Nandeshwar", "Kumar", "Sah"}
ReduceStr(plusInt, list) // returns: "NandeshwarKumarSah"

func plusStr(num1, num2 string) string {
	return num1 + num2
}

func ReduceStrErr 

func ReduceStrErr(f func(string, string) (string, error), list []string, initializer ...string) (string, error)

ReduceStrErr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (string, string)
B. list of type []string
C. initializer (optional of type string)

Returns: 

single value, error: (string, error)

func ReduceStrPtr 

func ReduceStrPtr(f func(*string, *string) *string, list []*string, initializer ...string) *string

ReduceStrPtr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

func ReduceStrPtrErr 

func ReduceStrPtrErr(f func(*string, *string) (*string, error), list []*string, initializer ...string) (*string, error)

ReduceStrPtrErr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (*string, *string)
B. list of type []*string
C. initializer (optional of type string)

Returns: 

single value, error: (*string, error)

func ReduceUint 

func ReduceUint(f func(uint, uint) uint, list []uint, initializer ...uint) uint

ReduceUint reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

Example 

list := []int8{1, 2, 3, 4, 5}
ReduceUint(plusInt, list) // returns: 15
ReduceUint(plusInt, list, 3) // returns: 18

func plusInt(num1, num2 int8) int8 {
	return num1 + num2
}

func ReduceUint16 

func ReduceUint16(f func(uint16, uint16) uint16, list []uint16, initializer ...uint16) uint16

ReduceUint16 reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

Example 

list := []uint16{1, 2, 3, 4, 5}
ReduceUint16(plusInt, list) // returns: 15
ReduceUint16(plusInt, list, 3) // returns: 18

func plusInt(num1, num2 uint16) uint16 {
	return num1 + num2
}

func ReduceUint16Err 

func ReduceUint16Err(f func(uint16, uint16) (uint16, error), list []uint16, initializer ...uint16) (uint16, error)

ReduceUint16Err reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (uint16, uint16)
B. list of type []uint16
C. initializer (optional of type uint16)

Returns: 

single value, error: (uint16, error)

func ReduceUint16Ptr 

func ReduceUint16Ptr(f func(*uint16, *uint16) *uint16, list []*uint16, initializer ...uint16) *uint16

ReduceUint16Ptr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

func ReduceUint16PtrErr 

func ReduceUint16PtrErr(f func(*uint16, *uint16) (*uint16, error), list []*uint16, initializer ...uint16) (*uint16, error)

ReduceUint16PtrErr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (*uint16, *uint16)
B. list of type []*uint16
C. initializer (optional of type uint16)

Returns: 

single value, error: (*uint16, error)

func ReduceUint32 

func ReduceUint32(f func(uint32, uint32) uint32, list []uint32, initializer ...uint32) uint32

ReduceUint32 reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

Example 

list := []uint32{1, 2, 3, 4, 5}
ReduceUint32(plusInt, list) // returns: 15
ReduceUint32(plusInt, list, 3) // returns: 18

func plusInt(num1, num2 uint32) uint32 {
	return num1 + num2
}

func ReduceUint32Err 

func ReduceUint32Err(f func(uint32, uint32) (uint32, error), list []uint32, initializer ...uint32) (uint32, error)

ReduceUint32Err reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (uint32, uint32)
B. list of type []uint32
C. initializer (optional of type uint32)

Returns: 

single value, error: (uint32, error)

func ReduceUint32Ptr 

func ReduceUint32Ptr(f func(*uint32, *uint32) *uint32, list []*uint32, initializer ...uint32) *uint32

ReduceUint32Ptr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

func ReduceUint32PtrErr 

func ReduceUint32PtrErr(f func(*uint32, *uint32) (*uint32, error), list []*uint32, initializer ...uint32) (*uint32, error)

ReduceUint32PtrErr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (*uint32, *uint32)
B. list of type []*uint32
C. initializer (optional of type uint32)

Returns: 

single value, error: (*uint32, error)

func ReduceUint64 

func ReduceUint64(f func(uint64, uint64) uint64, list []uint64, initializer ...uint64) uint64

ReduceUint64 reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

Example 

list := []uint64{1, 2, 3, 4, 5}
ReduceUint64(plusInt, list) // returns: 15
ReduceUint64(plusInt, list, 3) // returns: 18

func plusInt(num1, num2 uint64) uint64 {
	return num1 + num2
}

func ReduceUint64Err 

func ReduceUint64Err(f func(uint64, uint64) (uint64, error), list []uint64, initializer ...uint64) (uint64, error)

ReduceUint64Err reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (uint64, uint64)
B. list of type []uint64
C. initializer (optional of type uint64)

Returns: 

single value, error: (uint64, error)

func ReduceUint64Ptr 

func ReduceUint64Ptr(f func(*uint64, *uint64) *uint64, list []*uint64, initializer ...uint64) *uint64

ReduceUint64Ptr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

func ReduceUint64PtrErr 

func ReduceUint64PtrErr(f func(*uint64, *uint64) (*uint64, error), list []*uint64, initializer ...uint64) (*uint64, error)

ReduceUint64PtrErr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (*uint64, *uint64)
B. list of type []*uint64
C. initializer (optional of type uint64)

Returns: 

single value, error: (*uint64, error)

func ReduceUint8 

func ReduceUint8(f func(uint8, uint8) uint8, list []uint8, initializer ...uint8) uint8

ReduceUint8 reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

Example 

list := []uint8{1, 2, 3, 4, 5}
ReduceUint8(plusInt, list) // returns: 15
ReduceUint8(plusInt, list, 3) // returns: 18

func plusInt(num1, num2 uint8) uint8 {
	return num1 + num2
}

func ReduceUint8Err 

func ReduceUint8Err(f func(uint8, uint8) (uint8, error), list []uint8, initializer ...uint8) (uint8, error)

ReduceUint8Err reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (uint8, uint8)
B. list of type []uint8
C. initializer (optional of type uint8)

Returns: 

single value, error: (uint8, error)

func ReduceUint8Ptr 

func ReduceUint8Ptr(f func(*uint8, *uint8) *uint8, list []*uint8, initializer ...uint8) *uint8

ReduceUint8Ptr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

func ReduceUint8PtrErr 

func ReduceUint8PtrErr(f func(*uint8, *uint8) (*uint8, error), list []*uint8, initializer ...uint8) (*uint8, error)

ReduceUint8PtrErr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (*uint8, *uint8)
B. list of type []*uint8
C. initializer (optional of type uint8)

Returns: 

single value, error: (*uint8, error)

func ReduceUintErr 

func ReduceUintErr(f func(uint, uint) (uint, error), list []uint, initializer ...uint) (uint, error)

ReduceUintErr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (uint, uint)
B. list of type []uint
C. initializer (optional of type uint)

Returns: 

single value, error: (uint, error)

func ReduceUintPtr 

func ReduceUintPtr(f func(*uint, *uint) *uint, list []*uint, initializer ...uint) *uint

ReduceUintPtr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments
B. list
C. initializer (optional)

Returns: 

single value.

func ReduceUintPtrErr 

func ReduceUintPtrErr(f func(*uint, *uint) (*uint, error), list []*uint, initializer ...uint) (*uint, error)

ReduceUintPtrErr reduces a list to a single value by combining elements via a supplied function

Takes three inputs 

A. function - takes two arguments (*uint, *uint)
B. list of type []*uint
C. initializer (optional of type uint)

Returns: 

single value, error: (*uint, error)

func RemoveBool 

func RemoveBool(f func(bool) bool, list []bool) []bool

RemoveBool removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

func RemoveBoolErr 

func RemoveBoolErr(f func(bool) (bool, error), list []bool) ([]bool, error)

RemoveBoolErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type bool and return types(bool, error)
  2. List of type: []bool

Returns: 

New list and error: ([]bool, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveBoolPtr 

func RemoveBoolPtr(f func(*bool) bool, list []*bool) []*bool

RemoveBoolPtr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

func RemoveBoolPtrErr 

func RemoveBoolPtrErr(f func(*bool) (bool, error), list []*bool) ([]*bool, error)

RemoveBoolPtrErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type *bool and return types(bool, error)
  2. List of type: []*bool

Returns: 

New list and error: ([]*bool, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveFloat32 

func RemoveFloat32(f func(float32) bool, list []float32) []float32

RemoveFloat32 removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

Example: 

fp.RemoveFloat32(isPositive, []float32{0, -2, 2, 40.50}) // Returns: [0, -2]

func isPositive(num float32) bool {
	return num > 0
}

func RemoveFloat32Err 

func RemoveFloat32Err(f func(float32) (bool, error), list []float32) ([]float32, error)

RemoveFloat32Err removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type float32 and return types(bool, error)
  2. List of type: []float32

Returns: 

New list and error: ([]float32, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveFloat32Ptr 

func RemoveFloat32Ptr(f func(*float32) bool, list []*float32) []*float32

RemoveFloat32Ptr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

func RemoveFloat32PtrErr 

func RemoveFloat32PtrErr(f func(*float32) (bool, error), list []*float32) ([]*float32, error)

RemoveFloat32PtrErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type *float32 and return types(bool, error)
  2. List of type: []*float32

Returns: 

New list and error: ([]*float32, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveFloat64 

func RemoveFloat64(f func(float64) bool, list []float64) []float64

RemoveFloat64 removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

Example: 

fp.RemoveFloat64(isPositive, []float64{0, -2, 2, 40.50}) // Returns: [0, -2]

func isPositive(num float64) bool {
	return num > 0
}

func RemoveFloat64Err 

func RemoveFloat64Err(f func(float64) (bool, error), list []float64) ([]float64, error)

RemoveFloat64Err removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type float64 and return types(bool, error)
  2. List of type: []float64

Returns: 

New list and error: ([]float64, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveFloat64Ptr 

func RemoveFloat64Ptr(f func(*float64) bool, list []*float64) []*float64

RemoveFloat64Ptr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

func RemoveFloat64PtrErr 

func RemoveFloat64PtrErr(f func(*float64) (bool, error), list []*float64) ([]*float64, error)

RemoveFloat64PtrErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type *float64 and return types(bool, error)
  2. List of type: []*float64

Returns: 

New list and error: ([]*float64, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveInt 

func RemoveInt(f func(int) bool, list []int) []int

RemoveInt removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

Example: 

fp.RemoveInt(isEven, []int{1, 2, 3, 4}) // Returns: [1, 3]

func isEven(num int) bool {
	return num%2 == 0
}

func RemoveInt16 

func RemoveInt16(f func(int16) bool, list []int16) []int16

RemoveInt16 removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

Example: 

fp.RemoveInt16(isEven, []int16{1, 2, 3, 4}) // Returns: [1, 3]

func isEven(num int16) bool {
	return num%2 == 0
}

func RemoveInt16Err 

func RemoveInt16Err(f func(int16) (bool, error), list []int16) ([]int16, error)

RemoveInt16Err removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type int16 and return types(bool, error)
  2. List of type: []int16

Returns: 

New list and error: ([]int16, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveInt16Ptr 

func RemoveInt16Ptr(f func(*int16) bool, list []*int16) []*int16

RemoveInt16Ptr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

func RemoveInt16PtrErr 

func RemoveInt16PtrErr(f func(*int16) (bool, error), list []*int16) ([]*int16, error)

RemoveInt16PtrErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type *int16 and return types(bool, error)
  2. List of type: []*int16

Returns: 

New list and error: ([]*int16, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveInt32 

func RemoveInt32(f func(int32) bool, list []int32) []int32

RemoveInt32 removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

Example: 

fp.RemoveInt32(isEven, []int32{1, 2, 3, 4}) // Returns: [1, 3]

func isEven(num int32) bool {
	return num%2 == 0
}

func RemoveInt32Err 

func RemoveInt32Err(f func(int32) (bool, error), list []int32) ([]int32, error)

RemoveInt32Err removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type int32 and return types(bool, error)
  2. List of type: []int32

Returns: 

New list and error: ([]int32, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveInt32Ptr 

func RemoveInt32Ptr(f func(*int32) bool, list []*int32) []*int32

RemoveInt32Ptr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

func RemoveInt32PtrErr 

func RemoveInt32PtrErr(f func(*int32) (bool, error), list []*int32) ([]*int32, error)

RemoveInt32PtrErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type *int32 and return types(bool, error)
  2. List of type: []*int32

Returns: 

New list and error: ([]*int32, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveInt64 

func RemoveInt64(f func(int64) bool, list []int64) []int64

RemoveInt64 removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

Example: 

fp.RemoveInt64(isEven, []int64{1, 2, 3, 4}) // Returns: [1, 3]

func isEven(num int64) bool {
	return num%2 == 0
}

func RemoveInt64Err 

func RemoveInt64Err(f func(int64) (bool, error), list []int64) ([]int64, error)

RemoveInt64Err removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type int64 and return types(bool, error)
  2. List of type: []int64

Returns: 

New list and error: ([]int64, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveInt64Ptr 

func RemoveInt64Ptr(f func(*int64) bool, list []*int64) []*int64

RemoveInt64Ptr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

func RemoveInt64PtrErr 

func RemoveInt64PtrErr(f func(*int64) (bool, error), list []*int64) ([]*int64, error)

RemoveInt64PtrErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type *int64 and return types(bool, error)
  2. List of type: []*int64

Returns: 

New list and error: ([]*int64, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveInt8 

func RemoveInt8(f func(int8) bool, list []int8) []int8

RemoveInt8 removs the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

Example: 

fp.RemoveInt8(isEven, []int8{1, 2, 3, 4}) // Returns: [1, 3]

func isEven(num int8) bool {
	return num%2 == 0
}

func RemoveInt8Err 

func RemoveInt8Err(f func(int8) (bool, error), list []int8) ([]int8, error)

RemoveInt8Err removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type int8 and return types(bool, error)
  2. List of type: []int8

Returns: 

New list and error: ([]int8, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveInt8Ptr 

func RemoveInt8Ptr(f func(*int8) bool, list []*int8) []*int8

RemoveInt8Ptr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

func RemoveInt8PtrErr 

func RemoveInt8PtrErr(f func(*int8) (bool, error), list []*int8) ([]*int8, error)

RemoveInt8PtrErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type *int8 and return types(bool, error)
  2. List of type: []*int8

Returns: 

New list and error: ([]*int8, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveIntErr 

func RemoveIntErr(f func(int) (bool, error), list []int) ([]int, error)

RemoveIntErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type int and return types(bool, error)
  2. List of type: []int

Returns: 

New list and error: ([]int, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveIntPtr 

func RemoveIntPtr(f func(*int) bool, list []*int) []*int

RemoveIntPtr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

func RemoveIntPtrErr 

func RemoveIntPtrErr(f func(*int) (bool, error), list []*int) ([]*int, error)

RemoveIntPtrErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type *int and return types(bool, error)
  2. List of type: []*int

Returns: 

New list and error: ([]*int, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveStr 

func RemoveStr(f func(string) bool, list []string) []string

RemoveStr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

Example: 

fp.RemoveStr(isStringLengthLessThan10, []string{"gopal", "govinda", "Nandeshwar"}) // Returns: ["Nandeshwar"]

func isStringLengthLessThan10(str string) bool {
	return len(str) < 10
}

func RemoveStrErr 

func RemoveStrErr(f func(string) (bool, error), list []string) ([]string, error)

RemoveStrErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type string and return types(bool, error)
  2. List of type: []string

Returns: 

New list and error: ([]string, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveStrPtr 

func RemoveStrPtr(f func(*string) bool, list []*string) []*string

RemoveStrPtr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

func RemoveStrPtrErr 

func RemoveStrPtrErr(f func(*string) (bool, error), list []*string) ([]*string, error)

RemoveStrPtrErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type *string and return types(bool, error)
  2. List of type: []*string

Returns: 

New list and error: ([]*string, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveUint 

func RemoveUint(f func(uint) bool, list []uint) []uint

RemoveUint removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

Example: 

fp.RemoveUint(isEven, []uint{1, 2, 3, 4}) // Returns: [1, 3]

func isEven(num uint) bool {
	return num%2 == 0
}

func RemoveUint16 

func RemoveUint16(f func(uint16) bool, list []uint16) []uint16

RemoveUint16 removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

Example: 

fp.RemoveUint16(isEven, []uint16{1, 2, 3, 4}) // Returns: [1, 3]

func isEven(num uint16) bool {
	return num%2 == 0
}

func RemoveUint16Err 

func RemoveUint16Err(f func(uint16) (bool, error), list []uint16) ([]uint16, error)

RemoveUint16Err removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type uint16 and return types(bool, error)
  2. List of type: []uint16

Returns: 

New list and error: ([]uint16, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveUint16Ptr 

func RemoveUint16Ptr(f func(*uint16) bool, list []*uint16) []*uint16

RemoveUint16Ptr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

func RemoveUint16PtrErr 

func RemoveUint16PtrErr(f func(*uint16) (bool, error), list []*uint16) ([]*uint16, error)

RemoveUint16PtrErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type *uint16 and return types(bool, error)
  2. List of type: []*uint16

Returns: 

New list and error: ([]*uint16, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveUint32 

func RemoveUint32(f func(uint32) bool, list []uint32) []uint32

RemoveUint32 removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

Example: 

fp.RemoveUint32(isEven, []uint32{1, 2, 3, 4}) // Returns: [1, 3]

func isEven(num uint32) bool {
	return num%2 == 0
}

func RemoveUint32Err 

func RemoveUint32Err(f func(uint32) (bool, error), list []uint32) ([]uint32, error)

RemoveUint32Err removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type uint32 and return types(bool, error)
  2. List of type: []uint32

Returns: 

New list and error: ([]uint32, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveUint32Ptr 

func RemoveUint32Ptr(f func(*uint32) bool, list []*uint32) []*uint32

RemoveUint32Ptr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

func RemoveUint32PtrErr 

func RemoveUint32PtrErr(f func(*uint32) (bool, error), list []*uint32) ([]*uint32, error)

RemoveUint32PtrErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type *uint32 and return types(bool, error)
  2. List of type: []*uint32

Returns: 

New list and error: ([]*uint32, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveUint64 

func RemoveUint64(f func(uint64) bool, list []uint64) []uint64

RemoveUint64 removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

Example: 

fp.RemoveUint64(isEven, []uint64{1, 2, 3, 4}) // Returns: [1, 3]

func isEven(num uint64) bool {
	return num%2 == 0
}

func RemoveUint64Err 

func RemoveUint64Err(f func(uint64) (bool, error), list []uint64) ([]uint64, error)

RemoveUint64Err removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type uint64 and return types(bool, error)
  2. List of type: []uint64

Returns: 

New list and error: ([]uint64, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveUint64Ptr 

func RemoveUint64Ptr(f func(*uint64) bool, list []*uint64) []*uint64

RemoveUint64Ptr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

func RemoveUint64PtrErr 

func RemoveUint64PtrErr(f func(*uint64) (bool, error), list []*uint64) ([]*uint64, error)

RemoveUint64PtrErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type *uint64 and return types(bool, error)
  2. List of type: []*uint64

Returns: 

New list and error: ([]*uint64, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveUint8 

func RemoveUint8(f func(uint8) bool, list []uint8) []uint8

RemoveUint8 removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

Example: 

fp.RemoveUint8(isEven, []uint8{1, 2, 3, 4}) // Returns: [1, 3]

func isEven(num uint8) bool {
	return num%2 == 0
}

func RemoveUint8Err 

func RemoveUint8Err(f func(uint8) (bool, error), list []uint8) ([]uint8, error)

RemoveUint8Err removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type uint8 and return types(bool, error)
  2. List of type: []uint8

Returns: 

New list and error: ([]uint8, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveUint8Ptr 

func RemoveUint8Ptr(f func(*uint8) bool, list []*uint8) []*uint8

RemoveUint8Ptr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

func RemoveUint8PtrErr 

func RemoveUint8PtrErr(f func(*uint8) (bool, error), list []*uint8) ([]*uint8, error)

RemoveUint8PtrErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type *uint8 and return types(bool, error)
  2. List of type: []*uint8

Returns: 

New list and error: ([]*uint8, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveUintErr 

func RemoveUintErr(f func(uint) (bool, error), list []uint) ([]uint, error)

RemoveUintErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type uint and return types(bool, error)
  2. List of type: []uint

Returns: 

New list and error: ([]uint, error)
Empty list if both of arguments are nil or either one is nil.

func RemoveUintPtr 

func RemoveUintPtr(f func(*uint) bool, list []*uint) []*uint

RemoveUintPtr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List
Empty list if both of arguments are nil or either one is nil.

func RemoveUintPtrErr 

func RemoveUintPtrErr(f func(*uint) (bool, error), list []*uint) ([]*uint, error)

RemoveUintPtrErr removes the items from the given list based on supplied function and returns new list

Takes 2 inputs:

  1. Function: input type *uint and return types(bool, error)
  2. List of type: []*uint

Returns: 

New list and error: ([]*uint, error)
Empty list if both of arguments are nil or either one is nil.

func RestBoolPtr 

func RestBoolPtr(l []*bool) []*bool

RestBoolPtr removes 1st item of the list and return new list having rest of the items

func RestFloat32 

func RestFloat32(l []float32) []float32

RestFloat32 removes 1st item of the list and return new list having rest of the items

func RestFloat32Ptr 

func RestFloat32Ptr(l []*float32) []*float32

RestFloat32Ptr removes 1st item of the list and return new list having rest of the items

func RestFloat64 

func RestFloat64(l []float64) []float64

RestFloat64 removes 1st item of the list and return new list having rest of the items

func RestFloat64Ptr 

func RestFloat64Ptr(l []*float64) []*float64

RestFloat64Ptr removes 1st item of the list and return new list having rest of the items

func RestInt 

func RestInt(l []int) []int

RestInt removes 1st item of the list and return new list having rest of the items

func RestInt16 

func RestInt16(l []int16) []int16

RestInt16 removes 1st item of the list and return new list having rest of the items

func RestInt16Ptr 

func RestInt16Ptr(l []*int16) []*int16

RestInt16Ptr removes 1st item of the list and return new list having rest of the items

func RestInt32 

func RestInt32(l []int32) []int32

RestInt32 removes 1st item of the list and return new list having rest of the items

func RestInt32Ptr 

func RestInt32Ptr(l []*int32) []*int32

RestInt32Ptr removes 1st item of the list and return new list having rest of the items

func RestInt64 

func RestInt64(l []int64) []int64

RestInt64 removes 1st item of the list and return new list having rest of the items

func RestInt64Ptr 

func RestInt64Ptr(l []*int64) []*int64

RestInt64Ptr removes 1st item of the list and return new list having rest of the items

func RestInt8 

func RestInt8(l []int8) []int8

RestInt8 removes 1st item of the list and return new list having rest of the items

func RestInt8Ptr 

func RestInt8Ptr(l []*int8) []*int8

RestInt8Ptr removes 1st item of the list and return new list having rest of the items

func RestIntPtr 

func RestIntPtr(l []*int) []*int

RestIntPtr removes 1st item of the list and return new list having rest of the items

func RestStr 

func RestStr(l []string) []string

RestStr removes 1st item of the list and return new list having rest of the items

func RestStrPtr 

func RestStrPtr(l []*string) []*string

RestStrPtr removes 1st item of the list and return new list having rest of the items

func RestUint 

func RestUint(l []uint) []uint

RestUint removes 1st item of the list and return new list having rest of the items

func RestUint16 

func RestUint16(l []uint16) []uint16

RestUint16 removes 1st item of the list and return new list having rest of the items

func RestUint16Ptr 

func RestUint16Ptr(l []*uint16) []*uint16

RestUint16Ptr removes 1st item of the list and return new list having rest of the items

func RestUint32 

func RestUint32(l []uint32) []uint32

RestUint32 removes 1st item of the list and return new list having rest of the items

func RestUint32Ptr 

func RestUint32Ptr(l []*uint32) []*uint32

RestUint32Ptr removes 1st item of the list and return new list having rest of the items

func RestUint64 

func RestUint64(l []uint64) []uint64

RestUint64 removes 1st item of the list and return new list having rest of the items

func RestUint64Ptr 

func RestUint64Ptr(l []*uint64) []*uint64

RestUint64Ptr removes 1st item of the list and return new list having rest of the items

func RestUint8 

func RestUint8(l []uint8) []uint8

RestUint8 removes 1st item of the list and return new list having rest of the items

func RestUint8Ptr 

func RestUint8Ptr(l []*uint8) []*uint8

RestUint8Ptr removes 1st item of the list and return new list having rest of the items

func RestUintPtr 

func RestUintPtr(l []*uint) []*uint

RestUintPtr removes 1st item of the list and return new list having rest of the items

func ReverseBools 

func ReverseBools(list []bool) []bool

ReverseBools reverse the list

func ReverseBoolsPtr 

func ReverseBoolsPtr(list []*bool) []*bool

ReverseBoolsPtr reverse the list

func ReverseFloat32s 

func ReverseFloat32s(list []float32) []float32

ReverseFloat32s reverse the list

func ReverseFloat32sPtr 

func ReverseFloat32sPtr(list []*float32) []*float32

ReverseFloat32sPtr reverse the list

func ReverseFloat64s 

func ReverseFloat64s(list []float64) []float64

ReverseFloat64s reverse the list

func ReverseFloat64sPtr 

func ReverseFloat64sPtr(list []*float64) []*float64

ReverseFloat64sPtr reverse the list

func ReverseInts 

func ReverseInts(list []int) []int

ReverseInts reverse the list

func ReverseInts16 

func ReverseInts16(list []int16) []int16

ReverseInts16 reverse the list

func ReverseInts16Ptr 

func ReverseInts16Ptr(list []*int16) []*int16

ReverseInts16Ptr reverse the list

func ReverseInts32 

func ReverseInts32(list []int32) []int32

ReverseInts32 reverse the list

func ReverseInts32Ptr 

func ReverseInts32Ptr(list []*int32) []*int32

ReverseInts32Ptr reverse the list

func ReverseInts64 

func ReverseInts64(list []int64) []int64

ReverseInts64 reverse the list

func ReverseInts64Ptr 

func ReverseInts64Ptr(list []*int64) []*int64

ReverseInts64Ptr reverse the list

func ReverseInts8 

func ReverseInts8(list []int8) []int8

ReverseInts8 reverse the list

func ReverseInts8Ptr 

func ReverseInts8Ptr(list []*int8) []*int8

ReverseInts8Ptr reverse the list

func ReverseIntsPtr 

func ReverseIntsPtr(list []*int) []*int

ReverseIntsPtr reverse the list

func ReverseStrs 

func ReverseStrs(list []string) []string

ReverseStrs reverse the list

func ReverseStrsPtr 

func ReverseStrsPtr(list []*string) []*string

ReverseStrsPtr reverse the list

func ReverseUint64s 

func ReverseUint64s(list []uint64) []uint64

ReverseUint64s reverse the list

func ReverseUint64sPtr 

func ReverseUint64sPtr(list []*uint64) []*uint64

ReverseUint64sPtr reverse the list

func ReverseUints 

func ReverseUints(list []uint) []uint

ReverseUints reverse the list

func ReverseUints16 

func ReverseUints16(list []uint16) []uint16

ReverseUints16 reverse the list

func ReverseUints16Ptr 

func ReverseUints16Ptr(list []*uint16) []*uint16

ReverseUints16Ptr reverse the list

func ReverseUints32 

func ReverseUints32(list []uint32) []uint32

ReverseUints32 reverse the list

func ReverseUints32Ptr 

func ReverseUints32Ptr(list []*uint32) []*uint32

ReverseUints32Ptr reverse the list

func ReverseUints8 

func ReverseUints8(list []uint8) []uint8

ReverseUints8 reverse the list

func ReverseUints8Ptr 

func ReverseUints8Ptr(list []*uint8) []*uint8

ReverseUints8Ptr reverse the list

func ReverseUintsPtr 

func ReverseUintsPtr(list []*uint) []*uint

ReverseUintsPtr reverse the list

func SetBool 

func SetBool(list []bool) []bool

SetBool returns a set of the distinct elements of coll.

func SetBoolPtr 

func SetBoolPtr(list []*bool) []*bool

SetBoolPtr returns a set of the distinct elements of coll.

func SetFloat32 

func SetFloat32(list []float32) []float32

SetFloat32 returns a set of the distinct elements of coll.

func SetFloat32Ptr 

func SetFloat32Ptr(list []*float32) []*float32

SetFloat32Ptr returns a set of the distinct elements of coll.

func SetFloat64 

func SetFloat64(list []float64) []float64

SetFloat64 returns a set of the distinct elements of coll.

func SetFloat64Ptr 

func SetFloat64Ptr(list []*float64) []*float64

SetFloat64Ptr returns a set of the distinct elements of coll.

func SetInt 

func SetInt(list []int) []int

SetInt returns a set of the distinct elements of coll.

func SetInt16 

func SetInt16(list []int16) []int16

SetInt16 returns a set of the distinct elements of coll.

func SetInt16Ptr 

func SetInt16Ptr(list []*int16) []*int16

SetInt16Ptr returns a set of the distinct elements of coll.

func SetInt32 

func SetInt32(list []int32) []int32

SetInt32 returns a set of the distinct elements of coll.

func SetInt32Ptr 

func SetInt32Ptr(list []*int32) []*int32

SetInt32Ptr returns a set of the distinct elements of coll.

func SetInt64 

func SetInt64(list []int64) []int64

SetInt64 returns a set of the distinct elements of coll.

func SetInt64Ptr 

func SetInt64Ptr(list []*int64) []*int64

SetInt64Ptr returns a set of the distinct elements of coll.

func SetInt8 

func SetInt8(list []int8) []int8

SetInt8 returns a set of the distinct elements of coll.

func SetInt8Ptr 

func SetInt8Ptr(list []*int8) []*int8

SetInt8Ptr returns a set of the distinct elements of coll.

func SetIntPtr 

func SetIntPtr(list []*int) []*int

SetIntPtr returns a set of the distinct elements of coll.

func SetStr 

func SetStr(list []string) []string

SetStr returns a set of the distinct elements of coll.

func SetStrPtr 

func SetStrPtr(list []*string) []*string

SetStrPtr returns a set of the distinct elements of coll.

func SetUint 

func SetUint(list []uint) []uint

SetUint returns a set of the distinct elements of coll.

func SetUint16 

func SetUint16(list []uint16) []uint16

SetUint16 returns a set of the distinct elements of coll.

func SetUint16Ptr 

func SetUint16Ptr(list []*uint16) []*uint16

SetUint16Ptr returns a set of the distinct elements of coll.

func SetUint32 

func SetUint32(list []uint32) []uint32

SetUint32 returns a set of the distinct elements of coll.

func SetUint32Ptr 

func SetUint32Ptr(list []*uint32) []*uint32

SetUint32Ptr returns a set of the distinct elements of coll.

func SetUint64 

func SetUint64(list []uint64) []uint64

SetUint64 returns a set of the distinct elements of coll.

func SetUint64Ptr 

func SetUint64Ptr(list []*uint64) []*uint64

SetUint64Ptr returns a set of the distinct elements of coll.

func SetUint8 

func SetUint8(list []uint8) []uint8

SetUint8 returns a set of the distinct elements of coll.

func SetUint8Ptr 

func SetUint8Ptr(list []*uint8) []*uint8

SetUint8Ptr returns a set of the distinct elements of coll.

func SetUintPtr 

func SetUintPtr(list []*uint) []*uint

SetUintPtr returns a set of the distinct elements of coll.

func SomeBoolErr 

func SomeBoolErr(f func(bool) (bool, error), list []bool) (bool, error)

SomeBoolErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeBoolPtr 

func SomeBoolPtr(f func(*bool) bool, list []*bool) bool

SomeBoolPtr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

func SomeBoolPtrErr 

func SomeBoolPtrErr(f func(*bool) (bool, error), list []*bool) (bool, error)

SomeBoolPtrErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeFloat32 

func SomeFloat32(f func(float32) bool, list []float32) bool

SomeFloat32 finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

Example: 

fp.SomeFloat32(isPositive, []float32{8, 2, 10, 4}) // Returns true
fp.SomeFloat32(nil, nil) // Returns false
fp.SomeFloat32(isPositive, []float32{}) // Returns false

func isPositive(num float32) bool {
	return num > 0
}

func SomeFloat32Err 

func SomeFloat32Err(f func(float32) (bool, error), list []float32) (bool, error)

SomeFloat32Err finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeFloat32Ptr 

func SomeFloat32Ptr(f func(*float32) bool, list []*float32) bool

SomeFloat32Ptr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

func SomeFloat32PtrErr 

func SomeFloat32PtrErr(f func(*float32) (bool, error), list []*float32) (bool, error)

SomeFloat32PtrErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeFloat64 

func SomeFloat64(f func(float64) bool, list []float64) bool

SomeFloat64 finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

Example: 

fp.SomeFloat64(isPositive, []float64{8, 2, 10, 4}) // Returns true
fp.SomeFloat64(nil, nil) // Returns false
fp.SomeFloat64(isPositive, []float64{}) // Returns false

func isPositive(num float64) bool {
	return num > 0
}

func SomeFloat64Err 

func SomeFloat64Err(f func(float64) (bool, error), list []float64) (bool, error)

SomeFloat64Err finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeFloat64Ptr 

func SomeFloat64Ptr(f func(*float64) bool, list []*float64) bool

SomeFloat64Ptr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

func SomeFloat64PtrErr 

func SomeFloat64PtrErr(f func(*float64) (bool, error), list []*float64) (bool, error)

SomeFloat64PtrErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeInt 

func SomeInt(f func(int) bool, list []int) bool

SomeInt finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

Example: 

fp.SomeInt(isEven, []int{8, 2, 10, 4}) // Returns true
fp.SomeInt(isEven, []int{1, 3, 5, 7}) // Returns false
fp.SomeInt(nil, nil) // Returns false
fp.SomeInt(isEven, []int{}) // Returns false

func isEven(num int) bool {
	return num%2 == 0
}

func SomeInt16 

func SomeInt16(f func(int16) bool, list []int16) bool

SomeInt16 finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

Example: 

fp.SomeInt16(isEven, []int16{8, 2, 10, 4}) // Returns true
fp.SomeInt16(isEven, []int16{1, 3, 5, 7}) // Returns false
fp.SomeInt16(nil, nil) // Returns false
fp.SomeInt16(isEven, []int16{}) // Returns false

func isEven(num int16) bool {
	return num%2 == 0
}

func SomeInt16Err 

func SomeInt16Err(f func(int16) (bool, error), list []int16) (bool, error)

SomeInt16Err finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeInt16Ptr 

func SomeInt16Ptr(f func(*int16) bool, list []*int16) bool

SomeInt16Ptr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

func SomeInt16PtrErr 

func SomeInt16PtrErr(f func(*int16) (bool, error), list []*int16) (bool, error)

SomeInt16PtrErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeInt32 

func SomeInt32(f func(int32) bool, list []int32) bool

SomeInt32 finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

Example: 

fp.SomeInt32(isEven, []int32{8, 2, 10, 4}) // Returns true
fp.SomeInt32(isEven, []int32{1, 3, 5, 7}) // Returns false
fp.SomeInt32(nil, nil) // Returns false
fp.SomeInt32(isEven, []int32{}) // Returns false

func isEven(num int32) bool {
	return num%2 == 0
}

func SomeInt32Err 

func SomeInt32Err(f func(int32) (bool, error), list []int32) (bool, error)

SomeInt32Err finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeInt32Ptr 

func SomeInt32Ptr(f func(*int32) bool, list []*int32) bool

SomeInt32Ptr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

func SomeInt32PtrErr 

func SomeInt32PtrErr(f func(*int32) (bool, error), list []*int32) (bool, error)

SomeInt32PtrErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeInt64 

func SomeInt64(f func(int64) bool, list []int64) bool

SomeInt64 finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

Example: 

fp.SomeInt64(isEven, []int64{8, 2, 10, 4}) // Returns true
fp.SomeInt64(isEven, []int64{1, 3, 5, 7}) // Returns false
fp.SomeInt64(nil, nil) // Returns false
fp.SomeInt64(isEven, []int64{}) // Returns false

func isEven(num int64) bool {
	return num%2 == 0
}

func SomeInt64Err 

func SomeInt64Err(f func(int64) (bool, error), list []int64) (bool, error)

SomeInt64Err finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeInt64Ptr 

func SomeInt64Ptr(f func(*int64) bool, list []*int64) bool

SomeInt64Ptr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

func SomeInt64PtrErr 

func SomeInt64PtrErr(f func(*int64) (bool, error), list []*int64) (bool, error)

SomeInt64PtrErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeInt8 

func SomeInt8(f func(int8) bool, list []int8) bool

SomeInt8 finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

Example: 

fp.SomeInt8(isEven, []int16{8, 2, 10, 4}) // Returns true
fp.SomeInt8(isEven, []int16{1, 3, 5, 7}) // Returns false
fp.SomeInt8(nil, nil) // Returns false
fp.SomeInt8(isEven, []int16{}) // Returns false

func isEven(num int16) bool {
	return num%2 == 0
}

func SomeInt8Err 

func SomeInt8Err(f func(int8) (bool, error), list []int8) (bool, error)

SomeInt8Err finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeInt8Ptr 

func SomeInt8Ptr(f func(*int8) bool, list []*int8) bool

SomeInt8Ptr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

func SomeInt8PtrErr 

func SomeInt8PtrErr(f func(*int8) (bool, error), list []*int8) (bool, error)

SomeInt8PtrErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeIntErr 

func SomeIntErr(f func(int) (bool, error), list []int) (bool, error)

SomeIntErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeIntPtr 

func SomeIntPtr(f func(*int) bool, list []*int) bool

SomeIntPtr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

func SomeIntPtrErr 

func SomeIntPtrErr(f func(*int) (bool, error), list []*int) (bool, error)

SomeIntPtrErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeStr 

func SomeStr(f func(string) bool, list []string) bool

SomeStr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

Example: 

fp.SomeStr(isStringLengthLessThan10, []string{"gopal", "govinda", "Nandeshwar"}) // Returns true
fp.SomeStr(nil, nil) // Returns false
fp.SomeStr(isStringLengthLessThan10, []string{}) // Returns false

func isStringLengthLessThan10(str string) bool {
	return len(str) < 10
}

func SomeStrErr 

func SomeStrErr(f func(string) (bool, error), list []string) (bool, error)

SomeStrErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeStrPtr 

func SomeStrPtr(f func(*string) bool, list []*string) bool

SomeStrPtr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

func SomeStrPtrErr 

func SomeStrPtrErr(f func(*string) (bool, error), list []*string) (bool, error)

SomeStrPtrErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeUint 

func SomeUint(f func(uint) bool, list []uint) bool

SomeUint finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

Example: 

fp.SomeUint(isEven, []uint{8, 2, 10, 4}) // Returns true
fp.SomeUint(isEven, []uint{1, 3, 5, 7}) // Returns false
fp.SomeUint(nil, nil) // Returns false
fp.SomeUint(isEven, []uint{}) // Returns false

func isEven(num uint) bool {
	return num%2 == 0
}

func SomeUint16 

func SomeUint16(f func(uint16) bool, list []uint16) bool

SomeUint16 finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

Example: 

fp.SomeUint16(isEven, []uint16{8, 2, 10, 4}) // Returns true
fp.SomeUint16(isEven, []uint16{1, 3, 5, 7}) // Returns false
fp.SomeUint16(nil, nil) // Returns false
fp.SomeUint16(isEven, []uint16{}) // Returns false

func isEven(num uint16) bool {
	return num%2 == 0
}

func SomeUint16Err 

func SomeUint16Err(f func(uint16) (bool, error), list []uint16) (bool, error)

SomeUint16Err finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeUint16Ptr 

func SomeUint16Ptr(f func(*uint16) bool, list []*uint16) bool

SomeUint16Ptr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

func SomeUint16PtrErr 

func SomeUint16PtrErr(f func(*uint16) (bool, error), list []*uint16) (bool, error)

SomeUint16PtrErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeUint32 

func SomeUint32(f func(uint32) bool, list []uint32) bool

SomeUint32 finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

Example: 

fp.SomeUint32(isEven, []uint32{8, 2, 10, 4}) // Returns true
fp.SomeUint32(isEven, []uint32{1, 3, 5, 7}) // Returns false
fp.SomeUint32(nil, nil) // Returns false
fp.SomeUint32(isEven, []uint32{}) // Returns false

func isEven(num uint32) bool {
	return num%2 == 0
}

func SomeUint32Err 

func SomeUint32Err(f func(uint32) (bool, error), list []uint32) (bool, error)

SomeUint32Err finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeUint32Ptr 

func SomeUint32Ptr(f func(*uint32) bool, list []*uint32) bool

SomeUint32Ptr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

func SomeUint32PtrErr 

func SomeUint32PtrErr(f func(*uint32) (bool, error), list []*uint32) (bool, error)

SomeUint32PtrErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeUint64 

func SomeUint64(f func(uint64) bool, list []uint64) bool

SomeUint64 finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

Example: 

fp.SomeUint64(isEven, []uint64{8, 2, 10, 4}) // Returns true
fp.SomeUint64(isEven, []uint64{1, 3, 5, 7}) // Returns false
fp.SomeUint64(nil, nil) // Returns false
fp.SomeUint64(isEven, []uint64{}) // Returns false

func isEven(num int16) bool {
	return num%2 == 0
}

func SomeUint64Err 

func SomeUint64Err(f func(uint64) (bool, error), list []uint64) (bool, error)

SomeUint64Err finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeUint64Ptr 

func SomeUint64Ptr(f func(*uint64) bool, list []*uint64) bool

SomeUint64Ptr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

func SomeUint64PtrErr 

func SomeUint64PtrErr(f func(*uint64) (bool, error), list []*uint64) (bool, error)

SomeUint64PtrErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeUint8 

func SomeUint8(f func(uint8) bool, list []uint8) bool

SomeUint8 finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

Example: 

fp.SomeUint8(isEven, []uint8{8, 2, 10, 4}) // Returns true
fp.SomeUint8(isEven, []uint8{1, 3, 5, 7}) // Returns false
fp.SomeUint8(nil, nil) // Returns false
fp.SomeUint8(isEven, []uint8{}) // Returns false

func isEven(num uint8) bool {
	return num%2 == 0
}

func SomeUint8Err 

func SomeUint8Err(f func(uint8) (bool, error), list []uint8) (bool, error)

SomeUint8Err finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeUint8Ptr 

func SomeUint8Ptr(f func(*uint8) bool, list []*uint8) bool

SomeUint8Ptr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

func SomeUint8PtrErr 

func SomeUint8PtrErr(f func(*uint8) (bool, error), list []*uint8) (bool, error)

SomeUint8PtrErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeUintErr 

func SomeUintErr(f func(uint) (bool, error), list []uint) (bool, error)

SomeUintErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SomeUintPtr 

func SomeUintPtr(f func(*uint) bool, list []*uint) bool

SomeUintPtr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

bool.
True if condition satisfies, else false

func SomeUintPtrErr 

func SomeUintPtrErr(f func(*uint) (bool, error), list []*uint) (bool, error)

SomeUintPtrErr finds item in the list based on supplied function.

Takes 2 input:

  1. Function
  2. List

Returns: 

(bool,err).
True if condition satisfies, else false

func SortFloat32s 

func SortFloat32s(list []float32) []float32

SortFloat32s return new sorted list

func SortFloat32sDesc 

func SortFloat32sDesc(list []float32) []float32

SortFloat32sDesc return new sorted list

func SortFloat32sDescPtr 

func SortFloat32sDescPtr(list []*float32) []*float32

SortFloat32sDescPtr return new sorted list

func SortFloat32sPtr 

func SortFloat32sPtr(list []*float32) []*float32

SortFloat32sPtr return new sorted list

func SortFloat64s 

func SortFloat64s(list []float64) []float64

SortFloat64s return new sorted list

func SortFloat64sDesc 

func SortFloat64sDesc(list []float64) []float64

SortFloat64sDesc return new sorted list

func SortFloat64sDescPtr 

func SortFloat64sDescPtr(list []*float64) []*float64

SortFloat64sDescPtr return new sorted list

func SortFloat64sPtr 

func SortFloat64sPtr(list []*float64) []*float64

SortFloat64sPtr return new sorted list

func SortFloats64 

func SortFloats64(list []float64) []float64

SortFloats64 return new sorted list

func SortFloats64Desc 

func SortFloats64Desc(list []float64) []float64

SortFloats64Desc return new sorted list

func SortFloats64DescPtr 

func SortFloats64DescPtr(list []*float64) []*float64

SortFloats64DescPtr return new sorted list

func SortFloats64Ptr 

func SortFloats64Ptr(list []*float64) []*float64

SortFloats64Ptr return new sorted list

func SortInts 

func SortInts(list []int) []int

SortInts return new sorted list

func SortInts16 

func SortInts16(list []int16) []int16

SortInts16 return new sorted list

func SortInts16Desc 

func SortInts16Desc(list []int16) []int16

SortInts16Desc return new sorted list

func SortInts16DescPtr 

func SortInts16DescPtr(list []*int16) []*int16

SortInts16DescPtr return new sorted list

func SortInts16Ptr 

func SortInts16Ptr(list []*int16) []*int16

SortInts16Ptr return new sorted list

func SortInts32 

func SortInts32(list []int32) []int32

SortInts32 return new sorted list

func SortInts32Desc 

func SortInts32Desc(list []int32) []int32

SortInts32Desc return new sorted list

func SortInts32DescPtr 

func SortInts32DescPtr(list []*int32) []*int32

SortInts32DescPtr return new sorted list

func SortInts32Ptr 

func SortInts32Ptr(list []*int32) []*int32

SortInts32Ptr return new sorted list

func SortInts64 

func SortInts64(list []int64) []int64

SortInts64 return new sorted list

func SortInts64Desc 

func SortInts64Desc(list []int64) []int64

SortInts64Desc return new sorted list

func SortInts64DescPtr 

func SortInts64DescPtr(list []*int64) []*int64

SortInts64DescPtr return new sorted list

func SortInts64Ptr 

func SortInts64Ptr(list []*int64) []*int64

SortInts64Ptr return new sorted list

func SortInts8 

func SortInts8(list []int8) []int8

SortInts8 return new sorted list

func SortInts8Desc 

func SortInts8Desc(list []int8) []int8

SortInts8Desc return new sorted list

func SortInts8DescPtr 

func SortInts8DescPtr(list []*int8) []*int8

SortInts8DescPtr return new sorted list

func SortInts8Ptr 

func SortInts8Ptr(list []*int8) []*int8

SortInts8Ptr return new sorted list

func SortIntsDesc 

func SortIntsDesc(list []int) []int

SortIntsDesc return new sorted list

func SortIntsDescPtr 

func SortIntsDescPtr(list []*int) []*int

SortIntsDescPtr return new sorted list

func SortIntsPtr 

func SortIntsPtr(list []*int) []*int

SortIntsPtr return new sorted list

func SortStrs 

func SortStrs(list []string) []string

SortStrs return new sorted list

func SortStrsDesc 

func SortStrsDesc(list []string) []string

SortStrsDesc return new sorted list

func SortStrsDescPtr 

func SortStrsDescPtr(list []*string) []*string

SortStrsDescPtr return new sorted list

func SortStrsPtr 

func SortStrsPtr(list []*string) []*string

SortStrsPtr return new sorted list

func SortUint64s 

func SortUint64s(list []uint64) []uint64

SortUint64s return new sorted list

func SortUint64sDesc 

func SortUint64sDesc(list []uint64) []uint64

SortUint64sDesc return new sorted list

func SortUint64sDescPtr 

func SortUint64sDescPtr(list []*uint64) []*uint64

SortUint64sDescPtr return new sorted list

func SortUint64sPtr 

func SortUint64sPtr(list []*uint64) []*uint64

SortUint64sPtr return new sorted list

func SortUints 

func SortUints(list []uint) []uint

SortUints return new sorted list

func SortUints16 

func SortUints16(list []uint16) []uint16

SortUints16 return new sorted list

func SortUints16Desc 

func SortUints16Desc(list []uint16) []uint16

SortUints16Desc return new sorted list

func SortUints16DescPtr 

func SortUints16DescPtr(list []*uint16) []*uint16

SortUints16DescPtr return new sorted list

func SortUints16Ptr 

func SortUints16Ptr(list []*uint16) []*uint16

SortUints16Ptr return new sorted list

func SortUints32 

func SortUints32(list []uint32) []uint32

SortUints32 return new sorted list

func SortUints32Desc 

func SortUints32Desc(list []uint32) []uint32

SortUints32Desc return new sorted list

func SortUints32DescPtr 

func SortUints32DescPtr(list []*uint32) []*uint32

SortUints32DescPtr return new sorted list

func SortUints32Ptr 

func SortUints32Ptr(list []*uint32) []*uint32

SortUints32Ptr return new sorted list

func SortUints8 

func SortUints8(list []uint8) []uint8

SortUints8 return new sorted list

func SortUints8Desc 

func SortUints8Desc(list []uint8) []uint8

SortUints8Desc return new sorted list

func SortUints8DescPtr 

func SortUints8DescPtr(list []*uint8) []*uint8

SortUints8DescPtr return new sorted list

func SortUints8Ptr 

func SortUints8Ptr(list []*uint8) []*uint8

SortUints8Ptr return new sorted list

func SortUintsDesc 

func SortUintsDesc(list []uint) []uint

SortUintsDesc return new sorted list

func SortUintsDescPtr 

func SortUintsDescPtr(list []*uint) []*uint

SortUintsDescPtr return new sorted list

func SortUintsPtr 

func SortUintsPtr(list []*uint) []*uint

SortUintsPtr return new sorted list

func SubsetBool 

func SubsetBool(list1, list2 []bool) bool

SubsetBool returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetBoolPtr 

func SubsetBoolPtr(list1, list2 []*bool) bool

SubsetBoolPtr returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetFloat32 

func SubsetFloat32(list1, list2 []float32) bool

SubsetFloat32 returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetFloat32Ptr 

func SubsetFloat32Ptr(list1, list2 []*float32) bool

SubsetFloat32Ptr returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetFloat64 

func SubsetFloat64(list1, list2 []float64) bool

SubsetFloat64 returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetFloat64Ptr 

func SubsetFloat64Ptr(list1, list2 []*float64) bool

SubsetFloat64Ptr returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetInt 

func SubsetInt(list1, list2 []int) bool

SubsetInt returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetInt16 

func SubsetInt16(list1, list2 []int16) bool

SubsetInt16 returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetInt16Ptr 

func SubsetInt16Ptr(list1, list2 []*int16) bool

SubsetInt16Ptr returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetInt32 

func SubsetInt32(list1, list2 []int32) bool

SubsetInt32 returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetInt32Ptr 

func SubsetInt32Ptr(list1, list2 []*int32) bool

SubsetInt32Ptr returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetInt64 

func SubsetInt64(list1, list2 []int64) bool

SubsetInt64 returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetInt64Ptr 

func SubsetInt64Ptr(list1, list2 []*int64) bool

SubsetInt64Ptr returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetInt8 

func SubsetInt8(list1, list2 []int8) bool

SubsetInt8 returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetInt8Ptr 

func SubsetInt8Ptr(list1, list2 []*int8) bool

SubsetInt8Ptr returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetIntPtr 

func SubsetIntPtr(list1, list2 []*int) bool

SubsetIntPtr returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetStr 

func SubsetStr(list1, list2 []string) bool

SubsetStr returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetStrPtr 

func SubsetStrPtr(list1, list2 []*string) bool

SubsetStrPtr returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetUint 

func SubsetUint(list1, list2 []uint) bool

SubsetUint returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetUint16 

func SubsetUint16(list1, list2 []uint16) bool

SubsetUint16 returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetUint16Ptr 

func SubsetUint16Ptr(list1, list2 []*uint16) bool

SubsetUint16Ptr returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetUint32 

func SubsetUint32(list1, list2 []uint32) bool

SubsetUint32 returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetUint32Ptr 

func SubsetUint32Ptr(list1, list2 []*uint32) bool

SubsetUint32Ptr returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetUint64 

func SubsetUint64(list1, list2 []uint64) bool

SubsetUint64 returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetUint64Ptr 

func SubsetUint64Ptr(list1, list2 []*uint64) bool

SubsetUint64Ptr returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetUint8 

func SubsetUint8(list1, list2 []uint8) bool

SubsetUint8 returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetUint8Ptr 

func SubsetUint8Ptr(list1, list2 []*uint8) bool

SubsetUint8Ptr returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SubsetUintPtr 

func SubsetUintPtr(list1, list2 []*uint) bool

SubsetUintPtr returns true or false by checking if set1 is a subset of set2 repeated value within list parameter will be ignored

func SupersetBool 

func SupersetBool(list1, list2 []bool) bool

SupersetBool returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetBoolPtr 

func SupersetBoolPtr(list1, list2 []*bool) bool

SupersetBoolPtr returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetFloat32 

func SupersetFloat32(list1, list2 []float32) bool

SupersetFloat32 returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetFloat32Ptr 

func SupersetFloat32Ptr(list1, list2 []*float32) bool

SupersetFloat32Ptr returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetFloat64 

func SupersetFloat64(list1, list2 []float64) bool

SupersetFloat64 returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetFloat64Ptr 

func SupersetFloat64Ptr(list1, list2 []*float64) bool

SupersetFloat64Ptr returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetInt 

func SupersetInt(list1, list2 []int) bool

SupersetInt returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetInt16 

func SupersetInt16(list1, list2 []int16) bool

SupersetInt16 returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetInt16Ptr 

func SupersetInt16Ptr(list1, list2 []*int16) bool

SupersetInt16Ptr returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetInt32 

func SupersetInt32(list1, list2 []int32) bool

SupersetInt32 returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetInt32Ptr 

func SupersetInt32Ptr(list1, list2 []*int32) bool

SupersetInt32Ptr returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetInt64 

func SupersetInt64(list1, list2 []int64) bool

SupersetInt64 returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetInt64Ptr 

func SupersetInt64Ptr(list1, list2 []*int64) bool

SupersetInt64Ptr returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetInt8 

func SupersetInt8(list1, list2 []int8) bool

SupersetInt8 returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetInt8Ptr 

func SupersetInt8Ptr(list1, list2 []*int8) bool

SupersetInt8Ptr returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetIntPtr 

func SupersetIntPtr(list1, list2 []*int) bool

SupersetIntPtr returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetStr 

func SupersetStr(list1, list2 []string) bool

SupersetStr returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetStrPtr 

func SupersetStrPtr(list1, list2 []*string) bool

SupersetStrPtr returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetUint 

func SupersetUint(list1, list2 []uint) bool

SupersetUint returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetUint16 

func SupersetUint16(list1, list2 []uint16) bool

SupersetUint16 returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetUint16Ptr 

func SupersetUint16Ptr(list1, list2 []*uint16) bool

SupersetUint16Ptr returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetUint32 

func SupersetUint32(list1, list2 []uint32) bool

SupersetUint32 returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetUint32Ptr 

func SupersetUint32Ptr(list1, list2 []*uint32) bool

SupersetUint32Ptr returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetUint64 

func SupersetUint64(list1, list2 []uint64) bool

SupersetUint64 returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetUint64Ptr 

func SupersetUint64Ptr(list1, list2 []*uint64) bool

SupersetUint64Ptr returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetUint8 

func SupersetUint8(list1, list2 []uint8) bool

SupersetUint8 returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetUint8Ptr 

func SupersetUint8Ptr(list1, list2 []*uint8) bool

SupersetUint8Ptr returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func SupersetUintPtr 

func SupersetUintPtr(list1, list2 []*uint) bool

SupersetUintPtr returns true or false by checking if set1 is a superset of set2 repeated value within list parameter will be ignored

func TakeBool 

func TakeBool(n int, list []bool) []bool

TakeBool returns n items in the list

func TakeBoolPtr 

func TakeBoolPtr(n int, list []*bool) []*bool

TakeBoolPtr returns n items in the list

func TakeFloat32 

func TakeFloat32(n int, list []float32) []float32

TakeFloat32 returns n items in the list

func TakeFloat32Ptr 

func TakeFloat32Ptr(n int, list []*float32) []*float32

TakeFloat32Ptr returns n items in the list

func TakeFloat64 

func TakeFloat64(n int, list []float64) []float64

TakeFloat64 returns n items in the list

func TakeFloat64Ptr 

func TakeFloat64Ptr(n int, list []*float64) []*float64

TakeFloat64Ptr returns n items in the list

func TakeInt 

func TakeInt(n int, list []int) []int

TakeInt returns n items in the list

func TakeInt16 

func TakeInt16(n int, list []int16) []int16

TakeInt16 returns n items in the list

func TakeInt16Ptr 

func TakeInt16Ptr(n int, list []*int16) []*int16

TakeInt16Ptr returns n items in the list

func TakeInt32 

func TakeInt32(n int, list []int32) []int32

TakeInt32 returns n items in the list

func TakeInt32Ptr 

func TakeInt32Ptr(n int, list []*int32) []*int32

TakeInt32Ptr returns n items in the list

func TakeInt64 

func TakeInt64(n int, list []int64) []int64

TakeInt64 returns n items in the list

func TakeInt64Ptr 

func TakeInt64Ptr(n int, list []*int64) []*int64

TakeInt64Ptr returns n items in the list

func TakeInt8 

func TakeInt8(n int, list []int8) []int8

TakeInt8 returns n items in the list

func TakeInt8Ptr 

func TakeInt8Ptr(n int, list []*int8) []*int8

TakeInt8Ptr returns n items in the list

func TakeIntPtr 

func TakeIntPtr(n int, list []*int) []*int

TakeIntPtr returns n items in the list

func TakeStr 

func TakeStr(n int, list []string) []string

TakeStr returns n items in the list

func TakeStrPtr 

func TakeStrPtr(n int, list []*string) []*string

TakeStrPtr returns n items in the list

func TakeUint 

func TakeUint(n int, list []uint) []uint

TakeUint returns n items in the list

func TakeUint16 

func TakeUint16(n int, list []uint16) []uint16

TakeUint16 returns n items in the list

func TakeUint16Ptr 

func TakeUint16Ptr(n int, list []*uint16) []*uint16

TakeUint16Ptr returns n items in the list

func TakeUint32 

func TakeUint32(n int, list []uint32) []uint32

TakeUint32 returns n items in the list

func TakeUint32Ptr 

func TakeUint32Ptr(n int, list []*uint32) []*uint32

TakeUint32Ptr returns n items in the list

func TakeUint64 

func TakeUint64(n int, list []uint64) []uint64

TakeUint64 returns n items in the list

func TakeUint64Ptr 

func TakeUint64Ptr(n int, list []*uint64) []*uint64

TakeUint64Ptr returns n items in the list

func TakeUint8 

func TakeUint8(n int, list []uint8) []uint8

TakeUint8 returns n items in the list

func TakeUint8Ptr 

func TakeUint8Ptr(n int, list []*uint8) []*uint8

TakeUint8Ptr returns n items in the list

func TakeUintPtr 

func TakeUintPtr(n int, list []*uint) []*uint

TakeUintPtr returns n items in the list

func TakeWhileBool 

func TakeWhileBool(f func(bool) bool, list []bool) []bool

TakeWhileBool returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileBoolErr 

func TakeWhileBoolErr(f func(bool) (bool, error), list []bool) ([]bool, error)

TakeWhileBoolErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type bool and returns ([]bool, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileBoolPtr 

func TakeWhileBoolPtr(f func(*bool) bool, list []*bool) []*bool

TakeWhileBoolPtr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileBoolPtrErr 

func TakeWhileBoolPtrErr(f func(*bool) (bool, error), list []*bool) ([]*bool, error)

TakeWhileBoolPtrErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type *bool and returns ([]*bool, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileFloat32 

func TakeWhileFloat32(f func(float32) bool, list []float32) []float32

TakeWhileFloat32 returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

Example: 

fp.TakeWhileFloat32(isPositive, []float32{4, 2, 3, -1, 4, 5}) // Returns: [4, 2, 3]

func isPositive(num float32) bool {
	return num > 0
}

func TakeWhileFloat32Err 

func TakeWhileFloat32Err(f func(float32) (bool, error), list []float32) ([]float32, error)

TakeWhileFloat32Err returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type float32 and returns ([]float32, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileFloat32Ptr 

func TakeWhileFloat32Ptr(f func(*float32) bool, list []*float32) []*float32

TakeWhileFloat32Ptr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileFloat32PtrErr 

func TakeWhileFloat32PtrErr(f func(*float32) (bool, error), list []*float32) ([]*float32, error)

TakeWhileFloat32PtrErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type *float32 and returns ([]*float32, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileFloat64 

func TakeWhileFloat64(f func(float64) bool, list []float64) []float64

TakeWhileFloat64 returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

Example: 

fp.TakeWhileFloat64(isPositive, []float64{4, 2, 3, -1, 4, 5}) // Returns: [4, 2, 3]

func isPositive(num float64) bool {
	return num > 0
}

func TakeWhileFloat64Err 

func TakeWhileFloat64Err(f func(float64) (bool, error), list []float64) ([]float64, error)

TakeWhileFloat64Err returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type float64 and returns ([]float64, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileFloat64Ptr 

func TakeWhileFloat64Ptr(f func(*float64) bool, list []*float64) []*float64

TakeWhileFloat64Ptr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileFloat64PtrErr 

func TakeWhileFloat64PtrErr(f func(*float64) (bool, error), list []*float64) ([]*float64, error)

TakeWhileFloat64PtrErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type *float64 and returns ([]*float64, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileInt 

func TakeWhileInt(f func(int) bool, list []int) []int

TakeWhileInt returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

Example: 

fp.TakeWhileInt(isEven, []int{4, 2, 4, 7, 5}) // Returns: [4, 2, 4]

func isEven(num int) bool {
	return num%2 == 0
}

func TakeWhileInt16 

func TakeWhileInt16(f func(int16) bool, list []int16) []int16

TakeWhileInt16 returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

Example: 

fp.TakeWhileInt16(isEven, []int16{4, 2, 4, 7, 5}) // Returns: [4, 2, 4]

func isEven(num int16) bool {
	return num%2 == 0
}

func TakeWhileInt16Err 

func TakeWhileInt16Err(f func(int16) (bool, error), list []int16) ([]int16, error)

TakeWhileInt16Err returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type int16 and returns ([]int16, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileInt16Ptr 

func TakeWhileInt16Ptr(f func(*int16) bool, list []*int16) []*int16

TakeWhileInt16Ptr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileInt16PtrErr 

func TakeWhileInt16PtrErr(f func(*int16) (bool, error), list []*int16) ([]*int16, error)

TakeWhileInt16PtrErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type *int16 and returns ([]*int16, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileInt32 

func TakeWhileInt32(f func(int32) bool, list []int32) []int32

TakeWhileInt32 returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

Example: 

fp.TakeWhileInt32(isEven, []int32{4, 2, 4, 7, 5}) // Returns: [4, 2, 4]

func isEven(num int32) bool {
	return num%2 == 0
}

func TakeWhileInt32Err 

func TakeWhileInt32Err(f func(int32) (bool, error), list []int32) ([]int32, error)

TakeWhileInt32Err returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type int32 and returns ([]int32, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileInt32Ptr 

func TakeWhileInt32Ptr(f func(*int32) bool, list []*int32) []*int32

TakeWhileInt32Ptr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileInt32PtrErr 

func TakeWhileInt32PtrErr(f func(*int32) (bool, error), list []*int32) ([]*int32, error)

TakeWhileInt32PtrErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type *int32 and returns ([]*int32, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileInt64 

func TakeWhileInt64(f func(int64) bool, list []int64) []int64

TakeWhileInt64 returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

Example: 

fp.TakeWhileInt64(isEven, []int64{4, 2, 4, 7, 5}) // Returns: [4, 2, 4]

func isEven(num int64) bool {
	return num%2 == 0
}

func TakeWhileInt64Err 

func TakeWhileInt64Err(f func(int64) (bool, error), list []int64) ([]int64, error)

TakeWhileInt64Err returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type int64 and returns ([]int64, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileInt64Ptr 

func TakeWhileInt64Ptr(f func(*int64) bool, list []*int64) []*int64

TakeWhileInt64Ptr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileInt64PtrErr 

func TakeWhileInt64PtrErr(f func(*int64) (bool, error), list []*int64) ([]*int64, error)

TakeWhileInt64PtrErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type *int64 and returns ([]*int64, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileInt8 

func TakeWhileInt8(f func(int8) bool, list []int8) []int8

TakeWhileInt8 returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

Example: 

fp.TakeWhileInt8(isEven, []int8{4, 2, 4, 7, 5}) // Returns: [4, 2, 4]

func isEven(num int8) bool {
	return num%2 == 0
}

func TakeWhileInt8Err 

func TakeWhileInt8Err(f func(int8) (bool, error), list []int8) ([]int8, error)

TakeWhileInt8Err returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type int8 and returns ([]int8, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileInt8Ptr 

func TakeWhileInt8Ptr(f func(*int8) bool, list []*int8) []*int8

TakeWhileInt8Ptr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileInt8PtrErr 

func TakeWhileInt8PtrErr(f func(*int8) (bool, error), list []*int8) ([]*int8, error)

TakeWhileInt8PtrErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type *int8 and returns ([]*int8, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileIntErr 

func TakeWhileIntErr(f func(int) (bool, error), list []int) ([]int, error)

TakeWhileIntErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type int and returns ([]int, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileIntPtr 

func TakeWhileIntPtr(f func(*int) bool, list []*int) []*int

TakeWhileIntPtr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileIntPtrErr 

func TakeWhileIntPtrErr(f func(*int) (bool, error), list []*int) ([]*int, error)

TakeWhileIntPtrErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type *int and returns ([]*int, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileStr 

func TakeWhileStr(f func(string) bool, list []string) []string

TakeWhileStr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

Example: 

fp.TakeWhileStr(isStringLengthLessThan10, []string{"Ram", "Shyam", "Radha", "Nandeshwar", "ShyamSundar", "Hari Shankar"}) // Returns: ["Ram", "Shyam", "Radha"]

func isStringLengthLessThan10(str string) bool {
	return len(str) < 10
}

func TakeWhileStrErr 

func TakeWhileStrErr(f func(string) (bool, error), list []string) ([]string, error)

TakeWhileStrErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type string and returns ([]string, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileStrPtr 

func TakeWhileStrPtr(f func(*string) bool, list []*string) []*string

TakeWhileStrPtr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileStrPtrErr 

func TakeWhileStrPtrErr(f func(*string) (bool, error), list []*string) ([]*string, error)

TakeWhileStrPtrErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type *string and returns ([]*string, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileUint 

func TakeWhileUint(f func(uint) bool, list []uint) []uint

TakeWhileUint returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

Example: 

fp.TakeWhileUint(isEven, []uint{4, 2, 4, 7, 5}) // Returns: [4, 2, 4]

func isEven(num uint) bool {
	return num%2 == 0
}

func TakeWhileUint16 

func TakeWhileUint16(f func(uint16) bool, list []uint16) []uint16

TakeWhileUint16 returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

Example: 

fp.TakeWhileUint16(isEven, []uint16{4, 2, 4, 7, 5}) // Returns: [4, 2, 4]

func isEven(num uint16) bool {
	return num%2 == 0
}

func TakeWhileUint16Err 

func TakeWhileUint16Err(f func(uint16) (bool, error), list []uint16) ([]uint16, error)

TakeWhileUint16Err returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type uint16 and returns ([]uint16, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileUint16Ptr 

func TakeWhileUint16Ptr(f func(*uint16) bool, list []*uint16) []*uint16

TakeWhileUint16Ptr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileUint16PtrErr 

func TakeWhileUint16PtrErr(f func(*uint16) (bool, error), list []*uint16) ([]*uint16, error)

TakeWhileUint16PtrErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type *uint16 and returns ([]*uint16, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileUint32 

func TakeWhileUint32(f func(uint32) bool, list []uint32) []uint32

TakeWhileUint32 returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

Example: 

fp.TakeWhileUint32(isEven, []uint32{4, 2, 4, 7, 5}) // Returns: [4, 2, 4]

func isEven(num uint32) bool {
	return num%2 == 0
}

func TakeWhileUint32Err 

func TakeWhileUint32Err(f func(uint32) (bool, error), list []uint32) ([]uint32, error)

TakeWhileUint32Err returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type uint32 and returns ([]uint32, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileUint32Ptr 

func TakeWhileUint32Ptr(f func(*uint32) bool, list []*uint32) []*uint32

TakeWhileUint32Ptr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileUint32PtrErr 

func TakeWhileUint32PtrErr(f func(*uint32) (bool, error), list []*uint32) ([]*uint32, error)

TakeWhileUint32PtrErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type *uint32 and returns ([]*uint32, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileUint64 

func TakeWhileUint64(f func(uint64) bool, list []uint64) []uint64

TakeWhileUint64 returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

Example: 

fp.TakeWhileUint64(isEven, []uint64{4, 2, 4, 7, 5}) // Returns: [4, 2, 4]

func isEven(num uint64) bool {
	return num%2 == 0
}

func TakeWhileUint64Err 

func TakeWhileUint64Err(f func(uint64) (bool, error), list []uint64) ([]uint64, error)

TakeWhileUint64Err returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type uint64 and returns ([]uint64, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileUint64Ptr 

func TakeWhileUint64Ptr(f func(*uint64) bool, list []*uint64) []*uint64

TakeWhileUint64Ptr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileUint64PtrErr 

func TakeWhileUint64PtrErr(f func(*uint64) (bool, error), list []*uint64) ([]*uint64, error)

TakeWhileUint64PtrErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type *uint64 and returns ([]*uint64, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileUint8 

func TakeWhileUint8(f func(uint8) bool, list []uint8) []uint8

TakeWhileUint8 returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

Example: 

fp.TakeWhileUint8(isEven, []uint8{4, 2, 4, 7, 5}) // Returns: [4, 2, 4]

func isEven(num uint8) bool {
	return num%2 == 0
}

func TakeWhileUint8Err 

func TakeWhileUint8Err(f func(uint8) (bool, error), list []uint8) ([]uint8, error)

TakeWhileUint8Err returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type uint8 and returns ([]uint8, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileUint8Ptr 

func TakeWhileUint8Ptr(f func(*uint8) bool, list []*uint8) []*uint8

TakeWhileUint8Ptr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileUint8PtrErr 

func TakeWhileUint8PtrErr(f func(*uint8) (bool, error), list []*uint8) ([]*uint8, error)

TakeWhileUint8PtrErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type *uint8 and returns ([]*uint8, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileUintErr 

func TakeWhileUintErr(f func(uint) (bool, error), list []uint) ([]uint, error)

TakeWhileUintErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type uint and returns ([]uint, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileUintPtr 

func TakeWhileUintPtr(f func(*uint) bool, list []*uint) []*uint

TakeWhileUintPtr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function
  2. List

Returns: 

New List.
Empty list if all the parameters are nil or either of one parameter is nil

func TakeWhileUintPtrErr 

func TakeWhileUintPtrErr(f func(*uint) (bool, error), list []*uint) ([]*uint, error)

TakeWhileUintPtrErr returns new list based on condition in the supplied function. It returns new list once condition fails.

Takes 2 inputs:

  1. Function - 1 input of type *uint and returns ([]*uint, error)
  2. List

Returns: 

New List, error.
Empty list if all the parameters are nil or either of one parameter is nil

func True 

func True() bool

True returns true

func UnionBool 

func UnionBool(arrList ...[]bool) []bool

UnionBool return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionBoolPtr 

func UnionBoolPtr(arrList ...[]*bool) []*bool

UnionBoolPtr return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionFloat32 

func UnionFloat32(arrList ...[]float32) []float32

UnionFloat32 return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionFloat32Ptr 

func UnionFloat32Ptr(arrList ...[]*float32) []*float32

UnionFloat32Ptr return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionFloat64 

func UnionFloat64(arrList ...[]float64) []float64

UnionFloat64 return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionFloat64Ptr 

func UnionFloat64Ptr(arrList ...[]*float64) []*float64

UnionFloat64Ptr return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionInt 

func UnionInt(arrList ...[]int) []int

UnionInt return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionInt16 

func UnionInt16(arrList ...[]int16) []int16

UnionInt16 return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionInt16Ptr 

func UnionInt16Ptr(arrList ...[]*int16) []*int16

UnionInt16Ptr return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionInt32 

func UnionInt32(arrList ...[]int32) []int32

UnionInt32 return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionInt32Ptr 

func UnionInt32Ptr(arrList ...[]*int32) []*int32

UnionInt32Ptr return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionInt64 

func UnionInt64(arrList ...[]int64) []int64

UnionInt64 return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionInt64Ptr 

func UnionInt64Ptr(arrList ...[]*int64) []*int64

UnionInt64Ptr return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionInt8 

func UnionInt8(arrList ...[]int8) []int8

UnionInt8 return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionInt8Ptr 

func UnionInt8Ptr(arrList ...[]*int8) []*int8

UnionInt8Ptr return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionIntPtr 

func UnionIntPtr(arrList ...[]*int) []*int

UnionIntPtr return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionStr 

func UnionStr(arrList ...[]string) []string

UnionStr return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionStrPtr 

func UnionStrPtr(arrList ...[]*string) []*string

UnionStrPtr return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionUint 

func UnionUint(arrList ...[]uint) []uint

UnionUint return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionUint16 

func UnionUint16(arrList ...[]uint16) []uint16

UnionUint16 return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionUint16Ptr 

func UnionUint16Ptr(arrList ...[]*uint16) []*uint16

UnionUint16Ptr return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionUint32 

func UnionUint32(arrList ...[]uint32) []uint32

UnionUint32 return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionUint32Ptr 

func UnionUint32Ptr(arrList ...[]*uint32) []*uint32

UnionUint32Ptr return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionUint64 

func UnionUint64(arrList ...[]uint64) []uint64

UnionUint64 return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionUint64Ptr 

func UnionUint64Ptr(arrList ...[]*uint64) []*uint64

UnionUint64Ptr return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionUint8 

func UnionUint8(arrList ...[]uint8) []uint8

UnionUint8 return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionUint8Ptr 

func UnionUint8Ptr(arrList ...[]*uint8) []*uint8

UnionUint8Ptr return a set that is the union of the input sets repeated value within list parameter will be ignored

func UnionUintPtr 

func UnionUintPtr(arrList ...[]*uint) []*uint

UnionUintPtr return a set that is the union of the input sets repeated value within list parameter will be ignored

func ZeroFloat32P 

func ZeroFloat32P(v float32) bool

ZeroFloat32P Returns true if num is zero, else false

func ZeroFloat32PPtr 

func ZeroFloat32PPtr(v *float32) bool

ZeroFloat32PPtr Returns true if num is zero, else false

func ZeroFloat64P 

func ZeroFloat64P(v float64) bool

ZeroFloat64P Returns true if num is zero, else false

func ZeroFloat64PPtr 

func ZeroFloat64PPtr(v *float64) bool

ZeroFloat64PPtr Returns true if num is zero, else false

func ZeroInt16P 

func ZeroInt16P(v int16) bool

ZeroInt16P Returns true if num is zero, else false

func ZeroInt16PPtr 

func ZeroInt16PPtr(v *int16) bool

ZeroInt16PPtr Returns true if num is zero, else false

func ZeroInt32P 

func ZeroInt32P(v int32) bool

ZeroInt32P Returns true if num is zero, else false

func ZeroInt32PPtr 

func ZeroInt32PPtr(v *int32) bool

ZeroInt32PPtr Returns true if num is zero, else false

func ZeroInt64P 

func ZeroInt64P(v int64) bool

ZeroInt64P Returns true if num is zero, else false

func ZeroInt64PPtr 

func ZeroInt64PPtr(v *int64) bool

ZeroInt64PPtr Returns true if num is zero, else false

func ZeroInt8P 

func ZeroInt8P(v int8) bool

ZeroInt8P Returns true if num is zero, else false

func ZeroInt8PPtr 

func ZeroInt8PPtr(v *int8) bool

ZeroInt8PPtr Returns true if num is zero, else false

func ZeroIntP 

func ZeroIntP(v int) bool

ZeroIntP Returns true if num is zero, else false

func ZeroIntPPtr 

func ZeroIntPPtr(v *int) bool

ZeroIntPPtr Returns true if num is zero, else false

func ZeroUint16P 

func ZeroUint16P(v uint16) bool

ZeroUint16P Returns true if num is zero, else false

func ZeroUint16PPtr 

func ZeroUint16PPtr(v *uint16) bool

ZeroUint16PPtr Returns true if num is zero, else false

func ZeroUint32P 

func ZeroUint32P(v uint32) bool

ZeroUint32P Returns true if num is zero, else false

func ZeroUint32PPtr 

func ZeroUint32PPtr(v *uint32) bool

ZeroUint32PPtr Returns true if num is zero, else false

func ZeroUint64P 

func ZeroUint64P(v uint64) bool

ZeroUint64P Returns true if num is zero, else false

func ZeroUint64PPtr 

func ZeroUint64PPtr(v *uint64) bool

ZeroUint64PPtr Returns true if num is zero, else false

func ZeroUint8P 

func ZeroUint8P(v uint8) bool

ZeroUint8P Returns true if num is zero, else false

func ZeroUint8PPtr 

func ZeroUint8PPtr(v *uint8) bool

ZeroUint8PPtr Returns true if num is zero, else false

func ZeroUintP 

func ZeroUintP(v uint) bool

ZeroUintP Returns true if num is zero, else false

func ZeroUintPPtr 

func ZeroUintPPtr(v *uint) bool

ZeroUintPPtr Returns true if num is zero, else false

func ZipBool 

func ZipBool(list1 []bool, list2 []bool) map[bool]bool

ZipBool takes two inputs: first list of type: []bool, second list of type: []bool. Then it merges two list and returns a new map of type: map[bool]bool

func ZipBoolFloat32 

func ZipBoolFloat32(list1 []bool, list2 []float32) map[bool]float32

ZipBoolFloat32 takes two inputs: first list of type: []bool, second list of type: []float32. Then it merges two list and returns a new map of type: map[bool]float32

func ZipBoolFloat32Ptr 

func ZipBoolFloat32Ptr(list1 []*bool, list2 []*float32) map[*bool]*float32

ZipBoolFloat32Ptr takes two inputs: first list of type: []bool, second list of type: []float32. Then it merges two list and returns a new map of type: map[bool]float32

func ZipBoolFloat64 

func ZipBoolFloat64(list1 []bool, list2 []float64) map[bool]float64

ZipBoolFloat64 takes two inputs: first list of type: []bool, second list of type: []float64. Then it merges two list and returns a new map of type: map[bool]float64

func ZipBoolFloat64Ptr 

func ZipBoolFloat64Ptr(list1 []*bool, list2 []*float64) map[*bool]*float64

ZipBoolFloat64Ptr takes two inputs: first list of type: []bool, second list of type: []float64. Then it merges two list and returns a new map of type: map[bool]float64

func ZipBoolInt 

func ZipBoolInt(list1 []bool, list2 []int) map[bool]int

ZipBoolInt takes two inputs: first list of type: []bool, second list of type: []int. Then it merges two list and returns a new map of type: map[bool]int

func ZipBoolInt16 

func ZipBoolInt16(list1 []bool, list2 []int16) map[bool]int16

ZipBoolInt16 takes two inputs: first list of type: []bool, second list of type: []int16. Then it merges two list and returns a new map of type: map[bool]int16

func ZipBoolInt16Ptr 

func ZipBoolInt16Ptr(list1 []*bool, list2 []*int16) map[*bool]*int16

ZipBoolInt16Ptr takes two inputs: first list of type: []bool, second list of type: []int16. Then it merges two list and returns a new map of type: map[bool]int16

func ZipBoolInt32 

func ZipBoolInt32(list1 []bool, list2 []int32) map[bool]int32

ZipBoolInt32 takes two inputs: first list of type: []bool, second list of type: []int32. Then it merges two list and returns a new map of type: map[bool]int32

func ZipBoolInt32Ptr 

func ZipBoolInt32Ptr(list1 []*bool, list2 []*int32) map[*bool]*int32

ZipBoolInt32Ptr takes two inputs: first list of type: []bool, second list of type: []int32. Then it merges two list and returns a new map of type: map[bool]int32

func ZipBoolInt64 

func ZipBoolInt64(list1 []bool, list2 []int64) map[bool]int64

ZipBoolInt64 takes two inputs: first list of type: []bool, second list of type: []int64. Then it merges two list and returns a new map of type: map[bool]int64

func ZipBoolInt64Ptr 

func ZipBoolInt64Ptr(list1 []*bool, list2 []*int64) map[*bool]*int64

ZipBoolInt64Ptr takes two inputs: first list of type: []bool, second list of type: []int64. Then it merges two list and returns a new map of type: map[bool]int64

func ZipBoolInt8 

func ZipBoolInt8(list1 []bool, list2 []int8) map[bool]int8

ZipBoolInt8 takes two inputs: first list of type: []bool, second list of type: []int8. Then it merges two list and returns a new map of type: map[bool]int8

func ZipBoolInt8Ptr 

func ZipBoolInt8Ptr(list1 []*bool, list2 []*int8) map[*bool]*int8

ZipBoolInt8Ptr takes two inputs: first list of type: []bool, second list of type: []int8. Then it merges two list and returns a new map of type: map[bool]int8

func ZipBoolIntPtr 

func ZipBoolIntPtr(list1 []*bool, list2 []*int) map[*bool]*int

ZipBoolIntPtr takes two inputs: first list of type: []bool, second list of type: []int. Then it merges two list and returns a new map of type: map[bool]int

func ZipBoolPtr 

func ZipBoolPtr(list1 []*bool, list2 []*bool) map[*bool]*bool

ZipBoolPtr takes two inputs: first list of type: []bool, second list of type: []bool. Then it merges two list and returns a new map of type: map[bool]bool

func ZipBoolStr 

func ZipBoolStr(list1 []bool, list2 []string) map[bool]string

ZipBoolStr takes two inputs: first list of type: []bool, second list of type: []string. Then it merges two list and returns a new map of type: map[bool]string

func ZipBoolStrPtr 

func ZipBoolStrPtr(list1 []*bool, list2 []*string) map[*bool]*string

ZipBoolStrPtr takes two inputs: first list of type: []bool, second list of type: []string. Then it merges two list and returns a new map of type: map[bool]string

func ZipBoolUint 

func ZipBoolUint(list1 []bool, list2 []uint) map[bool]uint

ZipBoolUint takes two inputs: first list of type: []bool, second list of type: []uint. Then it merges two list and returns a new map of type: map[bool]uint

func ZipBoolUint16 

func ZipBoolUint16(list1 []bool, list2 []uint16) map[bool]uint16

ZipBoolUint16 takes two inputs: first list of type: []bool, second list of type: []uint16. Then it merges two list and returns a new map of type: map[bool]uint16

func ZipBoolUint16Ptr 

func ZipBoolUint16Ptr(list1 []*bool, list2 []*uint16) map[*bool]*uint16

ZipBoolUint16Ptr takes two inputs: first list of type: []bool, second list of type: []uint16. Then it merges two list and returns a new map of type: map[bool]uint16

func ZipBoolUint32 

func ZipBoolUint32(list1 []bool, list2 []uint32) map[bool]uint32

ZipBoolUint32 takes two inputs: first list of type: []bool, second list of type: []uint32. Then it merges two list and returns a new map of type: map[bool]uint32

func ZipBoolUint32Ptr 

func ZipBoolUint32Ptr(list1 []*bool, list2 []*uint32) map[*bool]*uint32

ZipBoolUint32Ptr takes two inputs: first list of type: []bool, second list of type: []uint32. Then it merges two list and returns a new map of type: map[bool]uint32

func ZipBoolUint64 

func ZipBoolUint64(list1 []bool, list2 []uint64) map[bool]uint64

ZipBoolUint64 takes two inputs: first list of type: []bool, second list of type: []uint64. Then it merges two list and returns a new map of type: map[bool]uint64

func ZipBoolUint64Ptr 

func ZipBoolUint64Ptr(list1 []*bool, list2 []*uint64) map[*bool]*uint64

ZipBoolUint64Ptr takes two inputs: first list of type: []bool, second list of type: []uint64. Then it merges two list and returns a new map of type: map[bool]uint64

func ZipBoolUint8 

func ZipBoolUint8(list1 []bool, list2 []uint8) map[bool]uint8

ZipBoolUint8 takes two inputs: first list of type: []bool, second list of type: []uint8. Then it merges two list and returns a new map of type: map[bool]uint8

func ZipBoolUint8Ptr 

func ZipBoolUint8Ptr(list1 []*bool, list2 []*uint8) map[*bool]*uint8

ZipBoolUint8Ptr takes two inputs: first list of type: []bool, second list of type: []uint8. Then it merges two list and returns a new map of type: map[bool]uint8

func ZipBoolUintPtr 

func ZipBoolUintPtr(list1 []*bool, list2 []*uint) map[*bool]*uint

ZipBoolUintPtr takes two inputs: first list of type: []bool, second list of type: []uint. Then it merges two list and returns a new map of type: map[bool]uint

func ZipFloat32 

func ZipFloat32(list1 []float32, list2 []float32) map[float32]float32

ZipFloat32 takes two inputs: first list of type: []float32, second list of type: []float32. Then it merges two list and returns a new map of type: map[float32]float32

func ZipFloat32Bool 

func ZipFloat32Bool(list1 []float32, list2 []bool) map[float32]bool

ZipFloat32Bool takes two inputs: first list of type: []float32, second list of type: []bool. Then it merges two list and returns a new map of type: map[float32]bool

func ZipFloat32BoolPtr 

func ZipFloat32BoolPtr(list1 []*float32, list2 []*bool) map[*float32]*bool

ZipFloat32BoolPtr takes two inputs: first list of type: []float32, second list of type: []bool. Then it merges two list and returns a new map of type: map[float32]bool

func ZipFloat32Float64 

func ZipFloat32Float64(list1 []float32, list2 []float64) map[float32]float64

ZipFloat32Float64 takes two inputs: first list of type: []float32, second list of type: []float64. Then it merges two list and returns a new map of type: map[float32]float64

func ZipFloat32Float64Ptr 

func ZipFloat32Float64Ptr(list1 []*float32, list2 []*float64) map[*float32]*float64

ZipFloat32Float64Ptr takes two inputs: first list of type: []float32, second list of type: []float64. Then it merges two list and returns a new map of type: map[float32]float64

func ZipFloat32Int 

func ZipFloat32Int(list1 []float32, list2 []int) map[float32]int

ZipFloat32Int takes two inputs: first list of type: []float32, second list of type: []int. Then it merges two list and returns a new map of type: map[float32]int

func ZipFloat32Int16 

func ZipFloat32Int16(list1 []float32, list2 []int16) map[float32]int16

ZipFloat32Int16 takes two inputs: first list of type: []float32, second list of type: []int16. Then it merges two list and returns a new map of type: map[float32]int16

func ZipFloat32Int16Ptr 

func ZipFloat32Int16Ptr(list1 []*float32, list2 []*int16) map[*float32]*int16

ZipFloat32Int16Ptr takes two inputs: first list of type: []float32, second list of type: []int16. Then it merges two list and returns a new map of type: map[float32]int16

func ZipFloat32Int32 

func ZipFloat32Int32(list1 []float32, list2 []int32) map[float32]int32

ZipFloat32Int32 takes two inputs: first list of type: []float32, second list of type: []int32. Then it merges two list and returns a new map of type: map[float32]int32

func ZipFloat32Int32Ptr 

func ZipFloat32Int32Ptr(list1 []*float32, list2 []*int32) map[*float32]*int32

ZipFloat32Int32Ptr takes two inputs: first list of type: []float32, second list of type: []int32. Then it merges two list and returns a new map of type: map[float32]int32

func ZipFloat32Int64 

func ZipFloat32Int64(list1 []float32, list2 []int64) map[float32]int64

ZipFloat32Int64 takes two inputs: first list of type: []float32, second list of type: []int64. Then it merges two list and returns a new map of type: map[float32]int64

func ZipFloat32Int64Ptr 

func ZipFloat32Int64Ptr(list1 []*float32, list2 []*int64) map[*float32]*int64

ZipFloat32Int64Ptr takes two inputs: first list of type: []float32, second list of type: []int64. Then it merges two list and returns a new map of type: map[float32]int64

func ZipFloat32Int8 

func ZipFloat32Int8(list1 []float32, list2 []int8) map[float32]int8

ZipFloat32Int8 takes two inputs: first list of type: []float32, second list of type: []int8. Then it merges two list and returns a new map of type: map[float32]int8

func ZipFloat32Int8Ptr 

func ZipFloat32Int8Ptr(list1 []*float32, list2 []*int8) map[*float32]*int8

ZipFloat32Int8Ptr takes two inputs: first list of type: []float32, second list of type: []int8. Then it merges two list and returns a new map of type: map[float32]int8

func ZipFloat32IntPtr 

func ZipFloat32IntPtr(list1 []*float32, list2 []*int) map[*float32]*int

ZipFloat32IntPtr takes two inputs: first list of type: []float32, second list of type: []int. Then it merges two list and returns a new map of type: map[float32]int

func ZipFloat32Ptr 

func ZipFloat32Ptr(list1 []*float32, list2 []*float32) map[*float32]*float32

ZipFloat32Ptr takes two inputs: first list of type: []float32, second list of type: []float32. Then it merges two list and returns a new map of type: map[float32]float32

func ZipFloat32Str 

func ZipFloat32Str(list1 []float32, list2 []string) map[float32]string

ZipFloat32Str takes two inputs: first list of type: []float32, second list of type: []string. Then it merges two list and returns a new map of type: map[float32]string

func ZipFloat32StrPtr 

func ZipFloat32StrPtr(list1 []*float32, list2 []*string) map[*float32]*string

ZipFloat32StrPtr takes two inputs: first list of type: []float32, second list of type: []string. Then it merges two list and returns a new map of type: map[float32]string

func ZipFloat32Uint 

func ZipFloat32Uint(list1 []float32, list2 []uint) map[float32]uint

ZipFloat32Uint takes two inputs: first list of type: []float32, second list of type: []uint. Then it merges two list and returns a new map of type: map[float32]uint

func ZipFloat32Uint16 

func ZipFloat32Uint16(list1 []float32, list2 []uint16) map[float32]uint16

ZipFloat32Uint16 takes two inputs: first list of type: []float32, second list of type: []uint16. Then it merges two list and returns a new map of type: map[float32]uint16

func ZipFloat32Uint16Ptr 

func ZipFloat32Uint16Ptr(list1 []*float32, list2 []*uint16) map[*float32]*uint16

ZipFloat32Uint16Ptr takes two inputs: first list of type: []float32, second list of type: []uint16. Then it merges two list and returns a new map of type: map[float32]uint16

func ZipFloat32Uint32 

func ZipFloat32Uint32(list1 []float32, list2 []uint32) map[float32]uint32

ZipFloat32Uint32 takes two inputs: first list of type: []float32, second list of type: []uint32. Then it merges two list and returns a new map of type: map[float32]uint32

func ZipFloat32Uint32Ptr 

func ZipFloat32Uint32Ptr(list1 []*float32, list2 []*uint32) map[*float32]*uint32

ZipFloat32Uint32Ptr takes two inputs: first list of type: []float32, second list of type: []uint32. Then it merges two list and returns a new map of type: map[float32]uint32

func ZipFloat32Uint64 

func ZipFloat32Uint64(list1 []float32, list2 []uint64) map[float32]uint64

ZipFloat32Uint64 takes two inputs: first list of type: []float32, second list of type: []uint64. Then it merges two list and returns a new map of type: map[float32]uint64

func ZipFloat32Uint64Ptr 

func ZipFloat32Uint64Ptr(list1 []*float32, list2 []*uint64) map[*float32]*uint64

ZipFloat32Uint64Ptr takes two inputs: first list of type: []float32, second list of type: []uint64. Then it merges two list and returns a new map of type: map[float32]uint64

func ZipFloat32Uint8 

func ZipFloat32Uint8(list1 []float32, list2 []uint8) map[float32]uint8

ZipFloat32Uint8 takes two inputs: first list of type: []float32, second list of type: []uint8. Then it merges two list and returns a new map of type: map[float32]uint8

func ZipFloat32Uint8Ptr 

func ZipFloat32Uint8Ptr(list1 []*float32, list2 []*uint8) map[*float32]*uint8

ZipFloat32Uint8Ptr takes two inputs: first list of type: []float32, second list of type: []uint8. Then it merges two list and returns a new map of type: map[float32]uint8

func ZipFloat32UintPtr 

func ZipFloat32UintPtr(list1 []*float32, list2 []*uint) map[*float32]*uint

ZipFloat32UintPtr takes two inputs: first list of type: []float32, second list of type: []uint. Then it merges two list and returns a new map of type: map[float32]uint

func ZipFloat64 

func ZipFloat64(list1 []float64, list2 []float64) map[float64]float64

ZipFloat64 takes two inputs: first list of type: []float64, second list of type: []float64. Then it merges two list and returns a new map of type: map[float64]float64

func ZipFloat64Bool 

func ZipFloat64Bool(list1 []float64, list2 []bool) map[float64]bool

ZipFloat64Bool takes two inputs: first list of type: []float64, second list of type: []bool. Then it merges two list and returns a new map of type: map[float64]bool

func ZipFloat64BoolPtr 

func ZipFloat64BoolPtr(list1 []*float64, list2 []*bool) map[*float64]*bool

ZipFloat64BoolPtr takes two inputs: first list of type: []float64, second list of type: []bool. Then it merges two list and returns a new map of type: map[float64]bool

func ZipFloat64Float32 

func ZipFloat64Float32(list1 []float64, list2 []float32) map[float64]float32

ZipFloat64Float32 takes two inputs: first list of type: []float64, second list of type: []float32. Then it merges two list and returns a new map of type: map[float64]float32

func ZipFloat64Float32Ptr 

func ZipFloat64Float32Ptr(list1 []*float64, list2 []*float32) map[*float64]*float32

ZipFloat64Float32Ptr takes two inputs: first list of type: []float64, second list of type: []float32. Then it merges two list and returns a new map of type: map[float64]float32

func ZipFloat64Int 

func ZipFloat64Int(list1 []float64, list2 []int) map[float64]int

ZipFloat64Int takes two inputs: first list of type: []float64, second list of type: []int. Then it merges two list and returns a new map of type: map[float64]int

func ZipFloat64Int16 

func ZipFloat64Int16(list1 []float64, list2 []int16) map[float64]int16

ZipFloat64Int16 takes two inputs: first list of type: []float64, second list of type: []int16. Then it merges two list and returns a new map of type: map[float64]int16

func ZipFloat64Int16Ptr 

func ZipFloat64Int16Ptr(list1 []*float64, list2 []*int16) map[*float64]*int16

ZipFloat64Int16Ptr takes two inputs: first list of type: []float64, second list of type: []int16. Then it merges two list and returns a new map of type: map[float64]int16

func ZipFloat64Int32 

func ZipFloat64Int32(list1 []float64, list2 []int32) map[float64]int32

ZipFloat64Int32 takes two inputs: first list of type: []float64, second list of type: []int32. Then it merges two list and returns a new map of type: map[float64]int32

func ZipFloat64Int32Ptr 

func ZipFloat64Int32Ptr(list1 []*float64, list2 []*int32) map[*float64]*int32

ZipFloat64Int32Ptr takes two inputs: first list of type: []float64, second list of type: []int32. Then it merges two list and returns a new map of type: map[float64]int32

func ZipFloat64Int64 

func ZipFloat64Int64(list1 []float64, list2 []int64) map[float64]int64

ZipFloat64Int64 takes two inputs: first list of type: []float64, second list of type: []int64. Then it merges two list and returns a new map of type: map[float64]int64

func ZipFloat64Int64Ptr 

func ZipFloat64Int64Ptr(list1 []*float64, list2 []*int64) map[*float64]*int64

ZipFloat64Int64Ptr takes two inputs: first list of type: []float64, second list of type: []int64. Then it merges two list and returns a new map of type: map[float64]int64

func ZipFloat64Int8 

func ZipFloat64Int8(list1 []float64, list2 []int8) map[float64]int8

ZipFloat64Int8 takes two inputs: first list of type: []float64, second list of type: []int8. Then it merges two list and returns a new map of type: map[float64]int8

func ZipFloat64Int8Ptr 

func ZipFloat64Int8Ptr(list1 []*float64, list2 []*int8) map[*float64]*int8

ZipFloat64Int8Ptr takes two inputs: first list of type: []float64, second list of type: []int8. Then it merges two list and returns a new map of type: map[float64]int8

func ZipFloat64IntPtr 

func ZipFloat64IntPtr(list1 []*float64, list2 []*int) map[*float64]*int

ZipFloat64IntPtr takes two inputs: first list of type: []float64, second list of type: []int. Then it merges two list and returns a new map of type: map[float64]int

func ZipFloat64Ptr 

func ZipFloat64Ptr(list1 []*float64, list2 []*float64) map[*float64]*float64

ZipFloat64Ptr takes two inputs: first list of type: []float64, second list of type: []float64. Then it merges two list and returns a new map of type: map[float64]float64

func ZipFloat64Str 

func ZipFloat64Str(list1 []float64, list2 []string) map[float64]string

ZipFloat64Str takes two inputs: first list of type: []float64, second list of type: []string. Then it merges two list and returns a new map of type: map[float64]string

func ZipFloat64StrPtr 

func ZipFloat64StrPtr(list1 []*float64, list2 []*string) map[*float64]*string

ZipFloat64StrPtr takes two inputs: first list of type: []float64, second list of type: []string. Then it merges two list and returns a new map of type: map[float64]string

func ZipFloat64Uint 

func ZipFloat64Uint(list1 []float64, list2 []uint) map[float64]uint

ZipFloat64Uint takes two inputs: first list of type: []float64, second list of type: []uint. Then it merges two list and returns a new map of type: map[float64]uint

func ZipFloat64Uint16 

func ZipFloat64Uint16(list1 []float64, list2 []uint16) map[float64]uint16

ZipFloat64Uint16 takes two inputs: first list of type: []float64, second list of type: []uint16. Then it merges two list and returns a new map of type: map[float64]uint16

func ZipFloat64Uint16Ptr 

func ZipFloat64Uint16Ptr(list1 []*float64, list2 []*uint16) map[*float64]*uint16

ZipFloat64Uint16Ptr takes two inputs: first list of type: []float64, second list of type: []uint16. Then it merges two list and returns a new map of type: map[float64]uint16

func ZipFloat64Uint32 

func ZipFloat64Uint32(list1 []float64, list2 []uint32) map[float64]uint32

ZipFloat64Uint32 takes two inputs: first list of type: []float64, second list of type: []uint32. Then it merges two list and returns a new map of type: map[float64]uint32

func ZipFloat64Uint32Ptr 

func ZipFloat64Uint32Ptr(list1 []*float64, list2 []*uint32) map[*float64]*uint32

ZipFloat64Uint32Ptr takes two inputs: first list of type: []float64, second list of type: []uint32. Then it merges two list and returns a new map of type: map[float64]uint32

func ZipFloat64Uint64 

func ZipFloat64Uint64(list1 []float64, list2 []uint64) map[float64]uint64

ZipFloat64Uint64 takes two inputs: first list of type: []float64, second list of type: []uint64. Then it merges two list and returns a new map of type: map[float64]uint64

func ZipFloat64Uint64Ptr 

func ZipFloat64Uint64Ptr(list1 []*float64, list2 []*uint64) map[*float64]*uint64

ZipFloat64Uint64Ptr takes two inputs: first list of type: []float64, second list of type: []uint64. Then it merges two list and returns a new map of type: map[float64]uint64

func ZipFloat64Uint8 

func ZipFloat64Uint8(list1 []float64, list2 []uint8) map[float64]uint8

ZipFloat64Uint8 takes two inputs: first list of type: []float64, second list of type: []uint8. Then it merges two list and returns a new map of type: map[float64]uint8

func ZipFloat64Uint8Ptr 

func ZipFloat64Uint8Ptr(list1 []*float64, list2 []*uint8) map[*float64]*uint8

ZipFloat64Uint8Ptr takes two inputs: first list of type: []float64, second list of type: []uint8. Then it merges two list and returns a new map of type: map[float64]uint8

func ZipFloat64UintPtr 

func ZipFloat64UintPtr(list1 []*float64, list2 []*uint) map[*float64]*uint

ZipFloat64UintPtr takes two inputs: first list of type: []float64, second list of type: []uint. Then it merges two list and returns a new map of type: map[float64]uint

func ZipInt 

func ZipInt(list1 []int, list2 []int) map[int]int

ZipInt takes two inputs: first list of type: []int, second list of type: []int. Then it merges two list and returns a new map of type: map[int]int

func ZipInt16 

func ZipInt16(list1 []int16, list2 []int16) map[int16]int16

ZipInt16 takes two inputs: first list of type: []int16, second list of type: []int16. Then it merges two list and returns a new map of type: map[int16]int16

func ZipInt16Bool 

func ZipInt16Bool(list1 []int16, list2 []bool) map[int16]bool

ZipInt16Bool takes two inputs: first list of type: []int16, second list of type: []bool. Then it merges two list and returns a new map of type: map[int16]bool

func ZipInt16BoolPtr 

func ZipInt16BoolPtr(list1 []*int16, list2 []*bool) map[*int16]*bool

ZipInt16BoolPtr takes two inputs: first list of type: []int16, second list of type: []bool. Then it merges two list and returns a new map of type: map[int16]bool

func ZipInt16Float32 

func ZipInt16Float32(list1 []int16, list2 []float32) map[int16]float32

ZipInt16Float32 takes two inputs: first list of type: []int16, second list of type: []float32. Then it merges two list and returns a new map of type: map[int16]float32

func ZipInt16Float32Ptr 

func ZipInt16Float32Ptr(list1 []*int16, list2 []*float32) map[*int16]*float32

ZipInt16Float32Ptr takes two inputs: first list of type: []int16, second list of type: []float32. Then it merges two list and returns a new map of type: map[int16]float32

func ZipInt16Float64 

func ZipInt16Float64(list1 []int16, list2 []float64) map[int16]float64

ZipInt16Float64 takes two inputs: first list of type: []int16, second list of type: []float64. Then it merges two list and returns a new map of type: map[int16]float64

func ZipInt16Float64Ptr 

func ZipInt16Float64Ptr(list1 []*int16, list2 []*float64) map[*int16]*float64

ZipInt16Float64Ptr takes two inputs: first list of type: []int16, second list of type: []float64. Then it merges two list and returns a new map of type: map[int16]float64

func ZipInt16Int 

func ZipInt16Int(list1 []int16, list2 []int) map[int16]int

ZipInt16Int takes two inputs: first list of type: []int16, second list of type: []int. Then it merges two list and returns a new map of type: map[int16]int

func ZipInt16Int32 

func ZipInt16Int32(list1 []int16, list2 []int32) map[int16]int32

ZipInt16Int32 takes two inputs: first list of type: []int16, second list of type: []int32. Then it merges two list and returns a new map of type: map[int16]int32

func ZipInt16Int32Ptr 

func ZipInt16Int32Ptr(list1 []*int16, list2 []*int32) map[*int16]*int32

ZipInt16Int32Ptr takes two inputs: first list of type: []int16, second list of type: []int32. Then it merges two list and returns a new map of type: map[int16]int32

func ZipInt16Int64 

func ZipInt16Int64(list1 []int16, list2 []int64) map[int16]int64

ZipInt16Int64 takes two inputs: first list of type: []int16, second list of type: []int64. Then it merges two list and returns a new map of type: map[int16]int64

func ZipInt16Int64Ptr 

func ZipInt16Int64Ptr(list1 []*int16, list2 []*int64) map[*int16]*int64

ZipInt16Int64Ptr takes two inputs: first list of type: []int16, second list of type: []int64. Then it merges two list and returns a new map of type: map[int16]int64

func ZipInt16Int8 

func ZipInt16Int8(list1 []int16, list2 []int8) map[int16]int8

ZipInt16Int8 takes two inputs: first list of type: []int16, second list of type: []int8. Then it merges two list and returns a new map of type: map[int16]int8

func ZipInt16Int8Ptr 

func ZipInt16Int8Ptr(list1 []*int16, list2 []*int8) map[*int16]*int8

ZipInt16Int8Ptr takes two inputs: first list of type: []int16, second list of type: []int8. Then it merges two list and returns a new map of type: map[int16]int8

func ZipInt16IntPtr 

func ZipInt16IntPtr(list1 []*int16, list2 []*int) map[*int16]*int

ZipInt16IntPtr takes two inputs: first list of type: []int16, second list of type: []int. Then it merges two list and returns a new map of type: map[int16]int

func ZipInt16Ptr 

func ZipInt16Ptr(list1 []*int16, list2 []*int16) map[*int16]*int16

ZipInt16Ptr takes two inputs: first list of type: []int16, second list of type: []int16. Then it merges two list and returns a new map of type: map[int16]int16

func ZipInt16Str 

func ZipInt16Str(list1 []int16, list2 []string) map[int16]string

ZipInt16Str takes two inputs: first list of type: []int16, second list of type: []string. Then it merges two list and returns a new map of type: map[int16]string

func ZipInt16StrPtr 

func ZipInt16StrPtr(list1 []*int16, list2 []*string) map[*int16]*string

ZipInt16StrPtr takes two inputs: first list of type: []int16, second list of type: []string. Then it merges two list and returns a new map of type: map[int16]string

func ZipInt16Uint 

func ZipInt16Uint(list1 []int16, list2 []uint) map[int16]uint

ZipInt16Uint takes two inputs: first list of type: []int16, second list of type: []uint. Then it merges two list and returns a new map of type: map[int16]uint

func ZipInt16Uint16 

func ZipInt16Uint16(list1 []int16, list2 []uint16) map[int16]uint16

ZipInt16Uint16 takes two inputs: first list of type: []int16, second list of type: []uint16. Then it merges two list and returns a new map of type: map[int16]uint16

func ZipInt16Uint16Ptr 

func ZipInt16Uint16Ptr(list1 []*int16, list2 []*uint16) map[*int16]*uint16

ZipInt16Uint16Ptr takes two inputs: first list of type: []int16, second list of type: []uint16. Then it merges two list and returns a new map of type: map[int16]uint16

func ZipInt16Uint32 

func ZipInt16Uint32(list1 []int16, list2 []uint32) map[int16]uint32

ZipInt16Uint32 takes two inputs: first list of type: []int16, second list of type: []uint32. Then it merges two list and returns a new map of type: map[int16]uint32

func ZipInt16Uint32Ptr 

func ZipInt16Uint32Ptr(list1 []*int16, list2 []*uint32) map[*int16]*uint32

ZipInt16Uint32Ptr takes two inputs: first list of type: []int16, second list of type: []uint32. Then it merges two list and returns a new map of type: map[int16]uint32

func ZipInt16Uint64 

func ZipInt16Uint64(list1 []int16, list2 []uint64) map[int16]uint64

ZipInt16Uint64 takes two inputs: first list of type: []int16, second list of type: []uint64. Then it merges two list and returns a new map of type: map[int16]uint64

func ZipInt16Uint64Ptr 

func ZipInt16Uint64Ptr(list1 []*int16, list2 []*uint64) map[*int16]*uint64

ZipInt16Uint64Ptr takes two inputs: first list of type: []int16, second list of type: []uint64. Then it merges two list and returns a new map of type: map[int16]uint64

func ZipInt16Uint8 

func ZipInt16Uint8(list1 []int16, list2 []uint8) map[int16]uint8

ZipInt16Uint8 takes two inputs: first list of type: []int16, second list of type: []uint8. Then it merges two list and returns a new map of type: map[int16]uint8

func ZipInt16Uint8Ptr 

func ZipInt16Uint8Ptr(list1 []*int16, list2 []*uint8) map[*int16]*uint8

ZipInt16Uint8Ptr takes two inputs: first list of type: []int16, second list of type: []uint8. Then it merges two list and returns a new map of type: map[int16]uint8

func ZipInt16UintPtr 

func ZipInt16UintPtr(list1 []*int16, list2 []*uint) map[*int16]*uint

ZipInt16UintPtr takes two inputs: first list of type: []int16, second list of type: []uint. Then it merges two list and returns a new map of type: map[int16]uint

func ZipInt32 

func ZipInt32(list1 []int32, list2 []int32) map[int32]int32

ZipInt32 takes two inputs: first list of type: []int32, second list of type: []int32. Then it merges two list and returns a new map of type: map[int32]int32

func ZipInt32Bool 

func ZipInt32Bool(list1 []int32, list2 []bool) map[int32]bool

ZipInt32Bool takes two inputs: first list of type: []int32, second list of type: []bool. Then it merges two list and returns a new map of type: map[int32]bool

func ZipInt32BoolPtr 

func ZipInt32BoolPtr(list1 []*int32, list2 []*bool) map[*int32]*bool

ZipInt32BoolPtr takes two inputs: first list of type: []int32, second list of type: []bool. Then it merges two list and returns a new map of type: map[int32]bool

func ZipInt32Float32 

func ZipInt32Float32(list1 []int32, list2 []float32) map[int32]float32

ZipInt32Float32 takes two inputs: first list of type: []int32, second list of type: []float32. Then it merges two list and returns a new map of type: map[int32]float32

func ZipInt32Float32Ptr 

func ZipInt32Float32Ptr(list1 []*int32, list2 []*float32) map[*int32]*float32

ZipInt32Float32Ptr takes two inputs: first list of type: []int32, second list of type: []float32. Then it merges two list and returns a new map of type: map[int32]float32

func ZipInt32Float64 

func ZipInt32Float64(list1 []int32, list2 []float64) map[int32]float64

ZipInt32Float64 takes two inputs: first list of type: []int32, second list of type: []float64. Then it merges two list and returns a new map of type: map[int32]float64

func ZipInt32Float64Ptr 

func ZipInt32Float64Ptr(list1 []*int32, list2 []*float64) map[*int32]*float64

ZipInt32Float64Ptr takes two inputs: first list of type: []int32, second list of type: []float64. Then it merges two list and returns a new map of type: map[int32]float64

func ZipInt32Int 

func ZipInt32Int(list1 []int32, list2 []int) map[int32]int

ZipInt32Int takes two inputs: first list of type: []int32, second list of type: []int. Then it merges two list and returns a new map of type: map[int32]int

func ZipInt32Int16 

func ZipInt32Int16(list1 []int32, list2 []int16) map[int32]int16

ZipInt32Int16 takes two inputs: first list of type: []int32, second list of type: []int16. Then it merges two list and returns a new map of type: map[int32]int16

func ZipInt32Int16Ptr 

func ZipInt32Int16Ptr(list1 []*int32, list2 []*int16) map[*int32]*int16

ZipInt32Int16Ptr takes two inputs: first list of type: []int32, second list of type: []int16. Then it merges two list and returns a new map of type: map[int32]int16

func ZipInt32Int64 

func ZipInt32Int64(list1 []int32, list2 []int64) map[int32]int64

ZipInt32Int64 takes two inputs: first list of type: []int32, second list of type: []int64. Then it merges two list and returns a new map of type: map[int32]int64

func ZipInt32Int64Ptr 

func ZipInt32Int64Ptr(list1 []*int32, list2 []*int64) map[*int32]*int64

ZipInt32Int64Ptr takes two inputs: first list of type: []int32, second list of type: []int64. Then it merges two list and returns a new map of type: map[int32]int64

func ZipInt32Int8 

func ZipInt32Int8(list1 []int32, list2 []int8) map[int32]int8

ZipInt32Int8 takes two inputs: first list of type: []int32, second list of type: []int8. Then it merges two list and returns a new map of type: map[int32]int8

func ZipInt32Int8Ptr 

func ZipInt32Int8Ptr(list1 []*int32, list2 []*int8) map[*int32]*int8

ZipInt32Int8Ptr takes two inputs: first list of type: []int32, second list of type: []int8. Then it merges two list and returns a new map of type: map[int32]int8

func ZipInt32IntPtr 

func ZipInt32IntPtr(list1 []*int32, list2 []*int) map[*int32]*int

ZipInt32IntPtr takes two inputs: first list of type: []int32, second list of type: []int. Then it merges two list and returns a new map of type: map[int32]int

func ZipInt32Ptr 

func ZipInt32Ptr(list1 []*int32, list2 []*int32) map[*int32]*int32

ZipInt32Ptr takes two inputs: first list of type: []int32, second list of type: []int32. Then it merges two list and returns a new map of type: map[int32]int32

func ZipInt32Str 

func ZipInt32Str(list1 []int32, list2 []string) map[int32]string

ZipInt32Str takes two inputs: first list of type: []int32, second list of type: []string. Then it merges two list and returns a new map of type: map[int32]string

func ZipInt32StrPtr 

func ZipInt32StrPtr(list1 []*int32, list2 []*string) map[*int32]*string

ZipInt32StrPtr takes two inputs: first list of type: []int32, second list of type: []string. Then it merges two list and returns a new map of type: map[int32]string

func ZipInt32Uint 

func ZipInt32Uint(list1 []int32, list2 []uint) map[int32]uint

ZipInt32Uint takes two inputs: first list of type: []int32, second list of type: []uint. Then it merges two list and returns a new map of type: map[int32]uint

func ZipInt32Uint16 

func ZipInt32Uint16(list1 []int32, list2 []uint16) map[int32]uint16

ZipInt32Uint16 takes two inputs: first list of type: []int32, second list of type: []uint16. Then it merges two list and returns a new map of type: map[int32]uint16

func ZipInt32Uint16Ptr 

func ZipInt32Uint16Ptr(list1 []*int32, list2 []*uint16) map[*int32]*uint16

ZipInt32Uint16Ptr takes two inputs: first list of type: []int32, second list of type: []uint16. Then it merges two list and returns a new map of type: map[int32]uint16

func ZipInt32Uint32 

func ZipInt32Uint32(list1 []int32, list2 []uint32) map[int32]uint32

ZipInt32Uint32 takes two inputs: first list of type: []int32, second list of type: []uint32. Then it merges two list and returns a new map of type: map[int32]uint32

func ZipInt32Uint32Ptr 

func ZipInt32Uint32Ptr(list1 []*int32, list2 []*uint32) map[*int32]*uint32

ZipInt32Uint32Ptr takes two inputs: first list of type: []int32, second list of type: []uint32. Then it merges two list and returns a new map of type: map[int32]uint32

func ZipInt32Uint64 

func ZipInt32Uint64(list1 []int32, list2 []uint64) map[int32]uint64

ZipInt32Uint64 takes two inputs: first list of type: []int32, second list of type: []uint64. Then it merges two list and returns a new map of type: map[int32]uint64

func ZipInt32Uint64Ptr 

func ZipInt32Uint64Ptr(list1 []*int32, list2 []*uint64) map[*int32]*uint64

ZipInt32Uint64Ptr takes two inputs: first list of type: []int32, second list of type: []uint64. Then it merges two list and returns a new map of type: map[int32]uint64

func ZipInt32Uint8 

func ZipInt32Uint8(list1 []int32, list2 []uint8) map[int32]uint8

ZipInt32Uint8 takes two inputs: first list of type: []int32, second list of type: []uint8. Then it merges two list and returns a new map of type: map[int32]uint8

func ZipInt32Uint8Ptr 

func ZipInt32Uint8Ptr(list1 []*int32, list2 []*uint8) map[*int32]*uint8

ZipInt32Uint8Ptr takes two inputs: first list of type: []int32, second list of type: []uint8. Then it merges two list and returns a new map of type: map[int32]uint8

func ZipInt32UintPtr 

func ZipInt32UintPtr(list1 []*int32, list2 []*uint) map[*int32]*uint

ZipInt32UintPtr takes two inputs: first list of type: []int32, second list of type: []uint. Then it merges two list and returns a new map of type: map[int32]uint

func ZipInt64 

func ZipInt64(list1 []int64, list2 []int64) map[int64]int64

ZipInt64 takes two inputs: first list of type: []int64, second list of type: []int64. Then it merges two list and returns a new map of type: map[int64]int64

func ZipInt64Bool 

func ZipInt64Bool(list1 []int64, list2 []bool) map[int64]bool

ZipInt64Bool takes two inputs: first list of type: []int64, second list of type: []bool. Then it merges two list and returns a new map of type: map[int64]bool

func ZipInt64BoolPtr 

func ZipInt64BoolPtr(list1 []*int64, list2 []*bool) map[*int64]*bool

ZipInt64BoolPtr takes two inputs: first list of type: []int64, second list of type: []bool. Then it merges two list and returns a new map of type: map[int64]bool

func ZipInt64Float32 

func ZipInt64Float32(list1 []int64, list2 []float32) map[int64]float32

ZipInt64Float32 takes two inputs: first list of type: []int64, second list of type: []float32. Then it merges two list and returns a new map of type: map[int64]float32

func ZipInt64Float32Ptr 

func ZipInt64Float32Ptr(list1 []*int64, list2 []*float32) map[*int64]*float32

ZipInt64Float32Ptr takes two inputs: first list of type: []int64, second list of type: []float32. Then it merges two list and returns a new map of type: map[int64]float32

func ZipInt64Float64 

func ZipInt64Float64(list1 []int64, list2 []float64) map[int64]float64

ZipInt64Float64 takes two inputs: first list of type: []int64, second list of type: []float64. Then it merges two list and returns a new map of type: map[int64]float64

func ZipInt64Float64Ptr 

func ZipInt64Float64Ptr(list1 []*int64, list2 []*float64) map[*int64]*float64

ZipInt64Float64Ptr takes two inputs: first list of type: []int64, second list of type: []float64. Then it merges two list and returns a new map of type: map[int64]float64

func ZipInt64Int 

func ZipInt64Int(list1 []int64, list2 []int) map[int64]int

ZipInt64Int takes two inputs: first list of type: []int64, second list of type: []int. Then it merges two list and returns a new map of type: map[int64]int

func ZipInt64Int16 

func ZipInt64Int16(list1 []int64, list2 []int16) map[int64]int16

ZipInt64Int16 takes two inputs: first list of type: []int64, second list of type: []int16. Then it merges two list and returns a new map of type: map[int64]int16

func ZipInt64Int16Ptr 

func ZipInt64Int16Ptr(list1 []*int64, list2 []*int16) map[*int64]*int16

ZipInt64Int16Ptr takes two inputs: first list of type: []int64, second list of type: []int16. Then it merges two list and returns a new map of type: map[int64]int16

func ZipInt64Int32 

func ZipInt64Int32(list1 []int64, list2 []int32) map[int64]int32

ZipInt64Int32 takes two inputs: first list of type: []int64, second list of type: []int32. Then it merges two list and returns a new map of type: map[int64]int32

func ZipInt64Int32Ptr 

func ZipInt64Int32Ptr(list1 []*int64, list2 []*int32) map[*int64]*int32

ZipInt64Int32Ptr takes two inputs: first list of type: []int64, second list of type: []int32. Then it merges two list and returns a new map of type: map[int64]int32

func ZipInt64Int8 

func ZipInt64Int8(list1 []int64, list2 []int8) map[int64]int8

ZipInt64Int8 takes two inputs: first list of type: []int64, second list of type: []int8. Then it merges two list and returns a new map of type: map[int64]int8

func ZipInt64Int8Ptr 

func ZipInt64Int8Ptr(list1 []*int64, list2 []*int8) map[*int64]*int8

ZipInt64Int8Ptr takes two inputs: first list of type: []int64, second list of type: []int8. Then it merges two list and returns a new map of type: map[int64]int8

func ZipInt64IntPtr 

func ZipInt64IntPtr(list1 []*int64, list2 []*int) map[*int64]*int

ZipInt64IntPtr takes two inputs: first list of type: []int64, second list of type: []int. Then it merges two list and returns a new map of type: map[int64]int

func ZipInt64Ptr 

func ZipInt64Ptr(list1 []*int64, list2 []*int64) map[*int64]*int64

ZipInt64Ptr takes two inputs: first list of type: []int64, second list of type: []int64. Then it merges two list and returns a new map of type: map[int64]int64

func ZipInt64Str 

func ZipInt64Str(list1 []int64, list2 []string) map[int64]string

ZipInt64Str takes two inputs: first list of type: []int64, second list of type: []string. Then it merges two list and returns a new map of type: map[int64]string

func ZipInt64StrPtr 

func ZipInt64StrPtr(list1 []*int64, list2 []*string) map[*int64]*string

ZipInt64StrPtr takes two inputs: first list of type: []int64, second list of type: []string. Then it merges two list and returns a new map of type: map[int64]string

func ZipInt64Uint 

func ZipInt64Uint(list1 []int64, list2 []uint) map[int64]uint

ZipInt64Uint takes two inputs: first list of type: []int64, second list of type: []uint. Then it merges two list and returns a new map of type: map[int64]uint

func ZipInt64Uint16 

func ZipInt64Uint16(list1 []int64, list2 []uint16) map[int64]uint16

ZipInt64Uint16 takes two inputs: first list of type: []int64, second list of type: []uint16. Then it merges two list and returns a new map of type: map[int64]uint16

func ZipInt64Uint16Ptr 

func ZipInt64Uint16Ptr(list1 []*int64, list2 []*uint16) map[*int64]*uint16

ZipInt64Uint16Ptr takes two inputs: first list of type: []int64, second list of type: []uint16. Then it merges two list and returns a new map of type: map[int64]uint16

func ZipInt64Uint32 

func ZipInt64Uint32(list1 []int64, list2 []uint32) map[int64]uint32

ZipInt64Uint32 takes two inputs: first list of type: []int64, second list of type: []uint32. Then it merges two list and returns a new map of type: map[int64]uint32

func ZipInt64Uint32Ptr 

func ZipInt64Uint32Ptr(list1 []*int64, list2 []*uint32) map[*int64]*uint32

ZipInt64Uint32Ptr takes two inputs: first list of type: []int64, second list of type: []uint32. Then it merges two list and returns a new map of type: map[int64]uint32

func ZipInt64Uint64 

func ZipInt64Uint64(list1 []int64, list2 []uint64) map[int64]uint64

ZipInt64Uint64 takes two inputs: first list of type: []int64, second list of type: []uint64. Then it merges two list and returns a new map of type: map[int64]uint64

func ZipInt64Uint64Ptr 

func ZipInt64Uint64Ptr(list1 []*int64, list2 []*uint64) map[*int64]*uint64

ZipInt64Uint64Ptr takes two inputs: first list of type: []int64, second list of type: []uint64. Then it merges two list and returns a new map of type: map[int64]uint64

func ZipInt64Uint8 

func ZipInt64Uint8(list1 []int64, list2 []uint8) map[int64]uint8

ZipInt64Uint8 takes two inputs: first list of type: []int64, second list of type: []uint8. Then it merges two list and returns a new map of type: map[int64]uint8

func ZipInt64Uint8Ptr 

func ZipInt64Uint8Ptr(list1 []*int64, list2 []*uint8) map[*int64]*uint8

ZipInt64Uint8Ptr takes two inputs: first list of type: []int64, second list of type: []uint8. Then it merges two list and returns a new map of type: map[int64]uint8

func ZipInt64UintPtr 

func ZipInt64UintPtr(list1 []*int64, list2 []*uint) map[*int64]*uint

ZipInt64UintPtr takes two inputs: first list of type: []int64, second list of type: []uint. Then it merges two list and returns a new map of type: map[int64]uint

func ZipInt8 

func ZipInt8(list1 []int8, list2 []int8) map[int8]int8

ZipInt8 takes two inputs: first list of type: []int8, second list of type: []int8. Then it merges two list and returns a new map of type: map[int8]int8

func ZipInt8Bool 

func ZipInt8Bool(list1 []int8, list2 []bool) map[int8]bool

ZipInt8Bool takes two inputs: first list of type: []int8, second list of type: []bool. Then it merges two list and returns a new map of type: map[int8]bool

func ZipInt8BoolPtr 

func ZipInt8BoolPtr(list1 []*int8, list2 []*bool) map[*int8]*bool

ZipInt8BoolPtr takes two inputs: first list of type: []int8, second list of type: []bool. Then it merges two list and returns a new map of type: map[int8]bool

func ZipInt8Float32 

func ZipInt8Float32(list1 []int8, list2 []float32) map[int8]float32

ZipInt8Float32 takes two inputs: first list of type: []int8, second list of type: []float32. Then it merges two list and returns a new map of type: map[int8]float32

func ZipInt8Float32Ptr 

func ZipInt8Float32Ptr(list1 []*int8, list2 []*float32) map[*int8]*float32

ZipInt8Float32Ptr takes two inputs: first list of type: []int8, second list of type: []float32. Then it merges two list and returns a new map of type: map[int8]float32

func ZipInt8Float64 

func ZipInt8Float64(list1 []int8, list2 []float64) map[int8]float64

ZipInt8Float64 takes two inputs: first list of type: []int8, second list of type: []float64. Then it merges two list and returns a new map of type: map[int8]float64

func ZipInt8Float64Ptr 

func ZipInt8Float64Ptr(list1 []*int8, list2 []*float64) map[*int8]*float64

ZipInt8Float64Ptr takes two inputs: first list of type: []int8, second list of type: []float64. Then it merges two list and returns a new map of type: map[int8]float64

func ZipInt8Int 

func ZipInt8Int(list1 []int8, list2 []int) map[int8]int

ZipInt8Int takes two inputs: first list of type: []int8, second list of type: []int. Then it merges two list and returns a new map of type: map[int8]int

func ZipInt8Int16 

func ZipInt8Int16(list1 []int8, list2 []int16) map[int8]int16

ZipInt8Int16 takes two inputs: first list of type: []int8, second list of type: []int16. Then it merges two list and returns a new map of type: map[int8]int16

func ZipInt8Int16Ptr 

func ZipInt8Int16Ptr(list1 []*int8, list2 []*int16) map[*int8]*int16

ZipInt8Int16Ptr takes two inputs: first list of type: []int8, second list of type: []int16. Then it merges two list and returns a new map of type: map[int8]int16

func ZipInt8Int32 

func ZipInt8Int32(list1 []int8, list2 []int32) map[int8]int32

ZipInt8Int32 takes two inputs: first list of type: []int8, second list of type: []int32. Then it merges two list and returns a new map of type: map[int8]int32

func ZipInt8Int32Ptr 

func ZipInt8Int32Ptr(list1 []*int8, list2 []*int32) map[*int8]*int32

ZipInt8Int32Ptr takes two inputs: first list of type: []int8, second list of type: []int32. Then it merges two list and returns a new map of type: map[int8]int32

func ZipInt8Int64 

func ZipInt8Int64(list1 []int8, list2 []int64) map[int8]int64

ZipInt8Int64 takes two inputs: first list of type: []int8, second list of type: []int64. Then it merges two list and returns a new map of type: map[int8]int64

func ZipInt8Int64Ptr 

func ZipInt8Int64Ptr(list1 []*int8, list2 []*int64) map[*int8]*int64

ZipInt8Int64Ptr takes two inputs: first list of type: []int8, second list of type: []int64. Then it merges two list and returns a new map of type: map[int8]int64

func ZipInt8IntPtr 

func ZipInt8IntPtr(list1 []*int8, list2 []*int) map[*int8]*int

ZipInt8IntPtr takes two inputs: first list of type: []int8, second list of type: []int. Then it merges two list and returns a new map of type: map[int8]int

func ZipInt8Ptr 

func ZipInt8Ptr(list1 []*int8, list2 []*int8) map[*int8]*int8

ZipInt8Ptr takes two inputs: first list of type: []int8, second list of type: []int8. Then it merges two list and returns a new map of type: map[int8]int8

func ZipInt8Str 

func ZipInt8Str(list1 []int8, list2 []string) map[int8]string

ZipInt8Str takes two inputs: first list of type: []int8, second list of type: []string. Then it merges two list and returns a new map of type: map[int8]string

func ZipInt8StrPtr 

func ZipInt8StrPtr(list1 []*int8, list2 []*string) map[*int8]*string

ZipInt8StrPtr takes two inputs: first list of type: []int8, second list of type: []string. Then it merges two list and returns a new map of type: map[int8]string

func ZipInt8Uint 

func ZipInt8Uint(list1 []int8, list2 []uint) map[int8]uint

ZipInt8Uint takes two inputs: first list of type: []int8, second list of type: []uint. Then it merges two list and returns a new map of type: map[int8]uint

func ZipInt8Uint16 

func ZipInt8Uint16(list1 []int8, list2 []uint16) map[int8]uint16

ZipInt8Uint16 takes two inputs: first list of type: []int8, second list of type: []uint16. Then it merges two list and returns a new map of type: map[int8]uint16

func ZipInt8Uint16Ptr 

func ZipInt8Uint16Ptr(list1 []*int8, list2 []*uint16) map[*int8]*uint16

ZipInt8Uint16Ptr takes two inputs: first list of type: []int8, second list of type: []uint16. Then it merges two list and returns a new map of type: map[int8]uint16

func ZipInt8Uint32 

func ZipInt8Uint32(list1 []int8, list2 []uint32) map[int8]uint32

ZipInt8Uint32 takes two inputs: first list of type: []int8, second list of type: []uint32. Then it merges two list and returns a new map of type: map[int8]uint32

func ZipInt8Uint32Ptr 

func ZipInt8Uint32Ptr(list1 []*int8, list2 []*uint32) map[*int8]*uint32

ZipInt8Uint32Ptr takes two inputs: first list of type: []int8, second list of type: []uint32. Then it merges two list and returns a new map of type: map[int8]uint32

func ZipInt8Uint64 

func ZipInt8Uint64(list1 []int8, list2 []uint64) map[int8]uint64

ZipInt8Uint64 takes two inputs: first list of type: []int8, second list of type: []uint64. Then it merges two list and returns a new map of type: map[int8]uint64

func ZipInt8Uint64Ptr 

func ZipInt8Uint64Ptr(list1 []*int8, list2 []*uint64) map[*int8]*uint64

ZipInt8Uint64Ptr takes two inputs: first list of type: []int8, second list of type: []uint64. Then it merges two list and returns a new map of type: map[int8]uint64

func ZipInt8Uint8 

func ZipInt8Uint8(list1 []int8, list2 []uint8) map[int8]uint8

ZipInt8Uint8 takes two inputs: first list of type: []int8, second list of type: []uint8. Then it merges two list and returns a new map of type: map[int8]uint8

func ZipInt8Uint8Ptr 

func ZipInt8Uint8Ptr(list1 []*int8, list2 []*uint8) map[*int8]*uint8

ZipInt8Uint8Ptr takes two inputs: first list of type: []int8, second list of type: []uint8. Then it merges two list and returns a new map of type: map[int8]uint8

func ZipInt8UintPtr 

func ZipInt8UintPtr(list1 []*int8, list2 []*uint) map[*int8]*uint

ZipInt8UintPtr takes two inputs: first list of type: []int8, second list of type: []uint. Then it merges two list and returns a new map of type: map[int8]uint

func ZipIntBool 

func ZipIntBool(list1 []int, list2 []bool) map[int]bool

ZipIntBool takes two inputs: first list of type: []int, second list of type: []bool. Then it merges two list and returns a new map of type: map[int]bool

func ZipIntBoolPtr 

func ZipIntBoolPtr(list1 []*int, list2 []*bool) map[*int]*bool

ZipIntBoolPtr takes two inputs: first list of type: []int, second list of type: []bool. Then it merges two list and returns a new map of type: map[int]bool

func ZipIntFloat32 

func ZipIntFloat32(list1 []int, list2 []float32) map[int]float32

ZipIntFloat32 takes two inputs: first list of type: []int, second list of type: []float32. Then it merges two list and returns a new map of type: map[int]float32

func ZipIntFloat32Ptr 

func ZipIntFloat32Ptr(list1 []*int, list2 []*float32) map[*int]*float32

ZipIntFloat32Ptr takes two inputs: first list of type: []int, second list of type: []float32. Then it merges two list and returns a new map of type: map[int]float32

func ZipIntFloat64 

func ZipIntFloat64(list1 []int, list2 []float64) map[int]float64

ZipIntFloat64 takes two inputs: first list of type: []int, second list of type: []float64. Then it merges two list and returns a new map of type: map[int]float64

func ZipIntFloat64Ptr 

func ZipIntFloat64Ptr(list1 []*int, list2 []*float64) map[*int]*float64

ZipIntFloat64Ptr takes two inputs: first list of type: []int, second list of type: []float64. Then it merges two list and returns a new map of type: map[int]float64

func ZipIntInt16 

func ZipIntInt16(list1 []int, list2 []int16) map[int]int16

ZipIntInt16 takes two inputs: first list of type: []int, second list of type: []int16. Then it merges two list and returns a new map of type: map[int]int16

func ZipIntInt16Ptr 

func ZipIntInt16Ptr(list1 []*int, list2 []*int16) map[*int]*int16

ZipIntInt16Ptr takes two inputs: first list of type: []int, second list of type: []int16. Then it merges two list and returns a new map of type: map[int]int16

func ZipIntInt32 

func ZipIntInt32(list1 []int, list2 []int32) map[int]int32

ZipIntInt32 takes two inputs: first list of type: []int, second list of type: []int32. Then it merges two list and returns a new map of type: map[int]int32

func ZipIntInt32Ptr 

func ZipIntInt32Ptr(list1 []*int, list2 []*int32) map[*int]*int32

ZipIntInt32Ptr takes two inputs: first list of type: []int, second list of type: []int32. Then it merges two list and returns a new map of type: map[int]int32

func ZipIntInt64 

func ZipIntInt64(list1 []int, list2 []int64) map[int]int64

ZipIntInt64 takes two inputs: first list of type: []int, second list of type: []int64. Then it merges two list and returns a new map of type: map[int]int64

func ZipIntInt64Ptr 

func ZipIntInt64Ptr(list1 []*int, list2 []*int64) map[*int]*int64

ZipIntInt64Ptr takes two inputs: first list of type: []int, second list of type: []int64. Then it merges two list and returns a new map of type: map[int]int64

func ZipIntInt8 

func ZipIntInt8(list1 []int, list2 []int8) map[int]int8

ZipIntInt8 takes two inputs: first list of type: []int, second list of type: []int8. Then it merges two list and returns a new map of type: map[int]int8

func ZipIntInt8Ptr 

func ZipIntInt8Ptr(list1 []*int, list2 []*int8) map[*int]*int8

ZipIntInt8Ptr takes two inputs: first list of type: []int, second list of type: []int8. Then it merges two list and returns a new map of type: map[int]int8

func ZipIntPtr 

func ZipIntPtr(list1 []*int, list2 []*int) map[*int]*int

ZipIntPtr takes two inputs: first list of type: []int, second list of type: []int. Then it merges two list and returns a new map of type: map[int]int

func ZipIntStr 

func ZipIntStr(list1 []int, list2 []string) map[int]string

ZipIntStr takes two inputs: first list of type: []int, second list of type: []string. Then it merges two list and returns a new map of type: map[int]string

func ZipIntStrPtr 

func ZipIntStrPtr(list1 []*int, list2 []*string) map[*int]*string

ZipIntStrPtr takes two inputs: first list of type: []int, second list of type: []string. Then it merges two list and returns a new map of type: map[int]string

func ZipIntUint 

func ZipIntUint(list1 []int, list2 []uint) map[int]uint

ZipIntUint takes two inputs: first list of type: []int, second list of type: []uint. Then it merges two list and returns a new map of type: map[int]uint

func ZipIntUint16 

func ZipIntUint16(list1 []int, list2 []uint16) map[int]uint16

ZipIntUint16 takes two inputs: first list of type: []int, second list of type: []uint16. Then it merges two list and returns a new map of type: map[int]uint16

func ZipIntUint16Ptr 

func ZipIntUint16Ptr(list1 []*int, list2 []*uint16) map[*int]*uint16

ZipIntUint16Ptr takes two inputs: first list of type: []int, second list of type: []uint16. Then it merges two list and returns a new map of type: map[int]uint16

func ZipIntUint32 

func ZipIntUint32(list1 []int, list2 []uint32) map[int]uint32

ZipIntUint32 takes two inputs: first list of type: []int, second list of type: []uint32. Then it merges two list and returns a new map of type: map[int]uint32

func ZipIntUint32Ptr 

func ZipIntUint32Ptr(list1 []*int, list2 []*uint32) map[*int]*uint32

ZipIntUint32Ptr takes two inputs: first list of type: []int, second list of type: []uint32. Then it merges two list and returns a new map of type: map[int]uint32

func ZipIntUint64 

func ZipIntUint64(list1 []int, list2 []uint64) map[int]uint64

ZipIntUint64 takes two inputs: first list of type: []int, second list of type: []uint64. Then it merges two list and returns a new map of type: map[int]uint64

func ZipIntUint64Ptr 

func ZipIntUint64Ptr(list1 []*int, list2 []*uint64) map[*int]*uint64

ZipIntUint64Ptr takes two inputs: first list of type: []int, second list of type: []uint64. Then it merges two list and returns a new map of type: map[int]uint64

func ZipIntUint8 

func ZipIntUint8(list1 []int, list2 []uint8) map[int]uint8

ZipIntUint8 takes two inputs: first list of type: []int, second list of type: []uint8. Then it merges two list and returns a new map of type: map[int]uint8

func ZipIntUint8Ptr 

func ZipIntUint8Ptr(list1 []*int, list2 []*uint8) map[*int]*uint8

ZipIntUint8Ptr takes two inputs: first list of type: []int, second list of type: []uint8. Then it merges two list and returns a new map of type: map[int]uint8

func ZipIntUintPtr 

func ZipIntUintPtr(list1 []*int, list2 []*uint) map[*int]*uint

ZipIntUintPtr takes two inputs: first list of type: []int, second list of type: []uint. Then it merges two list and returns a new map of type: map[int]uint

func ZipStr 

func ZipStr(list1 []string, list2 []string) map[string]string

ZipStr takes two inputs: first list of type: []string, second list of type: []string. Then it merges two list and returns a new map of type: map[string]string

func ZipStrBool 

func ZipStrBool(list1 []string, list2 []bool) map[string]bool

ZipStrBool takes two inputs: first list of type: []string, second list of type: []bool. Then it merges two list and returns a new map of type: map[string]bool

func ZipStrBoolPtr 

func ZipStrBoolPtr(list1 []*string, list2 []*bool) map[*string]*bool

ZipStrBoolPtr takes two inputs: first list of type: []string, second list of type: []bool. Then it merges two list and returns a new map of type: map[string]bool

func ZipStrFloat32 

func ZipStrFloat32(list1 []string, list2 []float32) map[string]float32

ZipStrFloat32 takes two inputs: first list of type: []string, second list of type: []float32. Then it merges two list and returns a new map of type: map[string]float32

func ZipStrFloat32Ptr 

func ZipStrFloat32Ptr(list1 []*string, list2 []*float32) map[*string]*float32

ZipStrFloat32Ptr takes two inputs: first list of type: []string, second list of type: []float32. Then it merges two list and returns a new map of type: map[string]float32

func ZipStrFloat64 

func ZipStrFloat64(list1 []string, list2 []float64) map[string]float64

ZipStrFloat64 takes two inputs: first list of type: []string, second list of type: []float64. Then it merges two list and returns a new map of type: map[string]float64

func ZipStrFloat64Ptr 

func ZipStrFloat64Ptr(list1 []*string, list2 []*float64) map[*string]*float64

ZipStrFloat64Ptr takes two inputs: first list of type: []string, second list of type: []float64. Then it merges two list and returns a new map of type: map[string]float64

func ZipStrInt 

func ZipStrInt(list1 []string, list2 []int) map[string]int

ZipStrInt takes two inputs: first list of type: []string, second list of type: []int. Then it merges two list and returns a new map of type: map[string]int

func ZipStrInt16 

func ZipStrInt16(list1 []string, list2 []int16) map[string]int16

ZipStrInt16 takes two inputs: first list of type: []string, second list of type: []int16. Then it merges two list and returns a new map of type: map[string]int16

func ZipStrInt16Ptr 

func ZipStrInt16Ptr(list1 []*string, list2 []*int16) map[*string]*int16

ZipStrInt16Ptr takes two inputs: first list of type: []string, second list of type: []int16. Then it merges two list and returns a new map of type: map[string]int16

func ZipStrInt32 

func ZipStrInt32(list1 []string, list2 []int32) map[string]int32

ZipStrInt32 takes two inputs: first list of type: []string, second list of type: []int32. Then it merges two list and returns a new map of type: map[string]int32

func ZipStrInt32Ptr 

func ZipStrInt32Ptr(list1 []*string, list2 []*int32) map[*string]*int32

ZipStrInt32Ptr takes two inputs: first list of type: []string, second list of type: []int32. Then it merges two list and returns a new map of type: map[string]int32

func ZipStrInt64 

func ZipStrInt64(list1 []string, list2 []int64) map[string]int64

ZipStrInt64 takes two inputs: first list of type: []string, second list of type: []int64. Then it merges two list and returns a new map of type: map[string]int64

func ZipStrInt64Ptr 

func ZipStrInt64Ptr(list1 []*string, list2 []*int64) map[*string]*int64

ZipStrInt64Ptr takes two inputs: first list of type: []string, second list of type: []int64. Then it merges two list and returns a new map of type: map[string]int64

func ZipStrInt8 

func ZipStrInt8(list1 []string, list2 []int8) map[string]int8

ZipStrInt8 takes two inputs: first list of type: []string, second list of type: []int8. Then it merges two list and returns a new map of type: map[string]int8

func ZipStrInt8Ptr 

func ZipStrInt8Ptr(list1 []*string, list2 []*int8) map[*string]*int8

ZipStrInt8Ptr takes two inputs: first list of type: []string, second list of type: []int8. Then it merges two list and returns a new map of type: map[string]int8

func ZipStrIntPtr 

func ZipStrIntPtr(list1 []*string, list2 []*int) map[*string]*int

ZipStrIntPtr takes two inputs: first list of type: []string, second list of type: []int. Then it merges two list and returns a new map of type: map[string]int

func ZipStrPtr 

func ZipStrPtr(list1 []*string, list2 []*string) map[*string]*string

ZipStrPtr takes two inputs: first list of type: []string, second list of type: []string. Then it merges two list and returns a new map of type: map[string]string

func ZipStrUint 

func ZipStrUint(list1 []string, list2 []uint) map[string]uint

ZipStrUint takes two inputs: first list of type: []string, second list of type: []uint. Then it merges two list and returns a new map of type: map[string]uint

func ZipStrUint16 

func ZipStrUint16(list1 []string, list2 []uint16) map[string]uint16

ZipStrUint16 takes two inputs: first list of type: []string, second list of type: []uint16. Then it merges two list and returns a new map of type: map[string]uint16

func ZipStrUint16Ptr 

func ZipStrUint16Ptr(list1 []*string, list2 []*uint16) map[*string]*uint16

ZipStrUint16Ptr takes two inputs: first list of type: []string, second list of type: []uint16. Then it merges two list and returns a new map of type: map[string]uint16

func ZipStrUint32 

func ZipStrUint32(list1 []string, list2 []uint32) map[string]uint32

ZipStrUint32 takes two inputs: first list of type: []string, second list of type: []uint32. Then it merges two list and returns a new map of type: map[string]uint32

func ZipStrUint32Ptr 

func ZipStrUint32Ptr(list1 []*string, list2 []*uint32) map[*string]*uint32

ZipStrUint32Ptr takes two inputs: first list of type: []string, second list of type: []uint32. Then it merges two list and returns a new map of type: map[string]uint32

func ZipStrUint64 

func ZipStrUint64(list1 []string, list2 []uint64) map[string]uint64

ZipStrUint64 takes two inputs: first list of type: []string, second list of type: []uint64. Then it merges two list and returns a new map of type: map[string]uint64

func ZipStrUint64Ptr 

func ZipStrUint64Ptr(list1 []*string, list2 []*uint64) map[*string]*uint64

ZipStrUint64Ptr takes two inputs: first list of type: []string, second list of type: []uint64. Then it merges two list and returns a new map of type: map[string]uint64

func ZipStrUint8 

func ZipStrUint8(list1 []string, list2 []uint8) map[string]uint8

ZipStrUint8 takes two inputs: first list of type: []string, second list of type: []uint8. Then it merges two list and returns a new map of type: map[string]uint8

func ZipStrUint8Ptr 

func ZipStrUint8Ptr(list1 []*string, list2 []*uint8) map[*string]*uint8

ZipStrUint8Ptr takes two inputs: first list of type: []string, second list of type: []uint8. Then it merges two list and returns a new map of type: map[string]uint8

func ZipStrUintPtr 

func ZipStrUintPtr(list1 []*string, list2 []*uint) map[*string]*uint

ZipStrUintPtr takes two inputs: first list of type: []string, second list of type: []uint. Then it merges two list and returns a new map of type: map[string]uint

func ZipUint 

func ZipUint(list1 []uint, list2 []uint) map[uint]uint

ZipUint takes two inputs: first list of type: []uint, second list of type: []uint. Then it merges two list and returns a new map of type: map[uint]uint

func ZipUint16 

func ZipUint16(list1 []uint16, list2 []uint16) map[uint16]uint16

ZipUint16 takes two inputs: first list of type: []uint16, second list of type: []uint16. Then it merges two list and returns a new map of type: map[uint16]uint16

func ZipUint16Bool 

func ZipUint16Bool(list1 []uint16, list2 []bool) map[uint16]bool

ZipUint16Bool takes two inputs: first list of type: []uint16, second list of type: []bool. Then it merges two list and returns a new map of type: map[uint16]bool

func ZipUint16BoolPtr 

func ZipUint16BoolPtr(list1 []*uint16, list2 []*bool) map[*uint16]*bool

ZipUint16BoolPtr takes two inputs: first list of type: []uint16, second list of type: []bool. Then it merges two list and returns a new map of type: map[uint16]bool

func ZipUint16Float32 

func ZipUint16Float32(list1 []uint16, list2 []float32) map[uint16]float32

ZipUint16Float32 takes two inputs: first list of type: []uint16, second list of type: []float32. Then it merges two list and returns a new map of type: map[uint16]float32

func ZipUint16Float32Ptr 

func ZipUint16Float32Ptr(list1 []*uint16, list2 []*float32) map[*uint16]*float32

ZipUint16Float32Ptr takes two inputs: first list of type: []uint16, second list of type: []float32. Then it merges two list and returns a new map of type: map[uint16]float32

func ZipUint16Float64 

func ZipUint16Float64(list1 []uint16, list2 []float64) map[uint16]float64

ZipUint16Float64 takes two inputs: first list of type: []uint16, second list of type: []float64. Then it merges two list and returns a new map of type: map[uint16]float64

func ZipUint16Float64Ptr 

func ZipUint16Float64Ptr(list1 []*uint16, list2 []*float64) map[*uint16]*float64

ZipUint16Float64Ptr takes two inputs: first list of type: []uint16, second list of type: []float64. Then it merges two list and returns a new map of type: map[uint16]float64

func ZipUint16Int 

func ZipUint16Int(list1 []uint16, list2 []int) map[uint16]int

ZipUint16Int takes two inputs: first list of type: []uint16, second list of type: []int. Then it merges two list and returns a new map of type: map[uint16]int

func ZipUint16Int16 

func ZipUint16Int16(list1 []uint16, list2 []int16) map[uint16]int16

ZipUint16Int16 takes two inputs: first list of type: []uint16, second list of type: []int16. Then it merges two list and returns a new map of type: map[uint16]int16

func ZipUint16Int16Ptr 

func ZipUint16Int16Ptr(list1 []*uint16, list2 []*int16) map[*uint16]*int16

ZipUint16Int16Ptr takes two inputs: first list of type: []uint16, second list of type: []int16. Then it merges two list and returns a new map of type: map[uint16]int16

func ZipUint16Int32 

func ZipUint16Int32(list1 []uint16, list2 []int32) map[uint16]int32

ZipUint16Int32 takes two inputs: first list of type: []uint16, second list of type: []int32. Then it merges two list and returns a new map of type: map[uint16]int32

func ZipUint16Int32Ptr 

func ZipUint16Int32Ptr(list1 []*uint16, list2 []*int32) map[*uint16]*int32

ZipUint16Int32Ptr takes two inputs: first list of type: []uint16, second list of type: []int32. Then it merges two list and returns a new map of type: map[uint16]int32

func ZipUint16Int64 

func ZipUint16Int64(list1 []uint16, list2 []int64) map[uint16]int64

ZipUint16Int64 takes two inputs: first list of type: []uint16, second list of type: []int64. Then it merges two list and returns a new map of type: map[uint16]int64

func ZipUint16Int64Ptr 

func ZipUint16Int64Ptr(list1 []*uint16, list2 []*int64) map[*uint16]*int64

ZipUint16Int64Ptr takes two inputs: first list of type: []uint16, second list of type: []int64. Then it merges two list and returns a new map of type: map[uint16]int64

func ZipUint16Int8 

func ZipUint16Int8(list1 []uint16, list2 []int8) map[uint16]int8

ZipUint16Int8 takes two inputs: first list of type: []uint16, second list of type: []int8. Then it merges two list and returns a new map of type: map[uint16]int8

func ZipUint16Int8Ptr 

func ZipUint16Int8Ptr(list1 []*uint16, list2 []*int8) map[*uint16]*int8

ZipUint16Int8Ptr takes two inputs: first list of type: []uint16, second list of type: []int8. Then it merges two list and returns a new map of type: map[uint16]int8

func ZipUint16IntPtr 

func ZipUint16IntPtr(list1 []*uint16, list2 []*int) map[*uint16]*int

ZipUint16IntPtr takes two inputs: first list of type: []uint16, second list of type: []int. Then it merges two list and returns a new map of type: map[uint16]int

func ZipUint16Ptr 

func ZipUint16Ptr(list1 []*uint16, list2 []*uint16) map[*uint16]*uint16

ZipUint16Ptr takes two inputs: first list of type: []uint16, second list of type: []uint16. Then it merges two list and returns a new map of type: map[uint16]uint16

func ZipUint16Str 

func ZipUint16Str(list1 []uint16, list2 []string) map[uint16]string

ZipUint16Str takes two inputs: first list of type: []uint16, second list of type: []string. Then it merges two list and returns a new map of type: map[uint16]string

func ZipUint16StrPtr 

func ZipUint16StrPtr(list1 []*uint16, list2 []*string) map[*uint16]*string

ZipUint16StrPtr takes two inputs: first list of type: []uint16, second list of type: []string. Then it merges two list and returns a new map of type: map[uint16]string

func ZipUint16Uint 

func ZipUint16Uint(list1 []uint16, list2 []uint) map[uint16]uint

ZipUint16Uint takes two inputs: first list of type: []uint16, second list of type: []uint. Then it merges two list and returns a new map of type: map[uint16]uint

func ZipUint16Uint32 

func ZipUint16Uint32(list1 []uint16, list2 []uint32) map[uint16]uint32

ZipUint16Uint32 takes two inputs: first list of type: []uint16, second list of type: []uint32. Then it merges two list and returns a new map of type: map[uint16]uint32

func ZipUint16Uint32Ptr 

func ZipUint16Uint32Ptr(list1 []*uint16, list2 []*uint32) map[*uint16]*uint32

ZipUint16Uint32Ptr takes two inputs: first list of type: []uint16, second list of type: []uint32. Then it merges two list and returns a new map of type: map[uint16]uint32

func ZipUint16Uint64 

func ZipUint16Uint64(list1 []uint16, list2 []uint64) map[uint16]uint64

ZipUint16Uint64 takes two inputs: first list of type: []uint16, second list of type: []uint64. Then it merges two list and returns a new map of type: map[uint16]uint64

func ZipUint16Uint64Ptr 

func ZipUint16Uint64Ptr(list1 []*uint16, list2 []*uint64) map[*uint16]*uint64

ZipUint16Uint64Ptr takes two inputs: first list of type: []uint16, second list of type: []uint64. Then it merges two list and returns a new map of type: map[uint16]uint64

func ZipUint16Uint8 

func ZipUint16Uint8(list1 []uint16, list2 []uint8) map[uint16]uint8

ZipUint16Uint8 takes two inputs: first list of type: []uint16, second list of type: []uint8. Then it merges two list and returns a new map of type: map[uint16]uint8

func ZipUint16Uint8Ptr 

func ZipUint16Uint8Ptr(list1 []*uint16, list2 []*uint8) map[*uint16]*uint8

ZipUint16Uint8Ptr takes two inputs: first list of type: []uint16, second list of type: []uint8. Then it merges two list and returns a new map of type: map[uint16]uint8

func ZipUint16UintPtr 

func ZipUint16UintPtr(list1 []*uint16, list2 []*uint) map[*uint16]*uint

ZipUint16UintPtr takes two inputs: first list of type: []uint16, second list of type: []uint. Then it merges two list and returns a new map of type: map[uint16]uint

func ZipUint32 

func ZipUint32(list1 []uint32, list2 []uint32) map[uint32]uint32

ZipUint32 takes two inputs: first list of type: []uint32, second list of type: []uint32. Then it merges two list and returns a new map of type: map[uint32]uint32

func ZipUint32Bool 

func ZipUint32Bool(list1 []uint32, list2 []bool) map[uint32]bool

ZipUint32Bool takes two inputs: first list of type: []uint32, second list of type: []bool. Then it merges two list and returns a new map of type: map[uint32]bool

func ZipUint32BoolPtr 

func ZipUint32BoolPtr(list1 []*uint32, list2 []*bool) map[*uint32]*bool

ZipUint32BoolPtr takes two inputs: first list of type: []uint32, second list of type: []bool. Then it merges two list and returns a new map of type: map[uint32]bool

func ZipUint32Float32 

func ZipUint32Float32(list1 []uint32, list2 []float32) map[uint32]float32

ZipUint32Float32 takes two inputs: first list of type: []uint32, second list of type: []float32. Then it merges two list and returns a new map of type: map[uint32]float32

func ZipUint32Float32Ptr 

func ZipUint32Float32Ptr(list1 []*uint32, list2 []*float32) map[*uint32]*float32

ZipUint32Float32Ptr takes two inputs: first list of type: []uint32, second list of type: []float32. Then it merges two list and returns a new map of type: map[uint32]float32

func ZipUint32Float64 

func ZipUint32Float64(list1 []uint32, list2 []float64) map[uint32]float64

ZipUint32Float64 takes two inputs: first list of type: []uint32, second list of type: []float64. Then it merges two list and returns a new map of type: map[uint32]float64

func ZipUint32Float64Ptr 

func ZipUint32Float64Ptr(list1 []*uint32, list2 []*float64) map[*uint32]*float64

ZipUint32Float64Ptr takes two inputs: first list of type: []uint32, second list of type: []float64. Then it merges two list and returns a new map of type: map[uint32]float64

func ZipUint32Int 

func ZipUint32Int(list1 []uint32, list2 []int) map[uint32]int

ZipUint32Int takes two inputs: first list of type: []uint32, second list of type: []int. Then it merges two list and returns a new map of type: map[uint32]int

func ZipUint32Int16 

func ZipUint32Int16(list1 []uint32, list2 []int16) map[uint32]int16

ZipUint32Int16 takes two inputs: first list of type: []uint32, second list of type: []int16. Then it merges two list and returns a new map of type: map[uint32]int16

func ZipUint32Int16Ptr 

func ZipUint32Int16Ptr(list1 []*uint32, list2 []*int16) map[*uint32]*int16

ZipUint32Int16Ptr takes two inputs: first list of type: []uint32, second list of type: []int16. Then it merges two list and returns a new map of type: map[uint32]int16

func ZipUint32Int32 

func ZipUint32Int32(list1 []uint32, list2 []int32) map[uint32]int32

ZipUint32Int32 takes two inputs: first list of type: []uint32, second list of type: []int32. Then it merges two list and returns a new map of type: map[uint32]int32

func ZipUint32Int32Ptr 

func ZipUint32Int32Ptr(list1 []*uint32, list2 []*int32) map[*uint32]*int32

ZipUint32Int32Ptr takes two inputs: first list of type: []uint32, second list of type: []int32. Then it merges two list and returns a new map of type: map[uint32]int32

func ZipUint32Int64 

func ZipUint32Int64(list1 []uint32, list2 []int64) map[uint32]int64

ZipUint32Int64 takes two inputs: first list of type: []uint32, second list of type: []int64. Then it merges two list and returns a new map of type: map[uint32]int64

func ZipUint32Int64Ptr 

func ZipUint32Int64Ptr(list1 []*uint32, list2 []*int64) map[*uint32]*int64

ZipUint32Int64Ptr takes two inputs: first list of type: []uint32, second list of type: []int64. Then it merges two list and returns a new map of type: map[uint32]int64

func ZipUint32Int8 

func ZipUint32Int8(list1 []uint32, list2 []int8) map[uint32]int8

ZipUint32Int8 takes two inputs: first list of type: []uint32, second list of type: []int8. Then it merges two list and returns a new map of type: map[uint32]int8

func ZipUint32Int8Ptr 

func ZipUint32Int8Ptr(list1 []*uint32, list2 []*int8) map[*uint32]*int8

ZipUint32Int8Ptr takes two inputs: first list of type: []uint32, second list of type: []int8. Then it merges two list and returns a new map of type: map[uint32]int8

func ZipUint32IntPtr 

func ZipUint32IntPtr(list1 []*uint32, list2 []*int) map[*uint32]*int

ZipUint32IntPtr takes two inputs: first list of type: []uint32, second list of type: []int. Then it merges two list and returns a new map of type: map[uint32]int

func ZipUint32Ptr 

func ZipUint32Ptr(list1 []*uint32, list2 []*uint32) map[*uint32]*uint32

ZipUint32Ptr takes two inputs: first list of type: []uint32, second list of type: []uint32. Then it merges two list and returns a new map of type: map[uint32]uint32

func ZipUint32Str 

func ZipUint32Str(list1 []uint32, list2 []string) map[uint32]string

ZipUint32Str takes two inputs: first list of type: []uint32, second list of type: []string. Then it merges two list and returns a new map of type: map[uint32]string

func ZipUint32StrPtr 

func ZipUint32StrPtr(list1 []*uint32, list2 []*string) map[*uint32]*string

ZipUint32StrPtr takes two inputs: first list of type: []uint32, second list of type: []string. Then it merges two list and returns a new map of type: map[uint32]string

func ZipUint32Uint 

func ZipUint32Uint(list1 []uint32, list2 []uint) map[uint32]uint

ZipUint32Uint takes two inputs: first list of type: []uint32, second list of type: []uint. Then it merges two list and returns a new map of type: map[uint32]uint

func ZipUint32Uint16 

func ZipUint32Uint16(list1 []uint32, list2 []uint16) map[uint32]uint16

ZipUint32Uint16 takes two inputs: first list of type: []uint32, second list of type: []uint16. Then it merges two list and returns a new map of type: map[uint32]uint16

func ZipUint32Uint16Ptr 

func ZipUint32Uint16Ptr(list1 []*uint32, list2 []*uint16) map[*uint32]*uint16

ZipUint32Uint16Ptr takes two inputs: first list of type: []uint32, second list of type: []uint16. Then it merges two list and returns a new map of type: map[uint32]uint16

func ZipUint32Uint64 

func ZipUint32Uint64(list1 []uint32, list2 []uint64) map[uint32]uint64

ZipUint32Uint64 takes two inputs: first list of type: []uint32, second list of type: []uint64. Then it merges two list and returns a new map of type: map[uint32]uint64

func ZipUint32Uint64Ptr 

func ZipUint32Uint64Ptr(list1 []*uint32, list2 []*uint64) map[*uint32]*uint64

ZipUint32Uint64Ptr takes two inputs: first list of type: []uint32, second list of type: []uint64. Then it merges two list and returns a new map of type: map[uint32]uint64

func ZipUint32Uint8 

func ZipUint32Uint8(list1 []uint32, list2 []uint8) map[uint32]uint8

ZipUint32Uint8 takes two inputs: first list of type: []uint32, second list of type: []uint8. Then it merges two list and returns a new map of type: map[uint32]uint8

func ZipUint32Uint8Ptr 

func ZipUint32Uint8Ptr(list1 []*uint32, list2 []*uint8) map[*uint32]*uint8

ZipUint32Uint8Ptr takes two inputs: first list of type: []uint32, second list of type: []uint8. Then it merges two list and returns a new map of type: map[uint32]uint8

func ZipUint32UintPtr 

func ZipUint32UintPtr(list1 []*uint32, list2 []*uint) map[*uint32]*uint

ZipUint32UintPtr takes two inputs: first list of type: []uint32, second list of type: []uint. Then it merges two list and returns a new map of type: map[uint32]uint

func ZipUint64 

func ZipUint64(list1 []uint64, list2 []uint64) map[uint64]uint64

ZipUint64 takes two inputs: first list of type: []uint64, second list of type: []uint64. Then it merges two list and returns a new map of type: map[uint64]uint64

func ZipUint64Bool 

func ZipUint64Bool(list1 []uint64, list2 []bool) map[uint64]bool

ZipUint64Bool takes two inputs: first list of type: []uint64, second list of type: []bool. Then it merges two list and returns a new map of type: map[uint64]bool

func ZipUint64BoolPtr 

func ZipUint64BoolPtr(list1 []*uint64, list2 []*bool) map[*uint64]*bool

ZipUint64BoolPtr takes two inputs: first list of type: []uint64, second list of type: []bool. Then it merges two list and returns a new map of type: map[uint64]bool

func ZipUint64Float32 

func ZipUint64Float32(list1 []uint64, list2 []float32) map[uint64]float32

ZipUint64Float32 takes two inputs: first list of type: []uint64, second list of type: []float32. Then it merges two list and returns a new map of type: map[uint64]float32

func ZipUint64Float32Ptr 

func ZipUint64Float32Ptr(list1 []*uint64, list2 []*float32) map[*uint64]*float32

ZipUint64Float32Ptr takes two inputs: first list of type: []uint64, second list of type: []float32. Then it merges two list and returns a new map of type: map[uint64]float32

func ZipUint64Float64 

func ZipUint64Float64(list1 []uint64, list2 []float64) map[uint64]float64

ZipUint64Float64 takes two inputs: first list of type: []uint64, second list of type: []float64. Then it merges two list and returns a new map of type: map[uint64]float64

func ZipUint64Float64Ptr 

func ZipUint64Float64Ptr(list1 []*uint64, list2 []*float64) map[*uint64]*float64

ZipUint64Float64Ptr takes two inputs: first list of type: []uint64, second list of type: []float64. Then it merges two list and returns a new map of type: map[uint64]float64

func ZipUint64Int 

func ZipUint64Int(list1 []uint64, list2 []int) map[uint64]int

ZipUint64Int takes two inputs: first list of type: []uint64, second list of type: []int. Then it merges two list and returns a new map of type: map[uint64]int

func ZipUint64Int16 

func ZipUint64Int16(list1 []uint64, list2 []int16) map[uint64]int16

ZipUint64Int16 takes two inputs: first list of type: []uint64, second list of type: []int16. Then it merges two list and returns a new map of type: map[uint64]int16

func ZipUint64Int16Ptr 

func ZipUint64Int16Ptr(list1 []*uint64, list2 []*int16) map[*uint64]*int16

ZipUint64Int16Ptr takes two inputs: first list of type: []uint64, second list of type: []int16. Then it merges two list and returns a new map of type: map[uint64]int16

func ZipUint64Int32 

func ZipUint64Int32(list1 []uint64, list2 []int32) map[uint64]int32

ZipUint64Int32 takes two inputs: first list of type: []uint64, second list of type: []int32. Then it merges two list and returns a new map of type: map[uint64]int32

func ZipUint64Int32Ptr 

func ZipUint64Int32Ptr(list1 []*uint64, list2 []*int32) map[*uint64]*int32

ZipUint64Int32Ptr takes two inputs: first list of type: []uint64, second list of type: []int32. Then it merges two list and returns a new map of type: map[uint64]int32

func ZipUint64Int64 

func ZipUint64Int64(list1 []uint64, list2 []int64) map[uint64]int64

ZipUint64Int64 takes two inputs: first list of type: []uint64, second list of type: []int64. Then it merges two list and returns a new map of type: map[uint64]int64

func ZipUint64Int64Ptr 

func ZipUint64Int64Ptr(list1 []*uint64, list2 []*int64) map[*uint64]*int64

ZipUint64Int64Ptr takes two inputs: first list of type: []uint64, second list of type: []int64. Then it merges two list and returns a new map of type: map[uint64]int64

func ZipUint64Int8 

func ZipUint64Int8(list1 []uint64, list2 []int8) map[uint64]int8

ZipUint64Int8 takes two inputs: first list of type: []uint64, second list of type: []int8. Then it merges two list and returns a new map of type: map[uint64]int8

func ZipUint64Int8Ptr 

func ZipUint64Int8Ptr(list1 []*uint64, list2 []*int8) map[*uint64]*int8

ZipUint64Int8Ptr takes two inputs: first list of type: []uint64, second list of type: []int8. Then it merges two list and returns a new map of type: map[uint64]int8

func ZipUint64IntPtr 

func ZipUint64IntPtr(list1 []*uint64, list2 []*int) map[*uint64]*int

ZipUint64IntPtr takes two inputs: first list of type: []uint64, second list of type: []int. Then it merges two list and returns a new map of type: map[uint64]int

func ZipUint64Ptr 

func ZipUint64Ptr(list1 []*uint64, list2 []*uint64) map[*uint64]*uint64

ZipUint64Ptr takes two inputs: first list of type: []uint64, second list of type: []uint64. Then it merges two list and returns a new map of type: map[uint64]uint64

func ZipUint64Str 

func ZipUint64Str(list1 []uint64, list2 []string) map[uint64]string

ZipUint64Str takes two inputs: first list of type: []uint64, second list of type: []string. Then it merges two list and returns a new map of type: map[uint64]string

func ZipUint64StrPtr 

func ZipUint64StrPtr(list1 []*uint64, list2 []*string) map[*uint64]*string

ZipUint64StrPtr takes two inputs: first list of type: []uint64, second list of type: []string. Then it merges two list and returns a new map of type: map[uint64]string

func ZipUint64Uint 

func ZipUint64Uint(list1 []uint64, list2 []uint) map[uint64]uint

ZipUint64Uint takes two inputs: first list of type: []uint64, second list of type: []uint. Then it merges two list and returns a new map of type: map[uint64]uint

func ZipUint64Uint16 

func ZipUint64Uint16(list1 []uint64, list2 []uint16) map[uint64]uint16

ZipUint64Uint16 takes two inputs: first list of type: []uint64, second list of type: []uint16. Then it merges two list and returns a new map of type: map[uint64]uint16

func ZipUint64Uint16Ptr 

func ZipUint64Uint16Ptr(list1 []*uint64, list2 []*uint16) map[*uint64]*uint16

ZipUint64Uint16Ptr takes two inputs: first list of type: []uint64, second list of type: []uint16. Then it merges two list and returns a new map of type: map[uint64]uint16

func ZipUint64Uint32 

func ZipUint64Uint32(list1 []uint64, list2 []uint32) map[uint64]uint32

ZipUint64Uint32 takes two inputs: first list of type: []uint64, second list of type: []uint32. Then it merges two list and returns a new map of type: map[uint64]uint32

func ZipUint64Uint32Ptr 

func ZipUint64Uint32Ptr(list1 []*uint64, list2 []*uint32) map[*uint64]*uint32

ZipUint64Uint32Ptr takes two inputs: first list of type: []uint64, second list of type: []uint32. Then it merges two list and returns a new map of type: map[uint64]uint32

func ZipUint64Uint8 

func ZipUint64Uint8(list1 []uint64, list2 []uint8) map[uint64]uint8

ZipUint64Uint8 takes two inputs: first list of type: []uint64, second list of type: []uint8. Then it merges two list and returns a new map of type: map[uint64]uint8

func ZipUint64Uint8Ptr 

func ZipUint64Uint8Ptr(list1 []*uint64, list2 []*uint8) map[*uint64]*uint8

ZipUint64Uint8Ptr takes two inputs: first list of type: []uint64, second list of type: []uint8. Then it merges two list and returns a new map of type: map[uint64]uint8

func ZipUint64UintPtr 

func ZipUint64UintPtr(list1 []*uint64, list2 []*uint) map[*uint64]*uint

ZipUint64UintPtr takes two inputs: first list of type: []uint64, second list of type: []uint. Then it merges two list and returns a new map of type: map[uint64]uint

func ZipUint8 

func ZipUint8(list1 []uint8, list2 []uint8) map[uint8]uint8

ZipUint8 takes two inputs: first list of type: []uint8, second list of type: []uint8. Then it merges two list and returns a new map of type: map[uint8]uint8

func ZipUint8Bool 

func ZipUint8Bool(list1 []uint8, list2 []bool) map[uint8]bool

ZipUint8Bool takes two inputs: first list of type: []uint8, second list of type: []bool. Then it merges two list and returns a new map of type: map[uint8]bool

func ZipUint8BoolPtr 

func ZipUint8BoolPtr(list1 []*uint8, list2 []*bool) map[*uint8]*bool

ZipUint8BoolPtr takes two inputs: first list of type: []uint8, second list of type: []bool. Then it merges two list and returns a new map of type: map[uint8]bool

func ZipUint8Float32 

func ZipUint8Float32(list1 []uint8, list2 []float32) map[uint8]float32

ZipUint8Float32 takes two inputs: first list of type: []uint8, second list of type: []float32. Then it merges two list and returns a new map of type: map[uint8]float32

func ZipUint8Float32Ptr 

func ZipUint8Float32Ptr(list1 []*uint8, list2 []*float32) map[*uint8]*float32

ZipUint8Float32Ptr takes two inputs: first list of type: []uint8, second list of type: []float32. Then it merges two list and returns a new map of type: map[uint8]float32

func ZipUint8Float64 

func ZipUint8Float64(list1 []uint8, list2 []float64) map[uint8]float64

ZipUint8Float64 takes two inputs: first list of type: []uint8, second list of type: []float64. Then it merges two list and returns a new map of type: map[uint8]float64

func ZipUint8Float64Ptr 

func ZipUint8Float64Ptr(list1 []*uint8, list2 []*float64) map[*uint8]*float64

ZipUint8Float64Ptr takes two inputs: first list of type: []uint8, second list of type: []float64. Then it merges two list and returns a new map of type: map[uint8]float64

func ZipUint8Int 

func ZipUint8Int(list1 []uint8, list2 []int) map[uint8]int

ZipUint8Int takes two inputs: first list of type: []uint8, second list of type: []int. Then it merges two list and returns a new map of type: map[uint8]int

func ZipUint8Int16 

func ZipUint8Int16(list1 []uint8, list2 []int16) map[uint8]int16

ZipUint8Int16 takes two inputs: first list of type: []uint8, second list of type: []int16. Then it merges two list and returns a new map of type: map[uint8]int16

func ZipUint8Int16Ptr 

func ZipUint8Int16Ptr(list1 []*uint8, list2 []*int16) map[*uint8]*int16

ZipUint8Int16Ptr takes two inputs: first list of type: []uint8, second list of type: []int16. Then it merges two list and returns a new map of type: map[uint8]int16

func ZipUint8Int32 

func ZipUint8Int32(list1 []uint8, list2 []int32) map[uint8]int32

ZipUint8Int32 takes two inputs: first list of type: []uint8, second list of type: []int32. Then it merges two list and returns a new map of type: map[uint8]int32

func ZipUint8Int32Ptr 

func ZipUint8Int32Ptr(list1 []*uint8, list2 []*int32) map[*uint8]*int32

ZipUint8Int32Ptr takes two inputs: first list of type: []uint8, second list of type: []int32. Then it merges two list and returns a new map of type: map[uint8]int32

func ZipUint8Int64 

func ZipUint8Int64(list1 []uint8, list2 []int64) map[uint8]int64

ZipUint8Int64 takes two inputs: first list of type: []uint8, second list of type: []int64. Then it merges two list and returns a new map of type: map[uint8]int64

func ZipUint8Int64Ptr 

func ZipUint8Int64Ptr(list1 []*uint8, list2 []*int64) map[*uint8]*int64

ZipUint8Int64Ptr takes two inputs: first list of type: []uint8, second list of type: []int64. Then it merges two list and returns a new map of type: map[uint8]int64

func ZipUint8Int8 

func ZipUint8Int8(list1 []uint8, list2 []int8) map[uint8]int8

ZipUint8Int8 takes two inputs: first list of type: []uint8, second list of type: []int8. Then it merges two list and returns a new map of type: map[uint8]int8

func ZipUint8Int8Ptr 

func ZipUint8Int8Ptr(list1 []*uint8, list2 []*int8) map[*uint8]*int8

ZipUint8Int8Ptr takes two inputs: first list of type: []uint8, second list of type: []int8. Then it merges two list and returns a new map of type: map[uint8]int8

func ZipUint8IntPtr 

func ZipUint8IntPtr(list1 []*uint8, list2 []*int) map[*uint8]*int

ZipUint8IntPtr takes two inputs: first list of type: []uint8, second list of type: []int. Then it merges two list and returns a new map of type: map[uint8]int

func ZipUint8Ptr 

func ZipUint8Ptr(list1 []*uint8, list2 []*uint8) map[*uint8]*uint8

ZipUint8Ptr takes two inputs: first list of type: []uint8, second list of type: []uint8. Then it merges two list and returns a new map of type: map[uint8]uint8

func ZipUint8Str 

func ZipUint8Str(list1 []uint8, list2 []string) map[uint8]string

ZipUint8Str takes two inputs: first list of type: []uint8, second list of type: []string. Then it merges two list and returns a new map of type: map[uint8]string

func ZipUint8StrPtr 

func ZipUint8StrPtr(list1 []*uint8, list2 []*string) map[*uint8]*string

ZipUint8StrPtr takes two inputs: first list of type: []uint8, second list of type: []string. Then it merges two list and returns a new map of type: map[uint8]string

func ZipUint8Uint 

func ZipUint8Uint(list1 []uint8, list2 []uint) map[uint8]uint

ZipUint8Uint takes two inputs: first list of type: []uint8, second list of type: []uint. Then it merges two list and returns a new map of type: map[uint8]uint

func ZipUint8Uint16 

func ZipUint8Uint16(list1 []uint8, list2 []uint16) map[uint8]uint16

ZipUint8Uint16 takes two inputs: first list of type: []uint8, second list of type: []uint16. Then it merges two list and returns a new map of type: map[uint8]uint16

func ZipUint8Uint16Ptr 

func ZipUint8Uint16Ptr(list1 []*uint8, list2 []*uint16) map[*uint8]*uint16

ZipUint8Uint16Ptr takes two inputs: first list of type: []uint8, second list of type: []uint16. Then it merges two list and returns a new map of type: map[uint8]uint16

func ZipUint8Uint32 

func ZipUint8Uint32(list1 []uint8, list2 []uint32) map[uint8]uint32

ZipUint8Uint32 takes two inputs: first list of type: []uint8, second list of type: []uint32. Then it merges two list and returns a new map of type: map[uint8]uint32

func ZipUint8Uint32Ptr 

func ZipUint8Uint32Ptr(list1 []*uint8, list2 []*uint32) map[*uint8]*uint32

ZipUint8Uint32Ptr takes two inputs: first list of type: []uint8, second list of type: []uint32. Then it merges two list and returns a new map of type: map[uint8]uint32

func ZipUint8Uint64 

func ZipUint8Uint64(list1 []uint8, list2 []uint64) map[uint8]uint64

ZipUint8Uint64 takes two inputs: first list of type: []uint8, second list of type: []uint64. Then it merges two list and returns a new map of type: map[uint8]uint64

func ZipUint8Uint64Ptr 

func ZipUint8Uint64Ptr(list1 []*uint8, list2 []*uint64) map[*uint8]*uint64

ZipUint8Uint64Ptr takes two inputs: first list of type: []uint8, second list of type: []uint64. Then it merges two list and returns a new map of type: map[uint8]uint64

func ZipUint8UintPtr 

func ZipUint8UintPtr(list1 []*uint8, list2 []*uint) map[*uint8]*uint

ZipUint8UintPtr takes two inputs: first list of type: []uint8, second list of type: []uint. Then it merges two list and returns a new map of type: map[uint8]uint

func ZipUintBool 

func ZipUintBool(list1 []uint, list2 []bool) map[uint]bool

ZipUintBool takes two inputs: first list of type: []uint, second list of type: []bool. Then it merges two list and returns a new map of type: map[uint]bool

func ZipUintBoolPtr 

func ZipUintBoolPtr(list1 []*uint, list2 []*bool) map[*uint]*bool

ZipUintBoolPtr takes two inputs: first list of type: []uint, second list of type: []bool. Then it merges two list and returns a new map of type: map[uint]bool

func ZipUintFloat32 

func ZipUintFloat32(list1 []uint, list2 []float32) map[uint]float32

ZipUintFloat32 takes two inputs: first list of type: []uint, second list of type: []float32. Then it merges two list and returns a new map of type: map[uint]float32

func ZipUintFloat32Ptr 

func ZipUintFloat32Ptr(list1 []*uint, list2 []*float32) map[*uint]*float32

ZipUintFloat32Ptr takes two inputs: first list of type: []uint, second list of type: []float32. Then it merges two list and returns a new map of type: map[uint]float32

func ZipUintFloat64 

func ZipUintFloat64(list1 []uint, list2 []float64) map[uint]float64

ZipUintFloat64 takes two inputs: first list of type: []uint, second list of type: []float64. Then it merges two list and returns a new map of type: map[uint]float64

func ZipUintFloat64Ptr 

func ZipUintFloat64Ptr(list1 []*uint, list2 []*float64) map[*uint]*float64

ZipUintFloat64Ptr takes two inputs: first list of type: []uint, second list of type: []float64. Then it merges two list and returns a new map of type: map[uint]float64

func ZipUintInt 

func ZipUintInt(list1 []uint, list2 []int) map[uint]int

ZipUintInt takes two inputs: first list of type: []uint, second list of type: []int. Then it merges two list and returns a new map of type: map[uint]int

func ZipUintInt16 

func ZipUintInt16(list1 []uint, list2 []int16) map[uint]int16

ZipUintInt16 takes two inputs: first list of type: []uint, second list of type: []int16. Then it merges two list and returns a new map of type: map[uint]int16

func ZipUintInt16Ptr 

func ZipUintInt16Ptr(list1 []*uint, list2 []*int16) map[*uint]*int16

ZipUintInt16Ptr takes two inputs: first list of type: []uint, second list of type: []int16. Then it merges two list and returns a new map of type: map[uint]int16

func ZipUintInt32 

func ZipUintInt32(list1 []uint, list2 []int32) map[uint]int32

ZipUintInt32 takes two inputs: first list of type: []uint, second list of type: []int32. Then it merges two list and returns a new map of type: map[uint]int32

func ZipUintInt32Ptr 

func ZipUintInt32Ptr(list1 []*uint, list2 []*int32) map[*uint]*int32

ZipUintInt32Ptr takes two inputs: first list of type: []uint, second list of type: []int32. Then it merges two list and returns a new map of type: map[uint]int32

func ZipUintInt64 

func ZipUintInt64(list1 []uint, list2 []int64) map[uint]int64

ZipUintInt64 takes two inputs: first list of type: []uint, second list of type: []int64. Then it merges two list and returns a new map of type: map[uint]int64

func ZipUintInt64Ptr 

func ZipUintInt64Ptr(list1 []*uint, list2 []*int64) map[*uint]*int64

ZipUintInt64Ptr takes two inputs: first list of type: []uint, second list of type: []int64. Then it merges two list and returns a new map of type: map[uint]int64

func ZipUintInt8 

func ZipUintInt8(list1 []uint, list2 []int8) map[uint]int8

ZipUintInt8 takes two inputs: first list of type: []uint, second list of type: []int8. Then it merges two list and returns a new map of type: map[uint]int8

func ZipUintInt8Ptr 

func ZipUintInt8Ptr(list1 []*uint, list2 []*int8) map[*uint]*int8

ZipUintInt8Ptr takes two inputs: first list of type: []uint, second list of type: []int8. Then it merges two list and returns a new map of type: map[uint]int8

func ZipUintIntPtr 

func ZipUintIntPtr(list1 []*uint, list2 []*int) map[*uint]*int

ZipUintIntPtr takes two inputs: first list of type: []uint, second list of type: []int. Then it merges two list and returns a new map of type: map[uint]int

func ZipUintPtr 

func ZipUintPtr(list1 []*uint, list2 []*uint) map[*uint]*uint

ZipUintPtr takes two inputs: first list of type: []uint, second list of type: []uint. Then it merges two list and returns a new map of type: map[uint]uint

func ZipUintStr 

func ZipUintStr(list1 []uint, list2 []string) map[uint]string

ZipUintStr takes two inputs: first list of type: []uint, second list of type: []string. Then it merges two list and returns a new map of type: map[uint]string

func ZipUintStrPtr 

func ZipUintStrPtr(list1 []*uint, list2 []*string) map[*uint]*string

ZipUintStrPtr takes two inputs: first list of type: []uint, second list of type: []string. Then it merges two list and returns a new map of type: map[uint]string

func ZipUintUint16 

func ZipUintUint16(list1 []uint, list2 []uint16) map[uint]uint16

ZipUintUint16 takes two inputs: first list of type: []uint, second list of type: []uint16. Then it merges two list and returns a new map of type: map[uint]uint16

func ZipUintUint16Ptr 

func ZipUintUint16Ptr(list1 []*uint, list2 []*uint16) map[*uint]*uint16

ZipUintUint16Ptr takes two inputs: first list of type: []uint, second list of type: []uint16. Then it merges two list and returns a new map of type: map[uint]uint16

func ZipUintUint32 

func ZipUintUint32(list1 []uint, list2 []uint32) map[uint]uint32

ZipUintUint32 takes two inputs: first list of type: []uint, second list of type: []uint32. Then it merges two list and returns a new map of type: map[uint]uint32

func ZipUintUint32Ptr 

func ZipUintUint32Ptr(list1 []*uint, list2 []*uint32) map[*uint]*uint32

ZipUintUint32Ptr takes two inputs: first list of type: []uint, second list of type: []uint32. Then it merges two list and returns a new map of type: map[uint]uint32

func ZipUintUint64 

func ZipUintUint64(list1 []uint, list2 []uint64) map[uint]uint64

ZipUintUint64 takes two inputs: first list of type: []uint, second list of type: []uint64. Then it merges two list and returns a new map of type: map[uint]uint64

func ZipUintUint64Ptr 

func ZipUintUint64Ptr(list1 []*uint, list2 []*uint64) map[*uint]*uint64

ZipUintUint64Ptr takes two inputs: first list of type: []uint, second list of type: []uint64. Then it merges two list and returns a new map of type: map[uint]uint64

func ZipUintUint8 

func ZipUintUint8(list1 []uint, list2 []uint8) map[uint]uint8

ZipUintUint8 takes two inputs: first list of type: []uint, second list of type: []uint8. Then it merges two list and returns a new map of type: map[uint]uint8

func ZipUintUint8Ptr 

func ZipUintUint8Ptr(list1 []*uint, list2 []*uint8) map[*uint]*uint8

ZipUintUint8Ptr takes two inputs: first list of type: []uint, second list of type: []uint8. Then it merges two list and returns a new map of type: map[uint]uint8

Types

type Optional 

type Optional struct {
	FixedPool   int // number of goroutines
	RandomOrder bool
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.