jackhammer

slicesx.go (7970B)

---

 // Package slicesx provides slice utilities that compliment Go standard
 // slices package.
 package slicesx
 
 import (
 	"errors"
 	"fmt"
 	"maps"
 	"slices"
 	"sync"
 
 	"git.sr.ht/~jackmordaunt/jackhammer/errorsx"
 	"git.sr.ht/~jackmordaunt/jackhammer/iterx"
 )
 
 // Fanout across all elements of a slice in parallel.
 // The function receives the index and element.
 func Fanout[S ~[]E, E any](seq S, fn func(int, E)) {
 	iterx.Fanout2(slices.All(seq), fn)
 }
 
 // FanoutErr is like [Fanout] but returns an aggregated error.
 func FanoutErr[S ~[]E, E any](seq S, fn func(int, E) error) error {
 	return iterx.FanoutErr2(slices.All(seq), fn)
 }
 
 // Map transforms a slice by applying a function to each element and returning the result.
 func Map[S ~[]E, E any, Out any](s S, fn func(E) Out) []Out {
 	out := make([]Out, len(s))
 	for ii := range s {
 		out[ii] = fn(s[ii])
 	}
 	return out
 }
 
 // MapIndex is like [Map] but provides the iteration index to the transform function.
 func MapIndex[S ~[]E, E any, Out any](s S, fn func(int, E) Out) []Out {
 	out := make([]Out, len(s))
 	for ii := range s {
 		out[ii] = fn(ii, s[ii])
 	}
 	return out
 }
 
 // MapSafe is like [Map] but recovers from panics and returns an error instead.
 func MapSafe[S ~[]E, E any, Out any](s S, fn func(E) Out) (_ []Out, err error) {
 	defer func() {
 		if v := recover(); v != nil {
 			if e, ok := v.(error); ok {
 				err = e
 			} else {
 				err = fmt.Errorf("%v", v)
 			}
 		}
 	}()
 	return Map(s, fn), err
 }
 
 // MapIndexSafe is like [MapIndex] but recovers from panics and returns an error instead.
 func MapIndexSafe[S ~[]E, E any, Out any](s S, fn func(int, E) Out) (_ []Out, err error) {
 	defer func() {
 		if v := recover(); v != nil {
 			if e, ok := v.(error); ok {
 				err = e
 			} else {
 				err = fmt.Errorf("%v", v)
 			}
 		}
 	}()
 	return MapIndex(s, fn), err
 }
 
 // ParaMap transforms a slice by applying a function to each element and returning the result.
 // Transforms are executed concurrently.
 func ParaMap[S ~[]E, E any, Out any](s S, fn func(E) Out) []Out {
 	out := make([]Out, len(s))
 	wg := sync.WaitGroup{}
 	for ii := range s {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			out[ii] = fn(s[ii])
 		}()
 	}
 	wg.Wait()
 	return out
 }
 
 // MapErr transforms a slice by applying a fallible function to each element and
 // returning the result.
 //
 // If the function returns an error the map operation completes, returning an
 // aggregated error for each failed transform. The output list will be short
 // by the number of failures. Length of the output is not guaranteed to match that
 // of the input.
 func MapErr[S ~[]E, E any, Out any](s S, fn func(E) (Out, error)) (out []Out, err error) {
 	out = make([]Out, 0, len(s))
 	for ii := range s {
 		v, e := fn(s[ii])
 		if e != nil {
 			err = errors.Join(err, e)
 		} else {
 			out = append(out, v)
 		}
 	}
 	return out, err
 }
 
 // ParaMapErr is [MapErr], but all instances of fn run concurrently.
 func ParaMapErr[S ~[]E, E any, Out any](s S, fn func(E) (Out, error)) (out []Out, err error) {
 	out = make([]Out, len(s))
 	errs := make([]error, len(s))
 	wg := sync.WaitGroup{}
 
 	for ii := range s {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			v, e := fn(s[ii])
 			if e != nil {
 				errs[ii] = e
 			} else {
 				out[ii] = v
 			}
 		}()
 	}
 
 	wg.Wait()
 
 	for ii, err := range errs {
 		if err != nil {
 			out = slices.Delete(out, ii, ii+1)
 		}
 	}
 
 	if len(errs) > 0 {
 		return out, errorsx.PolyError{Errs: errs}
 	}
 
 	return out, nil
 }
 
 // For processes a sequence with the given function.
 func For[S ~[]E, E any](seq S, fn func(int, E)) {
 	iterx.For2(slices.All(seq), fn)
 }
 
 // ForErr processes a sequence with the given function.
 func ForErr[S ~[]E, E any](seq S, fn func(int, E) error) error {
 	return iterx.ForErr2(slices.All(seq), fn)
 }
 
 // Generate returns a slice of [n] items produced by [fn].
 func Generate[E any](n int, fn func(int) E) []E {
 	out := make([]E, n)
 	for ii := range n {
 		out[ii] = fn(ii)
 	}
 	return out
 }
 
 // Repeat returns a slice of [n] items of value [v].
 func Repeat[E any](n int, v E) []E {
 	out := make([]E, n)
 	for ii := range n {
 		out[ii] = v
 	}
 	return out
 }
 
 // PopFront returns the first element from the slice.
 func PopFront[S ~[]E, E any](s *S) E {
 	defer func() { (*s) = (*s)[1:] }()
 	return (*s)[0]
 }
 
 // PopFrontSafe returns the first element from the slice, or false.
 func PopFrontSafe[S ~[]E, E any](s *S) (e E, ok bool) {
 	if s == nil {
 		return e, false
 	}
 	if len(*s) == 0 {
 		return e, false
 	}
 	return PopFront(s), true
 }
 
 // PopBack returns the last element from the slice.
 func PopBack[S ~[]E, E any](s *S) E {
 	defer func() { (*s) = (*s)[:len(*s)-1] }()
 	return (*s)[len(*s)-1]
 }
 
 // PopBackSafe returns the last element from the slice, or false.
 func PopBackSafe[S ~[]E, E any](s *S) (e E, ok bool) {
 	if s == nil {
 		return e, false
 	}
 	if len(*s) == 0 {
 		return e, false
 	}
 	return PopBack(s), true
 }
 
 // Filter out elements from a slice when the predicate returns false.
 func Filter[S ~[]E, E any](s S, fn func(E) bool) S {
 	out := make(S, 0, len(s))
 	for _, v := range s {
 		if fn(v) {
 			out = append(out, v)
 		}
 	}
 	return slices.Clip(out)
 }
 
 // FilterMap maps [In] to [Out], ignoring entries that return false.
 func FilterMap[S ~[]In, In any, Out any](s S, fn func(In) (Out, bool)) []Out {
 	out := make([]Out, 0, len(s))
 	for _, v := range s {
 		if v, ok := fn(v); ok {
 			out = append(out, v)
 		}
 	}
 	return slices.Clip(out)
 }
 
 // TakeRange selects all items between [start] and [end] and removes them from the slice.
 // Does not bounds check.
 func TakeRange[S ~[]E, E any](s *S, start, end int) S {
 	taken := (*s)[start:end]
 	*s = slices.Delete(*s, start, end)
 	return taken
 }
 
 // TakeRangeSafe selects all items between [start] and [end] and removes them from the slice.
 // Checks the bounds.
 func TakeRangeSafe[S ~[]E, E any](s *S, start, end int) (S, bool) {
 	if start < 0 || start >= end || end < 0 || end > len(*s)-1 || start > len(*s)-1 {
 		return nil, false
 	}
 	taken := (*s)[start:end]
 	*s = slices.Delete(*s, start, end)
 	return taken, true
 }
 
 // TakeAllFunc selects all items for which [fn] returns true and removes them from the slice.
 func TakeAllFunc[S ~[]E, E any](s *S, fn func(E) bool) (S, bool) {
 	indexes := []int{}
 	for ii, v := range *s {
 		if fn(v) {
 			indexes = append(indexes, ii)
 		}
 	}
 	if len(indexes) == 0 {
 		return nil, false
 	}
 	out := make(S, 0, len(indexes))
 	for _, index := range indexes {
 		out = append(out, (*s)[index])
 	}
 	*s = slices.DeleteFunc(*s, fn)
 	return out, true
 }
 
 // Take selects the item and removes it, without bounds checks.
 func Take[S ~[]E, E any](s *S, index int) E {
 	taken := (*s)[index]
 	*s = slices.Delete(*s, index, index+1)
 	return taken
 }
 
 // TakeSafe selects the item and removes it, returning true if found.
 func TakeSafe[S ~[]E, E any](s *S, index int) (E, bool) {
 	if index < 0 || index > len(*s)-1 {
 		return *new(E), false
 	}
 	taken := (*s)[index]
 	*s = slices.Delete(*s, index, index+1)
 	return taken, true
 }
 
 // TakeFunc selects the first item that satisfies [fn] and removes it.
 func TakeFunc[S ~[]E, E any](s *S, fn func(E) bool) (E, bool) {
 	ii := slices.IndexFunc(*s, fn)
 	if ii < 0 {
 		return *new(E), false
 	}
 	taken := (*s)[ii]
 	*s = slices.Delete(*s, ii, ii+1)
 	return taken, true
 }
 
 // Normalize de-duplicates a slices of comparable elements.
 // Doesn't rely on sorting.
 func Normalize[S ~[]E, E comparable](s S) S {
 	s = slices.Clone(s)
 	seen := map[E]struct{}{}
 	for _, e := range s {
 		seen[e] = struct{}{}
 	}
 	return slices.Collect(maps.Keys(seen))
 }
 
 // Flatten reduces a 2D slices to a 1D slice.
 func Flatten[E any](s [][]E) []E {
 	count := 0
 	for _, ss := range s {
 		count += len(ss)
 	}
 
 	out := make([]E, 0, count)
 
 	for _, ss := range s {
 		for _, e := range ss {
 			out = append(out, e)
 		}
 	}
 
 	return out
 }
 
 // ToMap converts a slice to a map, using [keyFor] to extract the key from each element.
 func ToMap[S ~[]E, E any, K comparable](s S, keyFor func(int, E) K) map[K]E {
 	return iterx.ToMap(slices.All(s), keyFor)
 }