lists.go

package utils

func First[T any](list []T) *T {
	if len(list) == 0 {
		return nil
	}
	return &list[0]
}

func FirstFn[T any](list []T, fn func(T) bool) *T {
	for _, t := range list {
		if fn(t) {
			return &t
		}
	}
	return nil
}

func Single[T any](list []T) (*T, error) {
	if len(list) == 1 {
		return &list[0], nil
	}
	return nil, ErrNoSingleElement
}

func SingleFn[T any](list []T, fn func(T) bool) (*T, error) {
	var single *T = nil
	for _, t := range list {
		if fn(t) {
			if single == nil {
				single = &t
			} else {
				return nil, ErrNoSingleElement
			}
		}
	}
	if single != nil {
		return single, nil
	}
	return nil, ErrNoSingleElement
}

func Filter[T any](list []T, fn func(T) bool) []T {
	result := make([]T, 0)
	for _, t := range list {
		if fn(t) {
			result = append(result, t)
		}
	}
	return result
}

func FilterNotNil[T any](list []*T) []*T {
	result := make([]*T, 0)
	for _, t := range list {
		if t != nil {
			result = append(result, t)
		}
	}
	return result
}

func Map[T, R any](list []T, fn func(T) R) []R {
	result := make([]R, 0, len(list))
	for _, t := range list {
		result = append(result, fn(t))
	}
	return result
}

func Any[T any](list []T, fn func(T) bool) bool {
	for _, t := range list {
		if fn(t) {
			return true
		}
	}
	return false
}

func All[T any](list []T, fn func(T) bool) bool {
	for _, t := range list {
		if !fn(t) {
			return false
		}
	}
	return true
}

func None[T any](list []T, fn func(T) bool) bool {
	return !Any(list, fn)
}

func Distinct[T comparable](list []T) []T {
	seen := make(map[T]struct{})
	result := make([]T, 0)
	for _, t := range list {
		if _, ok := seen[t]; !ok {
			seen[t] = struct{}{}
			result = append(result, t)
		}
	}
	return result
}

func ListEqual[T comparable](a, b []T) bool {
	if len(a) != len(b) {
		return false
	}
	for i := range a {
		if a[i] != b[i] {
			return false
		}
	}
	return true
}

func Count[T any](list []T, fn func(T) bool) int {
	count := 0
	for _, t := range list {
		if fn(t) {
			count++
		}
	}
	return count
}

// Sum returns the sum of the elements in the list.
func Sum[T Number](list []T) T {
	sum := T(0)
	for _, t := range list {
		sum += t
	}
	return sum
}

// SumBy returns the sum of the elements in the list mapped by fn.
func SumBy[T any, N Number](list []T, fn func(T) N) N {
	sum := N(0)
	for _, t := range list {
		sum += fn(t)
	}
	return sum
}