func (a complexAbs[T]) Abs() complexAbs[T] {
r := float64(real(a))
i := float64(imag(a))
- d := math.Sqrt(r * r + i * i)
+ d := math.Sqrt(r*r + i*i)
return complexAbs[T](complex(d, 0))
}
panic(fmt.Sprintf("got = %v, want = %v", got, want))
}
- if got, want := complexAbsDifference(5.0 + 2.0i, 2.0 - 2.0i), 5+0i; got != want {
+ if got, want := complexAbsDifference(5.0+2.0i, 2.0-2.0i), 5+0i; got != want {
panic(fmt.Sprintf("got = %v, want = %v", got, want))
}
- if got, want := complexAbsDifference(2.0 - 2.0i, 5.0 + 2.0i), 5+0i; got != want {
+ if got, want := complexAbsDifference(2.0-2.0i, 5.0+2.0i), 5+0i; got != want {
panic(fmt.Sprintf("got = %v, want = %v", got, want))
}
}
func (a complexAbs[T]) Abs() complexAbs[T] {
r := float64(real(a))
i := float64(imag(a))
- d := math.Sqrt(r * r + i * i)
+ d := math.Sqrt(r*r + i*i)
return complexAbs[T](complex(d, 0))
}
package a
type Rimp[T any] struct {
- F T
+ F T
}
import "a"
type R[T any] struct {
- F T
+ F T
}
type S = R
package main
import (
- "fmt"
- "reflect"
- "strconv"
+ "fmt"
+ "reflect"
+ "strconv"
)
type myint int
//go:noinline
func (m myint) String() string {
- return strconv.Itoa(int(m))
+ return strconv.Itoa(int(m))
}
type Stringer interface {
- String() string
+ String() string
}
func stringify[T Stringer](s []T) (ret []string) {
- for _, v := range s {
- ret = append(ret, v.String())
- }
- return ret
+ for _, v := range s {
+ ret = append(ret, v.String())
+ }
+ return ret
}
type StringInt[T any] T
//go:noinline
func (m StringInt[T]) String() string {
- return "aa"
+ return "aa"
}
func main() {
- x := []myint{myint(1), myint(2), myint(3)}
+ x := []myint{myint(1), myint(2), myint(3)}
- got := stringify(x)
- want := []string{"1", "2", "3"}
- if !reflect.DeepEqual(got, want) {
- panic(fmt.Sprintf("got %s, want %s", got, want))
- }
+ got := stringify(x)
+ want := []string{"1", "2", "3"}
+ if !reflect.DeepEqual(got, want) {
+ panic(fmt.Sprintf("got %s, want %s", got, want))
+ }
- x2 := []StringInt[myint]{StringInt[myint](1), StringInt[myint](2), StringInt[myint](3)}
+ x2 := []StringInt[myint]{StringInt[myint](1), StringInt[myint](2), StringInt[myint](3)}
- got2 := stringify(x2)
- want2 := []string{"aa", "aa", "aa"}
- if !reflect.DeepEqual(got2, want2) {
- panic(fmt.Sprintf("got %s, want %s", got2, want2))
- }
+ got2 := stringify(x2)
+ want2 := []string{"aa", "aa", "aa"}
+ if !reflect.DeepEqual(got2, want2) {
+ panic(fmt.Sprintf("got %s, want %s", got2, want2))
+ }
}
type M0 interface{ int }
type M1 interface{ map[string]int }
-type M2 interface { map[string]int | map[string]float64 }
+type M2 interface {
+ map[string]int | map[string]float64
+}
type M3 interface{ map[string]int | map[rune]int }
type M4[K comparable, V any] interface{ map[K]V | map[rune]V }
values: c,
done: d,
}
- r := &_Receiver[Elem] {
+ r := &_Receiver[Elem]{
values: c,
done: d,
}
values: c,
done: d,
}
- r := &Receiver[Elem] {
+ r := &Receiver[Elem]{
values: c,
done: d,
}
type Gen[A any] func() (A, bool)
func Combine[T1, T2, T any](g1 Gen[T1], g2 Gen[T2], join func(T1, T2) T) Gen[T] {
- return func() (T, bool) {
- var t T
- t1, ok := g1()
- if !ok {
- return t, false
- }
- t2, ok := g2()
- if !ok {
- return t, false
- }
- return join(t1, t2), true
- }
+ return func() (T, bool) {
+ var t T
+ t1, ok := g1()
+ if !ok {
+ return t, false
+ }
+ t2, ok := g2()
+ if !ok {
+ return t, false
+ }
+ return join(t1, t2), true
+ }
}
type Pair[A, B any] struct {
}
func Combine2[A, B any](ga Gen[A], gb Gen[B]) Gen[Pair[A, B]] {
- return Combine(ga, gb, _NewPair[A, B])
+ return Combine(ga, gb, _NewPair[A, B])
}
func main() {
}
gc4 := Combine2(g1, g3)
if got, ok := gc4(); !ok || got.A != 3 || got.B != "y" {
- panic (fmt.Sprintf("got %v, %v, wanted {3, y}, true", got, ok))
+ panic(fmt.Sprintf("got %v, %v, wanted {3, y}, true", got, ok))
}
}
Match(casenil Function[Nil[a], any], casecons Function[Cons[a], any]) any
}
-type Nil[a any] struct{
+type Nil[a any] struct {
}
func (xs Nil[a]) Match(casenil Function[Nil[a], any], casecons Function[Cons[a], any]) any {
return casecons.Apply(xs)
}
-type mapNil[a, b any] struct{
+type mapNil[a, b any] struct {
}
func (m mapNil[a, b]) Apply(_ Nil[a]) any {
}
func is77(x, y int) {
if x != 7 || y != 7 {
- println(x,y)
+ println(x, y)
panic("assertion failed")
}
}
}
func methodExpressions() {
- x := s[int]{a:7}
+ x := s[int]{a: 7}
f0 := s[int].g0
f0(x)
f1 := s[int].g1
}
func methodValues() {
- x := s[int]{a:7}
+ x := s[int]{a: 7}
f0 := x.g0
f0()
f1 := x.g1
is77(f2())
}
-var x interface{
+var x interface {
g0()
- g1()int
- g2()(int,int)
-} = s[int]{a:7}
-var y interface{} = s[int]{a:7}
+ g1() int
+ g2() (int, int)
+} = s[int]{a: 7}
+var y interface{} = s[int]{a: 7}
func interfaceMethods() {
x.g0()
is7(x.g1())
is77(x.g2())
- y.(interface{g0()}).g0()
- is7(y.(interface{g1()int}).g1())
- is77(y.(interface{g2()(int,int)}).g2())
+ y.(interface{ g0() }).g0()
+ is7(y.(interface{ g1() int }).g1())
+ is77(y.(interface{ g2() (int, int) }).g2())
}
// Also check for instantiations outside functions.
var hh1 = s[int].g1
var hh2 = s[int].g2
-var xtop = s[int]{a:7}
+var xtop = s[int]{a: 7}
var ii0 = x.g0
var ii1 = x.g1
var ii2 = x.g2
gg0(7)
is7(gg1(7))
is77(gg2(7))
- x := s[int]{a:7}
+ x := s[int]{a: 7}
hh0(x)
is7(hh1(x))
is77(hh2(x))
}
func is77(x, y int) {
if x != 7 || y != 7 {
- println(x,y)
+ println(x, y)
panic("assertion failed")
}
}
}
func methodExpressions() {
- x := s[int]{a:7}
+ x := s[int]{a: 7}
f0 := s[int].g0
f0(x)
f0p := (*s[int]).g0
}
func methodValues() {
- x := s[int]{a:7}
+ x := s[int]{a: 7}
f0 := x.g0
f0()
f1 := x.g1
}
}
-var x interface{
+var x interface {
g0()
- g1()int
- g2()(int,int)
-} = s[int]{a:7}
-var y interface{} = s[int]{a:7}
+ g1() int
+ g2() (int, int)
+} = s[int]{a: 7}
+var y interface{} = s[int]{a: 7}
func interfaceMethods() {
x.g0()
is7(x.g1())
is77(x.g2())
- y.(interface{g0()}).g0()
- is7(y.(interface{g1()int}).g1())
- is77(y.(interface{g2()(int,int)}).g2())
+ y.(interface{ g0() }).g0()
+ is7(y.(interface{ g1() int }).g1())
+ is77(y.(interface{ g2() (int, int) }).g2())
}
// Also check for instantiations outside functions.
var hh1 = s[int].g1
var hh2 = s[int].g2
-var xtop = s[int]{a:7}
+var xtop = s[int]{a: 7}
var ii0 = x.g0
var ii1 = x.g1
var ii2 = x.g2
gg0(7)
is7(gg1(7))
is77(gg2(7))
- x := s[int]{a:7}
+ x := s[int]{a: 7}
hh0(x)
is7(hh1(x))
is77(hh2(x))
is77(ii2())
}
-
func recursive() {
if got, want := recur1[int](5), 110; got != want {
panic(fmt.Sprintf("recur1[int](5) = %d, want = %d", got, want))
if n == 0 || n == 1 {
return T(1)
} else {
- return n * recur2(n - 1)
+ return n * recur2(n-1)
}
}
func recur2[T Integer](n T) T {
list := make([]T, n)
for i, _ := range list {
- list[i] = T(i+1)
+ list[i] = T(i + 1)
}
var sum T
for _, elt := range list {
return t, ok
}
-func h[T any](x interface{}) struct{a, b T} {
- return x.(struct{a, b T})
+func h[T any](x interface{}) struct{ a, b T } {
+ return x.(struct{ a, b T })
}
-func k[T any](x interface{}) interface { bar() T } {
- return x.(interface{bar() T })
+func k[T any](x interface{}) interface{ bar() T } {
+ return x.(interface{ bar() T })
}
type mybar int
+
func (x mybar) bar() int {
return int(x)
}
-
func main() {
var i interface{} = int(3)
var j I = myint(3)
println(g2[myint](j))
println(g2[myint](y))
- println(h[int](struct{a, b int}{3, 5}).a)
+ println(h[int](struct{ a, b int }{3, 5}).a)
println(k[int](mybar(3)).bar())
}
want := MySlice{2, 4, 6}
got := _DoubleElems[MySlice, int](arg)
if !reflect.DeepEqual(got, want) {
- panic(fmt.Sprintf("got %s, want %s", got, want))
+ panic(fmt.Sprintf("got %s, want %s", got, want))
}
// constraint type inference
got = _DoubleElems[MySlice](arg)
if !reflect.DeepEqual(got, want) {
- panic(fmt.Sprintf("got %s, want %s", got, want))
+ panic(fmt.Sprintf("got %s, want %s", got, want))
}
got = _DoubleElems(arg)
if !reflect.DeepEqual(got, want) {
- panic(fmt.Sprintf("got %s, want %s", got, want))
+ panic(fmt.Sprintf("got %s, want %s", got, want))
}
farg := MyFloatSlice{1.2, 2.0, 3.5}
fwant := MyFloatSlice{2.4, 4.0, 7.0}
fgot := _DoubleElems(farg)
if !reflect.DeepEqual(fgot, fwant) {
- panic(fmt.Sprintf("got %s, want %s", fgot, fwant))
+ panic(fmt.Sprintf("got %s, want %s", fgot, fwant))
}
fgot = _DoubleElems2(farg)
if !reflect.DeepEqual(fgot, fwant) {
- panic(fmt.Sprintf("got %s, want %s", fgot, fwant))
+ panic(fmt.Sprintf("got %s, want %s", fgot, fwant))
}
}
func k[T comparable](t T, i interface{}) bool {
// Compare derived type value to interface.
- return struct{a, b T}{t, t} == i
+ return struct{ a, b T }{t, t} == i
}
func main() {
assert(h(myint(3), myint(3)))
assert(!h(myint(3), myint(5)))
- type S struct { a, b float64 }
+ type S struct{ a, b float64 }
- assert(f(S{3,5}, S{3,5}))
- assert(!f(S{3,5}, S{4,6}))
- assert(g(S{3,5}, S{3,5}))
- assert(!g(S{3,5}, S{4,6}))
+ assert(f(S{3, 5}, S{3, 5}))
+ assert(!f(S{3, 5}, S{4, 6}))
+ assert(g(S{3, 5}, S{3, 5}))
+ assert(!g(S{3, 5}, S{4, 6}))
- assert(k(3, struct{a, b int}{3, 3}))
- assert(!k(3, struct{a, b int}{3, 4}))
+ assert(k(3, struct{ a, b int }{3, 3}))
+ assert(!k(3, struct{ a, b int }{3, 4}))
}
-func assert(b bool) {
+func assert(b bool) {
if !b {
panic("assertion failed")
}
}
-
-
import "fmt"
-func fact[T interface { ~int | ~int64 | ~float64 }](n T) T {
+func fact[T interface{ ~int | ~int64 | ~float64 }](n T) T {
if n == 1 {
return 1
}
- return n * fact(n - 1)
+ return n * fact(n-1)
}
func main() {
package a
-func Fact[T interface { int | int64 | float64 }](n T) T {
+func Fact[T interface{ int | int64 | float64 }](n T) T {
if n == 1 {
return 1
}
- return n * Fact(n - 1)
+ return n * Fact(n-1)
}
}
}
-
func main() {
TestShortestPath()
}
type myInt int
func (x myInt) foo() int {
- return int(x+1)
+ return int(x + 1)
}
-func h[T C](x T) interface{foo() int} {
- var i interface{foo()int} = x
+func h[T C](x T) interface{ foo() int } {
+ var i interface{ foo() int } = x
return i
}
func i[T C](x T) C {
panic(fmt.Sprintf("got %d, want %d", got, want))
}
}
-
// Testing the various combinations of method expressions.
type S1 struct{}
+
func (*S1) M() {}
type S2 struct{}
+
func (S2) M() {}
func _F1[T interface{ M() }](t T) {
package p
-func _[T interface{~map[string]int}](x T) {
+func _[T interface{ ~map[string]int }](x T) {
_ = x == nil
}
// simplified test case from issue
type PathParamsConstraint interface {
- ~map[string]string | ~[]struct{key, value string}
+ ~map[string]string | ~[]struct{ key, value string }
}
type PathParams[T PathParamsConstraint] struct {
package main
-type A1[T any] struct{
+type A1[T any] struct {
val T
}
type s[T any] struct {
a T
}
+
func (x s[T]) f() T {
return x.a
}
func main() {
- x := s[int]{a:7}
+ x := s[int]{a: 7}
f := x.f
if got, want := f(), 7; got != want {
panic(fmt.Sprintf("got %d, want %d", got, want))
switch v := interface{}(d).(type) {
case string:
if v != "x" {
- panic("unexpected v: "+v)
+ panic("unexpected v: " + v)
}
}
)
type Numeric interface {
- int32|int64|float64|complex64
+ int32 | int64 | float64 | complex64
}
//go:noline
)
type Ordered interface {
- ~int | ~int8 | ~int16 | ~int32 | ~int64 |
- ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
- ~float32 | ~float64 |
- ~string
+ ~int | ~int8 | ~int16 | ~int32 | ~int64 |
+ ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
+ ~float32 | ~float64 |
+ ~string
}
// _List is a linked list of ordered values of type T.
}
type OrderedNum interface {
- ~int | ~int8 | ~int16 | ~int32 | ~int64 |
- ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
- ~float32 | ~float64
+ ~int | ~int8 | ~int16 | ~int32 | ~int64 |
+ ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
+ ~float32 | ~float64
}
// _ListNum is a linked _List of ordered numeric values of type T.
i2 := &_List[int]{i3, 3}
i1 := &_List[int]{i2, 2}
if got, want := i1.Largest(), 3; got != want {
- panic(fmt.Sprintf("got %d, want %d", got, want))
+ panic(fmt.Sprintf("got %d, want %d", got, want))
}
b3 := &_List[byte]{nil, byte(1)}
b2 := &_List[byte]{b3, byte(3)}
b1 := &_List[byte]{b2, byte(2)}
if got, want := b1.Largest(), byte(3); got != want {
- panic(fmt.Sprintf("got %d, want %d", got, want))
+ panic(fmt.Sprintf("got %d, want %d", got, want))
}
f3 := &_List[float64]{nil, 13.5}
f2 := &_List[float64]{f3, 1.2}
f1 := &_List[float64]{f2, 4.5}
if got, want := f1.Largest(), 13.5; got != want {
- panic(fmt.Sprintf("got %f, want %f", got, want))
+ panic(fmt.Sprintf("got %f, want %f", got, want))
}
s3 := &_List[string]{nil, "dd"}
s2 := &_List[string]{s3, "aa"}
s1 := &_List[string]{s2, "bb"}
if got, want := s1.Largest(), "dd"; got != want {
- panic(fmt.Sprintf("got %s, want %s", got, want))
+ panic(fmt.Sprintf("got %s, want %s", got, want))
}
j3 := &_ListNum[int]{nil, 1}
j2 := &_ListNum[int]{j3, 32}
j1 := &_ListNum[int]{j2, 2}
if got, want := j1.ClippedLargest(), 2; got != want {
- panic(fmt.Sprintf("got %d, want %d", got, want))
+ panic(fmt.Sprintf("got %d, want %d", got, want))
}
g3 := &_ListNum[float64]{nil, 13.5}
g2 := &_ListNum[float64]{g3, 1.2}
g1 := &_ListNum[float64]{g2, 4.5}
if got, want := g1.ClippedLargest(), 4.5; got != want {
- panic(fmt.Sprintf("got %f, want %f", got, want))
+ panic(fmt.Sprintf("got %f, want %f", got, want))
}
}
// The zero value for _List is an empty list ready to use.
type _List[T any] struct {
root _Element[T] // sentinel list element, only &root, root.prev, and root.next are used
- len int // current list length excluding (this) sentinel element
+ len int // current list length excluding (this) sentinel element
}
// Init initializes or clears list l.
checkList(l2, []interface{}{"1", "2"})
}
-
func main() {
TestList()
TestExtending()
TestInsertAfterUnknownMark()
TestTransform()
}
-
package a
type Ordered interface {
- ~int | ~int8 | ~int16 | ~int32 | ~int64 |
- ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
- ~float32 | ~float64 |
- ~string
+ ~int | ~int8 | ~int16 | ~int32 | ~int64 |
+ ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
+ ~float32 | ~float64 |
+ ~string
}
// List is a linked list of ordered values of type T.
type List[T Ordered] struct {
- Next *List[T]
- Val T
+ Next *List[T]
+ Val T
}
func (l *List[T]) Largest() T {
- var max T
- for p := l; p != nil; p = p.Next {
- if p.Val > max {
- max = p.Val
- }
- }
- return max
+ var max T
+ for p := l; p != nil; p = p.Next {
+ if p.Val > max {
+ max = p.Val
+ }
+ }
+ return max
}
type OrderedNum interface {
- ~int | ~int8 | ~int16 | ~int32 | ~int64 |
- ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
- ~float32 | ~float64
+ ~int | ~int8 | ~int16 | ~int32 | ~int64 |
+ ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
+ ~float32 | ~float64
}
// ListNum is a linked _List of ordered numeric values of type T.
type ListNum[T OrderedNum] struct {
- Next *ListNum[T]
- Val T
+ Next *ListNum[T]
+ Val T
}
const Clip = 5
// clippedLargest returns the largest in the list of OrderNums, but a max of 5.
func (l *ListNum[T]) ClippedLargest() T {
- var max T
- for p := l; p != nil; p = p.Next {
- if p.Val > max && p.Val < Clip {
- max = p.Val
- }
- }
- return max
+ var max T
+ for p := l; p != nil; p = p.Next {
+ if p.Val > max && p.Val < Clip {
+ max = p.Val
+ }
+ }
+ return max
}
)
func main() {
- i3 := &a.List[int]{nil, 1}
- i2 := &a.List[int]{i3, 3}
- i1 := &a.List[int]{i2, 2}
- if got, want := i1.Largest(), 3; got != want {
- panic(fmt.Sprintf("got %d, want %d", got, want))
- }
+ i3 := &a.List[int]{nil, 1}
+ i2 := &a.List[int]{i3, 3}
+ i1 := &a.List[int]{i2, 2}
+ if got, want := i1.Largest(), 3; got != want {
+ panic(fmt.Sprintf("got %d, want %d", got, want))
+ }
- b3 := &a.List[byte]{nil, byte(1)}
- b2 := &a.List[byte]{b3, byte(3)}
- b1 := &a.List[byte]{b2, byte(2)}
- if got, want := b1.Largest(), byte(3); got != want {
- panic(fmt.Sprintf("got %d, want %d", got, want))
- }
+ b3 := &a.List[byte]{nil, byte(1)}
+ b2 := &a.List[byte]{b3, byte(3)}
+ b1 := &a.List[byte]{b2, byte(2)}
+ if got, want := b1.Largest(), byte(3); got != want {
+ panic(fmt.Sprintf("got %d, want %d", got, want))
+ }
- f3 := &a.List[float64]{nil, 13.5}
- f2 := &a.List[float64]{f3, 1.2}
- f1 := &a.List[float64]{f2, 4.5}
- if got, want := f1.Largest(), 13.5; got != want {
- panic(fmt.Sprintf("got %f, want %f", got, want))
- }
+ f3 := &a.List[float64]{nil, 13.5}
+ f2 := &a.List[float64]{f3, 1.2}
+ f1 := &a.List[float64]{f2, 4.5}
+ if got, want := f1.Largest(), 13.5; got != want {
+ panic(fmt.Sprintf("got %f, want %f", got, want))
+ }
- s3 := &a.List[string]{nil, "dd"}
- s2 := &a.List[string]{s3, "aa"}
- s1 := &a.List[string]{s2, "bb"}
- if got, want := s1.Largest(), "dd"; got != want {
- panic(fmt.Sprintf("got %s, want %s", got, want))
- }
- j3 := &a.ListNum[int]{nil, 1}
- j2 := &a.ListNum[int]{j3, 32}
- j1 := &a.ListNum[int]{j2, 2}
- if got, want := j1.ClippedLargest(), 2; got != want {
- panic(fmt.Sprintf("got %d, want %d", got, want))
- }
- g3 := &a.ListNum[float64]{nil, 13.5}
- g2 := &a.ListNum[float64]{g3, 1.2}
- g1 := &a.ListNum[float64]{g2, 4.5}
- if got, want := g1.ClippedLargest(), 4.5; got != want {
- panic(fmt.Sprintf("got %f, want %f", got, want))
- }
+ s3 := &a.List[string]{nil, "dd"}
+ s2 := &a.List[string]{s3, "aa"}
+ s1 := &a.List[string]{s2, "bb"}
+ if got, want := s1.Largest(), "dd"; got != want {
+ panic(fmt.Sprintf("got %s, want %s", got, want))
+ }
+ j3 := &a.ListNum[int]{nil, 1}
+ j2 := &a.ListNum[int]{j3, 32}
+ j1 := &a.ListNum[int]{j2, 2}
+ if got, want := j1.ClippedLargest(), 2; got != want {
+ panic(fmt.Sprintf("got %d, want %d", got, want))
+ }
+ g3 := &a.ListNum[float64]{nil, 13.5}
+ g2 := &a.ListNum[float64]{g3, 1.2}
+ g1 := &a.ListNum[float64]{g2, 4.5}
+ if got, want := g1.ClippedLargest(), 4.5; got != want {
+ panic(fmt.Sprintf("got %f, want %f", got, want))
+ }
}
// The zero value for List is an empty list ready to use.
type List[T any] struct {
root Element[T] // sentinel list element, only &root, root.prev, and root.next are used
- len int // current list length excluding (this) sentinel element
+ len int // current list length excluding (this) sentinel element
}
// Init initializes or clears list l.
checkList(l2, []interface{}{"1", "2"})
}
-
func main() {
TestList()
TestExtending()
// A Lockable is a value that may be safely simultaneously accessed
// from multiple goroutines via the Get and Set methods.
type Lockable[T any] struct {
- x T
+ x T
mu sync.Mutex
}
// Map calls the function f on every element of the slice s,
// returning a new slice of the results.
func Mapper[F, T any](s []F, f func(F) T) []T {
- r := make([]T, len(s))
- for i, v := range s {
- r[i] = f(v)
- }
- return r
+ r := make([]T, len(s))
+ for i, v := range s {
+ r[i] = f(v)
+ }
+ return r
}
package a
type Ordered interface {
- int | int64 | float64
+ int | int64 | float64
}
func Min[T Ordered](x, y T) T {
- if x < y {
- return x
- }
- return y
+ if x < y {
+ return x
+ }
+ return y
}
package a
type Ordered interface {
- ~int | ~int64 | ~float64 | ~string
+ ~int | ~int64 | ~float64 | ~string
}
func Min[T Ordered](x, y T) T {
- if x < y {
- return x
- }
- return y
+ if x < y {
+ return x
+ }
+ return y
}
package a
type X int
+
func (x X) M() X { return x }
func F[T interface{ M() U }, U interface{ M() T }]() {}
-func G() { F[X, X]() }
+func G() { F[X, X]() }
)
type Ordered interface {
- ~int | ~int8 | ~int16 | ~int32 | ~int64 |
- ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
- ~float32 | ~float64 |
- ~string
+ ~int | ~int8 | ~int16 | ~int32 | ~int64 |
+ ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
+ ~float32 | ~float64 |
+ ~string
}
type orderedSlice[Elem Ordered] []Elem
-func (s orderedSlice[Elem]) Len() int { return len(s) }
+func (s orderedSlice[Elem]) Len() int { return len(s) }
func (s orderedSlice[Elem]) Less(i, j int) bool {
if s[i] < s[j] {
return true
}
return false
}
-func (s orderedSlice[Elem]) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+func (s orderedSlice[Elem]) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func _OrderedSlice[Elem Ordered](s []Elem) {
sort.Sort(orderedSlice[Elem](s))
}
for i := len(s1) - 1; i > 0; i-- {
if s1[i] < s1[i-1] {
- fmt.Printf("%s: element %d (%v) < element %d (%v)", name, i, s1[i], i - 1, s1[i - 1])
+ fmt.Printf("%s: element %d (%v) < element %d (%v)", name, i, s1[i], i-1, s1[i-1])
ok = false
}
}
)
type Ordered interface {
- ~int | ~int8 | ~int16 | ~int32 | ~int64 |
- ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
- ~float32 | ~float64 |
- ~string
+ ~int | ~int8 | ~int16 | ~int32 | ~int64 |
+ ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
+ ~float32 | ~float64 |
+ ~string
}
// _Map is an ordered map.
values: c,
done: d,
}
- r := &_Receiver[Elem] {
+ r := &_Receiver[Elem]{
values: c,
done: d,
}
)
type Ordered interface {
- ~int | ~int8 | ~int16 | ~int32 | ~int64 |
- ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
- ~float32 | ~float64 |
- ~string
+ ~int | ~int8 | ~int16 | ~int32 | ~int64 |
+ ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
+ ~float32 | ~float64 |
+ ~string
}
// Map is an ordered map.
values: c,
done: d,
}
- r := &Receiver[Elem] {
+ r := &Receiver[Elem]{
values: c,
done: d,
}
panic(fmt.Sprintf("unexpectedly found %q in empty map", []byte("a")))
}
- for _, c := range []int{ 'a', 'c', 'b' } {
+ for _, c := range []int{'a', 'c', 'b'} {
if !m.Insert([]byte(string(c)), c) {
panic(fmt.Sprintf("key %q unexpectedly already present", []byte(string(c))))
}
panic(fmt.Sprintf("unexpected f2 size == %d, want %d", got, want))
}
- type mypair struct { f1 int32; f2 int64 }
+ type mypair struct {
+ f1 int32
+ f2 int64
+ }
mp := mypair(p)
if mp.f1 != 1 || mp.f2 != 2 {
panic(fmt.Sprintf("mp == %#v, want %#v", mp, mypair{1, 2}))
package a
type Pair[F1, F2 any] struct {
- Field1 F1
- Field2 F2
+ Field1 F1
+ Field2 F2
}
)
func main() {
- p := a.Pair[int32, int64]{1, 2}
- if got, want := unsafe.Sizeof(p.Field1), uintptr(4); got != want {
- panic(fmt.Sprintf("unexpected f1 size == %d, want %d", got, want))
- }
- if got, want := unsafe.Sizeof(p.Field2), uintptr(8); got != want {
- panic(fmt.Sprintf("unexpected f2 size == %d, want %d", got, want))
- }
+ p := a.Pair[int32, int64]{1, 2}
+ if got, want := unsafe.Sizeof(p.Field1), uintptr(4); got != want {
+ panic(fmt.Sprintf("unexpected f1 size == %d, want %d", got, want))
+ }
+ if got, want := unsafe.Sizeof(p.Field2), uintptr(8); got != want {
+ panic(fmt.Sprintf("unexpected f2 size == %d, want %d", got, want))
+ }
- type mypair struct { Field1 int32; Field2 int64 }
- mp := mypair(p)
- if mp.Field1 != 1 || mp.Field2 != 2 {
- panic(fmt.Sprintf("mp == %#v, want %#v", mp, mypair{1, 2}))
- }
+ type mypair struct {
+ Field1 int32
+ Field2 int64
+ }
+ mp := mypair(p)
+ if mp.Field1 != 1 || mp.Field2 != 2 {
+ panic(fmt.Sprintf("mp == %#v, want %#v", mp, mypair{1, 2}))
+ }
}
vals := s1.Values()
sort.Ints(vals)
w1 := []int{1, 2, 3, 4}
- if !_SliceEqual(vals, w1) {
+ if !_SliceEqual(vals, w1) {
panic(fmt.Sprintf("(%v).Values() == %v, want %v", s1, vals, w1))
}
}
return result
}
-
// Takes one type parameter and a set function
func fromStrings2[T any](s []string, set func(*T, string)) []T {
results := make([]T, len(s))
package a
type Ordered interface {
- ~int | ~int8 | ~int16 | ~int32 | ~int64 |
- ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
- ~float32 | ~float64 |
- ~string
+ ~int | ~int8 | ~int16 | ~int32 | ~int64 |
+ ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
+ ~float32 | ~float64 |
+ ~string
}
// Max returns the maximum of two values of some ordered type.
func Max[T Ordered](a, b T) T {
- if a > b {
- return a
- }
- return b
+ if a > b {
+ return a
+ }
+ return b
}
// Min returns the minimum of two values of some ordered type.
func Min[T Ordered](a, b T) T {
- if a < b {
- return a
- }
- return b
+ if a < b {
+ return a
+ }
+ return b
}
// Equal reports whether two slices are equal: the same length and all
if tot <= cap(s) {
s = s[:tot]
} else {
- news := make([]T, tot, tot + tot/2)
+ news := make([]T, tot, tot+tot/2)
Copy(news, s)
s = news
}
)
type Integer interface {
- ~int | ~int8 | ~int16 | ~int32 | ~int64 |
- ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
+ ~int | ~int8 | ~int16 | ~int32 | ~int64 |
+ ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
}
func TestEqual() {
- s1 := []int{1, 2, 3}
- if !a.Equal(s1, s1) {
- panic(fmt.Sprintf("a.Equal(%v, %v) = false, want true", s1, s1))
- }
- s2 := []int{1, 2, 3}
- if !a.Equal(s1, s2) {
- panic(fmt.Sprintf("a.Equal(%v, %v) = false, want true", s1, s2))
- }
- s2 = append(s2, 4)
- if a.Equal(s1, s2) {
- panic(fmt.Sprintf("a.Equal(%v, %v) = true, want false", s1, s2))
- }
-
- s3 := []float64{1, 2, math.NaN()}
- if !a.Equal(s3, s3) {
- panic(fmt.Sprintf("a.Equal(%v, %v) = false, want true", s3, s3))
- }
-
- if a.Equal(s1, nil) {
- panic(fmt.Sprintf("a.Equal(%v, nil) = true, want false", s1))
- }
- if a.Equal(nil, s1) {
- panic(fmt.Sprintf("a.Equal(nil, %v) = true, want false", s1))
- }
- if !a.Equal(s1[:0], nil) {
- panic(fmt.Sprintf("a.Equal(%v, nil = false, want true", s1[:0]))
- }
+ s1 := []int{1, 2, 3}
+ if !a.Equal(s1, s1) {
+ panic(fmt.Sprintf("a.Equal(%v, %v) = false, want true", s1, s1))
+ }
+ s2 := []int{1, 2, 3}
+ if !a.Equal(s1, s2) {
+ panic(fmt.Sprintf("a.Equal(%v, %v) = false, want true", s1, s2))
+ }
+ s2 = append(s2, 4)
+ if a.Equal(s1, s2) {
+ panic(fmt.Sprintf("a.Equal(%v, %v) = true, want false", s1, s2))
+ }
+
+ s3 := []float64{1, 2, math.NaN()}
+ if !a.Equal(s3, s3) {
+ panic(fmt.Sprintf("a.Equal(%v, %v) = false, want true", s3, s3))
+ }
+
+ if a.Equal(s1, nil) {
+ panic(fmt.Sprintf("a.Equal(%v, nil) = true, want false", s1))
+ }
+ if a.Equal(nil, s1) {
+ panic(fmt.Sprintf("a.Equal(nil, %v) = true, want false", s1))
+ }
+ if !a.Equal(s1[:0], nil) {
+ panic(fmt.Sprintf("a.Equal(%v, nil = false, want true", s1[:0]))
+ }
}
func offByOne[Elem Integer](a, b Elem) bool {
- return a == b + 1 || a == b - 1
+ return a == b+1 || a == b-1
}
func TestEqualFn() {
func TestReduce() {
s1 := []int{1, 2, 3}
- r := a.Reduce(s1, 0, func(f float64, i int) float64 { return float64(i) * 2.5 + f })
+ r := a.Reduce(s1, 0, func(f float64, i int) float64 { return float64(i)*2.5 + f })
if want := 15.0; r != want {
panic(fmt.Sprintf("a.Reduce(%v, 0, ...) = %v, want %v", s1, r, want))
}
- if got := a.Reduce(nil, 0, func(i, j int) int { return i + j}); got != 0 {
+ if got := a.Reduce(nil, 0, func(i, j int) int { return i + j }); got != 0 {
panic(fmt.Sprintf("a.Reduce(nil, 0, add) = %v, want 0", got))
}
}
)
type Ordered interface {
- ~int | ~int8 | ~int16 | ~int32 | ~int64 |
- ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
- ~float32 | ~float64 |
- ~string
+ ~int | ~int8 | ~int16 | ~int32 | ~int64 |
+ ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
+ ~float32 | ~float64 |
+ ~string
}
type Integer interface {
- ~int | ~int8 | ~int16 | ~int32 | ~int64 |
- ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
+ ~int | ~int8 | ~int16 | ~int32 | ~int64 |
+ ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
}
// Max returns the maximum of two values of some ordered type.
func _Max[T Ordered](a, b T) T {
- if a > b {
- return a
- }
- return b
+ if a > b {
+ return a
+ }
+ return b
}
// Min returns the minimum of two values of some ordered type.
func _Min[T Ordered](a, b T) T {
- if a < b {
- return a
- }
- return b
+ if a < b {
+ return a
+ }
+ return b
}
// _Equal reports whether two slices are equal: the same length and all
if tot <= cap(s) {
s = s[:tot]
} else {
- news := make([]T, tot, tot + tot/2)
+ news := make([]T, tot, tot+tot/2)
_Copy(news, s)
s = news
}
}
func TestEqual() {
- s1 := []int{1, 2, 3}
- if !_Equal(s1, s1) {
- panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s1, s1))
- }
- s2 := []int{1, 2, 3}
- if !_Equal(s1, s2) {
- panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s1, s2))
- }
- s2 = append(s2, 4)
- if _Equal(s1, s2) {
- panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", s1, s2))
- }
-
- s3 := []float64{1, 2, math.NaN()}
- if !_Equal(s3, s3) {
- panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s3, s3))
- }
-
- if _Equal(s1, nil) {
- panic(fmt.Sprintf("_Equal(%v, nil) = true, want false", s1))
- }
- if _Equal(nil, s1) {
- panic(fmt.Sprintf("_Equal(nil, %v) = true, want false", s1))
- }
- if !_Equal(s1[:0], nil) {
- panic(fmt.Sprintf("_Equal(%v, nil = false, want true", s1[:0]))
- }
+ s1 := []int{1, 2, 3}
+ if !_Equal(s1, s1) {
+ panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s1, s1))
+ }
+ s2 := []int{1, 2, 3}
+ if !_Equal(s1, s2) {
+ panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s1, s2))
+ }
+ s2 = append(s2, 4)
+ if _Equal(s1, s2) {
+ panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", s1, s2))
+ }
+
+ s3 := []float64{1, 2, math.NaN()}
+ if !_Equal(s3, s3) {
+ panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s3, s3))
+ }
+
+ if _Equal(s1, nil) {
+ panic(fmt.Sprintf("_Equal(%v, nil) = true, want false", s1))
+ }
+ if _Equal(nil, s1) {
+ panic(fmt.Sprintf("_Equal(nil, %v) = true, want false", s1))
+ }
+ if !_Equal(s1[:0], nil) {
+ panic(fmt.Sprintf("_Equal(%v, nil = false, want true", s1[:0]))
+ }
}
func offByOne[Elem Integer](a, b Elem) bool {
- return a == b + 1 || a == b - 1
+ return a == b+1 || a == b-1
}
func TestEqualFn() {
func TestReduce() {
s1 := []int{1, 2, 3}
- r := _Reduce(s1, 0, func(f float64, i int) float64 { return float64(i) * 2.5 + f })
+ r := _Reduce(s1, 0, func(f float64, i int) float64 { return float64(i)*2.5 + f })
if want := 15.0; r != want {
panic(fmt.Sprintf("_Reduce(%v, 0, ...) = %v, want %v", s1, r, want))
}
- if got := _Reduce(nil, 0, func(i, j int) int { return i + j}); got != 0 {
+ if got := _Reduce(nil, 0, func(i, j int) int { return i + j }); got != 0 {
panic(fmt.Sprintf("_Reduce(nil, 0, add) = %v, want 0", got))
}
}
)
type Ordered interface {
- ~int | ~int8 | ~int16 | ~int32 | ~int64 |
- ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
- ~float32 | ~float64 |
- ~string
+ ~int | ~int8 | ~int16 | ~int32 | ~int64 |
+ ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
+ ~float32 | ~float64 |
+ ~string
}
func Smallest[T Ordered](s []T) T {
type _ T3[bool]
// methods
-func (T1[P]) m1() {}
-func (T1[_]) m2() {}
+func (T1[P]) m1() {}
+func (T1[_]) m2() {}
func (x T2[P1, P2, P3]) m() {}
// type lists
}
func main() {
- v := StringableList[myint]{ myint(1), myint(2) }
+ v := StringableList[myint]{myint(1), myint(2)}
if got, want := v.String(), "1, 2"; got != want {
- panic(fmt.Sprintf("got %s, want %s", got, want))
+ panic(fmt.Sprintf("got %s, want %s", got, want))
}
}
func main() {
s1 := S1{Eint{2}, "foo"}
if got, want := s1.E.v, 2; got != want {
- panic(fmt.Sprintf("got %d, want %d", got, want))
+ panic(fmt.Sprintf("got %d, want %d", got, want))
}
s2 := S2{Eint{3}, Ebool{true}, "foo"}
if got, want := s2.Eint.v, 3; got != want {
- panic(fmt.Sprintf("got %d, want %d", got, want))
+ panic(fmt.Sprintf("got %d, want %d", got, want))
}
var s3 S3
s3.E = &Eint{4}
if got, want := s3.E.v, 4; got != want {
- panic(fmt.Sprintf("got %d, want %d", got, want))
+ panic(fmt.Sprintf("got %d, want %d", got, want))
}
}
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// Test cases where a main dictionary is needed inside a generic function/method, because
+// Test cases where a main dictionary is needed inside a generic function/method, because
// we are calling a method on a fully-instantiated type or a fully-instantiated function.
// (probably not common situations, of course)
}
}
-
func main() {
var s value[string]
if got, want := s.get("ab"), ""; got != want {
fwant := vec2[0] + vec2[1]
fgot := Sum[float64](vec2)
- if Abs(fgot - fwant) > 1e-10 {
+ if Abs(fgot-fwant) > 1e-10 {
panic(fmt.Sprintf("got %f, want %f", fgot, fwant))
}
fgot = Sum(vec2)
- if Abs(fgot - fwant) > 1e-10 {
+ if Abs(fgot-fwant) > 1e-10 {
panic(fmt.Sprintf("got %f, want %f", fgot, fwant))
}
}
// The predeclared identifier "any" is only visible as a constraint
// in a type parameter list.
-var _ any // ERROR "cannot use any outside constraint position"
+var _ any // ERROR "cannot use any outside constraint position"
func _(_ any) // ERROR "cannot use any outside constraint position"
-type _[_ any /* ok here */ ] struct{}
+type _[_ any /* ok here */] struct{}
const N = 10
type (
- _[] struct{} // slice
- _[N] struct{} // array
- _[T any] struct{}
- _[T, T any] struct{} // ERROR "T redeclared"
- _[T1, T2 any, T3 any] struct{}
+ _ []struct{} // slice
+ _ [N]struct{} // array
+ _[T any] struct{}
+ _[T, T any] struct{} // ERROR "T redeclared"
+ _[T1, T2 any, T3 any] struct{}
)
func _[T any]()
func _[T struct{}]() // ERROR "not an interface"
func _[T interface{ m() T }]()
func _[T1 interface{ m() T2 }, T2 interface{ m() T1 }]() {
- var _ T1
+ var _ T1
}
// TODO(gri) expand this
// Assignability of an unnamed pointer type to a type parameter that
// has a matching underlying type.
-func _[T interface{}, PT interface{type *T}] (x T) PT {
- return &x
+func _[T interface{}, PT interface{ type *T }](x T) PT {
+ return &x
}
// Indexing of generic types containing type parameters in their type list:
func at[T interface{ type []E }, E any](x T, i int) E {
- return x[i]
+ return x[i]
}
// A generic type inside a function acts like a named type. Its underlying
// type is itself, its "operational type" is defined by the type list in
// the tybe bound, if any.
-func _[T interface{type int}](x T) {
+func _[T interface{ type int }](x T) {
type myint int
var _ int = int(x)
var _ T = 42
}
// Indexing a generic type which has a structural contraints to be an array.
-func _[T interface { type [10]int }](x T) {
+func _[T interface{ type [10]int }](x T) {
_ = x[9] // ok
}
func _[T interface{ type chan int }](ch T) int {
// This would deadlock if executed (but ok for a compile test)
ch <- 0
- return <- ch
+ return <-ch
}
// Calling of a generic type which has a structural constraint to be a function.
}
// Map access of a generic type which has a structural constraint to be a map.
-func _[V any, T interface { type map[string]V }](p T) V {
+func _[V any, T interface{ type map[string]V }](p T) V {
return p["test"]
}
-
// Testing partial and full type inference, including the case where the types can
// be inferred without needing the types of the function arguments.
}
*/
-func f2[A any, B interface{type []A}](_ A, _ B)
+func f2[A any, B interface{ type []A }](_ A, _ B)
func _() {
f := f2[byte]
f(byte(0), []byte{})
}
*/
-func f4[A any, B interface{type []C}, C interface{type *A}](_ A, _ B, c C)
+func f4[A any, B interface{ type []C }, C interface{ type *A }](_ A, _ B, c C)
func _() {
f := f4[int]
var x int
f4(x, []*int{}, &x)
}
-func f5[A interface{type struct{b B; c C}}, B any, C interface{type *B}](x B) A
+func f5[A interface {
+ type struct {
+ b B
+ c C
+ }
+}, B any, C interface{ type *B }](x B) A
func _() {
x := f5(1.2)
var _ float64 = x.b
var _ float64 = *x.c
}
-func f6[A any, B interface{type struct{f []A}}](B) A
+func f6[A any, B interface{ type struct{ f []A } }](B) A
func _() {
- x := f6(struct{f []string}{})
+ x := f6(struct{ f []string }{})
var _ string = x
}
package a
type Value[T any] struct {
- val T
+ val T
}
// The noinline directive should survive across import, and prevent instantiations
//go:noinline
func Get[T any](v *Value[T]) T {
- return v.val
+ return v.val
}
//go:noinline
func Set[T any](v *Value[T], val T) {
- v.val = val
+ v.val = val
}
//go:noinline
func (v *Value[T]) Set(val T) {
- v.val = val
+ v.val = val
}
//go:noinline
func (v *Value[T]) Get() T {
- return v.val
+ return v.val
}
)
func main() {
- var v1 a.Value[int]
-
- a.Set(&v1, 1)
- if got, want := a.Get(&v1), 1; got != want {
- panic(fmt.Sprintf("Get() == %d, want %d", got, want))
- }
- v1.Set(2)
- if got, want := v1.Get(), 2; got != want {
- panic(fmt.Sprintf("Get() == %d, want %d", got, want))
- }
- v1p := new(a.Value[int])
- a.Set(v1p, 3)
- if got, want := a.Get(v1p), 3; got != want {
- panic(fmt.Sprintf("Get() == %d, want %d", got, want))
- }
-
- v1p.Set(4)
- if got, want := v1p.Get(), 4; got != want {
- panic(fmt.Sprintf("Get() == %d, want %d", got, want))
- }
-
- var v2 a.Value[string]
- a.Set(&v2, "a")
- if got, want := a.Get(&v2), "a"; got != want {
- panic(fmt.Sprintf("Get() == %q, want %q", got, want))
- }
-
- v2.Set("b")
- if got, want := a.Get(&v2), "b"; got != want {
- panic(fmt.Sprintf("Get() == %q, want %q", got, want))
- }
-
- v2p := new(a.Value[string])
- a.Set(v2p, "c")
- if got, want := a.Get(v2p), "c"; got != want {
- panic(fmt.Sprintf("Get() == %d, want %d", got, want))
- }
-
- v2p.Set("d")
- if got, want := v2p.Get(), "d"; got != want {
- panic(fmt.Sprintf("Get() == %d, want %d", got, want))
- }
+ var v1 a.Value[int]
+
+ a.Set(&v1, 1)
+ if got, want := a.Get(&v1), 1; got != want {
+ panic(fmt.Sprintf("Get() == %d, want %d", got, want))
+ }
+ v1.Set(2)
+ if got, want := v1.Get(), 2; got != want {
+ panic(fmt.Sprintf("Get() == %d, want %d", got, want))
+ }
+ v1p := new(a.Value[int])
+ a.Set(v1p, 3)
+ if got, want := a.Get(v1p), 3; got != want {
+ panic(fmt.Sprintf("Get() == %d, want %d", got, want))
+ }
+
+ v1p.Set(4)
+ if got, want := v1p.Get(), 4; got != want {
+ panic(fmt.Sprintf("Get() == %d, want %d", got, want))
+ }
+
+ var v2 a.Value[string]
+ a.Set(&v2, "a")
+ if got, want := a.Get(&v2), "a"; got != want {
+ panic(fmt.Sprintf("Get() == %q, want %q", got, want))
+ }
+
+ v2.Set("b")
+ if got, want := a.Get(&v2), "b"; got != want {
+ panic(fmt.Sprintf("Get() == %q, want %q", got, want))
+ }
+
+ v2p := new(a.Value[string])
+ a.Set(v2p, "c")
+ if got, want := a.Get(v2p), "c"; got != want {
+ panic(fmt.Sprintf("Get() == %d, want %d", got, want))
+ }
+
+ v2p.Set("d")
+ if got, want := v2p.Get(), "d"; got != want {
+ panic(fmt.Sprintf("Get() == %d, want %d", got, want))
+ }
}
-