int.go

package slices

import "sort"

/* generated by github.com/schigh/slices/base/base.go.  do not edit. */

// IntSlice is the alias of []int
type IntSlice []int

// Value returns the aliased []int
func (slice IntSlice) Value() []int {
	return []int(slice)
}

// IndexOf returns the first index of needle, or -1 if not found
func (slice IntSlice) IndexOf(needle int) int {
	for i := 0; i < len(slice); i++ {
		if needle == slice[i] {
			return i
		}
	}

	return NotInSlice
}

// Contains returns true if the slice contains needle
func (slice IntSlice) Contains(needle int) bool {
	return slice.IndexOf(needle) != NotInSlice
}

// SortAsc will sort the slice in ascending order
func (slice IntSlice) SortAsc() IntSlice {
	sort.SliceStable(slice, func(i, j int) bool {
		return slice[i] < slice[j]
	})
	return slice
}

// SortDesc will sort the slice in descending order
func (slice IntSlice) SortDesc() IntSlice {
	sort.SliceStable(slice, func(i, j int) bool {
		return slice[j] < slice[i]
	})
	return slice
}

// Reverse will reverse the order of the slice
func (slice IntSlice) Reverse() IntSlice {
	l := len(slice)
	for i, j := 0, l-1; i < l/2; i++ {
		slice[i], slice[j] = slice[j], slice[i]
		j--
	}

	return slice
}

// Unique filters out duplicate int values
func (slice IntSlice) Unique() IntSlice {
	u := make([]int, 0, len(slice))
	m := make(map[int]bool)

	for i := 0; i < len(slice); i++ {
		if _, ok := m[slice[i]]; !ok {
			m[slice[i]] = true
			u = append(u, slice[i])
		}
	}

	return IntSlice(u)
}

// Filter will return all int values that evaluate true in the user-supplied function
func (slice IntSlice) Filter(f func(int) bool) IntSlice {
	out := make([]int, 0, len(slice))
	for i := 0; i < len(slice); i++ {
		if f(slice[i]) {
			out = append(out, slice[i])
		}
	}

	return IntSlice(out)
}

// Each will apply a function to each int in the slice.
// This function will iterate over the slice completely.  No
// items in the slice should be mutated by this operation.
func (slice IntSlice) Each(f func(int)) {
	for i := 0; i < len(slice); i++ {
		f(slice[i])
	}
}

// TryEach will apply a function to each int in the slice.
// If the function returns an error, the iteration will stop and return
// the index of the element that caused the function to return the error.
// The second returned value will be first error returned from the
// supplied function, and nil otherwise.
// No items in the slice should be mutated by this operation.
func (slice IntSlice) TryEach(f func(int) error) (int, error) {
	for i := 0; i < len(slice); i++ {
		if err := f(slice[i]); err != nil {
			return i, err
		}
	}

	return NotInSlice, nil
}

// IfEach will apply a function to each int in the slice.
// If the function returns false, the iteration will stop and return
// the index of the element that caused the function to return false.
// The second returned value will be true if all members of the slice
// cause the provided function to return true, and false otherwise.
// No items in the slice should be mutated by this operation.
func (slice IntSlice) IfEach(f func(int) bool) (int, bool) {
	for i := 0; i < len(slice); i++ {
		if !f(slice[i]) {
			return i, false
		}
	}

	return NotInSlice, true
}

// Map will apply a function to each int in the slice and replace the previous value
func (slice IntSlice) Map(f func(int) int) {
	for i := 0; i < len(slice); i++ {
		slice[i] = f(slice[i])
	}
}

// Chunk will divide the slice of int into smaller slices defined by chunk length
func (slice IntSlice) Chunk(size int) [][]int {
	l := len(slice)
	if l == 0 || size <= 0 {
		return make([][]int, 0)
	}

	floor := l / size
	out := make([][]int, 0, floor+1)
	var k int

	for i := 0; i < floor; i++ {
		k = i*size + size
		out = append(out, slice[i*size:k])
	}
	if l > k {
		out = append(out, slice[k:])
	}

	return out
}