golist

package module
v0.1.0 Latest Latest
Warning

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

 Go to latest Published: Apr 8, 2020 License: MIT Imports: 4 Imported by: 0

README

Golist

Build Status Software License Go Doc Go Report Card

Golist provides useful functions for common list operations in Go.

Introduction

Working with lists of data in Go using the built-in slice data type and operators can sometimes be a pain. Simple and common operations such as sorting, removing duplicates, and manipulating data can often requires a lot of boilerplate code to accomplish. This package simplifies working with slices by providing easy to use methods for common operations. The methods can also be chained together to enable complex operations on the underlying data with a lot less code, but still highly-readable and easy to maintain.

Example

Here is an example that starts with a slice of integers, multiplies each item by 2, selects only those items that are greater than 20, removes any duplicates, then finally sorts the integers in ascending order.

	s := golist.NewSliceInt(-5, 3, 2, 21, 0, 40, -4, -20, 100, 40, -9, 18, 21, -33, 40)

	s.Transform(func(a int) int {
		return a * 2
	}).Filter(func(a int) bool {
		return a > 20
	}).Unique().Sort()

	for _, value := range s.Data() {
		fmt.Println(value)
	}

	// Output:
	// 36
	// 42
	// 80
	// 200

Inspiration

Warning

Golist is in active development and is not yet ready for use in production. The API is experimental and is subject to change without notice. Suggestions or contributions to improve Golist and help shape its design are welcome and encouraged!

Documentation

Overview

Package golist provides useful methods for working with slices of data.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type SliceBool 

type SliceBool struct {
	// contains filtered or unexported fields
}

SliceBool is a slice of type bool.

func NewSliceBool 

func NewSliceBool(elems ...bool) *SliceBool

NewSliceBool returns a pointer to a new SliceBool initialized with the specified elements.

func (*SliceBool) Append 

func (s *SliceBool) Append(elems ...bool) *SliceBool

Append adds the elements to the end of SliceBool.

func (*SliceBool) At 

func (s *SliceBool) At(index int) bool

At returns the element in SliceBool at the specified index.

func (*SliceBool) Clone 

func (s *SliceBool) Clone() *SliceBool

Clone performs a deep copy of SliceBool and returns it

func (*SliceBool) Count 

func (s *SliceBool) Count() int

Count returns the number of elements in SliceBool.

func (*SliceBool) Data 

func (s *SliceBool) Data() []bool

Data returns the raw elements of SliceBool.

func (*SliceBool) Equal 

func (s *SliceBool) Equal(s2 *SliceBool) bool

Equal returns true if the SliceBool is logically equivalent to the specified SliceBool.

func (*SliceBool) Filter 

func (s *SliceBool) Filter(fn func(elem bool) bool) *SliceBool

Filter removes elements from SliceBool that do not satisfy the filter function.

func (*SliceBool) Insert 

func (s *SliceBool) Insert(index int, elems ...bool) *SliceBool

Insert inserts the elements into SliceBool at the specified index.

func (*SliceBool) Len 

func (s *SliceBool) Len() int

Len returns the number of elements in SliceBool (alias for Count).

func (*SliceBool) Prepend 

func (s *SliceBool) Prepend(elems ...bool) *SliceBool

Prepend adds the elements to the beginning of SliceBool.

func (*SliceBool) Remove 

func (s *SliceBool) Remove(index int) *SliceBool

Remove removes the element from SliceBool at the specified index.

func (*SliceBool) Reverse 

func (s *SliceBool) Reverse() *SliceBool

Reverse reverses the order of the elements of SliceBool.

func (*SliceBool) Set 

func (s *SliceBool) Set(index int, elem bool) *SliceBool

Set sets the element of SliceBool at the specified index.

func (*SliceBool) Shuffle 

func (s *SliceBool) Shuffle(seed int64) *SliceBool

Shuffle randomly shuffles the order of the elements in SliceBool.

func (*SliceBool) Swap 

func (s *SliceBool) Swap(i, j int)

Swap swaps the elements in SliceBool specified by the indices i and j.

func (*SliceBool) Transform 

func (s *SliceBool) Transform(fn func(elem bool) bool) *SliceBool

Transform modifies each element of SliceBool according to the specified function.

func (*SliceBool) Unique 

func (s *SliceBool) Unique() *SliceBool

Unique modifies SliceBool to keep only the first occurrence of each element (removing any duplicates).

type SliceByte 

type SliceByte struct {
	// contains filtered or unexported fields
}

SliceByte is a slice of type byte.

func NewSliceByte 

func NewSliceByte(elems ...byte) *SliceByte

NewSliceByte returns a pointer to a new SliceByte initialized with the specified elements.

func (*SliceByte) Append 

func (s *SliceByte) Append(elems ...byte) *SliceByte

Append adds the elements to the end of SliceByte.

func (*SliceByte) At 

func (s *SliceByte) At(index int) byte

At returns the element in SliceByte at the specified index.

func (*SliceByte) Clone 

func (s *SliceByte) Clone() *SliceByte

Clone performs a deep copy of SliceByte and returns it

func (*SliceByte) Count 

func (s *SliceByte) Count() int

Count returns the number of elements in SliceByte.

func (*SliceByte) Data 

func (s *SliceByte) Data() []byte

Data returns the raw elements of SliceByte.

func (*SliceByte) Equal 

func (s *SliceByte) Equal(s2 *SliceByte) bool

Equal returns true if the SliceByte is logically equivalent to the specified SliceByte.

func (*SliceByte) Filter 

func (s *SliceByte) Filter(fn func(elem byte) bool) *SliceByte

Filter removes elements from SliceByte that do not satisfy the filter function.

func (*SliceByte) Insert 

func (s *SliceByte) Insert(index int, elems ...byte) *SliceByte

Insert inserts the elements into SliceByte at the specified index.

func (*SliceByte) Len 

func (s *SliceByte) Len() int

Len returns the number of elements in SliceByte (alias for Count).

func (*SliceByte) Less 

func (s *SliceByte) Less(i, j int) bool

Less returns true if the SliceByte element at index i is less than the element at index j.

func (*SliceByte) Max 

func (s *SliceByte) Max() byte

Max returns the largest (greatest ordered) element in SliceByte.

func (*SliceByte) Min 

func (s *SliceByte) Min() byte

Min returns the smallest (least ordered) element in SliceByte.

func (*SliceByte) Prepend 

func (s *SliceByte) Prepend(elems ...byte) *SliceByte

Prepend adds the elements to the beginning of SliceByte.

func (*SliceByte) Remove 

func (s *SliceByte) Remove(index int) *SliceByte

Remove removes the element from SliceByte at the specified index.

func (*SliceByte) Reverse 

func (s *SliceByte) Reverse() *SliceByte

Reverse reverses the order of the elements of SliceByte.

func (*SliceByte) Set 

func (s *SliceByte) Set(index int, elem byte) *SliceByte

Set sets the element of SliceByte at the specified index.

func (*SliceByte) Shuffle 

func (s *SliceByte) Shuffle(seed int64) *SliceByte

Shuffle randomly shuffles the order of the elements in SliceByte.

func (*SliceByte) Sort 

func (s *SliceByte) Sort() *SliceByte

Sort sorts the elements of SliceByte in increasing order.

func (*SliceByte) Swap 

func (s *SliceByte) Swap(i, j int)

Swap swaps the elements in SliceByte specified by the indices i and j.

func (*SliceByte) Transform 

func (s *SliceByte) Transform(fn func(elem byte) byte) *SliceByte

Transform modifies each element of SliceByte according to the specified function.

func (*SliceByte) Unique 

func (s *SliceByte) Unique() *SliceByte

Unique modifies SliceByte to keep only the first occurrence of each element (removing any duplicates).

type SliceComplex128 

type SliceComplex128 struct {
	// contains filtered or unexported fields
}

SliceComplex128 is a slice of type complex128.

func NewSliceComplex128 

func NewSliceComplex128(elems ...complex128) *SliceComplex128

NewSliceComplex128 returns a pointer to a new SliceComplex128 initialized with the specified elements.

func (*SliceComplex128) Append 

func (s *SliceComplex128) Append(elems ...complex128) *SliceComplex128

Append adds the elements to the end of SliceComplex128.

func (*SliceComplex128) At 

func (s *SliceComplex128) At(index int) complex128

At returns the element in SliceComplex128 at the specified index.

func (*SliceComplex128) Clone 

func (s *SliceComplex128) Clone() *SliceComplex128

Clone performs a deep copy of SliceComplex128 and returns it

func (*SliceComplex128) Count 

func (s *SliceComplex128) Count() int

Count returns the number of elements in SliceComplex128.

func (*SliceComplex128) Data 

func (s *SliceComplex128) Data() []complex128

Data returns the raw elements of SliceComplex128.

func (*SliceComplex128) Equal 

func (s *SliceComplex128) Equal(s2 *SliceComplex128) bool

Equal returns true if the SliceComplex128 is logically equivalent to the specified SliceComplex128.

func (*SliceComplex128) Filter 

func (s *SliceComplex128) Filter(fn func(elem complex128) bool) *SliceComplex128

Filter removes elements from SliceComplex128 that do not satisfy the filter function.

func (*SliceComplex128) Insert 

func (s *SliceComplex128) Insert(index int, elems ...complex128) *SliceComplex128

Insert inserts the elements into SliceComplex128 at the specified index.

func (*SliceComplex128) Len 

func (s *SliceComplex128) Len() int

Len returns the number of elements in SliceComplex128 (alias for Count).

func (*SliceComplex128) Prepend 

func (s *SliceComplex128) Prepend(elems ...complex128) *SliceComplex128

Prepend adds the elements to the beginning of SliceComplex128.

func (*SliceComplex128) Remove 

func (s *SliceComplex128) Remove(index int) *SliceComplex128

Remove removes the element from SliceComplex128 at the specified index.

func (*SliceComplex128) Reverse 

func (s *SliceComplex128) Reverse() *SliceComplex128

Reverse reverses the order of the elements of SliceComplex128.

func (*SliceComplex128) Set 

func (s *SliceComplex128) Set(index int, elem complex128) *SliceComplex128

Set sets the element of SliceComplex128 at the specified index.

func (*SliceComplex128) Shuffle 

func (s *SliceComplex128) Shuffle(seed int64) *SliceComplex128

Shuffle randomly shuffles the order of the elements in SliceComplex128.

func (*SliceComplex128) Swap 

func (s *SliceComplex128) Swap(i, j int)

Swap swaps the elements in SliceComplex128 specified by the indices i and j.

func (*SliceComplex128) Transform 

func (s *SliceComplex128) Transform(fn func(elem complex128) complex128) *SliceComplex128

Transform modifies each element of SliceComplex128 according to the specified function.

func (*SliceComplex128) Unique 

func (s *SliceComplex128) Unique() *SliceComplex128

Unique modifies SliceComplex128 to keep only the first occurrence of each element (removing any duplicates).

type SliceComplex64 

type SliceComplex64 struct {
	// contains filtered or unexported fields
}

SliceComplex64 is a slice of type complex64.

func NewSliceComplex64 

func NewSliceComplex64(elems ...complex64) *SliceComplex64

NewSliceComplex64 returns a pointer to a new SliceComplex64 initialized with the specified elements.

func (*SliceComplex64) Append 

func (s *SliceComplex64) Append(elems ...complex64) *SliceComplex64

Append adds the elements to the end of SliceComplex64.

func (*SliceComplex64) At 

func (s *SliceComplex64) At(index int) complex64

At returns the element in SliceComplex64 at the specified index.

func (*SliceComplex64) Clone 

func (s *SliceComplex64) Clone() *SliceComplex64

Clone performs a deep copy of SliceComplex64 and returns it

func (*SliceComplex64) Count 

func (s *SliceComplex64) Count() int

Count returns the number of elements in SliceComplex64.

func (*SliceComplex64) Data 

func (s *SliceComplex64) Data() []complex64

Data returns the raw elements of SliceComplex64.

func (*SliceComplex64) Equal 

func (s *SliceComplex64) Equal(s2 *SliceComplex64) bool

Equal returns true if the SliceComplex64 is logically equivalent to the specified SliceComplex64.

func (*SliceComplex64) Filter 

func (s *SliceComplex64) Filter(fn func(elem complex64) bool) *SliceComplex64

Filter removes elements from SliceComplex64 that do not satisfy the filter function.

func (*SliceComplex64) Insert 

func (s *SliceComplex64) Insert(index int, elems ...complex64) *SliceComplex64

Insert inserts the elements into SliceComplex64 at the specified index.

func (*SliceComplex64) Len 

func (s *SliceComplex64) Len() int

Len returns the number of elements in SliceComplex64 (alias for Count).

func (*SliceComplex64) Prepend 

func (s *SliceComplex64) Prepend(elems ...complex64) *SliceComplex64

Prepend adds the elements to the beginning of SliceComplex64.

func (*SliceComplex64) Remove 

func (s *SliceComplex64) Remove(index int) *SliceComplex64

Remove removes the element from SliceComplex64 at the specified index.

func (*SliceComplex64) Reverse 

func (s *SliceComplex64) Reverse() *SliceComplex64

Reverse reverses the order of the elements of SliceComplex64.

func (*SliceComplex64) Set 

func (s *SliceComplex64) Set(index int, elem complex64) *SliceComplex64

Set sets the element of SliceComplex64 at the specified index.

func (*SliceComplex64) Shuffle 

func (s *SliceComplex64) Shuffle(seed int64) *SliceComplex64

Shuffle randomly shuffles the order of the elements in SliceComplex64.

func (*SliceComplex64) Swap 

func (s *SliceComplex64) Swap(i, j int)

Swap swaps the elements in SliceComplex64 specified by the indices i and j.

func (*SliceComplex64) Transform 

func (s *SliceComplex64) Transform(fn func(elem complex64) complex64) *SliceComplex64

Transform modifies each element of SliceComplex64 according to the specified function.

func (*SliceComplex64) Unique 

func (s *SliceComplex64) Unique() *SliceComplex64

Unique modifies SliceComplex64 to keep only the first occurrence of each element (removing any duplicates).

type SliceError 

type SliceError struct {
	// contains filtered or unexported fields
}

SliceError is a slice of type error.

func NewSliceError 

func NewSliceError(elems ...error) *SliceError

NewSliceError returns a pointer to a new SliceError initialized with the specified elements.

func (*SliceError) Append 

func (s *SliceError) Append(elems ...error) *SliceError

Append adds the elements to the end of SliceError.

func (*SliceError) At 

func (s *SliceError) At(index int) error

At returns the element in SliceError at the specified index.

func (*SliceError) Clone 

func (s *SliceError) Clone() *SliceError

Clone performs a deep copy of SliceError and returns it

func (*SliceError) Count 

func (s *SliceError) Count() int

Count returns the number of elements in SliceError.

func (*SliceError) Data 

func (s *SliceError) Data() []error

Data returns the raw elements of SliceError.

func (*SliceError) Equal 

func (s *SliceError) Equal(s2 *SliceError) bool

Equal returns true if the SliceError is logically equivalent to the specified SliceError.

func (*SliceError) Filter 

func (s *SliceError) Filter(fn func(elem error) bool) *SliceError

Filter removes elements from SliceError that do not satisfy the filter function.

func (*SliceError) Insert 

func (s *SliceError) Insert(index int, elems ...error) *SliceError

Insert inserts the elements into SliceError at the specified index.

func (*SliceError) Len 

func (s *SliceError) Len() int

Len returns the number of elements in SliceError (alias for Count).

func (*SliceError) Prepend 

func (s *SliceError) Prepend(elems ...error) *SliceError

Prepend adds the elements to the beginning of SliceError.

func (*SliceError) Remove 

func (s *SliceError) Remove(index int) *SliceError

Remove removes the element from SliceError at the specified index.

func (*SliceError) Reverse 

func (s *SliceError) Reverse() *SliceError

Reverse reverses the order of the elements of SliceError.

func (*SliceError) Set 

func (s *SliceError) Set(index int, elem error) *SliceError

Set sets the element of SliceError at the specified index.

func (*SliceError) Shuffle 

func (s *SliceError) Shuffle(seed int64) *SliceError

Shuffle randomly shuffles the order of the elements in SliceError.

func (*SliceError) Swap 

func (s *SliceError) Swap(i, j int)

Swap swaps the elements in SliceError specified by the indices i and j.

func (*SliceError) Transform 

func (s *SliceError) Transform(fn func(elem error) error) *SliceError

Transform modifies each element of SliceError according to the specified function.

func (*SliceError) Unique 

func (s *SliceError) Unique() *SliceError

Unique modifies SliceError to keep only the first occurrence of each element (removing any duplicates).

type SliceFloat32 

type SliceFloat32 struct {
	// contains filtered or unexported fields
}

SliceFloat32 is a slice of type float32.

func NewSliceFloat32 

func NewSliceFloat32(elems ...float32) *SliceFloat32

NewSliceFloat32 returns a pointer to a new SliceFloat32 initialized with the specified elements.

func (*SliceFloat32) Append 

func (s *SliceFloat32) Append(elems ...float32) *SliceFloat32

Append adds the elements to the end of SliceFloat32.

func (*SliceFloat32) At 

func (s *SliceFloat32) At(index int) float32

At returns the element in SliceFloat32 at the specified index.

func (*SliceFloat32) Clone 

func (s *SliceFloat32) Clone() *SliceFloat32

Clone performs a deep copy of SliceFloat32 and returns it

func (*SliceFloat32) Count 

func (s *SliceFloat32) Count() int

Count returns the number of elements in SliceFloat32.

func (*SliceFloat32) Data 

func (s *SliceFloat32) Data() []float32

Data returns the raw elements of SliceFloat32.

func (*SliceFloat32) Equal 

func (s *SliceFloat32) Equal(s2 *SliceFloat32) bool

Equal returns true if the SliceFloat32 is logically equivalent to the specified SliceFloat32.

func (*SliceFloat32) Filter 

func (s *SliceFloat32) Filter(fn func(elem float32) bool) *SliceFloat32

Filter removes elements from SliceFloat32 that do not satisfy the filter function.

func (*SliceFloat32) Insert 

func (s *SliceFloat32) Insert(index int, elems ...float32) *SliceFloat32

Insert inserts the elements into SliceFloat32 at the specified index.

func (*SliceFloat32) Len 

func (s *SliceFloat32) Len() int

Len returns the number of elements in SliceFloat32 (alias for Count).

func (*SliceFloat32) Less 

func (s *SliceFloat32) Less(i, j int) bool

Less returns true if the SliceFloat32 element at index i is less than the element at index j.

func (*SliceFloat32) Max 

func (s *SliceFloat32) Max() float32

Max returns the largest (greatest ordered) element in SliceFloat32.

func (*SliceFloat32) Min 

func (s *SliceFloat32) Min() float32

Min returns the smallest (least ordered) element in SliceFloat32.

func (*SliceFloat32) Prepend 

func (s *SliceFloat32) Prepend(elems ...float32) *SliceFloat32

Prepend adds the elements to the beginning of SliceFloat32.

func (*SliceFloat32) Remove 

func (s *SliceFloat32) Remove(index int) *SliceFloat32

Remove removes the element from SliceFloat32 at the specified index.

func (*SliceFloat32) Reverse 

func (s *SliceFloat32) Reverse() *SliceFloat32

Reverse reverses the order of the elements of SliceFloat32.

func (*SliceFloat32) Set 

func (s *SliceFloat32) Set(index int, elem float32) *SliceFloat32

Set sets the element of SliceFloat32 at the specified index.

func (*SliceFloat32) Shuffle 

func (s *SliceFloat32) Shuffle(seed int64) *SliceFloat32

Shuffle randomly shuffles the order of the elements in SliceFloat32.

func (*SliceFloat32) Sort 

func (s *SliceFloat32) Sort() *SliceFloat32

Sort sorts the elements of SliceFloat32 in increasing order.

func (*SliceFloat32) Swap 

func (s *SliceFloat32) Swap(i, j int)

Swap swaps the elements in SliceFloat32 specified by the indices i and j.

func (*SliceFloat32) Transform 

func (s *SliceFloat32) Transform(fn func(elem float32) float32) *SliceFloat32

Transform modifies each element of SliceFloat32 according to the specified function.

func (*SliceFloat32) Unique 

func (s *SliceFloat32) Unique() *SliceFloat32

Unique modifies SliceFloat32 to keep only the first occurrence of each element (removing any duplicates).

type SliceFloat64 

type SliceFloat64 struct {
	// contains filtered or unexported fields
}

SliceFloat64 is a slice of type float64.

func NewSliceFloat64 

func NewSliceFloat64(elems ...float64) *SliceFloat64

NewSliceFloat64 returns a pointer to a new SliceFloat64 initialized with the specified elements.

func (*SliceFloat64) Append 

func (s *SliceFloat64) Append(elems ...float64) *SliceFloat64

Append adds the elements to the end of SliceFloat64.

func (*SliceFloat64) At 

func (s *SliceFloat64) At(index int) float64

At returns the element in SliceFloat64 at the specified index.

func (*SliceFloat64) Clone 

func (s *SliceFloat64) Clone() *SliceFloat64

Clone performs a deep copy of SliceFloat64 and returns it

func (*SliceFloat64) Count 

func (s *SliceFloat64) Count() int

Count returns the number of elements in SliceFloat64.

func (*SliceFloat64) Data 

func (s *SliceFloat64) Data() []float64

Data returns the raw elements of SliceFloat64.

func (*SliceFloat64) Equal 

func (s *SliceFloat64) Equal(s2 *SliceFloat64) bool

Equal returns true if the SliceFloat64 is logically equivalent to the specified SliceFloat64.

func (*SliceFloat64) Filter 

func (s *SliceFloat64) Filter(fn func(elem float64) bool) *SliceFloat64

Filter removes elements from SliceFloat64 that do not satisfy the filter function.

func (*SliceFloat64) Insert 

func (s *SliceFloat64) Insert(index int, elems ...float64) *SliceFloat64

Insert inserts the elements into SliceFloat64 at the specified index.

func (*SliceFloat64) Len 

func (s *SliceFloat64) Len() int

Len returns the number of elements in SliceFloat64 (alias for Count).

func (*SliceFloat64) Less 

func (s *SliceFloat64) Less(i, j int) bool

Less returns true if the SliceFloat64 element at index i is less than the element at index j.

func (*SliceFloat64) Max 

func (s *SliceFloat64) Max() float64

Max returns the largest (greatest ordered) element in SliceFloat64.

func (*SliceFloat64) Min 

func (s *SliceFloat64) Min() float64

Min returns the smallest (least ordered) element in SliceFloat64.

func (*SliceFloat64) Prepend 

func (s *SliceFloat64) Prepend(elems ...float64) *SliceFloat64

Prepend adds the elements to the beginning of SliceFloat64.

func (*SliceFloat64) Remove 

func (s *SliceFloat64) Remove(index int) *SliceFloat64

Remove removes the element from SliceFloat64 at the specified index.

func (*SliceFloat64) Reverse 

func (s *SliceFloat64) Reverse() *SliceFloat64

Reverse reverses the order of the elements of SliceFloat64.

func (*SliceFloat64) Set 

func (s *SliceFloat64) Set(index int, elem float64) *SliceFloat64

Set sets the element of SliceFloat64 at the specified index.

func (*SliceFloat64) Shuffle 

func (s *SliceFloat64) Shuffle(seed int64) *SliceFloat64

Shuffle randomly shuffles the order of the elements in SliceFloat64.

func (*SliceFloat64) Sort 

func (s *SliceFloat64) Sort() *SliceFloat64

Sort sorts the elements of SliceFloat64 in increasing order.

func (*SliceFloat64) Swap 

func (s *SliceFloat64) Swap(i, j int)

Swap swaps the elements in SliceFloat64 specified by the indices i and j.

func (*SliceFloat64) Transform 

func (s *SliceFloat64) Transform(fn func(elem float64) float64) *SliceFloat64

Transform modifies each element of SliceFloat64 according to the specified function.

func (*SliceFloat64) Unique 

func (s *SliceFloat64) Unique() *SliceFloat64

Unique modifies SliceFloat64 to keep only the first occurrence of each element (removing any duplicates).

type SliceInt 

type SliceInt struct {
	// contains filtered or unexported fields
}

SliceInt is a slice of type int.

func NewSliceInt 

func NewSliceInt(elems ...int) *SliceInt

NewSliceInt returns a pointer to a new SliceInt initialized with the specified elements.

func (*SliceInt) Append 

func (s *SliceInt) Append(elems ...int) *SliceInt

Append adds the elements to the end of SliceInt.

func (*SliceInt) At 

func (s *SliceInt) At(index int) int

At returns the element in SliceInt at the specified index.

func (*SliceInt) Clone 

func (s *SliceInt) Clone() *SliceInt

Clone performs a deep copy of SliceInt and returns it

func (*SliceInt) Count 

func (s *SliceInt) Count() int

Count returns the number of elements in SliceInt.

Example 
package main

import (
	"fmt"

	"github.com/schoukri/golist"
)

func main() {
	s := golist.NewSliceInt(-5, 3, 2, 21, 0, 40, -4, -20, 100, 40, -9, 18, 21, -33, 40)

	count := s.Filter(func(a int) bool {
		return a > 10
	}).Count()

	uniqCount := s.Filter(func(a int) bool {
		return a > 10
	}).Unique().Count()

	fmt.Println("total count:", count)
	fmt.Println("unique count:", uniqCount)

}

Output:

total count: 7
unique count: 4

func (*SliceInt) Data 

func (s *SliceInt) Data() []int

Data returns the raw elements of SliceInt.

func (*SliceInt) Equal 

func (s *SliceInt) Equal(s2 *SliceInt) bool

Equal returns true if the SliceInt is logically equivalent to the specified SliceInt.

func (*SliceInt) Filter 

func (s *SliceInt) Filter(fn func(elem int) bool) *SliceInt

Filter removes elements from SliceInt that do not satisfy the filter function.

func (*SliceInt) Insert 

func (s *SliceInt) Insert(index int, elems ...int) *SliceInt

Insert inserts the elements into SliceInt at the specified index.

Example 
package main

import (
	"fmt"

	"github.com/schoukri/golist"
)

func main() {
	s := golist.NewSliceInt(10, 40)
	s.Insert(1, 20, 30)

	for _, value := range s.Data() {
		fmt.Println(value)
	}

}

Output:

10
20
30
40

func (*SliceInt) Len 

func (s *SliceInt) Len() int

Len returns the number of elements in SliceInt (alias for Count).

func (*SliceInt) Less 

func (s *SliceInt) Less(i, j int) bool

Less returns true if the SliceInt element at index i is less than the element at index j.

func (*SliceInt) Max 

func (s *SliceInt) Max() int

Max returns the largest (greatest ordered) element in SliceInt.

func (*SliceInt) Min 

func (s *SliceInt) Min() int

Min returns the smallest (least ordered) element in SliceInt.

func (*SliceInt) Prepend 

func (s *SliceInt) Prepend(elems ...int) *SliceInt

Prepend adds the elements to the beginning of SliceInt.

func (*SliceInt) Remove 

func (s *SliceInt) Remove(index int) *SliceInt

Remove removes the element from SliceInt at the specified index.

func (*SliceInt) Reverse 

func (s *SliceInt) Reverse() *SliceInt

Reverse reverses the order of the elements of SliceInt.

func (*SliceInt) Set 

func (s *SliceInt) Set(index int, elem int) *SliceInt

Set sets the element of SliceInt at the specified index.

func (*SliceInt) Shuffle 

func (s *SliceInt) Shuffle(seed int64) *SliceInt

Shuffle randomly shuffles the order of the elements in SliceInt.

func (*SliceInt) Sort 

func (s *SliceInt) Sort() *SliceInt

Sort sorts the elements of SliceInt in increasing order.

func (*SliceInt) Swap 

func (s *SliceInt) Swap(i, j int)

Swap swaps the elements in SliceInt specified by the indices i and j.

func (*SliceInt) Transform 

func (s *SliceInt) Transform(fn func(elem int) int) *SliceInt

Transform modifies each element of SliceInt according to the specified function.

Example 
package main

import (
	"fmt"

	"github.com/schoukri/golist"
)

func main() {
	s := golist.NewSliceInt(-5, 3, 2, 21, 0, 40, -4, -20, 100, 40, -9, 18, 21, -33, 40)

	s.Transform(func(a int) int {
		return a * 2
	}).Filter(func(a int) bool {
		return a > 20
	}).Unique().Sort()

	for _, value := range s.Data() {
		fmt.Println(value)
	}

}

Output:

36
42
80
200

func (*SliceInt) Unique 

func (s *SliceInt) Unique() *SliceInt

Unique modifies SliceInt to keep only the first occurrence of each element (removing any duplicates).

type SliceInt16 

type SliceInt16 struct {
	// contains filtered or unexported fields
}

SliceInt16 is a slice of type int16.

func NewSliceInt16 

func NewSliceInt16(elems ...int16) *SliceInt16

NewSliceInt16 returns a pointer to a new SliceInt16 initialized with the specified elements.

func (*SliceInt16) Append 

func (s *SliceInt16) Append(elems ...int16) *SliceInt16

Append adds the elements to the end of SliceInt16.

func (*SliceInt16) At 

func (s *SliceInt16) At(index int) int16

At returns the element in SliceInt16 at the specified index.

func (*SliceInt16) Clone 

func (s *SliceInt16) Clone() *SliceInt16

Clone performs a deep copy of SliceInt16 and returns it

func (*SliceInt16) Count 

func (s *SliceInt16) Count() int

Count returns the number of elements in SliceInt16.

func (*SliceInt16) Data 

func (s *SliceInt16) Data() []int16

Data returns the raw elements of SliceInt16.

func (*SliceInt16) Equal 

func (s *SliceInt16) Equal(s2 *SliceInt16) bool

Equal returns true if the SliceInt16 is logically equivalent to the specified SliceInt16.

func (*SliceInt16) Filter 

func (s *SliceInt16) Filter(fn func(elem int16) bool) *SliceInt16

Filter removes elements from SliceInt16 that do not satisfy the filter function.

func (*SliceInt16) Insert 

func (s *SliceInt16) Insert(index int, elems ...int16) *SliceInt16

Insert inserts the elements into SliceInt16 at the specified index.

func (*SliceInt16) Len 

func (s *SliceInt16) Len() int

Len returns the number of elements in SliceInt16 (alias for Count).

func (*SliceInt16) Less 

func (s *SliceInt16) Less(i, j int) bool

Less returns true if the SliceInt16 element at index i is less than the element at index j.

func (*SliceInt16) Max 

func (s *SliceInt16) Max() int16

Max returns the largest (greatest ordered) element in SliceInt16.

func (*SliceInt16) Min 

func (s *SliceInt16) Min() int16

Min returns the smallest (least ordered) element in SliceInt16.

func (*SliceInt16) Prepend 

func (s *SliceInt16) Prepend(elems ...int16) *SliceInt16

Prepend adds the elements to the beginning of SliceInt16.

func (*SliceInt16) Remove 

func (s *SliceInt16) Remove(index int) *SliceInt16

Remove removes the element from SliceInt16 at the specified index.

func (*SliceInt16) Reverse 

func (s *SliceInt16) Reverse() *SliceInt16

Reverse reverses the order of the elements of SliceInt16.

func (*SliceInt16) Set 

func (s *SliceInt16) Set(index int, elem int16) *SliceInt16

Set sets the element of SliceInt16 at the specified index.

func (*SliceInt16) Shuffle 

func (s *SliceInt16) Shuffle(seed int64) *SliceInt16

Shuffle randomly shuffles the order of the elements in SliceInt16.

func (*SliceInt16) Sort 

func (s *SliceInt16) Sort() *SliceInt16

Sort sorts the elements of SliceInt16 in increasing order.

func (*SliceInt16) Swap 

func (s *SliceInt16) Swap(i, j int)

Swap swaps the elements in SliceInt16 specified by the indices i and j.

func (*SliceInt16) Transform 

func (s *SliceInt16) Transform(fn func(elem int16) int16) *SliceInt16

Transform modifies each element of SliceInt16 according to the specified function.

func (*SliceInt16) Unique 

func (s *SliceInt16) Unique() *SliceInt16

Unique modifies SliceInt16 to keep only the first occurrence of each element (removing any duplicates).

type SliceInt32 

type SliceInt32 struct {
	// contains filtered or unexported fields
}

SliceInt32 is a slice of type int32.

func NewSliceInt32 

func NewSliceInt32(elems ...int32) *SliceInt32

NewSliceInt32 returns a pointer to a new SliceInt32 initialized with the specified elements.

func (*SliceInt32) Append 

func (s *SliceInt32) Append(elems ...int32) *SliceInt32

Append adds the elements to the end of SliceInt32.

func (*SliceInt32) At 

func (s *SliceInt32) At(index int) int32

At returns the element in SliceInt32 at the specified index.

func (*SliceInt32) Clone 

func (s *SliceInt32) Clone() *SliceInt32

Clone performs a deep copy of SliceInt32 and returns it

func (*SliceInt32) Count 

func (s *SliceInt32) Count() int

Count returns the number of elements in SliceInt32.

func (*SliceInt32) Data 

func (s *SliceInt32) Data() []int32

Data returns the raw elements of SliceInt32.

func (*SliceInt32) Equal 

func (s *SliceInt32) Equal(s2 *SliceInt32) bool

Equal returns true if the SliceInt32 is logically equivalent to the specified SliceInt32.

func (*SliceInt32) Filter 

func (s *SliceInt32) Filter(fn func(elem int32) bool) *SliceInt32

Filter removes elements from SliceInt32 that do not satisfy the filter function.

func (*SliceInt32) Insert 

func (s *SliceInt32) Insert(index int, elems ...int32) *SliceInt32

Insert inserts the elements into SliceInt32 at the specified index.

func (*SliceInt32) Len 

func (s *SliceInt32) Len() int

Len returns the number of elements in SliceInt32 (alias for Count).

func (*SliceInt32) Less 

func (s *SliceInt32) Less(i, j int) bool

Less returns true if the SliceInt32 element at index i is less than the element at index j.

func (*SliceInt32) Max 

func (s *SliceInt32) Max() int32

Max returns the largest (greatest ordered) element in SliceInt32.

func (*SliceInt32) Min 

func (s *SliceInt32) Min() int32

Min returns the smallest (least ordered) element in SliceInt32.

func (*SliceInt32) Prepend 

func (s *SliceInt32) Prepend(elems ...int32) *SliceInt32

Prepend adds the elements to the beginning of SliceInt32.

func (*SliceInt32) Remove 

func (s *SliceInt32) Remove(index int) *SliceInt32

Remove removes the element from SliceInt32 at the specified index.

func (*SliceInt32) Reverse 

func (s *SliceInt32) Reverse() *SliceInt32

Reverse reverses the order of the elements of SliceInt32.

func (*SliceInt32) Set 

func (s *SliceInt32) Set(index int, elem int32) *SliceInt32

Set sets the element of SliceInt32 at the specified index.

func (*SliceInt32) Shuffle 

func (s *SliceInt32) Shuffle(seed int64) *SliceInt32

Shuffle randomly shuffles the order of the elements in SliceInt32.

func (*SliceInt32) Sort 

func (s *SliceInt32) Sort() *SliceInt32

Sort sorts the elements of SliceInt32 in increasing order.

func (*SliceInt32) Swap 

func (s *SliceInt32) Swap(i, j int)

Swap swaps the elements in SliceInt32 specified by the indices i and j.

func (*SliceInt32) Transform 

func (s *SliceInt32) Transform(fn func(elem int32) int32) *SliceInt32

Transform modifies each element of SliceInt32 according to the specified function.

func (*SliceInt32) Unique 

func (s *SliceInt32) Unique() *SliceInt32

Unique modifies SliceInt32 to keep only the first occurrence of each element (removing any duplicates).

type SliceInt64 

type SliceInt64 struct {
	// contains filtered or unexported fields
}

SliceInt64 is a slice of type int64.

func NewSliceInt64 

func NewSliceInt64(elems ...int64) *SliceInt64

NewSliceInt64 returns a pointer to a new SliceInt64 initialized with the specified elements.

func (*SliceInt64) Append 

func (s *SliceInt64) Append(elems ...int64) *SliceInt64

Append adds the elements to the end of SliceInt64.

func (*SliceInt64) At 

func (s *SliceInt64) At(index int) int64

At returns the element in SliceInt64 at the specified index.

func (*SliceInt64) Clone 

func (s *SliceInt64) Clone() *SliceInt64

Clone performs a deep copy of SliceInt64 and returns it

func (*SliceInt64) Count 

func (s *SliceInt64) Count() int

Count returns the number of elements in SliceInt64.

func (*SliceInt64) Data 

func (s *SliceInt64) Data() []int64

Data returns the raw elements of SliceInt64.

func (*SliceInt64) Equal 

func (s *SliceInt64) Equal(s2 *SliceInt64) bool

Equal returns true if the SliceInt64 is logically equivalent to the specified SliceInt64.

func (*SliceInt64) Filter 

func (s *SliceInt64) Filter(fn func(elem int64) bool) *SliceInt64

Filter removes elements from SliceInt64 that do not satisfy the filter function.

func (*SliceInt64) Insert 

func (s *SliceInt64) Insert(index int, elems ...int64) *SliceInt64

Insert inserts the elements into SliceInt64 at the specified index.

func (*SliceInt64) Len 

func (s *SliceInt64) Len() int

Len returns the number of elements in SliceInt64 (alias for Count).

func (*SliceInt64) Less 

func (s *SliceInt64) Less(i, j int) bool

Less returns true if the SliceInt64 element at index i is less than the element at index j.

func (*SliceInt64) Max 

func (s *SliceInt64) Max() int64

Max returns the largest (greatest ordered) element in SliceInt64.

func (*SliceInt64) Min 

func (s *SliceInt64) Min() int64

Min returns the smallest (least ordered) element in SliceInt64.

func (*SliceInt64) Prepend 

func (s *SliceInt64) Prepend(elems ...int64) *SliceInt64

Prepend adds the elements to the beginning of SliceInt64.

func (*SliceInt64) Remove 

func (s *SliceInt64) Remove(index int) *SliceInt64

Remove removes the element from SliceInt64 at the specified index.

func (*SliceInt64) Reverse 

func (s *SliceInt64) Reverse() *SliceInt64

Reverse reverses the order of the elements of SliceInt64.

func (*SliceInt64) Set 

func (s *SliceInt64) Set(index int, elem int64) *SliceInt64

Set sets the element of SliceInt64 at the specified index.

func (*SliceInt64) Shuffle 

func (s *SliceInt64) Shuffle(seed int64) *SliceInt64

Shuffle randomly shuffles the order of the elements in SliceInt64.

func (*SliceInt64) Sort 

func (s *SliceInt64) Sort() *SliceInt64

Sort sorts the elements of SliceInt64 in increasing order.

func (*SliceInt64) Swap 

func (s *SliceInt64) Swap(i, j int)

Swap swaps the elements in SliceInt64 specified by the indices i and j.

func (*SliceInt64) Transform 

func (s *SliceInt64) Transform(fn func(elem int64) int64) *SliceInt64

Transform modifies each element of SliceInt64 according to the specified function.

func (*SliceInt64) Unique 

func (s *SliceInt64) Unique() *SliceInt64

Unique modifies SliceInt64 to keep only the first occurrence of each element (removing any duplicates).

type SliceInt8 

type SliceInt8 struct {
	// contains filtered or unexported fields
}

SliceInt8 is a slice of type int8.

func NewSliceInt8 

func NewSliceInt8(elems ...int8) *SliceInt8

NewSliceInt8 returns a pointer to a new SliceInt8 initialized with the specified elements.

func (*SliceInt8) Append 

func (s *SliceInt8) Append(elems ...int8) *SliceInt8

Append adds the elements to the end of SliceInt8.

func (*SliceInt8) At 

func (s *SliceInt8) At(index int) int8

At returns the element in SliceInt8 at the specified index.

func (*SliceInt8) Clone 

func (s *SliceInt8) Clone() *SliceInt8

Clone performs a deep copy of SliceInt8 and returns it

func (*SliceInt8) Count 

func (s *SliceInt8) Count() int

Count returns the number of elements in SliceInt8.

func (*SliceInt8) Data 

func (s *SliceInt8) Data() []int8

Data returns the raw elements of SliceInt8.

func (*SliceInt8) Equal 

func (s *SliceInt8) Equal(s2 *SliceInt8) bool

Equal returns true if the SliceInt8 is logically equivalent to the specified SliceInt8.

func (*SliceInt8) Filter 

func (s *SliceInt8) Filter(fn func(elem int8) bool) *SliceInt8

Filter removes elements from SliceInt8 that do not satisfy the filter function.

func (*SliceInt8) Insert 

func (s *SliceInt8) Insert(index int, elems ...int8) *SliceInt8

Insert inserts the elements into SliceInt8 at the specified index.

func (*SliceInt8) Len 

func (s *SliceInt8) Len() int

Len returns the number of elements in SliceInt8 (alias for Count).

func (*SliceInt8) Less 

func (s *SliceInt8) Less(i, j int) bool

Less returns true if the SliceInt8 element at index i is less than the element at index j.

func (*SliceInt8) Max 

func (s *SliceInt8) Max() int8

Max returns the largest (greatest ordered) element in SliceInt8.

func (*SliceInt8) Min 

func (s *SliceInt8) Min() int8

Min returns the smallest (least ordered) element in SliceInt8.

func (*SliceInt8) Prepend 

func (s *SliceInt8) Prepend(elems ...int8) *SliceInt8

Prepend adds the elements to the beginning of SliceInt8.

func (*SliceInt8) Remove 

func (s *SliceInt8) Remove(index int) *SliceInt8

Remove removes the element from SliceInt8 at the specified index.

func (*SliceInt8) Reverse 

func (s *SliceInt8) Reverse() *SliceInt8

Reverse reverses the order of the elements of SliceInt8.

func (*SliceInt8) Set 

func (s *SliceInt8) Set(index int, elem int8) *SliceInt8

Set sets the element of SliceInt8 at the specified index.

func (*SliceInt8) Shuffle 

func (s *SliceInt8) Shuffle(seed int64) *SliceInt8

Shuffle randomly shuffles the order of the elements in SliceInt8.

func (*SliceInt8) Sort 

func (s *SliceInt8) Sort() *SliceInt8

Sort sorts the elements of SliceInt8 in increasing order.

func (*SliceInt8) Swap 

func (s *SliceInt8) Swap(i, j int)

Swap swaps the elements in SliceInt8 specified by the indices i and j.

func (*SliceInt8) Transform 

func (s *SliceInt8) Transform(fn func(elem int8) int8) *SliceInt8

Transform modifies each element of SliceInt8 according to the specified function.

func (*SliceInt8) Unique 

func (s *SliceInt8) Unique() *SliceInt8

Unique modifies SliceInt8 to keep only the first occurrence of each element (removing any duplicates).

type SliceRune 

type SliceRune struct {
	// contains filtered or unexported fields
}

SliceRune is a slice of type rune.

func NewSliceRune 

func NewSliceRune(elems ...rune) *SliceRune

NewSliceRune returns a pointer to a new SliceRune initialized with the specified elements.

func (*SliceRune) Append 

func (s *SliceRune) Append(elems ...rune) *SliceRune

Append adds the elements to the end of SliceRune.

func (*SliceRune) At 

func (s *SliceRune) At(index int) rune

At returns the element in SliceRune at the specified index.

func (*SliceRune) Clone 

func (s *SliceRune) Clone() *SliceRune

Clone performs a deep copy of SliceRune and returns it

func (*SliceRune) Count 

func (s *SliceRune) Count() int

Count returns the number of elements in SliceRune.

func (*SliceRune) Data 

func (s *SliceRune) Data() []rune

Data returns the raw elements of SliceRune.

func (*SliceRune) Equal 

func (s *SliceRune) Equal(s2 *SliceRune) bool

Equal returns true if the SliceRune is logically equivalent to the specified SliceRune.

func (*SliceRune) Filter 

func (s *SliceRune) Filter(fn func(elem rune) bool) *SliceRune

Filter removes elements from SliceRune that do not satisfy the filter function.

func (*SliceRune) Insert 

func (s *SliceRune) Insert(index int, elems ...rune) *SliceRune

Insert inserts the elements into SliceRune at the specified index.

func (*SliceRune) Len 

func (s *SliceRune) Len() int

Len returns the number of elements in SliceRune (alias for Count).

func (*SliceRune) Less 

func (s *SliceRune) Less(i, j int) bool

Less returns true if the SliceRune element at index i is less than the element at index j.

func (*SliceRune) Max 

func (s *SliceRune) Max() rune

Max returns the largest (greatest ordered) element in SliceRune.

func (*SliceRune) Min 

func (s *SliceRune) Min() rune

Min returns the smallest (least ordered) element in SliceRune.

func (*SliceRune) Prepend 

func (s *SliceRune) Prepend(elems ...rune) *SliceRune

Prepend adds the elements to the beginning of SliceRune.

func (*SliceRune) Remove 

func (s *SliceRune) Remove(index int) *SliceRune

Remove removes the element from SliceRune at the specified index.

func (*SliceRune) Reverse 

func (s *SliceRune) Reverse() *SliceRune

Reverse reverses the order of the elements of SliceRune.

func (*SliceRune) Set 

func (s *SliceRune) Set(index int, elem rune) *SliceRune

Set sets the element of SliceRune at the specified index.

func (*SliceRune) Shuffle 

func (s *SliceRune) Shuffle(seed int64) *SliceRune

Shuffle randomly shuffles the order of the elements in SliceRune.

func (*SliceRune) Sort 

func (s *SliceRune) Sort() *SliceRune

Sort sorts the elements of SliceRune in increasing order.

func (*SliceRune) Swap 

func (s *SliceRune) Swap(i, j int)

Swap swaps the elements in SliceRune specified by the indices i and j.

func (*SliceRune) Transform 

func (s *SliceRune) Transform(fn func(elem rune) rune) *SliceRune

Transform modifies each element of SliceRune according to the specified function.

func (*SliceRune) Unique 

func (s *SliceRune) Unique() *SliceRune

Unique modifies SliceRune to keep only the first occurrence of each element (removing any duplicates).

type SliceString 

type SliceString struct {
	// contains filtered or unexported fields
}

SliceString is a slice of type string.

func NewSliceString 

func NewSliceString(elems ...string) *SliceString

NewSliceString returns a pointer to a new SliceString initialized with the specified elements.

func (*SliceString) Append 

func (s *SliceString) Append(elems ...string) *SliceString

Append adds the elements to the end of SliceString.

func (*SliceString) At 

func (s *SliceString) At(index int) string

At returns the element in SliceString at the specified index.

func (*SliceString) Clone 

func (s *SliceString) Clone() *SliceString

Clone performs a deep copy of SliceString and returns it

func (*SliceString) Count 

func (s *SliceString) Count() int

Count returns the number of elements in SliceString.

func (*SliceString) Data 

func (s *SliceString) Data() []string

Data returns the raw elements of SliceString.

func (*SliceString) Equal 

func (s *SliceString) Equal(s2 *SliceString) bool

Equal returns true if the SliceString is logically equivalent to the specified SliceString.

func (*SliceString) Filter 

func (s *SliceString) Filter(fn func(elem string) bool) *SliceString

Filter removes elements from SliceString that do not satisfy the filter function.

func (*SliceString) Insert 

func (s *SliceString) Insert(index int, elems ...string) *SliceString

Insert inserts the elements into SliceString at the specified index.

func (*SliceString) Len 

func (s *SliceString) Len() int

Len returns the number of elements in SliceString (alias for Count).

func (*SliceString) Less 

func (s *SliceString) Less(i, j int) bool

Less returns true if the SliceString element at index i is less than the element at index j.

func (*SliceString) Max 

func (s *SliceString) Max() string

Max returns the largest (greatest ordered) element in SliceString.

func (*SliceString) Min 

func (s *SliceString) Min() string

Min returns the smallest (least ordered) element in SliceString.

func (*SliceString) Prepend 

func (s *SliceString) Prepend(elems ...string) *SliceString

Prepend adds the elements to the beginning of SliceString.

func (*SliceString) Remove 

func (s *SliceString) Remove(index int) *SliceString

Remove removes the element from SliceString at the specified index.

func (*SliceString) Reverse 

func (s *SliceString) Reverse() *SliceString

Reverse reverses the order of the elements of SliceString.

func (*SliceString) Set 

func (s *SliceString) Set(index int, elem string) *SliceString

Set sets the element of SliceString at the specified index.

func (*SliceString) Shuffle 

func (s *SliceString) Shuffle(seed int64) *SliceString

Shuffle randomly shuffles the order of the elements in SliceString.

func (*SliceString) Sort 

func (s *SliceString) Sort() *SliceString

Sort sorts the elements of SliceString in increasing order.

func (*SliceString) Swap 

func (s *SliceString) Swap(i, j int)

Swap swaps the elements in SliceString specified by the indices i and j.

func (*SliceString) Transform 

func (s *SliceString) Transform(fn func(elem string) string) *SliceString

Transform modifies each element of SliceString according to the specified function.

func (*SliceString) Unique 

func (s *SliceString) Unique() *SliceString

Unique modifies SliceString to keep only the first occurrence of each element (removing any duplicates).

type SliceUint 

type SliceUint struct {
	// contains filtered or unexported fields
}

SliceUint is a slice of type uint.

func NewSliceUint 

func NewSliceUint(elems ...uint) *SliceUint

NewSliceUint returns a pointer to a new SliceUint initialized with the specified elements.

func (*SliceUint) Append 

func (s *SliceUint) Append(elems ...uint) *SliceUint

Append adds the elements to the end of SliceUint.

func (*SliceUint) At 

func (s *SliceUint) At(index int) uint

At returns the element in SliceUint at the specified index.

func (*SliceUint) Clone 

func (s *SliceUint) Clone() *SliceUint

Clone performs a deep copy of SliceUint and returns it

func (*SliceUint) Count 

func (s *SliceUint) Count() int

Count returns the number of elements in SliceUint.

func (*SliceUint) Data 

func (s *SliceUint) Data() []uint

Data returns the raw elements of SliceUint.

func (*SliceUint) Equal 

func (s *SliceUint) Equal(s2 *SliceUint) bool

Equal returns true if the SliceUint is logically equivalent to the specified SliceUint.

func (*SliceUint) Filter 

func (s *SliceUint) Filter(fn func(elem uint) bool) *SliceUint

Filter removes elements from SliceUint that do not satisfy the filter function.

func (*SliceUint) Insert 

func (s *SliceUint) Insert(index int, elems ...uint) *SliceUint

Insert inserts the elements into SliceUint at the specified index.

func (*SliceUint) Len 

func (s *SliceUint) Len() int

Len returns the number of elements in SliceUint (alias for Count).

func (*SliceUint) Less 

func (s *SliceUint) Less(i, j int) bool

Less returns true if the SliceUint element at index i is less than the element at index j.

func (*SliceUint) Max 

func (s *SliceUint) Max() uint

Max returns the largest (greatest ordered) element in SliceUint.

func (*SliceUint) Min 

func (s *SliceUint) Min() uint

Min returns the smallest (least ordered) element in SliceUint.

func (*SliceUint) Prepend 

func (s *SliceUint) Prepend(elems ...uint) *SliceUint

Prepend adds the elements to the beginning of SliceUint.

func (*SliceUint) Remove 

func (s *SliceUint) Remove(index int) *SliceUint

Remove removes the element from SliceUint at the specified index.

func (*SliceUint) Reverse 

func (s *SliceUint) Reverse() *SliceUint

Reverse reverses the order of the elements of SliceUint.

func (*SliceUint) Set 

func (s *SliceUint) Set(index int, elem uint) *SliceUint

Set sets the element of SliceUint at the specified index.

func (*SliceUint) Shuffle 

func (s *SliceUint) Shuffle(seed int64) *SliceUint

Shuffle randomly shuffles the order of the elements in SliceUint.

func (*SliceUint) Sort 

func (s *SliceUint) Sort() *SliceUint

Sort sorts the elements of SliceUint in increasing order.

func (*SliceUint) Swap 

func (s *SliceUint) Swap(i, j int)

Swap swaps the elements in SliceUint specified by the indices i and j.

func (*SliceUint) Transform 

func (s *SliceUint) Transform(fn func(elem uint) uint) *SliceUint

Transform modifies each element of SliceUint according to the specified function.

func (*SliceUint) Unique 

func (s *SliceUint) Unique() *SliceUint

Unique modifies SliceUint to keep only the first occurrence of each element (removing any duplicates).

type SliceUint16 

type SliceUint16 struct {
	// contains filtered or unexported fields
}

SliceUint16 is a slice of type uint16.

func NewSliceUint16 

func NewSliceUint16(elems ...uint16) *SliceUint16

NewSliceUint16 returns a pointer to a new SliceUint16 initialized with the specified elements.

func (*SliceUint16) Append 

func (s *SliceUint16) Append(elems ...uint16) *SliceUint16

Append adds the elements to the end of SliceUint16.

func (*SliceUint16) At 

func (s *SliceUint16) At(index int) uint16

At returns the element in SliceUint16 at the specified index.

func (*SliceUint16) Clone 

func (s *SliceUint16) Clone() *SliceUint16

Clone performs a deep copy of SliceUint16 and returns it

func (*SliceUint16) Count 

func (s *SliceUint16) Count() int

Count returns the number of elements in SliceUint16.

func (*SliceUint16) Data 

func (s *SliceUint16) Data() []uint16

Data returns the raw elements of SliceUint16.

func (*SliceUint16) Equal 

func (s *SliceUint16) Equal(s2 *SliceUint16) bool

Equal returns true if the SliceUint16 is logically equivalent to the specified SliceUint16.

func (*SliceUint16) Filter 

func (s *SliceUint16) Filter(fn func(elem uint16) bool) *SliceUint16

Filter removes elements from SliceUint16 that do not satisfy the filter function.

func (*SliceUint16) Insert 

func (s *SliceUint16) Insert(index int, elems ...uint16) *SliceUint16

Insert inserts the elements into SliceUint16 at the specified index.

func (*SliceUint16) Len 

func (s *SliceUint16) Len() int

Len returns the number of elements in SliceUint16 (alias for Count).

func (*SliceUint16) Less 

func (s *SliceUint16) Less(i, j int) bool

Less returns true if the SliceUint16 element at index i is less than the element at index j.

func (*SliceUint16) Max 

func (s *SliceUint16) Max() uint16

Max returns the largest (greatest ordered) element in SliceUint16.

func (*SliceUint16) Min 

func (s *SliceUint16) Min() uint16

Min returns the smallest (least ordered) element in SliceUint16.

func (*SliceUint16) Prepend 

func (s *SliceUint16) Prepend(elems ...uint16) *SliceUint16

Prepend adds the elements to the beginning of SliceUint16.

func (*SliceUint16) Remove 

func (s *SliceUint16) Remove(index int) *SliceUint16

Remove removes the element from SliceUint16 at the specified index.

func (*SliceUint16) Reverse 

func (s *SliceUint16) Reverse() *SliceUint16

Reverse reverses the order of the elements of SliceUint16.

func (*SliceUint16) Set 

func (s *SliceUint16) Set(index int, elem uint16) *SliceUint16

Set sets the element of SliceUint16 at the specified index.

func (*SliceUint16) Shuffle 

func (s *SliceUint16) Shuffle(seed int64) *SliceUint16

Shuffle randomly shuffles the order of the elements in SliceUint16.

func (*SliceUint16) Sort 

func (s *SliceUint16) Sort() *SliceUint16

Sort sorts the elements of SliceUint16 in increasing order.

func (*SliceUint16) Swap 

func (s *SliceUint16) Swap(i, j int)

Swap swaps the elements in SliceUint16 specified by the indices i and j.

func (*SliceUint16) Transform 

func (s *SliceUint16) Transform(fn func(elem uint16) uint16) *SliceUint16

Transform modifies each element of SliceUint16 according to the specified function.

func (*SliceUint16) Unique 

func (s *SliceUint16) Unique() *SliceUint16

Unique modifies SliceUint16 to keep only the first occurrence of each element (removing any duplicates).

type SliceUint32 

type SliceUint32 struct {
	// contains filtered or unexported fields
}

SliceUint32 is a slice of type uint32.

func NewSliceUint32 

func NewSliceUint32(elems ...uint32) *SliceUint32

NewSliceUint32 returns a pointer to a new SliceUint32 initialized with the specified elements.

func (*SliceUint32) Append 

func (s *SliceUint32) Append(elems ...uint32) *SliceUint32

Append adds the elements to the end of SliceUint32.

func (*SliceUint32) At 

func (s *SliceUint32) At(index int) uint32

At returns the element in SliceUint32 at the specified index.

func (*SliceUint32) Clone 

func (s *SliceUint32) Clone() *SliceUint32

Clone performs a deep copy of SliceUint32 and returns it

func (*SliceUint32) Count 

func (s *SliceUint32) Count() int

Count returns the number of elements in SliceUint32.

func (*SliceUint32) Data 

func (s *SliceUint32) Data() []uint32

Data returns the raw elements of SliceUint32.

func (*SliceUint32) Equal 

func (s *SliceUint32) Equal(s2 *SliceUint32) bool

Equal returns true if the SliceUint32 is logically equivalent to the specified SliceUint32.

func (*SliceUint32) Filter 

func (s *SliceUint32) Filter(fn func(elem uint32) bool) *SliceUint32

Filter removes elements from SliceUint32 that do not satisfy the filter function.

func (*SliceUint32) Insert 

func (s *SliceUint32) Insert(index int, elems ...uint32) *SliceUint32

Insert inserts the elements into SliceUint32 at the specified index.

func (*SliceUint32) Len 

func (s *SliceUint32) Len() int

Len returns the number of elements in SliceUint32 (alias for Count).

func (*SliceUint32) Less 

func (s *SliceUint32) Less(i, j int) bool

Less returns true if the SliceUint32 element at index i is less than the element at index j.

func (*SliceUint32) Max 

func (s *SliceUint32) Max() uint32

Max returns the largest (greatest ordered) element in SliceUint32.

func (*SliceUint32) Min 

func (s *SliceUint32) Min() uint32

Min returns the smallest (least ordered) element in SliceUint32.

func (*SliceUint32) Prepend 

func (s *SliceUint32) Prepend(elems ...uint32) *SliceUint32

Prepend adds the elements to the beginning of SliceUint32.

func (*SliceUint32) Remove 

func (s *SliceUint32) Remove(index int) *SliceUint32

Remove removes the element from SliceUint32 at the specified index.

func (*SliceUint32) Reverse 

func (s *SliceUint32) Reverse() *SliceUint32

Reverse reverses the order of the elements of SliceUint32.

func (*SliceUint32) Set 

func (s *SliceUint32) Set(index int, elem uint32) *SliceUint32

Set sets the element of SliceUint32 at the specified index.

func (*SliceUint32) Shuffle 

func (s *SliceUint32) Shuffle(seed int64) *SliceUint32

Shuffle randomly shuffles the order of the elements in SliceUint32.

func (*SliceUint32) Sort 

func (s *SliceUint32) Sort() *SliceUint32

Sort sorts the elements of SliceUint32 in increasing order.

func (*SliceUint32) Swap 

func (s *SliceUint32) Swap(i, j int)

Swap swaps the elements in SliceUint32 specified by the indices i and j.

func (*SliceUint32) Transform 

func (s *SliceUint32) Transform(fn func(elem uint32) uint32) *SliceUint32

Transform modifies each element of SliceUint32 according to the specified function.

func (*SliceUint32) Unique 

func (s *SliceUint32) Unique() *SliceUint32

Unique modifies SliceUint32 to keep only the first occurrence of each element (removing any duplicates).

type SliceUint64 

type SliceUint64 struct {
	// contains filtered or unexported fields
}

SliceUint64 is a slice of type uint64.

func NewSliceUint64 

func NewSliceUint64(elems ...uint64) *SliceUint64

NewSliceUint64 returns a pointer to a new SliceUint64 initialized with the specified elements.

func (*SliceUint64) Append 

func (s *SliceUint64) Append(elems ...uint64) *SliceUint64

Append adds the elements to the end of SliceUint64.

func (*SliceUint64) At 

func (s *SliceUint64) At(index int) uint64

At returns the element in SliceUint64 at the specified index.

func (*SliceUint64) Clone 

func (s *SliceUint64) Clone() *SliceUint64

Clone performs a deep copy of SliceUint64 and returns it

func (*SliceUint64) Count 

func (s *SliceUint64) Count() int

Count returns the number of elements in SliceUint64.

func (*SliceUint64) Data 

func (s *SliceUint64) Data() []uint64

Data returns the raw elements of SliceUint64.

func (*SliceUint64) Equal 

func (s *SliceUint64) Equal(s2 *SliceUint64) bool

Equal returns true if the SliceUint64 is logically equivalent to the specified SliceUint64.

func (*SliceUint64) Filter 

func (s *SliceUint64) Filter(fn func(elem uint64) bool) *SliceUint64

Filter removes elements from SliceUint64 that do not satisfy the filter function.

func (*SliceUint64) Insert 

func (s *SliceUint64) Insert(index int, elems ...uint64) *SliceUint64

Insert inserts the elements into SliceUint64 at the specified index.

func (*SliceUint64) Len 

func (s *SliceUint64) Len() int

Len returns the number of elements in SliceUint64 (alias for Count).

func (*SliceUint64) Less 

func (s *SliceUint64) Less(i, j int) bool

Less returns true if the SliceUint64 element at index i is less than the element at index j.

func (*SliceUint64) Max 

func (s *SliceUint64) Max() uint64

Max returns the largest (greatest ordered) element in SliceUint64.

func (*SliceUint64) Min 

func (s *SliceUint64) Min() uint64

Min returns the smallest (least ordered) element in SliceUint64.

func (*SliceUint64) Prepend 

func (s *SliceUint64) Prepend(elems ...uint64) *SliceUint64

Prepend adds the elements to the beginning of SliceUint64.

func (*SliceUint64) Remove 

func (s *SliceUint64) Remove(index int) *SliceUint64

Remove removes the element from SliceUint64 at the specified index.

func (*SliceUint64) Reverse 

func (s *SliceUint64) Reverse() *SliceUint64

Reverse reverses the order of the elements of SliceUint64.

func (*SliceUint64) Set 

func (s *SliceUint64) Set(index int, elem uint64) *SliceUint64

Set sets the element of SliceUint64 at the specified index.

func (*SliceUint64) Shuffle 

func (s *SliceUint64) Shuffle(seed int64) *SliceUint64

Shuffle randomly shuffles the order of the elements in SliceUint64.

func (*SliceUint64) Sort 

func (s *SliceUint64) Sort() *SliceUint64

Sort sorts the elements of SliceUint64 in increasing order.

func (*SliceUint64) Swap 

func (s *SliceUint64) Swap(i, j int)

Swap swaps the elements in SliceUint64 specified by the indices i and j.

func (*SliceUint64) Transform 

func (s *SliceUint64) Transform(fn func(elem uint64) uint64) *SliceUint64

Transform modifies each element of SliceUint64 according to the specified function.

func (*SliceUint64) Unique 

func (s *SliceUint64) Unique() *SliceUint64

Unique modifies SliceUint64 to keep only the first occurrence of each element (removing any duplicates).

type SliceUint8 

type SliceUint8 struct {
	// contains filtered or unexported fields
}

SliceUint8 is a slice of type uint8.

func NewSliceUint8 

func NewSliceUint8(elems ...uint8) *SliceUint8

NewSliceUint8 returns a pointer to a new SliceUint8 initialized with the specified elements.

func (*SliceUint8) Append 

func (s *SliceUint8) Append(elems ...uint8) *SliceUint8

Append adds the elements to the end of SliceUint8.

func (*SliceUint8) At 

func (s *SliceUint8) At(index int) uint8

At returns the element in SliceUint8 at the specified index.

func (*SliceUint8) Clone 

func (s *SliceUint8) Clone() *SliceUint8

Clone performs a deep copy of SliceUint8 and returns it

func (*SliceUint8) Count 

func (s *SliceUint8) Count() int

Count returns the number of elements in SliceUint8.

func (*SliceUint8) Data 

func (s *SliceUint8) Data() []uint8

Data returns the raw elements of SliceUint8.

func (*SliceUint8) Equal 

func (s *SliceUint8) Equal(s2 *SliceUint8) bool

Equal returns true if the SliceUint8 is logically equivalent to the specified SliceUint8.

func (*SliceUint8) Filter 

func (s *SliceUint8) Filter(fn func(elem uint8) bool) *SliceUint8

Filter removes elements from SliceUint8 that do not satisfy the filter function.

func (*SliceUint8) Insert 

func (s *SliceUint8) Insert(index int, elems ...uint8) *SliceUint8

Insert inserts the elements into SliceUint8 at the specified index.

func (*SliceUint8) Len 

func (s *SliceUint8) Len() int

Len returns the number of elements in SliceUint8 (alias for Count).

func (*SliceUint8) Less 

func (s *SliceUint8) Less(i, j int) bool

Less returns true if the SliceUint8 element at index i is less than the element at index j.

func (*SliceUint8) Max 

func (s *SliceUint8) Max() uint8

Max returns the largest (greatest ordered) element in SliceUint8.

func (*SliceUint8) Min 

func (s *SliceUint8) Min() uint8

Min returns the smallest (least ordered) element in SliceUint8.

func (*SliceUint8) Prepend 

func (s *SliceUint8) Prepend(elems ...uint8) *SliceUint8

Prepend adds the elements to the beginning of SliceUint8.

func (*SliceUint8) Remove 

func (s *SliceUint8) Remove(index int) *SliceUint8

Remove removes the element from SliceUint8 at the specified index.

func (*SliceUint8) Reverse 

func (s *SliceUint8) Reverse() *SliceUint8

Reverse reverses the order of the elements of SliceUint8.

func (*SliceUint8) Set 

func (s *SliceUint8) Set(index int, elem uint8) *SliceUint8

Set sets the element of SliceUint8 at the specified index.

func (*SliceUint8) Shuffle 

func (s *SliceUint8) Shuffle(seed int64) *SliceUint8

Shuffle randomly shuffles the order of the elements in SliceUint8.

func (*SliceUint8) Sort 

func (s *SliceUint8) Sort() *SliceUint8

Sort sorts the elements of SliceUint8 in increasing order.

func (*SliceUint8) Swap 

func (s *SliceUint8) Swap(i, j int)

Swap swaps the elements in SliceUint8 specified by the indices i and j.

func (*SliceUint8) Transform 

func (s *SliceUint8) Transform(fn func(elem uint8) uint8) *SliceUint8

Transform modifies each element of SliceUint8 according to the specified function.

func (*SliceUint8) Unique 

func (s *SliceUint8) Unique() *SliceUint8

Unique modifies SliceUint8 to keep only the first occurrence of each element (removing any duplicates).

type SliceUintptr 

type SliceUintptr struct {
	// contains filtered or unexported fields
}

SliceUintptr is a slice of type uintptr.

func NewSliceUintptr 

func NewSliceUintptr(elems ...uintptr) *SliceUintptr

NewSliceUintptr returns a pointer to a new SliceUintptr initialized with the specified elements.

func (*SliceUintptr) Append 

func (s *SliceUintptr) Append(elems ...uintptr) *SliceUintptr

Append adds the elements to the end of SliceUintptr.

func (*SliceUintptr) At 

func (s *SliceUintptr) At(index int) uintptr

At returns the element in SliceUintptr at the specified index.

func (*SliceUintptr) Clone 

func (s *SliceUintptr) Clone() *SliceUintptr

Clone performs a deep copy of SliceUintptr and returns it

func (*SliceUintptr) Count 

func (s *SliceUintptr) Count() int

Count returns the number of elements in SliceUintptr.

func (*SliceUintptr) Data 

func (s *SliceUintptr) Data() []uintptr

Data returns the raw elements of SliceUintptr.

func (*SliceUintptr) Equal 

func (s *SliceUintptr) Equal(s2 *SliceUintptr) bool

Equal returns true if the SliceUintptr is logically equivalent to the specified SliceUintptr.

func (*SliceUintptr) Filter 

func (s *SliceUintptr) Filter(fn func(elem uintptr) bool) *SliceUintptr

Filter removes elements from SliceUintptr that do not satisfy the filter function.

func (*SliceUintptr) Insert 

func (s *SliceUintptr) Insert(index int, elems ...uintptr) *SliceUintptr

Insert inserts the elements into SliceUintptr at the specified index.

func (*SliceUintptr) Len 

func (s *SliceUintptr) Len() int

Len returns the number of elements in SliceUintptr (alias for Count).

func (*SliceUintptr) Less 

func (s *SliceUintptr) Less(i, j int) bool

Less returns true if the SliceUintptr element at index i is less than the element at index j.

func (*SliceUintptr) Max 

func (s *SliceUintptr) Max() uintptr

Max returns the largest (greatest ordered) element in SliceUintptr.

func (*SliceUintptr) Min 

func (s *SliceUintptr) Min() uintptr

Min returns the smallest (least ordered) element in SliceUintptr.

func (*SliceUintptr) Prepend 

func (s *SliceUintptr) Prepend(elems ...uintptr) *SliceUintptr

Prepend adds the elements to the beginning of SliceUintptr.

func (*SliceUintptr) Remove 

func (s *SliceUintptr) Remove(index int) *SliceUintptr

Remove removes the element from SliceUintptr at the specified index.

func (*SliceUintptr) Reverse 

func (s *SliceUintptr) Reverse() *SliceUintptr

Reverse reverses the order of the elements of SliceUintptr.

func (*SliceUintptr) Set 

func (s *SliceUintptr) Set(index int, elem uintptr) *SliceUintptr

Set sets the element of SliceUintptr at the specified index.

func (*SliceUintptr) Shuffle 

func (s *SliceUintptr) Shuffle(seed int64) *SliceUintptr

Shuffle randomly shuffles the order of the elements in SliceUintptr.

func (*SliceUintptr) Sort 

func (s *SliceUintptr) Sort() *SliceUintptr

Sort sorts the elements of SliceUintptr in increasing order.

func (*SliceUintptr) Swap 

func (s *SliceUintptr) Swap(i, j int)

Swap swaps the elements in SliceUintptr specified by the indices i and j.

func (*SliceUintptr) Transform 

func (s *SliceUintptr) Transform(fn func(elem uintptr) uintptr) *SliceUintptr

Transform modifies each element of SliceUintptr according to the specified function.

func (*SliceUintptr) Unique 

func (s *SliceUintptr) Unique() *SliceUintptr

Unique modifies SliceUintptr to keep only the first occurrence of each element (removing any duplicates).

Source Files

View all Source files

Directories

Path Synopsis
cmd
golist
Golist is a tool that generates 'Slice*' type wrappers for a given slice type T. Typically this process would be run using go generate, like this: //go:generate golist -type=Foo running this command golist -type=Foo in the same directory will create the file slice_foo.go containing a definition of type SliceFoo struct { data []Foo } The default type is SliceT or sliceT (depending on if the type is exported) and output file is slice_t.go.
 Golist is a tool that generates 'Slice*' type wrappers for a given slice type T. Typically this process would be run using go generate, like this: //go:generate golist -type=Foo running this command golist -type=Foo in the same directory will create the file slice_foo.go containing a definition of type SliceFoo struct { data []Foo } The default type is SliceT or sliceT (depending on if the type is exported) and output file is slice_t.go.

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.