tuple

package
v2.3.1 Latest Latest
Warning

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

 Go to latest Published: May 14, 2024 License: MIT Imports: 1 Imported by: 0

Documentation

Overview

Package tuple implements tuple data type and some operations on it.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func Unzip10 

func Unzip10[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any](tuples []Tuple10[A, B, C, D, E, F, G, H, I, J]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I, []J)

Unzip10 creates a group of slice from a slice of Tuple10. Play: https://go.dev/play/p/-taQB6Wfre_z

Example 
v1, v2, v3, v4, v5, v6, v7, v8, v9, v10 := Unzip10([]Tuple10[int, float64, string, bool, int, float32, string, string, int64, bool]{
	{FieldA: 1, FieldB: 0.1, FieldC: "a", FieldD: true, FieldE: 2, FieldF: 2.2, FieldG: "b", FieldH: "c", FieldI: 3, FieldJ: false},
})

fmt.Printf("%v %v %v %v %v %v %v %v %v %v", v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)

Output:

[1] [0.1] [a] [true] [2] [2.2] [b] [c] [3] [false]

func Unzip2 

func Unzip2[A any, B any](tuples []Tuple2[A, B]) ([]A, []B)

Unzip2 creates a group of slice from a slice of Tuple2. Play: https://go.dev/play/p/KBecr60feXb

Example 
v1, v2 := Unzip2([]Tuple2[int, float64]{{FieldA: 1, FieldB: 0.1}})

fmt.Printf("%v %v", v1, v2)

Output:

[1] [0.1]

func Unzip3 

func Unzip3[A any, B any, C any](tuples []Tuple3[A, B, C]) ([]A, []B, []C)

Unzip3 creates a group of slice from a slice of Tuple3. Play: https://go.dev/play/p/bba4cpAa7KO

Example 
v1, v2, v3 := Unzip3([]Tuple3[int, float64, string]{
	{FieldA: 1, FieldB: 0.1, FieldC: "a"},
})

fmt.Printf("%v %v %v", v1, v2, v3)

Output:

[1] [0.1] [a]

func Unzip4 

func Unzip4[A any, B any, C any, D any](tuples []Tuple4[A, B, C, D]) ([]A, []B, []C, []D)

Unzip4 creates a group of slice from a slice of Tuple4. Play: https://go.dev/play/p/rb8z4gyYSRN

Example 
v1, v2, v3, v4 := Unzip4([]Tuple4[int, float64, string, bool]{
	{FieldA: 1, FieldB: 0.1, FieldC: "a", FieldD: true},
})

fmt.Printf("%v %v %v %v", v1, v2, v3, v4)

Output:

[1] [0.1] [a] [true]

func Unzip5 

func Unzip5[A any, B any, C any, D any, E any](tuples []Tuple5[A, B, C, D, E]) ([]A, []B, []C, []D, []E)

Unzip5 creates a group of slice from a slice of Tuple5. Play: https://go.dev/play/p/gyl6vKfhqPb

Example 
v1, v2, v3, v4, v5 := Unzip5([]Tuple5[int, float64, string, bool, int]{
	{FieldA: 1, FieldB: 0.1, FieldC: "a", FieldD: true, FieldE: 2},
})

fmt.Printf("%v %v %v %v %v", v1, v2, v3, v4, v5)

Output:

[1] [0.1] [a] [true] [2]

func Unzip6 

func Unzip6[A any, B any, C any, D any, E any, F any](tuples []Tuple6[A, B, C, D, E, F]) ([]A, []B, []C, []D, []E, []F)

Unzip6 creates a group of slice from a slice of Tuple6. Play: https://go.dev/play/p/l41XFqCyh5E

Example 
v1, v2, v3, v4, v5, v6 := Unzip6([]Tuple6[int, float64, string, bool, int, float32]{
	{FieldA: 1, FieldB: 0.1, FieldC: "a", FieldD: true, FieldE: 2, FieldF: 2.2},
})

fmt.Printf("%v %v %v %v %v %v", v1, v2, v3, v4, v5, v6)

Output:

[1] [0.1] [a] [true] [2] [2.2]

func Unzip7 

func Unzip7[A any, B any, C any, D any, E any, F any, G any](tuples []Tuple7[A, B, C, D, E, F, G]) ([]A, []B, []C, []D, []E, []F, []G)

Unzip7 creates a group of slice from a slice of Tuple7. Play: https://go.dev/play/p/hws_P1Fr2j3

Example 
v1, v2, v3, v4, v5, v6, v7 := Unzip7([]Tuple7[int, float64, string, bool, int, float32, string]{
	{FieldA: 1, FieldB: 0.1, FieldC: "a", FieldD: true, FieldE: 2, FieldF: 2.2, FieldG: "b"},
})

fmt.Printf("%v %v %v %v %v %v %v", v1, v2, v3, v4, v5, v6, v7)

Output:

[1] [0.1] [a] [true] [2] [2.2] [b]

func Unzip8 

func Unzip8[A any, B any, C any, D any, E any, F any, G any, H any](tuples []Tuple8[A, B, C, D, E, F, G, H]) ([]A, []B, []C, []D, []E, []F, []G, []H)

Unzip8 creates a group of slice from a slice of Tuple8. Play: https://go.dev/play/p/1SndOwGsZB4

Example 
v1, v2, v3, v4, v5, v6, v7, v8 := Unzip8([]Tuple8[int, float64, string, bool, int, float32, string, string]{
	{FieldA: 1, FieldB: 0.1, FieldC: "a", FieldD: true, FieldE: 2, FieldF: 2.2, FieldG: "b", FieldH: "c"},
})

fmt.Printf("%v %v %v %v %v %v %v %v", v1, v2, v3, v4, v5, v6, v7, v8)

Output:

[1] [0.1] [a] [true] [2] [2.2] [b] [c]

func Unzip9 

func Unzip9[A any, B any, C any, D any, E any, F any, G any, H any, I any](tuples []Tuple9[A, B, C, D, E, F, G, H, I]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I)

Unzip9 creates a group of slice from a slice of Tuple9. Play: https://go.dev/play/p/91-BU_KURSA

Example 
v1, v2, v3, v4, v5, v6, v7, v8, v9 := Unzip9([]Tuple9[int, float64, string, bool, int, float32, string, string, int64]{
	{FieldA: 1, FieldB: 0.1, FieldC: "a", FieldD: true, FieldE: 2, FieldF: 2.2, FieldG: "b", FieldH: "c", FieldI: 3},
})

fmt.Printf("%v %v %v %v %v %v %v %v %v", v1, v2, v3, v4, v5, v6, v7, v8, v9)

Output:

[1] [0.1] [a] [true] [2] [2.2] [b] [c] [3]

Types

type Tuple10 

type Tuple10[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any] struct {
	FieldA A
	FieldB B
	FieldC C
	FieldD D
	FieldE E
	FieldF F
	FieldG G
	FieldH H
	FieldI I
	FieldJ J
}

Tuple10 represents a 10 elemnets tuple

func NewTuple10 

func NewTuple10[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any](a A, b B, c C, d D, e E, f F, g G, h H, i I, j J) Tuple10[A, B, C, D, E, F, G, H, I, J]

NewTuple10 creates a 10 elemnets tuple from a list of values. Play: https://go.dev/play/p/799qqZg0hUv

Example 
type foo struct {
	A string
}
t := NewTuple10(1, 0.1, "a", true, 2, 2.2, "b", "c", map[string]int{"a": 1}, foo{A: "a"})
fmt.Printf("%v %v %v %v %v %v %v %v %v %v", t.FieldA, t.FieldB, t.FieldC, t.FieldD, t.FieldE, t.FieldF, t.FieldG, t.FieldH, t.FieldI, t.FieldJ)

Output:

1 0.1 a true 2 2.2 b c map[a:1] {a}

func Zip10 

func Zip10[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I, j []J) []Tuple10[A, B, C, D, E, F, G, H, I, J]

Zip10 create a slice of Tuple10, whose elements are correspond to the given slice elements. Play: https://go.dev/play/p/YSR-2cXnrY4

Example 
result := Zip10([]int{1}, []float64{0.1}, []string{"a"}, []bool{true}, []int{2}, []float32{2.2}, []string{"b"}, []string{"c"}, []int64{3}, []bool{false})
fmt.Println(result)

Output:

[{1 0.1 a true 2 2.2 b c 3 false}]

func (Tuple10[A, B, C, D, E, F, G, H, I, J]) Unbox 

func (t Tuple10[A, B, C, D, E, F, G, H, I, J]) Unbox() (A, B, C, D, E, F, G, H, I, J)

Unbox returns values in tuple. Play: https://go.dev/play/p/qfyx3x_X0Cu

Example 
type foo struct {
	A string
}
t := NewTuple10(1, 0.1, "a", true, 2, 2.2, "b", "c", map[string]int{"a": 1}, foo{A: "a"})
v1, v2, v3, v4, v5, v6, v7, v8, v9, v10 := t.Unbox()
fmt.Printf("%v %v %v %v %v %v %v %v %v %v", v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)

Output:

1 0.1 a true 2 2.2 b c map[a:1] {a}

type Tuple2 

type Tuple2[A any, B any] struct {
	FieldA A
	FieldB B
}

Tuple2 represents a 2 elemnets tuple

func NewTuple2 

func NewTuple2[A any, B any](a A, b B) Tuple2[A, B]

NewTuple2 creates a 2 elemnets tuple from a list of values. Play: https://go.dev/play/p/3sHVqBQpLYN

Example 
t := NewTuple2(1, 0.1)
fmt.Printf("%v %v", t.FieldA, t.FieldB)

Output:

1 0.1

func Zip2 

func Zip2[A any, B any](a []A, b []B) []Tuple2[A, B]

Zip2 create a slice of Tuple2, whose elements are correspond to the given slice elements. Play: https://go.dev/play/p/4ncWJJ77Xio

Example 
result := Zip2([]int{1}, []float64{0.1})
fmt.Println(result)

Output:

[{1 0.1}]

func (Tuple2[A, B]) Unbox 

func (t Tuple2[A, B]) Unbox() (A, B)

Unbox returns values in tuple. Play: https://go.dev/play/p/0fD1qfCVwjm

Example 
t := NewTuple2(1, 0.1)
v1, v2 := t.Unbox()
fmt.Printf("%v %v", v1, v2)

Output:

1 0.1

type Tuple3 

type Tuple3[A any, B any, C any] struct {
	FieldA A
	FieldB B
	FieldC C
}

Tuple3 represents a 3 elemnets tuple

func NewTuple3 

func NewTuple3[A any, B any, C any](a A, b B, c C) Tuple3[A, B, C]

NewTuple3 creates a 3 elemnets tuple from a list of values. Play: https://go.dev/play/p/FtH2sdCLlCf

Example 
t := NewTuple3(1, 0.1, "a")
fmt.Printf("%v %v %v", t.FieldA, t.FieldB, t.FieldC)

Output:

1 0.1 a

func Zip3 

func Zip3[A any, B any, C any](a []A, b []B, c []C) []Tuple3[A, B, C]

Zip3 create a slice of Tuple3, whose elements are correspond to the given slice elements. Play: https://go.dev/play/p/97NgmsTILfu

Example 
result := Zip3([]int{1}, []float64{0.1}, []string{"a"})
fmt.Println(result)

Output:

[{1 0.1 a}]

func (Tuple3[A, B, C]) Unbox 

func (t Tuple3[A, B, C]) Unbox() (A, B, C)

Unbox returns values in tuple. Play: https://go.dev/play/p/YojLy-id1BS

Example 
t := NewTuple3(1, 0.1, "a")
v1, v2, v3 := t.Unbox()
fmt.Printf("%v %v %v", v1, v2, v3)

Output:

1 0.1 a

type Tuple4 

type Tuple4[A any, B any, C any, D any] struct {
	FieldA A
	FieldB B
	FieldC C
	FieldD D
}

Tuple4 represents a 4 elemnets tuple

func NewTuple4 

func NewTuple4[A any, B any, C any, D any](a A, b B, c C, d D) Tuple4[A, B, C, D]

NewTuple4 creates a 4 elemnets tuple from a list of values. Play: https://go.dev/play/p/D2EqDz096tk

Example 
t := NewTuple4(1, 0.1, "a", true)
fmt.Printf("%v %v %v %v", t.FieldA, t.FieldB, t.FieldC, t.FieldD)

Output:

1 0.1 a true

func Zip4 

func Zip4[A any, B any, C any, D any](a []A, b []B, c []C, d []D) []Tuple4[A, B, C, D]

Zip4 create a slice of Tuple4, whose elements are correspond to the given slice elements. Play: https://go.dev/play/p/PEmTYVK5hL4

Example 
result := Zip4([]int{1}, []float64{0.1}, []string{"a"}, []bool{true})
fmt.Println(result)

Output:

[{1 0.1 a true}]

func (Tuple4[A, B, C, D]) Unbox 

func (t Tuple4[A, B, C, D]) Unbox() (A, B, C, D)

Unbox returns values in tuple. Play: https://go.dev/play/p/ACj9YuACGgW

Example 
t := NewTuple4(1, 0.1, "a", true)
v1, v2, v3, v4 := t.Unbox()
fmt.Printf("%v %v %v %v", v1, v2, v3, v4)

Output:

1 0.1 a true

type Tuple5 

type Tuple5[A any, B any, C any, D any, E any] struct {
	FieldA A
	FieldB B
	FieldC C
	FieldD D
	FieldE E
}

Tuple5 represents a 5 elemnets tuple

func NewTuple5 

func NewTuple5[A any, B any, C any, D any, E any](a A, b B, c C, d D, e E) Tuple5[A, B, C, D, E]

NewTuple5 creates a 5 elemnets tuple from a list of values. Play: https://go.dev/play/p/2WndmVxPg-r

Example 
t := NewTuple5(1, 0.1, "a", true, 2)
fmt.Printf("%v %v %v %v %v", t.FieldA, t.FieldB, t.FieldC, t.FieldD, t.FieldE)

Output:

1 0.1 a true 2

func Zip5 

func Zip5[A any, B any, C any, D any, E any](a []A, b []B, c []C, d []D, e []E) []Tuple5[A, B, C, D, E]

Zip5 create a slice of Tuple5, whose elements are correspond to the given slice elements. Play: https://go.dev/play/p/fCAAJLMfBIP

Example 
result := Zip5([]int{1}, []float64{0.1}, []string{"a"}, []bool{true}, []int{2})
fmt.Println(result)

Output:

[{1 0.1 a true 2}]

func (Tuple5[A, B, C, D, E]) Unbox 

func (t Tuple5[A, B, C, D, E]) Unbox() (A, B, C, D, E)

Unbox returns values in tuple. Play: https://go.dev/play/p/GyIyZHjCvoS

Example 
t := NewTuple5(1, 0.1, "a", true, 2)
v1, v2, v3, v4, v5 := t.Unbox()
fmt.Printf("%v %v %v %v %v", v1, v2, v3, v4, v5)

Output:

1 0.1 a true 2

type Tuple6 

type Tuple6[A any, B any, C any, D any, E any, F any] struct {
	FieldA A
	FieldB B
	FieldC C
	FieldD D
	FieldE E
	FieldF F
}

Tuple6 represents a 6 elemnets tuple

func NewTuple6 

func NewTuple6[A any, B any, C any, D any, E any, F any](a A, b B, c C, d D, e E, f F) Tuple6[A, B, C, D, E, F]

NewTuple6 creates a 6 elemnets tuple from a list of values. Play: https://go.dev/play/p/VjqcCwEJZbs

Example 
t := NewTuple6(1, 0.1, "a", true, 2, 2.2)
fmt.Printf("%v %v %v %v %v %v", t.FieldA, t.FieldB, t.FieldC, t.FieldD, t.FieldE, t.FieldF)

Output:

1 0.1 a true 2 2.2

func Zip6 

func Zip6[A any, B any, C any, D any, E any, F any](a []A, b []B, c []C, d []D, e []E, f []F) []Tuple6[A, B, C, D, E, F]

Zip6 create a slice of Tuple6, whose elements are correspond to the given slice elements. Play: https://go.dev/play/p/oWPrnUYuFHo

Example 
result := Zip6([]int{1}, []float64{0.1}, []string{"a"}, []bool{true}, []int{2}, []float32{2.2})
fmt.Println(result)

Output:

[{1 0.1 a true 2 2.2}]

func (Tuple6[A, B, C, D, E, F]) Unbox 

func (t Tuple6[A, B, C, D, E, F]) Unbox() (A, B, C, D, E, F)

Unbox returns values in tuple. Play: https://go.dev/play/p/FjIHV7lpxmW

Example 
t := NewTuple6(1, 0.1, "a", true, 2, 2.2)
v1, v2, v3, v4, v5, v6 := t.Unbox()
fmt.Printf("%v %v %v %v %v %v", v1, v2, v3, v4, v5, v6)

Output:

1 0.1 a true 2 2.2

type Tuple7 

type Tuple7[A any, B any, C any, D any, E any, F any, G any] struct {
	FieldA A
	FieldB B
	FieldC C
	FieldD D
	FieldE E
	FieldF F
	FieldG G
}

Tuple7 represents a 7 elemnets tuple

func NewTuple7 

func NewTuple7[A any, B any, C any, D any, E any, F any, G any](a A, b B, c C, d D, e E, f F, g G) Tuple7[A, B, C, D, E, F, G]

NewTuple7 creates a 7 elemnets tuple from a list of values. Play: https://go.dev/play/p/dzAgv_Ezub9

Example 
t := NewTuple7(1, 0.1, "a", true, 2, 2.2, "b")
fmt.Printf("%v %v %v %v %v %v %v", t.FieldA, t.FieldB, t.FieldC, t.FieldD, t.FieldE, t.FieldF, t.FieldG)

Output:

1 0.1 a true 2 2.2 b

func Zip7 

func Zip7[A any, B any, C any, D any, E any, F any, G any](a []A, b []B, c []C, d []D, e []E, f []F, g []G) []Tuple7[A, B, C, D, E, F, G]

Zip7 create a slice of Tuple7, whose elements are correspond to the given slice elements. Play: https://go.dev/play/p/WUJuo897Egf

Example 
result := Zip7([]int{1}, []float64{0.1}, []string{"a"}, []bool{true}, []int{2}, []float32{2.2}, []string{"b"})
fmt.Println(result)

Output:

[{1 0.1 a true 2 2.2 b}]

func (Tuple7[A, B, C, D, E, F, G]) Unbox 

func (t Tuple7[A, B, C, D, E, F, G]) Unbox() (A, B, C, D, E, F, G)

Unbox returns values in tuple. Play: https://go.dev/play/p/R9I8qeDk0zs

Example 
t := NewTuple7(1, 0.1, "a", true, 2, 2.2, "b")
v1, v2, v3, v4, v5, v6, v7 := t.Unbox()
fmt.Printf("%v %v %v %v %v %v %v", v1, v2, v3, v4, v5, v6, v7)

Output:

1 0.1 a true 2 2.2 b

type Tuple8 

type Tuple8[A any, B any, C any, D any, E any, F any, G any, H any] struct {
	FieldA A
	FieldB B
	FieldC C
	FieldD D
	FieldE E
	FieldF F
	FieldG G
	FieldH H
}

Tuple8 represents a 8 elemnets tuple

func NewTuple8 

func NewTuple8[A any, B any, C any, D any, E any, F any, G any, H any](a A, b B, c C, d D, e E, f F, g G, h H) Tuple8[A, B, C, D, E, F, G, H]

NewTuple8 creates a 8 elemnets tuple from a list of values. Play: https://go.dev/play/p/YA9S0rz3dRz

Example 
t := NewTuple8(1, 0.1, "a", true, 2, 2.2, "b", "c")
fmt.Printf("%v %v %v %v %v %v %v %v", t.FieldA, t.FieldB, t.FieldC, t.FieldD, t.FieldE, t.FieldF, t.FieldG, t.FieldH)

Output:

1 0.1 a true 2 2.2 b c

func Zip8 

func Zip8[A any, B any, C any, D any, E any, F any, G any, H any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H) []Tuple8[A, B, C, D, E, F, G, H]

Zip8 create a slice of Tuple8, whose elements are correspond to the given slice elements. Play: https://go.dev/play/p/8V9jWkuJfaQ

Example 
result := Zip8([]int{1}, []float64{0.1}, []string{"a"}, []bool{true}, []int{2}, []float32{2.2}, []string{"b"}, []string{"c"})
fmt.Println(result)

Output:

[{1 0.1 a true 2 2.2 b c}]

func (Tuple8[A, B, C, D, E, F, G, H]) Unbox 

func (t Tuple8[A, B, C, D, E, F, G, H]) Unbox() (A, B, C, D, E, F, G, H)

Unbox returns values in tuple. Play: https://go.dev/play/p/PRxLBBb4SMl

Example 
t := NewTuple8(1, 0.1, "a", true, 2, 2.2, "b", "c")
v1, v2, v3, v4, v5, v6, v7, v8 := t.Unbox()
fmt.Printf("%v %v %v %v %v %v %v %v", v1, v2, v3, v4, v5, v6, v7, v8)

Output:

1 0.1 a true 2 2.2 b c

type Tuple9 

type Tuple9[A any, B any, C any, D any, E any, F any, G any, H any, I any] struct {
	FieldA A
	FieldB B
	FieldC C
	FieldD D
	FieldE E
	FieldF F
	FieldG G
	FieldH H
	FieldI I
}

Tuple9 represents a 9 elemnets tuple

func NewTuple9 

func NewTuple9[A any, B any, C any, D any, E any, F any, G any, H any, I any](a A, b B, c C, d D, e E, f F, g G, h H, i I) Tuple9[A, B, C, D, E, F, G, H, I]

NewTuple9 creates a 9 elemnets tuple from a list of values. Play: https://go.dev/play/p/yS2NGGtZpQr

Example 
t := NewTuple9(1, 0.1, "a", true, 2, 2.2, "b", "c", map[string]int{"a": 1})
fmt.Printf("%v %v %v %v %v %v %v %v %v", t.FieldA, t.FieldB, t.FieldC, t.FieldD, t.FieldE, t.FieldF, t.FieldG, t.FieldH, t.FieldI)

Output:

1 0.1 a true 2 2.2 b c map[a:1]

func Zip9 

func Zip9[A any, B any, C any, D any, E any, F any, G any, H any, I any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I) []Tuple9[A, B, C, D, E, F, G, H, I]

Zip9 create a slice of Tuple9, whose elements are correspond to the given slice elements. Play: https://go.dev/play/p/cgsL15QYnfz

Example 
result := Zip9([]int{1}, []float64{0.1}, []string{"a"}, []bool{true}, []int{2}, []float32{2.2}, []string{"b"}, []string{"c"}, []int64{3})
fmt.Println(result)

Output:

[{1 0.1 a true 2 2.2 b c 3}]

func (Tuple9[A, B, C, D, E, F, G, H, I]) Unbox 

func (t Tuple9[A, B, C, D, E, F, G, H, I]) Unbox() (A, B, C, D, E, F, G, H, I)

Unbox returns values in tuple. Play: https://go.dev/play/p/oFJFGTAuOa8

Example 
t := NewTuple9(1, 0.1, "a", true, 2, 2.2, "b", "c", map[string]int{"a": 1})
v1, v2, v3, v4, v5, v6, v7, v8, v9 := t.Unbox()
fmt.Printf("%v %v %v %v %v %v %v %v %v", v1, v2, v3, v4, v5, v6, v7, v8, v9)

Output:

1 0.1 a true 2 2.2 b c map[a:1]

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.