apply.go2

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package filter contains utility functions for filtering slices through the
// distributed application of a filter function.
//
// The package is an experiment to see how easy it is to write such things
// in Go. It is easy, but for loops are just as easy and more efficient.
//
// You should not use this package.
//
package filter // import "robpike.io/filter"

// Apply takes a slice of type []T and a function of type func(T) U. (If the
// input conditions are not satisfied, Apply panics.) It returns a newly
// allocated slice where each element is the result of calling the function on
// successive elements of the slice.
func Apply[T, U any](slice []T, function func(T) U) []U {
	out := make([]U, len(slice))
	for i, x := range slice {
		out[i] = function(x)
	}
	return out
}

// ApplyInPlace is like Apply, but overwrites the slice rather than returning a
// newly allocated slice.
func ApplyInPlace[T any](slice []T, function func(T) T) {
	for i, x := range slice {
		slice[i] = function(x)
	}
}

// Choose takes a slice of type []T and a function of type func(T) bool. It returns a newly
// allocated slice containing only those elements of the input slice that
// satisfy the function.
func Choose[T any](slice []T, function func(T) bool) []T {
	out := make([]T, 0)
	for _, x := range slice {
		if function(x) {
			out = append(out, x)
		}
	}
	return out
}

// Drop takes a slice of type []T and a function of type func(T) bool. It returns a newly
// allocated slice containing only those elements of the input slice that do
// not satisfy the function, that is, it removes elements that satisfy the
// function.
func Drop[T any](slice []T, function func(T) bool) []T {
	out := make([]T, 0)
	for _, x := range slice {
		if !function(x) {
			out = append(out, x)
		}
	}
	return out
}

// ChooseInPlace is like Choose, but overwrites the slice rather than returning
// a newly allocated slice. Since ChooseInPlace must modify the slice,
// it takes as argument a pointer to a slice rather than a slice.
func ChooseInPlace[T any](pointerToSlice *[]T, function func(T) bool) {
	out := (*pointerToSlice)[:0]
	for _, x := range *pointerToSlice {
		if function(x) {
			out = append(out, x)
		}
	}
	*pointerToSlice = out
}

// DropInPlace is like Drop, but overwrites the slice rather than returning a
// newly allocated slice. Since DropInPlace must modify the slice,
// it takes as argument a pointer to a slice rather than a slice.
func DropInPlace[T any](pointerToSlice *[]T, function func(T) bool) {
	out := (*pointerToSlice)[:0]
	for _, x := range *pointerToSlice {
		if !function(x) {
			out = append(out, x)
		}
	}
	*pointerToSlice = out
}