Documentation ¶
Overview ¶
Package list implements a generic list. It is a wrapper around a slice and has multiple useful methods.
Index ¶
- type List
- func (l *List[T]) Append(items ...T) *List[T]
- func (l *List[T]) Clear() *List[T]
- func (l List[T]) Contains(item T) bool
- func (l *List[T]) Copy() *List[T]
- func (l *List[T]) Filter(f func(T) bool) *List[T]
- func (l List[T]) ForEach(f func(T))
- func (l *List[T]) Get(i int) T
- func (l List[T]) IndexOf(item T) int
- func (l *List[T]) Insert(i int, items ...T) *List[T]
- func (l *List[T]) Len() int
- func (l *List[T]) Map(f func(T) T) *List[T]
- func (l *List[T]) Prepend(items ...T) *List[T]
- func (l *List[T]) Reduce(f func(T, T) T) T
- func (l *List[T]) Remove(i int) *List[T]
- func (l *List[T]) Reverse() *List[T]
- func (l *List[T]) Set(i int, item T) *List[T]
- func (l *List[T]) Shuffle() *List[T]
- func (l *List[T]) Slice() []T
- func (l *List[T]) Sort(f func(T, T) bool) *List[T]
- func (l List[T]) String() string
- func (l *List[T]) Swap(i, j int) *List[T]
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type List ¶
type List[T any] struct { // contains filtered or unexported fields }
List is a generic list type.
Example (Functional) ¶
package main import ( "fmt" "strings" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c") l.Map(func(s string) string { return s + "!" }).Filter(func(s string) bool { return !strings.Contains(s, "b") }) fmt.Println(l) }
Output: [a! c!]
func SliceToList ¶
SliceToList converts a slice to a list.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { l := list.SliceToList([]string{"a", "b", "c"}) fmt.Println(l) }
Output: [a b c]
func (*List[T]) Append ¶
Append adds items to the end of list.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c") fmt.Println(l) }
Output: [a b c]
func (*List[T]) Clear ¶
Clear removes all items from the list.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c") l.Clear() fmt.Println(l) }
Output: []
func (List[T]) Contains ¶
Contains returns true if the list contains the given item.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c") fmt.Println(l.Contains("b")) }
Output: true
func (*List[T]) Copy ¶
Copy returns a new copy of the list. Useful when you want to modify a list without modifying the original.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c") fmt.Println(l.Append("appended")) // Overwrites the original list fmt.Println(l.Copy().Append("appended1")) // Does not overwrite the original list fmt.Println(l.Copy().Append("appended2")) // Does not overwrite the original list fmt.Println(l) }
Output: [a b c appended] [a b c appended appended1] [a b c appended appended2] [a b c appended]
func (*List[T]) Filter ¶
Filter removes all items from the list that do not match the given predicate.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c") l.Filter(func(s string) bool { return s != "b" }) fmt.Println(l) }
Output: [a c]
func (List[T]) ForEach ¶
func (l List[T]) ForEach(f func(T))
ForEach iterates over the list and calls the given function for each item.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c") l.ForEach(func(s string) { fmt.Println(s) }) }
Output: a b c
func (*List[T]) Get ¶
Get returns the item at the given index.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c") fmt.Println(l.Get(1)) }
Output: b
func (List[T]) IndexOf ¶
IndexOf returns the index of the first occurrence of the given item.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c") fmt.Println(l.IndexOf("b")) }
Output: 1
func (*List[T]) Insert ¶
Insert adds items at the given index.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c") l.Insert(1, "inserted") fmt.Println(l) l.Insert(0, "a", "b", "c") fmt.Println(l) }
Output: [a inserted b c] [a b c a inserted b c]
func (*List[T]) Len ¶
Len returns the length of the list.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c") fmt.Println(l.Len()) }
Output: 3
func (*List[T]) Map ¶
Map overwrites the list with the result of applying the given function to each item.
Example ¶
package main import ( "fmt" "strings" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c").Map(strings.ToUpper) fmt.Println(l) }
Output: [A B C]
func (*List[T]) Prepend ¶
Prepend adds items to the beginning of list.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c") l.Prepend("d", "e", "f") fmt.Println(l) }
Output: [d e f a b c]
func (*List[T]) Reduce ¶
func (l *List[T]) Reduce(f func(T, T) T) T
Reduce reduces the list to a single value by applying the given function to each item.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[int] l.Append(1, 2, 3) sum := l.Reduce(func(a, b int) int { return a + b }) fmt.Println(sum) }
Output: 6
func (*List[T]) Remove ¶
Remove removes the item at the given index.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c") l.Remove(1) fmt.Println(l) }
Output: [a c]
func (*List[T]) Reverse ¶
Reverse reverses the list.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c") l.Reverse() fmt.Println(l) }
Output: [c b a]
func (*List[T]) Set ¶
Set sets the item at the given index.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c") l.Set(1, "set") fmt.Println(l) }
Output: [a set c]
func (*List[T]) Shuffle ¶
Shuffle shuffles the list. You need to seed the random number generator yourself.
Example ¶
package main import ( "fmt" "math/rand" "atomicgo.dev/list" ) func main() { var l list.List[string] rand.Seed(1337) // You should probably use time.Now().UnixNano() in your code. l.Append("a", "b", "c") l.Shuffle() fmt.Println(l) }
Output: [b a c]
func (*List[T]) Slice ¶
func (l *List[T]) Slice() []T
Slice returns the list as a slice.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[string] l.Append("a", "b", "c") fmt.Println(l.Slice()) }
Output: [a b c]
func (*List[T]) Sort ¶
Sort sorts the list using the given function.
Example ¶
package main import ( "fmt" "atomicgo.dev/list" ) func main() { var l list.List[int] l.Append(3, 2, 1) l.Sort(func(a, b int) bool { return a < b }) fmt.Println(l) }
Output: [1 2 3]