https://github.com/atomicgo/list
📝 A generic list implementation in Go for easy functional programming
https://github.com/atomicgo/list
array atomicgo generic go golang golang-library list
Last synced: about 1 year ago
JSON representation
📝 A generic list implementation in Go for easy functional programming
- Host: GitHub
- URL: https://github.com/atomicgo/list
- Owner: atomicgo
- License: mit
- Created: 2022-10-08T21:42:00.000Z (over 3 years ago)
- Default Branch: main
- Last Pushed: 2024-08-08T17:04:26.000Z (almost 2 years ago)
- Last Synced: 2024-11-09T02:09:19.258Z (over 1 year ago)
- Topics: array, atomicgo, generic, go, golang, golang-library, list
- Language: Go
- Homepage: https://atomicgo.dev
- Size: 57.6 KB
- Stars: 10
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
AtomicGo | list
---
Documentation
|
Contributing
|
Code of Conduct
---
go get atomicgo.dev/list
# list
```go
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](<#List>)
- [func SliceToList\[T any\]\(items \[\]T\) List\[T\]](<#SliceToList>)
- [func \(l \*List\[T\]\) Append\(items ...T\) \*List\[T\]](<#List[T].Append>)
- [func \(l \*List\[T\]\) Clear\(\) \*List\[T\]](<#List[T].Clear>)
- [func \(l List\[T\]\) Contains\(item T\) bool](<#List[T].Contains>)
- [func \(l \*List\[T\]\) Copy\(\) \*List\[T\]](<#List[T].Copy>)
- [func \(l \*List\[T\]\) Filter\(f func\(T\) bool\) \*List\[T\]](<#List[T].Filter>)
- [func \(l List\[T\]\) ForEach\(f func\(T\)\)](<#List[T].ForEach>)
- [func \(l \*List\[T\]\) Get\(i int\) T](<#List[T].Get>)
- [func \(l List\[T\]\) IndexOf\(item T\) int](<#List[T].IndexOf>)
- [func \(l \*List\[T\]\) Insert\(i int, items ...T\) \*List\[T\]](<#List[T].Insert>)
- [func \(l \*List\[T\]\) Len\(\) int](<#List[T].Len>)
- [func \(l \*List\[T\]\) Map\(f func\(T\) T\) \*List\[T\]](<#List[T].Map>)
- [func \(l \*List\[T\]\) Prepend\(items ...T\) \*List\[T\]](<#List[T].Prepend>)
- [func \(l \*List\[T\]\) Reduce\(f func\(T, T\) T\) T](<#List[T].Reduce>)
- [func \(l \*List\[T\]\) Remove\(i int\) \*List\[T\]](<#List[T].Remove>)
- [func \(l \*List\[T\]\) Reverse\(\) \*List\[T\]](<#List[T].Reverse>)
- [func \(l \*List\[T\]\) Set\(i int, item T\) \*List\[T\]](<#List[T].Set>)
- [func \(l \*List\[T\]\) Shuffle\(\) \*List\[T\]](<#List[T].Shuffle>)
- [func \(l \*List\[T\]\) Slice\(\) \[\]T](<#List[T].Slice>)
- [func \(l \*List\[T\]\) Sort\(f func\(T, T\) bool\) \*List\[T\]](<#List[T].Sort>)
- [func \(l List\[T\]\) String\(\) string](<#List[T].String>)
- [func \(l \*List\[T\]\) Swap\(i, j int\) \*List\[T\]](<#List[T].Swap>)
List is a generic list type.
```go
type List[T any] struct {
// contains filtered or unexported fields
}
```
```go
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!]
```
```go
func SliceToList[T any](items []T) List[T]
```
SliceToList converts a slice to a list.
```go
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]()
```go
func (l *List[T]) Append(items ...T) *List[T]
```
Append adds items to the end of list.
```go
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]()
```go
func (l *List[T]) Clear() *List[T]
```
Clear removes all items from the list.
```go
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]()
```go
func (l List[T]) Contains(item T) bool
```
Contains returns true if the list contains the given item.
```go
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]()
```go
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.
```go
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]()
```go
func (l *List[T]) Filter(f func(T) bool) *List[T]
```
Filter removes all items from the list that do not match the given predicate.
```go
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]()
```go
func (l List[T]) ForEach(f func(T))
```
ForEach iterates over the list and calls the given function for each item.
```go
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]()
```go
func (l *List[T]) Get(i int) T
```
Get returns the item at the given index.
```go
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]()
```go
func (l List[T]) IndexOf(item T) int
```
IndexOf returns the index of the first occurrence of the given item.
```go
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]()
```go
func (l *List[T]) Insert(i int, items ...T) *List[T]
```
Insert adds items at the given index.
```go
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]()
```go
func (l *List[T]) Len() int
```
Len returns the length of the list.
```go
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]()
```go
func (l *List[T]) Map(f func(T) T) *List[T]
```
Map overwrites the list with the result of applying the given function to each item.
```go
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]()
```go
func (l *List[T]) Prepend(items ...T) *List[T]
```
Prepend adds items to the beginning of list.
```go
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]()
```go
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.
```go
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]()
```go
func (l *List[T]) Remove(i int) *List[T]
```
Remove removes the item at the given index.
```go
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]()
```go
func (l *List[T]) Reverse() *List[T]
```
Reverse reverses the list.
```go
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]()
```go
func (l *List[T]) Set(i int, item T) *List[T]
```
Set sets the item at the given index.
```go
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]()
```go
func (l *List[T]) Shuffle() *List[T]
```
Shuffle shuffles the list. You need to seed the random number generator yourself.
```go
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]()
```go
func (l *List[T]) Slice() []T
```
Slice returns the list as a slice.
```go
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]()
```go
func (l *List[T]) Sort(f func(T, T) bool) *List[T]
```
Sort sorts the list using the given function.
```go
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]
```
### func \(List\[T\]\) [String]()
```go
func (l List[T]) String() string
```
```go
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\]\) [Swap]()
```go
func (l *List[T]) Swap(i, j int) *List[T]
```
Swap swaps the items at the given indices.
```go
package main
import (
"fmt"
"atomicgo.dev/list"
)
func main() {
var l list.List[string]
l.Append("a", "b", "c")
l.Swap(0, 2)
fmt.Println(l)
}
```
#### Output
```
[c b a]
```
Generated by [gomarkdoc]()
---
> [AtomicGo.dev](https://atomicgo.dev) ·
> with ❤️ by [@MarvinJWendt](https://github.com/MarvinJWendt) |
> [MarvinJWendt.com](https://marvinjwendt.com)