func PMapEmployerPtr(f func(*employer.Employer) *employer.Employer, list []*employer.Employer, optional ...fp.Optional) []*employer.Employer {
	if f == nil {
		return []*employer.Employer{}
	}
	var worker = len(list)
	if optional != nil && len(optional) > 0 {
		if optional[0].FixedPool > 0 && optional[0].FixedPool < worker {
			worker = optional[0].FixedPool
		}
		if optional[0].RandomOrder == true {
			return pMapEmployerPtrNoOrder(f, list, worker)
		}
	}
	return pMapEmployerPtrPreserveOrder(f, list, worker)
}
PMapEmployerPtr applies the function(1st argument) on each item in the list and returns a new list.
Order of new list is guaranteed. This feature can be disabled by passing: Optional{RandomOrder: true} to gain performance
Run in parallel. no_of_goroutines = no_of_items_in_list or 3rd argument can be passed to fix the number of goroutines.

Takes 3 inputs. 3rd argument is optional
1. Function - takes 1 input
2. List
3. optional argument - fp.Optional{FixedPool: <some_number>}
package gfp
import _ "reflect" 
import "sync" 
import "github.com/logic-building/functional-go/fp" 
import "github.com/logic-building/functional-go/internal/employee" 
import "github.com/logic-building/functional-go/internal/employer" 
func MapEmployer(f func(employer.Employer) employer.Employer, list []employer.Employer) []employer.Employer {
	if f == nil {
		return []employer.Employer{}
	}
	newList := make([]employer.Employer, len(list))
	for i, v := range list {
		newList[i] = f(v)
	}
	return newList
}
func MapEmployerPtr(f func(*employer.Employer) *employer.Employer, list []*employer.Employer) []*employer.Employer {
	if f == nil {
		return []*employer.Employer{}
	}
	newList := make([]*employer.Employer, len(list))
	for i, v := range list {
		newList[i] = f(v)
	}
	return newList
}
func MapEmployerPtrErr(f func(*employer.Employer) (*employer.Employer, error), list []*employer.Employer) ([]*employer.Employer, error) {
	if f == nil {
		return []*employer.Employer{}, nil
	}
	newList := make([]*employer.Employer, len(list))
	for i, v := range list {
		var err error
		newList[i], err = f(v)
		if err != nil {
			return nil, err
		}
	}
	return newList, nil
}
func MapEmployerErr(f func(employer.Employer) (employer.Employer, error), list []employer.Employer) ([]employer.Employer, error) {
	if f == nil {
		return []employer.Employer{}, nil
	}
	newList := make([]employer.Employer, len(list))
	for i, v := range list {
		var err error
		newList[i], err = f(v)
		if err != nil {
			return nil, err
		}
	}
	return newList, nil
}
func FilterEmployer(f func(employer.Employer) bool, list []employer.Employer) []employer.Employer {
	if f == nil {
		return []employer.Employer{}
	}
	var newList []employer.Employer
	for _, v := range list {
		if f(v) {
			newList = append(newList, v)
		}
	}
	return newList
}
func FilterEmployerPtr(f func(*employer.Employer) bool, list []*employer.Employer) []*employer.Employer {
	if f == nil {
		return []*employer.Employer{}
	}
	var newList []*employer.Employer
	for _, v := range list {
		if f(v) {
			newList = append(newList, v)
		}
	}
	return newList
}
func FilterEmployerPtrErr(f func(*employer.Employer) (bool, error), list []*employer.Employer) ([]*employer.Employer, error) {
	if f == nil {
		return []*employer.Employer{}, nil
	}
	var newList []*employer.Employer
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}
func FilterEmployerErr(f func(employer.Employer) (bool, error), list []employer.Employer) ([]employer.Employer, error) {
	if f == nil {
		return []employer.Employer{}, nil
	}
	var newList []employer.Employer
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}
func RemoveEmployer(f func(employer.Employer) bool, list []employer.Employer) []employer.Employer {
	if f == nil {
		return []employer.Employer{}
	}
	var newList []employer.Employer
	for _, v := range list {
		if !f(v) {
			newList = append(newList, v)
		}
	}
	return newList
}
func RemoveEmployerPtr(f func(*employer.Employer) bool, list []*employer.Employer) []*employer.Employer {
	if f == nil {
		return []*employer.Employer{}
	}
	var newList []*employer.Employer
	for _, v := range list {
		if !f(v) {
			newList = append(newList, v)
		}
	}
	return newList
}
func RemoveEmployerPtrErr(f func(*employer.Employer) (bool, error), list []*employer.Employer) ([]*employer.Employer, error) {
	if f == nil {
		return []*employer.Employer{}, nil
	}
	var newList []*employer.Employer
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if !r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}
func RemoveEmployerErr(f func(employer.Employer) (bool, error), list []employer.Employer) ([]employer.Employer, error) {
	if f == nil {
		return []employer.Employer{}, nil
	}
	var newList []employer.Employer
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if !r {
			newList = append(newList, v)
		}
	}
	return newList, nil
}
func SomeEmployer(f func(employer.Employer) bool, list []employer.Employer) bool {
	if f == nil {
		return false
	}
	for _, v := range list {
		if f(v) {
			return true
		}
	}
	return false
}
func SomeEmployerPtr(f func(*employer.Employer) bool, list []*employer.Employer) bool {
	if f == nil {
		return false
	}
	for _, v := range list {
		if f(v) {
			return true
		}
	}
	return false
}
func SomeEmployerPtrErr(f func(*employer.Employer) (bool, error), list []*employer.Employer) (bool, error) {
	if f == nil {
		return false, nil
	}
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return false, err
		}
		if r {
			return true, nil
		}
	}
	return false, nil
}
func SomeEmployerErr(f func(employer.Employer) (bool, error), list []employer.Employer) (bool, error) {
	if f == nil {
		return false, nil
	}
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return false, err
		}
		if r {
			return true, nil
		}
	}
	return false, nil
}
func EveryEmployer(f func(employer.Employer) bool, list []employer.Employer) bool {
	if f == nil || len(list) == 0 {
		return false
	}
	for _, v := range list {
		if !f(v) {
			return false
		}
	}
	return true
}
func EveryEmployerPtr(f func(*employer.Employer) bool, list []*employer.Employer) bool {
	if f == nil || len(list) == 0 {
		return false
	}
	for _, v := range list {
		if !f(v) {
			return false
		}
	}
	return true
}
func EveryEmployerPtrErr(f func(*employer.Employer) (bool, error), list []*employer.Employer) (bool, error) {
	if f == nil || len(list) == 0 {
		return false, nil
	}
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return false, err
		}
		if !r {
			return false, nil
		}
	}
	return true, nil
}
func EveryEmployerErr(f func(employer.Employer) (bool, error), list []employer.Employer) (bool, error) {
	if f == nil || len(list) == 0 {
		return false, nil
	}
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return false, err
		}
		if !r {
			return false, nil
		}
	}
	return true, nil
}
func DropWhileEmployer(f func(employer.Employer) bool, list []employer.Employer) []employer.Employer {
	if f == nil {
		return []employer.Employer{}
	}
	var newList []employer.Employer
	for i, v := range list {
		if !f(v) {
			listLen := len(list)
			newList = make([]employer.Employer, listLen-i)
			j := 0
			for i < listLen {
				newList[j] = list[i]
				i++
				j++
			}
			return newList
		}
	}
	return newList
}
func DropWhileEmployerPtr(f func(*employer.Employer) bool, list []*employer.Employer) []*employer.Employer {
	if f == nil {
		return []*employer.Employer{}
	}
	var newList []*employer.Employer
	for i, v := range list {
		if !f(v) {
			listLen := len(list)
			newList = make([]*employer.Employer, listLen-i)
			j := 0
			for i < listLen {
				newList[j] = list[i]
				i++
				j++
			}
			return newList
		}
	}
	return newList
}
func DropWhileEmployerPtrErr(f func(*employer.Employer) (bool, error), list []*employer.Employer) ([]*employer.Employer, error) {
	if f == nil {
		return []*employer.Employer{}, nil
	}
	var newList []*employer.Employer
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if !r {
			listLen := len(list)
			newList = make([]*employer.Employer, listLen-i)
			j := 0
			for i < listLen {
				newList[j] = list[i]
				i++
				j++
			}
			return newList, nil
		}
	}
	return newList, nil
}
func DropWhileEmployerErr(f func(employer.Employer) (bool, error), list []employer.Employer) ([]employer.Employer, error) {
	if f == nil {
		return []employer.Employer{}, nil
	}
	var newList []employer.Employer
	for i, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if !r {
			listLen := len(list)
			newList = make([]employer.Employer, listLen-i)
			j := 0
			for i < listLen {
				newList[j] = list[i]
				i++
				j++
			}
			return newList, nil
		}
	}
	return newList, nil
}
func TakeWhileEmployer(f func(employer.Employer) bool, list []employer.Employer) []employer.Employer {
	if f == nil {
		return []employer.Employer{}
	}
	var newList []employer.Employer
	for _, v := range list {
		if !f(v) {
			return newList
		}
		newList = append(newList, v)
	}
	return newList
}
func (slice employerSlice) TakeWhile(functors ...employerFunctorForFilter) employerSlice {
	tmpSlice := slice
	for _, f := range functors {
		if f == nil {
			continue
		}
		tmpSlice = TakeWhileEmployer(f, tmpSlice)
	}
	return tmpSlice
}
func TakeWhileEmployerPtr(f func(*employer.Employer) bool, list []*employer.Employer) []*employer.Employer {
	if f == nil {
		return []*employer.Employer{}
	}
	var newList []*employer.Employer
	for _, v := range list {
		if !f(v) {
			return newList
		}
		newList = append(newList, v)
	}
	return newList
}
func (slice employerSlicePtr) TakeWhilePtr(functors ...employerFunctorForFilterPtr) employerSlicePtr {
	tmpSlice := slice
	for _, f := range functors {
		if f == nil {
			continue
		}
		tmpSlice = TakeWhileEmployerPtr(f, tmpSlice)
	}
	return tmpSlice
}
func TakeWhileEmployerPtrErr(f func(*employer.Employer) (bool, error), list []*employer.Employer) ([]*employer.Employer, error) {
	if f == nil {
		return []*employer.Employer{}, nil
	}
	var newList []*employer.Employer
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if !r {
			return newList, nil
		}
		newList = append(newList, v)
	}
	return newList, nil
}
func TakeWhileEmployerErr(f func(employer.Employer) (bool, error), list []employer.Employer) ([]employer.Employer, error) {
	if f == nil {
		return []employer.Employer{}, nil
	}
	var newList []employer.Employer
	for _, v := range list {
		r, err := f(v)
		if err != nil {
			return nil, err
		}
		if !r {
			return newList, nil
		}
		newList = append(newList, v)
	}
	return newList, nil
}
func PMapEmployer(f func(employer.Employer) employer.Employer, list []employer.Employer, optional ...fp.Optional) []employer.Employer {
	if f == nil {
		return []employer.Employer{}
	}
	var worker = len(list)
	if optional != nil && len(optional) > 0 {
		if optional[0].FixedPool > 0 && optional[0].FixedPool < worker {
			worker = optional[0].FixedPool
		}
		if optional[0].RandomOrder == true {
			return pMapEmployerNoOrder(f, list, worker)
		}
	}
	return pMapEmployerPreserveOrder(f, list, worker)
}
func pMapEmployerPreserveOrder(f func(employer.Employer) employer.Employer, list []employer.Employer, worker int) []employer.Employer {
	chJobs := make(chan map[int]employer.Employer, len(list))
	go func() {
		for i, v := range list {
			chJobs <- map[int]employer.Employer{i: v}
		}
		close(chJobs)
	}()
	chResult := make(chan map[int]employer.Employer, worker/3)
	var wg sync.WaitGroup
	for i := 0; i < worker; i++ {
		wg.Add(1)
		go func(chResult chan map[int]employer.Employer, chJobs chan map[int]employer.Employer) {
			defer wg.Done()
			for m := range chJobs {
				for k, v := range m {
					chResult <- map[int]employer.Employer{k: f(v)}
				}
			}
		}(chResult, chJobs)
	}
	go func() {
		wg.Wait()
		close(chResult)
	}()
	newListMap := make(map[int]employer.Employer, len(list))
	newList := make([]employer.Employer, len(list))
	for m := range chResult {
		for k, v := range m {
			newListMap[k] = v
		}
	}
	for i := 0; i < len(list); i++ {
		newList[i] = newListMap[i]
	}
	return newList
}
func pMapEmployerNoOrder(f func(employer.Employer) employer.Employer, list []employer.Employer, worker int) []employer.Employer {
	chJobs := make(chan employer.Employer, len(list))
	go func() {
		for _, v := range list {
			chJobs <- v
		}
		close(chJobs)
	}()
	chResult := make(chan employer.Employer, worker/3)
	var wg sync.WaitGroup
	for i := 0; i < worker; i++ {
		wg.Add(1)
		go func(chResult chan employer.Employer, chJobs chan employer.Employer) {
			defer wg.Done()
			for v := range chJobs {
				chResult <- f(v)
			}
		}(chResult, chJobs)
	}
	go func() {
		wg.Wait()
		close(chResult)
	}()
	newList := make([]employer.Employer, len(list))
	i := 0
	for v := range chResult {
		newList[i] = v
		i++
	}
	return newList
}