Help us shape the future of Go! Take the 2026 Go Developer Survey

tuple

package
v2.4.0 Latest Latest
Warning

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

 Go to latest Published: Oct 24, 2026 License: MIT Imports: 1 Imported by: 1

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 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]

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]

Types

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]

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}

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.