list

package module
v0.0.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 28, 2025 License: Apache-2.0 Imports: 2 Imported by: 0

README

List

Go Reference Bitbucket Pipelines

A library regrouping functions for manipulating slices

Installation

go get bitbucket.org/amotus/list

Test

go test -cover ./...

License

Licensed under Apache License, Version 2.0 LICENSE.

Documentation

Overview

Package list provides utility functions for working with slices and lists in Go.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Contains 

func Contains[T, E any](list []T, item E, compare func(T, E) bool) bool

Contains checks if an item exists in a slice based on a custom comparison function.

Parameters:

  • list: The slice of items to search within.
  • item: The value to search for in the slice.
  • compare: A comparison function that takes an item of type T and an item of type E and returns true if they are considered equal, false otherwise.

Returns:

  • true if the item is found in the slice according to the comparison function, false otherwise.

Example: 

items := []string{"apple", "banana", "cherry"}
exists := Contains("BANANA", items, func(a, b string) bool {
    return strings.ToLower(a) == strings.ToLower(b)
}) // true

func ContainsComparable 

func ContainsComparable[T comparable](list []T, item T) bool

ContainsComparable checks if a comparable item exists in a slice.

Parameters:

  • list: The slice of comparable items to search within.
  • item: The value to search for in the slice.

Returns:

  • true if the item is found in the slice, false otherwise.

Example: 

items := []int{1, 2, 3}
exists := ContainsComparable(2, items) // true

func ContainsSlice 

func ContainsSlice[T, E any](list []T, subset []E, compare func(T, E) bool) bool

ContainsSlice checks if all elements of one slice (`subset`) are present in another slice (`list`), based on a custom comparison function.

Parameters:

  • list: The slice of items to search within.
  • subset: The slice of type T containing elements to check for in the `list`.
  • compare: A comparison function that takes an item of type T and an item of type E and returns true if they are considered equal, false otherwise.

Returns:

  • true if all elements in `subset` are present in `list` according to the comparison function, false otherwise.

Example: 

numbers := []int{1, 2, 3, 4, 5}
subset := []int{2, 3}
isSubset := ContainsSlice(numbers, subset, func(a, b int) bool {
    return a == b
}) // true

strings := []string{"apple", "banana", "cherry"}
toCheck := []string{"banana", "cherry"}
isAllPresent := ContainsSlice(strings, toCheck, func(a, b string) bool {
    return a == b
}) // true

missingItems := []string{"banana", "pear"}
isAllPresent = ContainsSlice(strings, missingItems, func(a, b string) bool {
    return a == b
}) // false

func Filter 

func Filter[T any](input []T, check func(T) bool) []T

Filter returns a new slice containing only the elements of the input slice that satisfy the check function.

Parameters:

  • input: The slice of type T to filter.
  • check: A function that takes an element of type T and returns true if the element should be included in the output slice.

Returns:

  • A new slice containing only the elements of `input []T` for which `check` returns true.

Example: 

numbers := []int{1, 2, 3, 4, 5}
evens := Filter(numbers, func(n int) bool { return n%2 == 0 }) // []int{2, 4}

strings := []string{"apple", "banana", "cherry"}
startsWithB := Filter(strings, func(s string) bool { return strings.HasPrefix(s, "b") }) // []string{"banana"}

func FindAll 

func FindAll[T any](list []T, check func(T) bool) (elements []T)

FindAll finds and returns all elements in the slice that satisfy the provided check function.

Parameters:

  • list: The slice of type T to search through.
  • check: A function that takes an element of type T and returns true if the element satisfies the condition.

Returns:

  • A slice containing all elements that satisfy the condition.

Example: 

numbers := []int{1, 2, 3, 4, 5}
allGreaterThanTwo := FindAll(numbers, func(n int) bool { return n > 2 }) // []int{3, 4, 5}

strings := []string{"apple", "banana", "cherry", "blueberry"}
allStartingWithB := FindAll(strings, func(s string) bool { return strings.HasPrefix(s, "b") }) // []string{"banana", "blueberry"}

func FindMany 

func FindMany[T any](list []T, check func(T) bool, number int) (elements []T)

FindMany finds and returns up to a specified number of elements in the slice that satisfy the provided check function.

Parameters:

  • list: The slice of type T to search through.
  • check: A function that takes an element of type T and returns true if the element satisfies the condition.
  • number: The maximum number of elements to return.

Returns:

  • A slice containing up to `number` elements that satisfy the condition.

Example: 

numbers := []int{1, 2, 3, 4, 5}
firstTwo := FindMany(numbers, func(n int) bool { return n > 2 }, 2) // []int{3, 4}

strings := []string{"apple", "banana", "cherry", "blueberry"}
firstOne := FindMany(strings, func(s string) bool { return strings.HasPrefix(s, "b") }, 1) // []string{"banana"}

func FindOne 

func FindOne[T any](list []T, check func(T) bool) optional.Optional[T]

FindOne searches a slice for the first element that satisfies a given check function.

Parameters:

  • list: The slice of items to search within.
  • check: A check function that takes an item of type T and returns true if the item satisfies the condition.

Returns:

  • An optional value containing the first element that satisfies the check function, or an empty optional if no such element is found.

Example: 

numbers := []int{1, 2, 3, 4, 5}
firstEven := FindOne(numbers, func(n int) bool { return n%2 == 0 }) // optional.Of(2)

strings := []string{"apple", "banana", "cherry"}
firstBanana := FindOne(strings, func(s string) bool { return s == "banana" }) // optional.Of("banana")

noMatch := FindOne(numbers, func(n int) bool { return n > 10 }) // optional.Empty[int]()

func IndexOf 

func IndexOf[T any](list []T, check func(item T) bool) int

IndexOf returns the index of the first element in the slice that satisfies the provided check function.

Parameters:

  • list: The slice of type T to search through.
  • check: A function that takes an element of type T and returns true if the element satisfies the condition.

Returns:

  • The index of the first matching element if found.
  • -1 if no element satisfies the condition.

Example: 

numbers := []int{1, 2, 3, 4, 5}
index := IndexOf(numbers, func(n int) bool { return n > 3 }) // 3

strings := []string{"apple", "banana", "cherry"}
index := IndexOf(strings, func(s string) bool { return s == "banana" }) // 1

func IndexesOf 

func IndexesOf[T any](list []T, check func(item T) bool) []int

IndexesOf returns the indexes of all elements in the slice that satisfy the provided check function.

Parameters:

  • list: The slice of type T to search through.
  • check: A function that takes an element of type T and returns true if the element satisfies the condition.

Returns:

  • A slice of integers representing the indexes of all matching elements.
  • An empty slice if no elements satisfy the condition.

Example: 

numbers := []int{1, 2, 3, 4, 5, 4}
indexes := IndexesOf(numbers, func(n int) bool { return n == 4 }) // []int{3, 5}

strings := []string{"apple", "banana", "cherry", "banana"}
indexes := IndexesOf(strings, func(s string) bool { return s == "banana" }) // []int{1, 3}

func InsertOneBefore 

func InsertOneBefore[T any](before T, input []T) []T

InsertOneBefore inserts a single element at the beginning of a slice.

Parameters:

  • before: The element to insert at the beginning of the slice.
  • input: The original slice where the element will be inserted.

Returns:

  • A new slice with the `before` element added at the start, followed by all elements of the original slice.

Example: 

original := []int{2, 3, 4}
withOne := InsertOneBefore(1, original) // []int{1, 2, 3, 4}

strings := []string{"banana", "cherry"}
withApple := InsertOneBefore("apple", strings) // []string{"apple", "banana", "cherry"}

func LastIndexOf 

func LastIndexOf[T any](list []T, check func(item T) bool) int

LastIndexOf returns the index of the last element in the slice that satisfies the provided check function.

Parameters:

  • list: The slice of type T to search through.
  • check: A function that takes an element of type T and returns true if the element satisfies the condition.

Returns:

  • The index of the last matching element if found.
  • -1 if no element satisfies the condition.

Example: 

numbers := []int{1, 2, 3, 4, 5, 4}
index := LastIndexOf(numbers, func(n int) bool { return n == 4 }) // 5

strings := []string{"apple", "banana", "cherry", "banana"}
index := LastIndexOf(strings, func(s string) bool { return s == "banana" }) // 3

func Map 

func Map[T, U any](input []T, mapperFunc func(T) U) []U

Map transforms a slice of type T into a slice of type U by applying a mapping function to each element.

Parameters:

  • input: The slice of type T to be transformed.
  • mapperFunc: A function that takes an element of type T and returns an element of type U.

Returns:

  • A new slice of type U where each element is the result of applying `mapperFunc` to the corresponding element of `input []T`.

Example: 

numbers := []int{1, 2, 3}
squared := Map(numbers, func(n int) int { return n * n }) // []int{1, 4, 9}

strings := []string{"apple", "banana", "cherry"}
lengths := Map(strings, func(s string) int { return len(s) }) // []int{5, 6, 6}

func MapDistinct 

func MapDistinct[T any, U any](input []T, mapperFunc func(T) U, comparatorFunc func(U, U) bool) (output []U)

MapDistinct applies a mapping function to each element in the input slice, ensuring that the output slice contains only distinct elements based on a custom comparator function.

Parameters:

  • input: The slice of type T to transform.
  • mapperFunc: A function that maps an element of type T to a new element of type U.
  • comparatorFunc: A function that compares two elements of type U and returns true if they are considered equal. Calls the Contains function

Returns:

  • A slice of type U containing distinct elements based on the comparator function.

Example 1: 

type Person struct {
    Name string
    Age  int
}

input := []Person{
    {"Alice", 25},
    {"Bob", 30},
    {"Alice", 30},
}

names := MapDistinct(input, func(p Person) string {
    return p.Name
}, func(a, b string) bool {
    return a == b
}) // []string{"Alice", "Bob"}

Example: 

numbers := []int{1, 2, 2, 3, 4, 3}
distinctSquares := MapDistinct(numbers, func(n int) int {
    return n * n
}, func(a, b int) bool {
    return a == b
}) // []int{1, 4, 9, 16}

func Split 

func Split[T Splittable[U, V], U, V any](input []T) ([]U, []V)

Split takes a slice of elements that implement the Splittable interface and splits them into two separate slices.

Parameters:

  • input: A slice of elements of type T, where T implements Splittable[U, V].

Returns:

  • Two slices:
  • The first slice contains all elements of type U extracted from the input.
  • The second slice contains all elements of type V extracted from the input.

Example: 

type Item struct {
    Key   string
    Value int
}
type Split_U struct {
	Key string
}

type Split_V struct {
	Value int
}

func (p Item) Split() (Split_U, Split_V) {
	return Split_U{Key: p.Key}, Split_V{Value: p.Value}
}

items := []Item{
    {"apple", 5},
    {"banana", 3},
    {"cherry", 7},
}
keys, values := Split(items) // keys: []string{"apple", "banana", "cherry"}, values: []int{5, 3, 7}

func Without added in v0.0.4 

func Without[S ~[]E, E comparable](a S, b S) S

Without returns a new slice containing the elements of one input slice that are not contained in a second slice.

Parameters:

  • a: The base slice.
  • b: The slice of elements to not include.

Returns:

  • A new slice containing the elements of `a` that are not in `b`.

Example: 

numbers := []int{1, 2, 3, 4, 5}
bad := []int{7, 3}
good := Without(numbers, bad) // []int{1, 2, 4, 5}

Types

type Splittable 

type Splittable[U, V any] interface {
	Split() (U, V)
}

Splittable is an interface representing a type that can be split into two components of types U and V.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.