AtomicGo | list

---

Documentation | Contributing | Code of Conduct

---

go get atomicgo.dev/list

list

import"atomicgo.dev/list"

Package list implements a generic list. It is a wrapper around a slice and has multiple useful methods. It can be used to develop in a functional style, but it is not required. The main purpose of this package is, to make working with slices easier. The package supports sorting, shuffling, filtering, mapping, appending, prepending, removing, inserting and more.

Index

• type List
  • func SliceToList[T any](items []T) List[T]
  • 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]

type List

List is a generic list type.

typeList[Tany] struct {
// contains filtered or unexported fields
}

package main
import (
"fmt""strings""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c")
l.Map(func(sstring) string {
returns+"!"
}).Filter(func(sstring) bool {
return!strings.Contains(s, "b")
})
fmt.Println(l)
}

Output

[a! c!]

func SliceToList

funcSliceToList[Tany](items []T) List[T]

SliceToList converts a slice to a list.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
l:=list.SliceToList([]string{"a", "b", "c"})
fmt.Println(l)
}

Output

[a b c]

func (*List[T]) Append

func (l*List[T]) Append(items...T) *List[T]

Append adds items to the end of list.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c")
fmt.Println(l)
}

Output

[a b c]

func (*List[T]) Clear

func (l*List[T]) Clear() *List[T]

Clear removes all items from the list.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c")
l.Clear()
fmt.Println(l)
}

Output

[]

func (List[T]) Contains

func (lList[T]) Contains(itemT) bool

Contains returns true if the list contains the given item.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c")
fmt.Println(l.Contains("b"))
}

Output

true

func (*List[T]) Copy

func (l*List[T]) Copy() *List[T]

Copy returns a new copy of the list. Useful when you want to modify a list without modifying the original.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c")
fmt.Println(l.Append("appended")) // Overwrites the original listfmt.Println(l.Copy().Append("appended1")) // Does not overwrite the original listfmt.Println(l.Copy().Append("appended2")) // Does not overwrite the original listfmt.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

func (l*List[T]) Filter(ffunc(T) bool) *List[T]

Filter removes all items from the list that do not match the given predicate.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c")
l.Filter(func(sstring) bool {
returns!="b"
})
fmt.Println(l)
}

Output

[a c]

func (List[T]) ForEach

func (lList[T]) ForEach(ffunc(T))

ForEach iterates over the list and calls the given function for each item.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c")
l.ForEach(func(sstring) {
fmt.Println(s)
})
}

Output

a
b
c

func (*List[T]) Get

func (l*List[T]) Get(iint) T

Get returns the item at the given index.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c")
fmt.Println(l.Get(1))
}

Output

b

func (List[T]) IndexOf

func (lList[T]) IndexOf(itemT) int

IndexOf returns the index of the first occurrence of the given item.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c")
fmt.Println(l.IndexOf("b"))
}

Output

1

func (*List[T]) Insert

func (l*List[T]) Insert(iint, items...T) *List[T]

Insert adds items at the given index.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl 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

func (l*List[T]) Len() int

Len returns the length of the list.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c")
fmt.Println(l.Len())
}

Output

3

func (*List[T]) Map

func (l*List[T]) Map(ffunc(T) T) *List[T]

Map overwrites the list with the result of applying the given function to each item.

package main
import (
"fmt""strings""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c").Map(strings.ToUpper)
fmt.Println(l)
}

Output

[A B C]

func (*List[T]) Prepend

func (l*List[T]) Prepend(items...T) *List[T]

Prepend adds items to the beginning of list.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl 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(ffunc(T, T) T) T

Reduce reduces the list to a single value by applying the given function to each item.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[int]
l.Append(1, 2, 3)
sum:=l.Reduce(func(a, bint) int {
returna+b
})
fmt.Println(sum)
}

Output

6

func (*List[T]) Remove

func (l*List[T]) Remove(iint) *List[T]

Remove removes the item at the given index.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c")
l.Remove(1)
fmt.Println(l)
}

Output

[a c]

func (*List[T]) Reverse

func (l*List[T]) Reverse() *List[T]

Reverse reverses the list.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c")
l.Reverse()
fmt.Println(l)
}

Output

[c b a]

func (*List[T]) Set

func (l*List[T]) Set(iint, itemT) *List[T]

Set sets the item at the given index.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c")
l.Set(1, "set")
fmt.Println(l)
}

Output

[a set c]

func (*List[T]) Shuffle

func (l*List[T]) Shuffle() *List[T]

Shuffle shuffles the list. You need to seed the random number generator yourself.

package main
import (
"fmt""math/rand""atomicgo.dev/list"
)
funcmain() {
varl 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.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c")
fmt.Println(l.Slice())
}

Output

[a b c]

func (*List[T]) Sort

func (l*List[T]) Sort(ffunc(T, T) bool) *List[T]

Sort sorts the list using the given function.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[int]
l.Append(3, 2, 1)
l.Sort(func(a, bint) bool {
returna<b
})
fmt.Println(l)
}

Output

[1 2 3]

func (List[T]) String

func (lList[T]) String() string

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c")
fmt.Println(l)
}

Output

[a b c]

func (*List[T]) Swap

func (l*List[T]) Swap(i, jint) *List[T]

Swap swaps the items at the given indices.

package main
import (
"fmt""atomicgo.dev/list"
)
funcmain() {
varl list.List[string]
l.Append("a", "b", "c")
l.Swap(0, 2)
fmt.Println(l)
}

Output

[c b a]

Generated by gomarkdoc

---

AtomicGo.dev · with ❤️ by @MarvinJWendt | mjw.dev