slices

package
v0.1.2 Latest Latest
Warning

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

 Go to latest Published: May 15, 2022 License: Apache-2.0 Imports: 4 Imported by: 0

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func All 

func All[T any](slice []T, f func(T) bool) bool

All returns true if all elements in the given slice satisfy the given predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.All(slice, func(i int) bool { return i > 0 })
	fmt.Println(result)
}

Output:

true

func Any 

func Any[T any](slice []T, f func(T) bool) bool

Any returns true if any element in the given slice satisfies the given predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.Any(slice, func(i int) bool { return i > 1 })
	fmt.Println(result)
}

Output:

true
Example (False) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
	}
	result := slices.Any(slice, func(u user) bool { return u.Id == 3 })
	fmt.Println(result)
}

Output:

false
Example (User) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
	}
	result := slices.Any(slice, func(u user) bool { return u.Id == 2 })
	fmt.Println(result)
}

Output:

true

func Chunk 

func Chunk[T any](slice []T, chunk int) [][]T

Chunk returns a new slice with the given slice split into smaller slices of the given size.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	result := slices.Chunk(slice, 3)
	fmt.Println(result)
}

Output:

[[1 2 3] [4 5 6] [7 8 9] [10]]
Example (Empty) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{}
	result := slices.Chunk(slice, 3)
	fmt.Println(result)
}

Output:

[]

func Clone added in v0.1.1 

func Clone[T any](slice []T) []T

Clone returns a new slice with the same elements as the given slice.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.Clone(slice)
	fmt.Println(result)
}

Output:

[1 2 3]

func Contains 

func Contains[T comparable](slice []T, v T) bool

Contains returns true if the given slice contains the given element.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.Contains(slice, 6)
	fmt.Println(result)
}

Output:

false

func ContainsBy 

func ContainsBy[T any](slice []T, v T, cmp func(T, T) bool) bool

ContainsBy returns true if the given slice contains an element that satisfies the given predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
	}
	result := slices.ContainsBy(slice, user{Id: 2}, func(t, u user) bool { return u.Id == t.Id })
	fmt.Println(result)
}

Output:

true

func DeepClone 

func DeepClone[T clone.Cloneable[T]](slice []T) []T

DeepClone returns a new slice with the cloned elements.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.DeepCloneBy(slice, func(i int) int { return i })
	fmt.Println(result)
}

Output:

[1 2 3]
Example (User) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 2, Name: "Jack"},
	}
	result := slices.DeepClone(slice)
	fmt.Println(result)
}

Output:

[{1 John} {2 Jane} {2 Jack}]

func DeepCloneBy added in v0.1.1 

func DeepCloneBy[T any](slice []T, clone func(T) T) []T

DeepCloneBy returns a new slice with the cloned elements as the given slice.

func DifferenceBy added in v0.1.1 

func DifferenceBy[T any](slice1 []T, slice2 []T, eq func(T, T) bool) []T

DifferenceBy returns a new slice with the elements that are in the first slice but not in the second by the given function.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 3, Name: "Jack"},
		{Id: 4, Name: "Bob"},
	}
	slice2 := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 5, Name: "Bob"},
		{Id: 6, Name: "Jack"},
	}
	result := slices.DifferenceBy(slice, slice2, func(a, b user) bool { return a.Id == b.Id && a.Name == b.Name })
	fmt.Println(result)
}

Output:

[{3 Jack} {4 Bob}]

func Equal 

func Equal[T comparable](slice1 []T, slice2 []T) bool

Equal returns true if the given slices are equal.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	slice2 := []int{1, 2, 3}
	result := slices.Equal(slice, slice2)
	fmt.Println(result)
	slice3 := []int{1, 2, 3, 4}
	result2 := slices.Equal(slice, slice3)
	fmt.Println(result2)
	slice4 := []int{1, 2, 4}
	result3 := slices.Equal(slice, slice4)
	fmt.Println(result3)
}

Output:

true
false
false

func EqualBy 

func EqualBy[T any](slice1 []T, slice2 []T, eq func(T, T) bool) bool

EqualBy returns true if the given slices are equal by the given function.

Example (Full) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 2, Name: "Jack"},
		{Id: 4, Name: "Bob"},
	}
	slice2 := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 2, Name: "Jack"},
		{Id: 4, Name: "Bob"},
	}
	result := slices.EqualBy(slice, slice2, func(a, b user) bool { return a.Id == b.Id && a.Name == b.Name })
	fmt.Println(result)
}

Output:

true
Example (Partial) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 2, Name: "Jack"},
		{Id: 4, Name: "Bob"},
	}
	slice2 := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 2, Name: "Jack"},
		{Id: 4, Name: "Bob"},
	}
	result := slices.EqualBy(slice, slice2, func(a, b user) bool { return a.Id == b.Id })
	fmt.Println(result)
}

Output:

true

func Filter 

func Filter[T any](slice []T, f func(T) bool) []T

Filter returns a new slice with all elements that satisfy the given predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.Filter(slice, func(i int) bool { return i > 1 })
	fmt.Println(result)
}

Output:

[2 3]
Example (User) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 3, Name: "Jack"},
	}
	result := slices.Filter(slice, func(u user) bool { return u.Id&1 == 1 })
	fmt.Println(result)
}

Output:

[{1 John} {3 Jack}]

func FindIndex added in v0.1.1 

func FindIndex[T comparable](slice []T, v T) int

FindIndex returns the index of the first element in the given slice that satisfies the given predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.FindIndex(slice, 2)
	fmt.Println(result)
}

Output:

1

func FindIndexBy 

func FindIndexBy[T any](slice []T, v T, eq func(T, T) bool) int

FindIndexBy returns the index of the first element in the given slice that satisfies the given predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
	}
	result := slices.FindIndexBy(slice, user{Id: 2}, func(t, u user) bool { return u.Id == t.Id })
	fmt.Println(result)
}

Output:

1

func Flatten 

func Flatten[T any](slice [][]T) []T

Flatten returns a new slice with all elements in the given slice and all elements in all sub-slices.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := [][]int{{1, 2, 3}, {4, 5, 6}}
	result := slices.Flatten(slice)
	fmt.Println(result)
}

Output:

[1 2 3 4 5 6]
Example (Empty) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := [][]int{}
	result := slices.Flatten(slice)
	fmt.Println(result)
}

Output:

[]

func FlattenBy added in v0.1.1 

func FlattenBy[T, S any](slice []T, f func(T) []S) []S

FlattenBy returns a new slice with all elements in the given slice and all elements in the given slices.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.FlattenBy(slice, func(i int) []int {
		s := make([]int, i)
		for j := 0; j < i; j++ {
			s[j] = j
		}
		return s
	})
	fmt.Println(result)
}

Output:

[0 0 1 0 1 2]

func Fold 

func Fold[T, A any](slice []T, initial A, accumulator func(A, T) A) A

Fold returns the result of applying the given function to each element in the given slice.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.Fold(slice, 0, func(acc, i int) int { return acc + i })
	fmt.Println(result)
}

Output:

6
Example (Diff) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.Fold(slice, "", func(acc string, i int) string {
		return acc + fmt.Sprintf("%d", i)
	})
	fmt.Println(result)
}

Output:

123
Example (User) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 3, Name: "Jack"},
	}
	result := slices.Fold(slice, "", func(acc string, u user) string { return acc + u.Name })
	fmt.Println(result)
}

Output:

JohnJaneJack

func ForEach 

func ForEach[T any](slice []T, f func(T))

ForEach iterates over the given slice and calls the given function for each element.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	slices.ForEach(slice, func(i int) { fmt.Println(i) })
}

Output:

1
2
3

func GroupBy 

func GroupBy[T any, TKey comparable](slice []T, group func(T) TKey) map[TKey][]T

GroupBy returns a new map with the given slice split into smaller slices of the given size.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 2, Name: "Jack"},
		{Id: 4, Name: "Bob"},
	}
	result := slices.GroupBy(slice, func(u user) int64 { return u.Id })
	fmt.Println(result)
}

Output:

map[1:[{1 John}] 2:[{2 Jane} {2 Jack}] 4:[{4 Bob}]]

func IntersectionBy added in v0.1.1 

func IntersectionBy[T any](slice1 []T, slice2 []T, eq func(T, T) bool) []T

IntersectionBy returns a new slice with the elements that are in both given slices by the given function.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 3, Name: "Jack"},
		{Id: 4, Name: "Bob"},
	}
	slice2 := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 5, Name: "Bob"},
		{Id: 6, Name: "Jack"},
	}
	result := slices.IntersectionBy(slice, slice2, func(a, b user) bool { return a.Id == b.Id && a.Name == b.Name })
	fmt.Println(result)
}

Output:

[{1 John} {2 Jane}]

func IsSorted added in v0.1.1 

func IsSorted[T core.Ordered](slice []T) bool

IsSorted returns true if the given slice is sorted.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	isSorted := slices.IsSorted(slice)
	fmt.Println(isSorted)
}

Output:

true
Example (Not) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{3, 2, 1}
	isSorted := slices.IsSorted(slice)
	fmt.Println(isSorted)
}

Output:

false

func IsSortedBy added in v0.1.1 

func IsSortedBy[T any](slice []T, less func(a, b T) bool) bool

IsSortedBy returns true if the given slice is sorted by the given less function.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 3, Name: "Jack"},
	}
	isSortedBy := slices.IsSortedBy(slice, func(a, b user) bool { return a.Id < b.Id })
	fmt.Println(isSortedBy)
}

Output:

true
Example (Not) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 2, Name: "Jane"},
		{Id: 3, Name: "Jack"},
		{Id: 1, Name: "John"},
	}
	isSortedBy := slices.IsSortedBy(slice, func(a, b user) bool { return a.Id < b.Id })
	fmt.Println(isSortedBy)
}

Output:

false

func Map 

func Map[T, U any](slice []T, f func(T) U) []U

Map returns a new slice with the results of applying the given function to each element in the given slice.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.Map(slice, func(i int) int { return i * 2 })
	fmt.Println(result)
}

Output:

[2 4 6]
Example (User) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 3, Name: "Jack"},
	}
	ids := slices.Map(slice, func(u user) int64 { return u.Id })
	names := slices.Map(slice, func(u user) string { return u.Name })
	fmt.Println(ids)
	fmt.Println(names)
}

Output:

[1 2 3]
[John Jane Jack]

func Max added in v0.1.1 

func Max[T core.Ordered](slice []T) optional.Optional[T]

Max returns the maximum element in the given slice.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.Max(slice)
	fmt.Println(result)
}

Output:

Some(3)

func MaxBy 

func MaxBy[T any](slice []T, less func(T, T) bool) optional.Optional[T]

MaxBy returns the maximum element in the given slice that satisfies the given function.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 3, Name: "Jack"},
		{Id: 4, Name: "Bob"},
	}
	maxId := slices.MaxBy(slice, func(a, b user) bool { return a.Id < b.Id })
	maxName := slices.MaxBy(slice, func(a, b user) bool { return a.Name < b.Name })
	fmt.Println(maxId, maxName)
}

Output:

Some({Id:4 Name:Bob}) Some({Id:1 Name:John})

func Min added in v0.1.1 

func Min[T core.Ordered](slice []T) optional.Optional[T]

Min returns the minimum element in the given slice.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.Min(slice)
	fmt.Println(result)
}

Output:

Some(1)

func MinBy 

func MinBy[T any](slice []T, less func(T, T) bool) optional.Optional[T]

MinBy returns the minimum element in the given slice that satisfies the given function.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 3, Name: "Jack"},
		{Id: 4, Name: "Bob"},
	}
	minId := slices.MinBy(slice, func(a, b user) bool { return a.Id < b.Id })
	minName := slices.MinBy(slice, func(a, b user) bool { return a.Name < b.Name })
	fmt.Println(minId, minName)
}

Output:

Some({Id:1 Name:John}) Some({Id:4 Name:Bob})

func None 

func None[T any](slice []T, f func(T) bool) bool

None returns true if no element in the given slice satisfies the given predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.None(slice, func(i int) bool { return i > 5 })
	fmt.Println(result)
}

Output:

true

func Nth 

func Nth[T any](slice []T, n int) optional.Optional[T]

Nth returns the nth element in the given slice.

Example (In) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.Nth(slice, 1)
	fmt.Println(result)
}

Output:

Some(2)
Example (Not_in) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.Nth(slice, 4)
	fmt.Println(result)
}

Output:

None

func Reduce 

func Reduce[T any](slice []T, f func(T, T) T) optional.Optional[T]

Reduce returns the result of applying the given function to each element in the given slice.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.Reduce(slice, func(acc, i int) int { return acc + i })
	fmt.Println(result)
}

Output:

Some(6)
Example (None) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{}
	result := slices.Reduce(slice, func(acc, i int) int { return acc + i })
	fmt.Println(result)
}

Output:

None
Example (User) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
		{Id: 3, Name: "Jack"},
	}
	result := slices.Reduce(slice, func(acc, u user) user { return u })
	fmt.Println(result)
}

Output:

Some({Id:3 Name:Jack})

func Sort added in v0.1.1 

func Sort[T core.Ordered](slice []T)

Sort sorts the given slice in-place.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{3, 1, 2}
	slices.Sort(slice)
	fmt.Println(slice)
}

Output:

[1 2 3]

func SortBy 

func SortBy[T any](slice []T, less func(a, b T) bool)

SortBy sorts the given slice in-place by the given less function.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{3, 1, 2}
	slices.SortBy(slice, func(a, b int) bool { return a < b })
	fmt.Println(slice)
}

Output:

[1 2 3]
Example (Key) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

type user struct {
	Id   int64  `json:"id"`
	Name string `json:"Name"`
}

func (u user) Clone() user {
	return user{Id: u.Id, Name: u.Name}
}

func main() {
	slice := []user{
		{Id: 3, Name: "Jack"},
		{Id: 1, Name: "John"},
		{Id: 2, Name: "Jane"},
	}
	slices.SortBy(slice, func(a, b user) bool { return a.Id < b.Id })
	fmt.Println(slice)
}

Output:

[{1 John} {2 Jane} {3 Jack}]

func ToSet added in v0.1.1 

func ToSet[T comparable](slice []T) map[T]struct{}

ToSet returns a new set with the given slice.

Example 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3}
	result := slices.ToSet(slice)
	fmt.Println(result)
}

Output:

map[1:{} 2:{} 3:{}]
Example (Duplicate) 
package main

import (
	"fmt"

	"github.com/go-board/std/slices"
)

func main() {
	slice := []int{1, 2, 3, 3}
	result := slices.ToSet(slice)
	fmt.Println(result)
}

Output:

map[1:{} 2:{} 3:{}]

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

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