Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2024-02-02 18:09
📄 absdiff.go // run // Copyright 2020 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Numeric interface { ~int \| ~int8 \| ~int16 \| ~int32 \| ~int64 \| ~uint \| ~uint8 \| ~uint16 \| ~uint32 \| ~uint64 \| ~uintptr \| ~float32 \| ~float64 \| ~complex64 \| ~complex128 } // numericAbs matches numeric types with an Abs method. type numericAbs[T any] interface { Numeric Abs() T } // AbsDifference computes the absolute value of the difference of // a and b, where the absolute value is determined by the Abs method. func absDifference[T numericAbs[T]](a, b T) T { d := a - b return d.Abs() } // orderedNumeric matches numeric types that support the < operator. type orderedNumeric interface { ~int \| ~int8 \| ~int16 \| ~int32 \| ~int64 \| ~uint \| ~uint8 \| ~uint16 \| ~uint32 \| ~uint64 \| ~uintptr \| ~float32 \| ~float64 } // Complex matches the two complex types, which do not have a < operator. type Complex interface { ~complex64 \| ~complex128 } // For now, a lone type parameter is not permitted as RHS in a type declaration (issue #45639). // // orderedAbs is a helper type that defines an Abs method for // // ordered numeric types. // type orderedAbs[T orderedNumeric] T // // func (a orderedAbs[T]) Abs() orderedAbs[T] { // if a < 0 { // return -a // } // return a // } // // // complexAbs is a helper type that defines an Abs method for // // complex types. // type complexAbs[T Complex] T // // func (a complexAbs[T]) Abs() complexAbs[T] { // r := float64(real(a)) // i := float64(imag(a)) // d := math.Sqrt(rr + ii) // return complexAbs[T](complex(d, 0)) // } // // // OrderedAbsDifference returns the absolute value of the difference // // between a and b, where a and b are of an ordered type. // func orderedAbsDifference[T orderedNumeric](a, b T) T { // return T(absDifference(orderedAbs[T](a), orderedAbs[T](b))) // } // // // ComplexAbsDifference returns the absolute value of the difference // // between a and b, where a and b are of a complex type. // func complexAbsDifference[T Complex](a, b T) T { // return T(absDifference(complexAbs[T](a), complexAbs[T](b))) // } func main() { // // For now, a lone type parameter is not permitted as RHS in a type declaration (issue #45639). // if got, want := orderedAbsDifference(1.0, -2.0), 3.0; got != want { // panic(fmt.Sprintf("got = %v, want = %v", got, want)) // } // if got, want := orderedAbsDifference(-1.0, 2.0), 3.0; got != want { // panic(fmt.Sprintf("got = %v, want = %v", got, want)) // } // if got, want := orderedAbsDifference(-20, 15), 35; got != want { // 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 { // 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 { // panic(fmt.Sprintf("got = %v, want = %v", got, want)) // } }	2.95 KB	2024-02-02 18:09
📄 absdiff2.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // absdiff example in which an Abs method is attached to a generic type, which is a // structure with a single field that may be a list of possible basic types. package main import ( "fmt" "math" ) type Numeric interface { ~int \| ~int8 \| ~int16 \| ~int32 \| ~int64 \| ~uint \| ~uint8 \| ~uint16 \| ~uint32 \| ~uint64 \| ~uintptr \| ~float32 \| ~float64 \| ~complex64 \| ~complex128 } // numericAbs matches a struct containing a numeric type that has an Abs method. type numericAbs[T Numeric] interface { ~struct{ Value_ T } Abs() T Value() T } // absDifference computes the absolute value of the difference of // a and b, where the absolute value is determined by the Abs method. func absDifference[T Numeric, U numericAbs[T]](a, b U) T { d := a.Value() - b.Value() dt := U{Value_: d} return dt.Abs() } // orderedNumeric matches numeric types that support the < operator. type orderedNumeric interface { ~int \| ~int8 \| ~int16 \| ~int32 \| ~int64 \| ~uint \| ~uint8 \| ~uint16 \| ~uint32 \| ~uint64 \| ~uintptr \| ~float32 \| ~float64 } // Complex matches the two complex types, which do not have a < operator. type Complex interface { ~complex64 \| ~complex128 } // orderedAbs is a helper type that defines an Abs method for // a struct containing an ordered numeric type. type orderedAbs[T orderedNumeric] struct { Value_ T } func (a orderedAbs[T]) Abs() T { if a.Value_ < 0 { return -a.Value_ } return a.Value_ } // Field accesses through type parameters are disabled // until we have a more thorough understanding of the // implications on the spec. See issue #51576. // Use accessor method instead. func (a orderedAbs[T]) Value() T { return a.Value_ } // complexAbs is a helper type that defines an Abs method for // a struct containing a complex type. type complexAbs[T Complex] struct { Value_ T } func realimag(x any) (re, im float64) { switch z := x.(type) { case complex64: re = float64(real(z)) im = float64(imag(z)) case complex128: re = real(z) im = imag(z) default: panic("unknown complex type") } return } func (a complexAbs[T]) Abs() T { // TODO use direct conversion instead of realimag once #50937 is fixed r, i := realimag(a.Value_) // r := float64(real(a.Value)) // i := float64(imag(a.Value)) d := math.Sqrt(rr + ii) return T(complex(d, 0)) } func (a complexAbs[T]) Value() T { return a.Value_ } // OrderedAbsDifference returns the absolute value of the difference // between a and b, where a and b are of an ordered type. func OrderedAbsDifference[T orderedNumeric](a, b T) T { return absDifference(orderedAbs[T]{a}, orderedAbs[T]{b}) } // ComplexAbsDifference returns the absolute value of the difference // between a and b, where a and b are of a complex type. func ComplexAbsDifference[T Complex](a, b T) T { return absDifference(complexAbs[T]{a}, complexAbs[T]{b}) } func main() { if got, want := OrderedAbsDifference(1.0, -2.0), 3.0; got != want { panic(fmt.Sprintf("got = %v, want = %v", got, want)) } if got, want := OrderedAbsDifference(-1.0, 2.0), 3.0; got != want { panic(fmt.Sprintf("got = %v, want = %v", got, want)) } if got, want := OrderedAbsDifference(-20, 15), 35; got != want { 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 { 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 { panic(fmt.Sprintf("got = %v, want = %v", got, want)) } }	3.59 KB	2024-02-02 18:09
📄 absdiff3.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // absdiff example using a function argument rather than attaching an // Abs method to a structure containing base types. package main import ( "fmt" "math" ) type Numeric interface { OrderedNumeric \| Complex } // absDifference computes the absolute value of the difference of // a and b, where the absolute value is determined by the abs function. func absDifference[T Numeric](a, b T, abs func(a T) T) T { return abs(a - b) } // OrderedNumeric matches numeric types that support the < operator. type OrderedNumeric interface { ~int \| ~int8 \| ~int16 \| ~int32 \| ~int64 \| ~uint \| ~uint8 \| ~uint16 \| ~uint32 \| ~uint64 \| ~uintptr \| ~float32 \| ~float64 } func Abs[T OrderedNumeric](a T) T { if a < 0 { return -a } return a } // Complex matches the two complex types, which do not have a < operator. type Complex interface { ~complex64 \| ~complex128 } func realimag(x any) (re, im float64) { switch z := x.(type) { case complex64: re = float64(real(z)) im = float64(imag(z)) case complex128: re = real(z) im = imag(z) default: panic("unknown complex type") } return } func ComplexAbs[T Complex](a T) T { // TODO use direct conversion instead of realimag once #50937 is fixed r, i := realimag(a) // r := float64(real(a)) // i := float64(imag(a)) d := math.Sqrt(rr + ii) return T(complex(d, 0)) } // OrderedAbsDifference returns the absolute value of the difference // between a and b, where a and b are of an ordered type. func OrderedAbsDifference[T OrderedNumeric](a, b T) T { return absDifference(a, b, Abs[T]) } // ComplexAbsDifference returns the absolute value of the difference // between a and b, where a and b are of a complex type. func ComplexAbsDifference[T Complex](a, b T) T { return absDifference(a, b, ComplexAbs[T]) } func main() { if got, want := OrderedAbsDifference(1.0, -2.0), 3.0; got != want { panic(fmt.Sprintf("got = %v, want = %v", got, want)) } if got, want := OrderedAbsDifference(-1.0, 2.0), 3.0; got != want { panic(fmt.Sprintf("got = %v, want = %v", got, want)) } if got, want := OrderedAbsDifference(-20, 15), 35; got != want { 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 { 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 { panic(fmt.Sprintf("got = %v, want = %v", got, want)) } }	2.56 KB	2024-02-02 18:09
📁 absdiffimp.dir	-	2024-02-02 18:09
📄 absdiffimp.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📁 absdiffimp2.dir	-	2024-02-02 18:09
📄 absdiffimp2.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 adder.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" ) type AddType interface { int \| int64 \| string } // Add can add numbers or strings func Add[T AddType](a, b T) T { return a + b } func main() { if got, want := Add(5, 3), 8; got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } if got, want := Add("ab", "cd"), "abcd"; got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } }	559 B	2024-02-02 18:09
📁 aliasimp.dir	-	2024-02-02 18:09
📄 aliasimp.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 append.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Recv <-chan int type sliceOf[E any] interface { ~[]E } func _Append[S sliceOf[T], T any](s S, t ...T) S { return append(s, t...) } func main() { recv := make(Recv) a := _Append([]Recv{recv}, recv) if len(a) != 2 \|\| a[0] != recv \|\| a[1] != recv { panic(a) } recv2 := make(chan<- int) a2 := _Append([]chan<- int{recv2}, recv2) if len(a2) != 2 \|\| a2[0] != recv2 \|\| a2[1] != recv2 { panic(a) } }	597 B	2024-02-02 18:09
📄 boundmethod.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // This test illustrates how a type bound method (String below) can be implemented // either by a concrete type (myint below) or an instantiated generic type // (StringInt[myint] below). package main import ( "fmt" "reflect" "strconv" ) type myint int //go:noinline func (m myint) String() string { return strconv.Itoa(int(m)) } type Stringer interface { String() string } func stringify[T Stringer](s []T) (ret []string) { for _, v := range s { // Test normal bounds method call on type param x1 := v.String() // Test converting type param to its bound interface first v1 := Stringer(v) x2 := v1.String() // Test method expression with type param type f1 := T.String x3 := f1(v) // Test creating and calling closure equivalent to the method expression f2 := func(v1 T) string { return Stringer(v1).String() } x4 := f2(v) if x1 != x2 \|\| x2 != x3 \|\| x3 != x4 { panic(fmt.Sprintf("Mismatched values %v, %v, %v, %v\n", x1, x2, x3, x4)) } ret = append(ret, v.String()) } return ret } type Ints interface { ~int32 \| ~int } // For now, a lone type parameter is not permitted as RHS in a type declaration (issue #45639). // type StringInt[T Ints] T // // //go:noinline // func (m StringInt[T]) String() string { // return strconv.Itoa(int(m)) // } type StringStruct[T Ints] struct { f T } func (m StringStruct[T]) String() string { return strconv.Itoa(int(m.f)) } func main() { x := []myint{myint(1), myint(2), myint(3)} // stringify on a normal type, whose bound method is associated with the base type. got := stringify(x) want := []string{"1", "2", "3"} if !reflect.DeepEqual(got, want) { panic(fmt.Sprintf("got %s, want %s", got, want)) } // For now, a lone type parameter is not permitted as RHS in a type declaration (issue #45639). // x2 := []StringInt[myint]{StringInt[myint](5), StringInt[myint](7), StringInt[myint](6)} // // // stringify on an instantiated type, whose bound method is associated with // // the generic type StringInt[T], which maps directly to T. // got2 := stringify(x2) // want2 := []string{"5", "7", "6"} // if !reflect.DeepEqual(got2, want2) { // panic(fmt.Sprintf("got %s, want %s", got2, want2)) // } // stringify on an instantiated type, whose bound method is associated with // the generic type StringStruct[T], which maps to a struct containing T. x3 := []StringStruct[myint]{StringStruct[myint]{f: 11}, StringStruct[myint]{f: 10}, StringStruct[myint]{f: 9}} got3 := stringify(x3) want3 := []string{"11", "10", "9"} if !reflect.DeepEqual(got3, want3) { panic(fmt.Sprintf("got %s, want %s", got3, want3)) } }	2.74 KB	2024-02-02 18:09
📄 builtins.go // compile // Copyright 2020 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // This file tests built-in calls on generic types. // derived and expanded from cmd/compile/internal/types2/testdata/check/builtins.go2 package builtins // close type C0 interface{ int } type C1 interface{ chan int } type C2 interface{ chan int \| <-chan int } type C3 interface{ chan int \| chan float32 } type C4 interface{ chan int \| chan<- int } type C5[T any] interface{ ~chan T \| chan<- T } func f1[T C1](ch T) { close(ch) } func f2[T C3](ch T) { close(ch) } func f3[T C4](ch T) { close(ch) } func f4[T C5[X], X any](ch T) { close(ch) } // delete type M0 interface{ int } type M1 interface{ map[string]int } 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 } func g1[T M1](m T) { delete(m, "foo") } func g2[T M2](m T) { delete(m, "foo") } func g3[T M4[rune, V], V any](m T) { delete(m, 'k') } // make func m1[ S1 interface{ []int }, S2 interface{ []int \| chan int }, M1 interface{ map[string]int }, M2 interface{ map[string]int \| chan int }, C1 interface{ chan int }, C2 interface{ chan int \| chan string }, ]() { _ = make([]int, 10) _ = make(m1S0, 10) _ = make(S1, 10) _ = make(S1, 10, 20) _ = make(map[string]int) _ = make(m1M0) _ = make(M1) _ = make(M1, 10) _ = make(chan int) _ = make(m1C0) _ = make(C1) _ = make(C1, 10) } // TODO: put these type declarations back inside m1 when issue 47631 is fixed. type m1S0 []int type m1M0 map[string]int type m1C0 chan int // len/cap type Slice[T any] interface { []T } func c1[T any, S Slice[T]]() { x := make(S, 5, 10) _ = len(x) _ = cap(x) } // append func a1[T any, S Slice[T]]() { x := make(S, 5) y := make(S, 2) var z T _ = append(x, y...) _ = append(x, z) }	1.92 KB	2024-02-02 18:09
📄 chans.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Package chans provides utility functions for working with channels. package main import ( "context" "fmt" "runtime" "sort" "sync" "time" ) // _Equal reports whether two slices are equal: the same length and all // elements equal. All floating point NaNs are considered equal. func _SliceEqual[Elem comparable](s1, s2 []Elem) bool { if len(s1) != len(s2) { return false } for i, v1 := range s1 { v2 := s2[i] if v1 != v2 { isNaN := func(f Elem) bool { return f != f } if !isNaN(v1) \|\| !isNaN(v2) { return false } } } return true } // _ReadAll reads from c until the channel is closed or the context is // canceled, returning all the values read. func _ReadAll[Elem any](ctx context.Context, c <-chan Elem) []Elem { var r []Elem for { select { case <-ctx.Done(): return r case v, ok := <-c: if !ok { return r } r = append(r, v) } } } // _Merge merges two channels into a single channel. // This will leave a goroutine running until either both channels are closed // or the context is canceled, at which point the returned channel is closed. func _Merge[Elem any](ctx context.Context, c1, c2 <-chan Elem) <-chan Elem { r := make(chan Elem) go func(ctx context.Context, c1, c2 <-chan Elem, r chan<- Elem) { defer close(r) for c1 != nil \|\| c2 != nil { select { case <-ctx.Done(): return case v1, ok := <-c1: if ok { r <- v1 } else { c1 = nil } case v2, ok := <-c2: if ok { r <- v2 } else { c2 = nil } } } }(ctx, c1, c2, r) return r } // _Filter calls f on each value read from c. If f returns true the value // is sent on the returned channel. This will leave a goroutine running // until c is closed or the context is canceled, at which point the // returned channel is closed. func _Filter[Elem any](ctx context.Context, c <-chan Elem, f func(Elem) bool) <-chan Elem { r := make(chan Elem) go func(ctx context.Context, c <-chan Elem, f func(Elem) bool, r chan<- Elem) { defer close(r) for { select { case <-ctx.Done(): return case v, ok := <-c: if !ok { return } if f(v) { r <- v } } } }(ctx, c, f, r) return r } // _Sink returns a channel that discards all values sent to it. // This will leave a goroutine running until the context is canceled // or the returned channel is closed. func _Sink[Elem any](ctx context.Context) chan<- Elem { r := make(chan Elem) go func(ctx context.Context, r <-chan Elem) { for { select { case <-ctx.Done(): return case _, ok := <-r: if !ok { return } } } }(ctx, r) return r } // An Exclusive is a value that may only be used by a single goroutine // at a time. This is implemented using channels rather than a mutex. type _Exclusive[Val any] struct { c chan Val } // _MakeExclusive makes an initialized exclusive value. func _MakeExclusive[Val any](initial Val) _Exclusive[Val] { r := &_Exclusive[Val]{ c: make(chan Val, 1), } r.c <- initial return r } // _Acquire acquires the exclusive value for private use. // It must be released using the Release method. func (e _Exclusive[Val]) Acquire() Val { return <-e.c } // TryAcquire attempts to acquire the value. The ok result reports whether // the value was acquired. If the value is acquired, it must be released // using the Release method. func (e _Exclusive[Val]) TryAcquire() (v Val, ok bool) { select { case r := <-e.c: return r, true default: return v, false } } // Release updates and releases the value. // This method panics if the value has not been acquired. func (e _Exclusive[Val]) Release(v Val) { select { case e.c <- v: default: panic("_Exclusive Release without Acquire") } } // Ranger returns a Sender and a Receiver. The Receiver provides a // Next method to retrieve values. The Sender provides a Send method // to send values and a Close method to stop sending values. The Next // method indicates when the Sender has been closed, and the Send // method indicates when the Receiver has been freed. // // This is a convenient way to exit a goroutine sending values when // the receiver stops reading them. func _Ranger[Elem any]() (_Sender[Elem], _Receiver[Elem]) { c := make(chan Elem) d := make(chan struct{}) s := &_Sender[Elem]{ values: c, done: d, } r := &_Receiver[Elem]{ values: c, done: d, } runtime.SetFinalizer(r, (_Receiver[Elem]).finalize) return s, r } // A _Sender is used to send values to a Receiver. type _Sender[Elem any] struct { values chan<- Elem done <-chan struct{} } // Send sends a value to the receiver. It reports whether the value was sent. // The value will not be sent if the context is closed or the receiver // is freed. func (s _Sender[Elem]) Send(ctx context.Context, v Elem) bool { select { case <-ctx.Done(): return false case s.values <- v: return true case <-s.done: return false } } // Close tells the receiver that no more values will arrive. // After Close is called, the _Sender may no longer be used. func (s _Sender[Elem]) Close() { close(s.values) } // A _Receiver receives values from a _Sender. type _Receiver[Elem any] struct { values <-chan Elem done chan<- struct{} } // Next returns the next value from the channel. The bool result indicates // whether the value is valid. func (r _Receiver[Elem]) Next(ctx context.Context) (v Elem, ok bool) { select { case <-ctx.Done(): case v, ok = <-r.values: } return v, ok } // finalize is a finalizer for the receiver. func (r _Receiver[Elem]) finalize() { close(r.done) } func TestReadAll() { c := make(chan int) go func() { c <- 4 c <- 2 c <- 5 close(c) }() got := _ReadAll(context.Background(), c) want := []int{4, 2, 5} if !_SliceEqual(got, want) { panic(fmt.Sprintf("_ReadAll returned %v, want %v", got, want)) } } func TestMerge() { c1 := make(chan int) c2 := make(chan int) go func() { c1 <- 1 c1 <- 3 c1 <- 5 close(c1) }() go func() { c2 <- 2 c2 <- 4 c2 <- 6 close(c2) }() ctx := context.Background() got := _ReadAll(ctx, _Merge(ctx, c1, c2)) sort.Ints(got) want := []int{1, 2, 3, 4, 5, 6} if !_SliceEqual(got, want) { panic(fmt.Sprintf("_Merge returned %v, want %v", got, want)) } } func TestFilter() { c := make(chan int) go func() { c <- 1 c <- 2 c <- 3 close(c) }() even := func(i int) bool { return i%2 == 0 } ctx := context.Background() got := _ReadAll(ctx, _Filter(ctx, c, even)) want := []int{2} if !_SliceEqual(got, want) { panic(fmt.Sprintf("_Filter returned %v, want %v", got, want)) } } func TestSink() { c := _Sink[int](context.Background()) after := time.NewTimer(time.Minute) defer after.Stop() send := func(v int) { select { case c <- v: case <-after.C: panic("timed out sending to _Sink") } } send(1) send(2) send(3) close(c) } func TestExclusive() { val := 0 ex := _MakeExclusive(&val) var wg sync.WaitGroup f := func() { defer wg.Done() for i := 0; i < 10; i++ { p := ex.Acquire() (p)++ ex.Release(p) } } wg.Add(2) go f() go f() wg.Wait() if val != 20 { panic(fmt.Sprintf("after Acquire/Release loop got %d, want 20", val)) } } func TestExclusiveTry() { s := "" ex := _MakeExclusive(&s) p, ok := ex.TryAcquire() if !ok { panic("TryAcquire failed") } *p = "a" var wg sync.WaitGroup wg.Add(1) go func() { defer wg.Done() _, ok := ex.TryAcquire() if ok { panic(fmt.Sprintf("TryAcquire succeeded unexpectedly")) } }() wg.Wait() ex.Release(p) p, ok = ex.TryAcquire() if !ok { panic(fmt.Sprintf("TryAcquire failed")) } } func TestRanger() { s, r := _Ranger[int]() ctx := context.Background() go func() { // Receive one value then exit. v, ok := r.Next(ctx) if !ok { panic(fmt.Sprintf("did not receive any values")) } else if v != 1 { panic(fmt.Sprintf("received %d, want 1", v)) } }() c1 := make(chan bool) c2 := make(chan bool) go func() { defer close(c2) if !s.Send(ctx, 1) { panic(fmt.Sprintf("Send failed unexpectedly")) } close(c1) if s.Send(ctx, 2) { panic(fmt.Sprintf("Send succeeded unexpectedly")) } }() <-c1 // Force a garbage collection to try to get the finalizers to run. runtime.GC() select { case <-c2: case <-time.After(time.Minute): panic("_Ranger Send should have failed, but timed out") } } func main() { TestReadAll() TestMerge() TestFilter() TestSink() TestExclusive() TestExclusiveTry() TestRanger() }	8.45 KB	2024-02-02 18:09
📁 chansimp.dir	-	2024-02-02 18:09
📄 chansimp.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 combine.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" ) 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 } } type Pair[A, B any] struct { A A B B } func _NewPair[A, B any](a A, b B) Pair[A, B] { return Pair[A, B]{a, b} } func Combine2[A, B any](ga Gen[A], gb Gen[B]) Gen[Pair[A, B]] { return Combine(ga, gb, _NewPair[A, B]) } func main() { var g1 Gen[int] = func() (int, bool) { return 3, true } var g2 Gen[string] = func() (string, bool) { return "x", false } var g3 Gen[string] = func() (string, bool) { return "y", true } gc := Combine(g1, g2, _NewPair[int, string]) if got, ok := gc(); ok { panic(fmt.Sprintf("got %v, %v, wanted -/false", got, ok)) } gc2 := Combine2(g1, g2) if got, ok := gc2(); ok { panic(fmt.Sprintf("got %v, %v, wanted -/false", got, ok)) } gc3 := Combine(g1, g3, _NewPair[int, string]) if got, ok := gc3(); !ok \|\| got.A != 3 \|\| got.B != "y" { panic(fmt.Sprintf("got %v, %v, wanted {3, y}, true", got, ok)) } 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)) } }	1.46 KB	2024-02-02 18:09
📄 cons.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import "fmt" // Overriding the predeclare "any", so it can be used as a type constraint or a type // argument type any interface{} type Function[a, b any] interface { Apply(x a) b } type incr struct{ n int } func (this incr) Apply(x int) int { return x + this.n } type pos struct{} func (this pos) Apply(x int) bool { return x > 0 } type compose[a, b, c any] struct { f Function[a, b] g Function[b, c] } func (this compose[a, b, c]) Apply(x a) c { return this.g.Apply(this.f.Apply(x)) } type _Eq[a any] interface { Equal(a) bool } type Int int func (this Int) Equal(that int) bool { return int(this) == that } type List[a any] interface { Match(casenil Function[Nil[a], any], casecons Function[Cons[a], any]) any } type Nil[a any] struct { } func (xs Nil[a]) Match(casenil Function[Nil[a], any], casecons Function[Cons[a], any]) any { return casenil.Apply(xs) } type Cons[a any] struct { Head a Tail List[a] } func (xs Cons[a]) Match(casenil Function[Nil[a], any], casecons Function[Cons[a], any]) any { return casecons.Apply(xs) } type mapNil[a, b any] struct { } func (m mapNil[a, b]) Apply(_ Nil[a]) any { return Nil[b]{} } type mapCons[a, b any] struct { f Function[a, b] } func (m mapCons[a, b]) Apply(xs Cons[a]) any { return Cons[b]{m.f.Apply(xs.Head), Map[a, b](m.f, xs.Tail)} } func Map[a, b any](f Function[a, b], xs List[a]) List[b] { return xs.Match(mapNil[a, b]{}, mapCons[a, b]{f}).(List[b]) } func main() { var xs List[int] = Cons[int]{3, Cons[int]{6, Nil[int]{}}} var ys List[int] = Map[int, int](incr{-5}, xs) var xz List[bool] = Map[int, bool](pos{}, ys) cs1 := xz.(Cons[bool]) cs2 := cs1.Tail.(Cons[bool]) _, ok := cs2.Tail.(Nil[bool]) if cs1.Head != false \|\| cs2.Head != true \|\| !ok { panic(fmt.Sprintf("got %v, %v, %v, expected false, true, true", cs1.Head, cs2.Head, ok)) } }	1.98 KB	2024-02-02 18:09
📁 dedup.dir	-	2024-02-02 18:09
📄 dedup.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Note: this doesn't really test the deduplication of // instantiations. It just provides an easy mechanism to build a // binary that you can then check with objdump manually to make sure // deduplication is happening. TODO: automate this somehow? package ignored	437 B	2024-02-02 18:09
📄 dedup.out true true true true	20 B	2024-02-02 18:09
📄 devirtualize1.go // run // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type S struct { x int } func (t *S) M1() { } func F[T any](x T) any { return x } func main() { F(&S{}).(interface{ M1() }).M1() }	318 B	2024-02-02 18:09
📄 devirtualize2.go // run // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type S struct { x int } func (t S) M1() { } func (t S) M2() { } type I interface { M1() } func F[T I](x T) I { return x } func main() { F(&S{}).(interface{ M2() }).M2() }	363 B	2024-02-02 18:09
📄 dictionaryCapture-noinline.go // run -gcflags="-l" // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test situations where functions/methods are not // immediately called and we need to capture the dictionary // required for later invocation. package main func main() { functions() methodExpressions() methodValues() interfaceMethods() globals() } func g0[T any](x T) { } func g1[T any](x T) T { return x } func g2[T any](x T) (T, T) { return x, x } func functions() { f0 := g0[int] f0(7) f1 := g1[int] is7(f1(7)) f2 := g2[int] is77(f2(7)) } func is7(x int) { if x != 7 { println(x) panic("assertion failed") } } func is77(x, y int) { if x != 7 \|\| y != 7 { println(x, y) panic("assertion failed") } } type s[T any] struct { a T } func (x s[T]) g0() { } func (x s[T]) g1() T { return x.a } func (x s[T]) g2() (T, T) { return x.a, x.a } func methodExpressions() { x := s[int]{a: 7} f0 := s[int].g0 f0(x) f1 := s[int].g1 is7(f1(x)) f2 := s[int].g2 is77(f2(x)) } func methodValues() { x := s[int]{a: 7} f0 := x.g0 f0() f1 := x.g1 is7(f1()) f2 := x.g2 is77(f2()) } var x interface { g0() 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()) } // Also check for instantiations outside functions. var gg0 = g0[int] var gg1 = g1[int] var gg2 = g2[int] var hh0 = s[int].g0 var hh1 = s[int].g1 var hh2 = s[int].g2 var xtop = s[int]{a: 7} var ii0 = x.g0 var ii1 = x.g1 var ii2 = x.g2 func globals() { gg0(7) is7(gg1(7)) is77(gg2(7)) x := s[int]{a: 7} hh0(x) is7(hh1(x)) is77(hh2(x)) ii0() is7(ii1()) is77(ii2()) }	1.81 KB	2024-02-02 18:09
📄 dictionaryCapture.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test situations where functions/methods are not // immediately called and we need to capture the dictionary // required for later invocation. package main import ( "fmt" ) func main() { functions() methodExpressions() genMethodExpressions[int](7) methodValues() genMethodValues[int](7) interfaceMethods() globals() recursive() } func g0[T any](x T) { } func g1[T any](x T) T { return x } func g2[T any](x T) (T, T) { return x, x } func functions() { f0 := g0[int] f0(7) f1 := g1[int] is7(f1(7)) f2 := g2[int] is77(f2(7)) } func is7(x int) { if x != 7 { println(x) panic("assertion failed") } } func is77(x, y int) { if x != 7 \|\| y != 7 { println(x, y) panic("assertion failed") } } type s[T any] struct { a T } func (x s[T]) g0() { } func (x s[T]) g1() T { return x.a } func (x s[T]) g2() (T, T) { return x.a, x.a } func methodExpressions() { x := s[int]{a: 7} f0 := s[int].g0 f0(x) f0p := (s[int]).g0 f0p(&x) f1 := s[int].g1 is7(f1(x)) f1p := (s[int]).g1 is7(f1p(&x)) f2 := s[int].g2 is77(f2(x)) f2p := (s[int]).g2 is77(f2p(&x)) } func genMethodExpressions[T comparable](want T) { x := s[T]{a: want} f0 := s[T].g0 f0(x) f0p := (s[T]).g0 f0p(&x) f1 := s[T].g1 if got := f1(x); got != want { panic(fmt.Sprintf("f1(x) == %d, want %d", got, want)) } f1p := (s[T]).g1 if got := f1p(&x); got != want { panic(fmt.Sprintf("f1p(&x) == %d, want %d", got, want)) } f2 := s[T].g2 if got1, got2 := f2(x); got1 != want \|\| got2 != want { panic(fmt.Sprintf("f2(x) == %d, %d, want %d, %d", got1, got2, want, want)) } } func methodValues() { x := s[int]{a: 7} f0 := x.g0 f0() f1 := x.g1 is7(f1()) f2 := x.g2 is77(f2()) } func genMethodValues[T comparable](want T) { x := s[T]{a: want} f0 := x.g0 f0() f1 := x.g1 if got := f1(); got != want { panic(fmt.Sprintf("f1() == %d, want %d", got, want)) } f2 := x.g2 if got1, got2 := f2(); got1 != want \|\| got2 != want { panic(fmt.Sprintf("f2() == %d, %d, want %d, %d", got1, got2, want, want)) } } var x interface { g0() 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()) } // Also check for instantiations outside functions. var gg0 = g0[int] var gg1 = g1[int] var gg2 = g2[int] var hh0 = s[int].g0 var hh1 = s[int].g1 var hh2 = s[int].g2 var xtop = s[int]{a: 7} var ii0 = x.g0 var ii1 = x.g1 var ii2 = x.g2 func globals() { gg0(7) is7(gg1(7)) is77(gg2(7)) x := s[int]{a: 7} hh0(x) is7(hh1(x)) is77(hh2(x)) ii0() is7(ii1()) is77(ii2()) } func recursive() { if got, want := recur1[int](5), 110; got != want { panic(fmt.Sprintf("recur1[int](5) = %d, want = %d", got, want)) } } type Integer interface { int \| int32 \| int64 } func recur1[T Integer](n T) T { if n == 0 \|\| n == 1 { return T(1) } else { 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) } var sum T for _, elt := range list { sum += elt } return sum + recur1(n-1) }	3.26 KB	2024-02-02 18:09
📄 dottype.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func f[T any](x interface{}) T { return x.(T) } func f2[T any](x interface{}) (T, bool) { t, ok := x.(T) return t, ok } type I interface { foo() } type myint int func (myint) foo() { } type myfloat float64 func (myfloat) foo() { } func g[T I](x I) T { return x.(T) } func g2[T I](x I) (T, bool) { t, ok := x.(T) return t, ok } 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 }) } type mybar int func (x mybar) bar() int { return int(x) } func main() { var i interface{} = int(3) var j I = myint(3) var x interface{} = float64(3) var y I = myfloat(3) println(f[int](i)) shouldpanic(func() { f[int](x) }) println(f2[int](i)) println(f2[int](x)) println(g[myint](j)) shouldpanic(func() { g[myint](y) }) println(g2[myint](j)) println(g2[myint](y)) println(h[int](struct{ a, b int }{3, 5}).a) println(k[int](mybar(3)).bar()) type large struct {a,b,c,d,e,f int} println(f[large](large{}).a) l2, ok := f2[large](large{}) println(l2.a, ok) } func shouldpanic(x func()) { defer func() { e := recover() if e == nil { panic("didn't panic") } }() x() }	1.36 KB	2024-02-02 18:09
📄 dottype.out 3 3 true 0 false 3 3 true 0 false 3 3 0 0 true	47 B	2024-02-02 18:09
📄 double.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" "reflect" ) type Number interface { ~int \| ~int8 \| ~int16 \| ~int32 \| ~int64 \| ~uint \| ~uint8 \| ~uint16 \| ~uint32 \| ~uint64 \| ~uintptr \| ~float32 \| ~float64 } type MySlice []int type MyFloatSlice []float64 type _SliceOf[E any] interface { ~[]E } func _DoubleElems[S _SliceOf[E], E Number](s S) S { r := make(S, len(s)) for i, v := range s { r[i] = v + v } return r } // Test use of untyped constant in an expression with a generically-typed parameter func _DoubleElems2[S _SliceOf[E], E Number](s S) S { r := make(S, len(s)) for i, v := range s { r[i] = v * 2 } return r } func main() { arg := MySlice{1, 2, 3} want := MySlice{2, 4, 6} got := _DoubleElems[MySlice, int](arg) if !reflect.DeepEqual(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)) } got = _DoubleElems(arg) if !reflect.DeepEqual(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)) } fgot = _DoubleElems2(farg) if !reflect.DeepEqual(fgot, fwant) { panic(fmt.Sprintf("got %s, want %s", fgot, fwant)) } }	1.54 KB	2024-02-02 18:09
📄 eface.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Make sure we handle instantiated empty interfaces. package main type E[T any] interface { } //go:noinline func f[T any](x E[T]) interface{} { return x } //go:noinline func g[T any](x interface{}) E[T] { return x } type I[T any] interface { foo() } type myint int func (x myint) foo() {} //go:noinline func h[T any](x I[T]) interface{ foo() } { return x } //go:noinline func i[T any](x interface{ foo() }) I[T] { return x } func main() { if f[int](1) != 1 { println("test 1 failed") } if f[int](2) != (interface{})(2) { println("test 2 failed") } if g[int](3) != 3 { println("test 3 failed") } if g[int](4) != (E[int])(4) { println("test 4 failed") } if h[int](myint(5)) != myint(5) { println("test 5 failed") } if h[int](myint(6)) != interface{ foo() }(myint(6)) { println("test 6 failed") } if i[int](myint(7)) != myint(7) { println("test 7 failed") } if i[int](myint(8)) != I[int](myint(8)) { println("test 8 failed") } }	1.12 KB	2024-02-02 18:09
📄 equal.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // comparisons of type parameters to interfaces package main func f[T comparable](t, u T) bool { // Comparing two type parameters directly. // (Not really testing comparisons to interfaces, but just 'cause we're here.) return t == u } func g[T comparable](t T, i interface{}) bool { // Compare type parameter value to empty interface. return t == i } type I interface { foo() } type C interface { comparable I } func h[T C](t T, i I) bool { // Compare type parameter value to nonempty interface. return t == i } type myint int func (x myint) foo() { } func k[T comparable](t T, i interface{}) bool { // Compare derived type value to interface. return struct{ a, b T }{t, t} == i } func main() { assert(f(3, 3)) assert(!f(3, 5)) assert(g(3, 3)) assert(!g(3, 5)) assert(h(myint(3), myint(3))) assert(!h(myint(3), myint(5))) 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(k(3, struct{ a, b int }{3, 3})) assert(!k(3, struct{ a, b int }{3, 4})) } func assert(b bool) { if !b { panic("assertion failed") } }	1.29 KB	2024-02-02 18:09
📄 fact.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import "fmt" func fact[T interface{ ~int \| ~int64 \| ~float64 }](n T) T { if n == 1 { return 1 } return n * fact(n-1) } func main() { const want = 120 if got := fact(5); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } if got := fact[int64](5); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } if got := fact(5.0); got != want { panic(fmt.Sprintf("got %f, want %f", got, want)) } }	618 B	2024-02-02 18:09
📁 factimp.dir	-	2024-02-02 18:09
📄 factimp.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📁 gencrawler.dir	-	2024-02-02 18:09
📄 gencrawler.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Testing that all methods of a private generic type are exported, if a variable // with that type is exported. package ignored	301 B	2024-02-02 18:09
📄 gencrawler.out 0 0	4 B	2024-02-02 18:09
📄 genembed.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test wrappers/interfaces for generic type embedding another generic type. package main import "fmt" type A[T any] struct { B[T] } type B[T any] struct { val T } func (b *B[T]) get() T { return b.val } type getter[T any] interface { get() T } //go:noinline func doGet[T any](i getter[T]) T { return i.get() } //go:noline func doGet2[T any](i interface{}) T { i2 := i.(getter[T]) return i2.get() } func main() { a := A[int]{B: B[int]{3}} var i getter[int] = &a if got, want := doGet(i), 3; got != want { panic(fmt.Sprintf("got %v, want %v", got, want)) } as := A[string]{B: B[string]{"abc"}} if got, want := doGet2[string](&as), "abc"; got != want { panic(fmt.Sprintf("got %v, want %v", got, want)) } }	901 B	2024-02-02 18:09
📄 genembed2.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test for declaration and use of a parameterized embedded field. package main import ( "fmt" "sync" ) type MyStruct[T any] struct { val T } type Lockable[T any] struct { MyStruct[T] mu sync.Mutex } // Get returns the value stored in a Lockable. func (l Lockable[T]) Get() T { l.mu.Lock() defer l.mu.Unlock() return l.MyStruct.val } // Set sets the value in a Lockable. func (l Lockable[T]) Set(v T) { l.mu.Lock() defer l.mu.Unlock() l.MyStruct = MyStruct[T]{v} } func main() { var li Lockable[int] li.Set(5) if got, want := li.Get(), 5; got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } }	801 B	2024-02-02 18:09
📁 geninline.dir	-	2024-02-02 18:09
📄 geninline.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 graph.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "errors" "fmt" ) // _Equal reports whether two slices are equal: the same length and all // elements equal. All floating point NaNs are considered equal. func _SliceEqual[Elem comparable](s1, s2 []Elem) bool { if len(s1) != len(s2) { return false } for i, v1 := range s1 { v2 := s2[i] if v1 != v2 { isNaN := func(f Elem) bool { return f != f } if !isNaN(v1) \|\| !isNaN(v2) { return false } } } return true } // A Graph is a collection of nodes. A node may have an arbitrary number // of edges. An edge connects two nodes. Both nodes and edges must be // comparable. This is an undirected simple graph. type _Graph[_Node _NodeC[_Edge], _Edge _EdgeC[_Node]] struct { nodes []_Node } // _NodeC is the constraints on a node in a graph, given the _Edge type. type _NodeC[_Edge any] interface { comparable Edges() []_Edge } // Edgec is the constraints on an edge in a graph, given the _Node type. type _EdgeC[_Node any] interface { comparable Nodes() (a, b _Node) } // _New creates a new _Graph from a collection of Nodes. func _New[_Node _NodeC[_Edge], _Edge _EdgeC[_Node]](nodes []_Node) _Graph[_Node, _Edge] { return &_Graph[_Node, _Edge]{nodes: nodes} } // nodePath holds the path to a node during ShortestPath. // This should ideally be a type defined inside ShortestPath, // but the translator tool doesn't support that. type nodePath[_Node _NodeC[_Edge], _Edge _EdgeC[_Node]] struct { node _Node path []_Edge } // ShortestPath returns the shortest path between two nodes, // as an ordered list of edges. If there are multiple shortest paths, // which one is returned is unpredictable. func (g _Graph[_Node, _Edge]) ShortestPath(from, to _Node) ([]_Edge, error) { visited := make(map[_Node]bool) visited[from] = true workqueue := []nodePath[_Node, _Edge]{nodePath[_Node, _Edge]{from, nil}} for len(workqueue) > 0 { current := workqueue workqueue = nil for _, np := range current { edges := np.node.Edges() for _, edge := range edges { a, b := edge.Nodes() if a == np.node { a = b } if !visited[a] { ve := append([]_Edge(nil), np.path...) ve = append(ve, edge) if a == to { return ve, nil } workqueue = append(workqueue, nodePath[_Node, _Edge]{a, ve}) visited[a] = true } } } } return nil, errors.New("no path") } type direction int const ( north direction = iota ne east se south sw west nw up down ) func (dir direction) String() string { strs := map[direction]string{ north: "north", ne: "ne", east: "east", se: "se", south: "south", sw: "sw", west: "west", nw: "nw", up: "up", down: "down", } if str, ok := strs[dir]; ok { return str } return fmt.Sprintf("direction %d", dir) } type mazeRoom struct { index int exits [10]int } type mazeEdge struct { from, to int dir direction } // Edges returns the exits from the room. func (m mazeRoom) Edges() []mazeEdge { var r []mazeEdge for i, exit := range m.exits { if exit != 0 { r = append(r, mazeEdge{ from: m.index, to: exit, dir: direction(i), }) } } return r } // Nodes returns the rooms connected by an edge. //go:noinline func (e mazeEdge) Nodes() (mazeRoom, mazeRoom) { m1, ok := zork[e.from] if !ok { panic("bad edge") } m2, ok := zork[e.to] if !ok { panic("bad edge") } return m1, m2 } // The first maze in Zork. Room indexes based on original Fortran data file. // You are in a maze of twisty little passages, all alike. var zork = map[int]mazeRoom{ 11: {exits: [10]int{north: 11, south: 12, east: 14}}, // west to Troll Room 12: {exits: [10]int{south: 11, north: 14, east: 13}}, 13: {exits: [10]int{west: 12, north: 14, up: 16}}, 14: {exits: [10]int{west: 13, north: 11, east: 15}}, 15: {exits: [10]int{south: 14}}, // Dead End 16: {exits: [10]int{east: 17, north: 13, sw: 18}}, // skeleton, etc. 17: {exits: [10]int{west: 16}}, // Dead End 18: {exits: [10]int{down: 16, east: 19, west: 18, up: 22}}, 19: {exits: [10]int{up: 29, west: 18, ne: 15, east: 20, south: 30}}, 20: {exits: [10]int{ne: 19, west: 20, se: 21}}, 21: {exits: [10]int{north: 20}}, // Dead End 22: {exits: [10]int{north: 18, east: 24, down: 23, south: 28, west: 26, nw: 22}}, 23: {exits: [10]int{east: 22, west: 28, up: 24}}, 24: {exits: [10]int{ne: 25, down: 23, nw: 28, sw: 26}}, 25: {exits: [10]int{sw: 24}}, // Grating room (up to Clearing) 26: {exits: [10]int{west: 16, sw: 24, east: 28, up: 22, north: 27}}, 27: {exits: [10]int{south: 26}}, // Dead End 28: {exits: [10]int{east: 22, down: 26, south: 23, west: 24}}, 29: {exits: [10]int{west: 30, nw: 29, ne: 19, south: 19}}, 30: {exits: [10]int{west: 29, south: 19}}, // ne to Cyclops Room } func TestShortestPath() { // The Zork maze is not a proper undirected simple graph, // as there are some one way paths (e.g., 19 -> 15), // but for this test that doesn't matter. // Set the index field in the map. Simpler than doing it in the // composite literal. for k := range zork { r := zork[k] r.index = k zork[k] = r } var nodes []mazeRoom for idx, room := range zork { mridx := room mridx.index = idx nodes = append(nodes, mridx) } g := _New[mazeRoom, mazeEdge](nodes) path, err := g.ShortestPath(zork[11], zork[30]) if err != nil { panic(fmt.Sprintf("%v", err)) } var steps []direction for _, edge := range path { steps = append(steps, edge.dir) } want := []direction{east, west, up, sw, east, south} if !_SliceEqual(steps, want) { panic(fmt.Sprintf("ShortestPath returned %v, want %v", steps, want)) } } func main() { TestShortestPath() }	5.72 KB	2024-02-02 18:09
📄 ifaceconv.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test that we can convert type parameters to both empty // and nonempty interfaces, and named and nonnamed versions // thereof. package main import "fmt" type E interface{} func f[T any](x T) interface{} { var i interface{} = x return i } func fs[T any](x T) interface{} { y := []T{x} var i interface{} = y return i } func g[T any](x T) E { var i E = x return i } type C interface { foo() int } type myInt int func (x myInt) foo() int { return int(x + 1) } func h[T C](x T) interface{ foo() int } { var i interface{ foo() int } = x return i } func i[T C](x T) C { var i C = x // conversion in assignment return i } func j[T C](t T) C { return C(t) // explicit conversion } func js[T any](x T) interface{} { y := []T{x} return interface{}(y) } func main() { if got, want := f[int](7), 7; got != want { panic(fmt.Sprintf("got %d want %d", got, want)) } if got, want := fs[int](7), []int{7}; got.([]int)[0] != want[0] { panic(fmt.Sprintf("got %d want %d", got, want)) } if got, want := g[int](7), 7; got != want { panic(fmt.Sprintf("got %d want %d", got, want)) } if got, want := h[myInt](7).foo(), 8; got != want { panic(fmt.Sprintf("got %d want %d", got, want)) } if got, want := i[myInt](7).foo(), 8; got != want { panic(fmt.Sprintf("got %d want %d", got, want)) } if got, want := j[myInt](7).foo(), 8; got != want { panic(fmt.Sprintf("got %d want %d", got, want)) } if got, want := js[int](7), []int{7}; got.([]int)[0] != want[0] { panic(fmt.Sprintf("got %d want %d", got, want)) } }	1.67 KB	2024-02-02 18:09
📄 importtest.go // compile // Copyright 2020 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // This file checks that basic importing works in -G mode. package p import "fmt" import "math" func f(x float64) { fmt.Println(math.Sin(x)) }	319 B	2024-02-02 18:09
📄 index.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" ) // Index returns the index of x in s, or -1 if not found. func Index[T comparable](s []T, x T) int { for i, v := range s { // v and x are type T, which has the comparable // constraint, so we can use == here. if v == x { return i } } return -1 } type obj struct { x int } type obj2 struct { x int8 y float64 } type obj3 struct { x int64 y int8 } type inner struct { y int64 z int32 } type obj4 struct { x int32 s inner } func main() { want := 2 vec1 := []string{"ab", "cd", "ef"} if got := Index(vec1, "ef"); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } vec2 := []byte{'c', '6', '@'} if got := Index(vec2, '@'); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } vec3 := []*obj{&obj{2}, &obj{42}, &obj{1}} if got := Index(vec3, vec3[2]); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } vec4 := []obj2{obj2{2, 3.0}, obj2{3, 4.0}, obj2{4, 5.0}} if got := Index(vec4, vec4[2]); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } vec5 := []obj3{obj3{2, 3}, obj3{3, 4}, obj3{4, 5}} if got := Index(vec5, vec5[2]); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } vec6 := []obj4{obj4{2, inner{3, 4}}, obj4{3, inner{4, 5}}, obj4{4, inner{5, 6}}} if got := Index(vec6, vec6[2]); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } }	1.55 KB	2024-02-02 18:09
📄 index2.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Testing various generic uses of indexing, both for reads and writes. package main import "fmt" // Can index an argument (read/write) constrained to be a slice or an array. func Index1[T interface{ []int64 \| [5]int64 }](x T) int64 { x[2] = 5 return x[3] } // Can index an argument (read) constrained to be a byte array or a string. func Index2[T interface{ []byte \| string }](x T) byte { return x[3] } // Can index an argument (write) constrained to be a byte array, but not a string. func Index2a[T interface{ []byte }](x T) byte { x[2] = 'b' return x[3] } // Can index an argument (read/write) constrained to be a map. Maps can't // be combined with any other type for indexing purposes. func Index3[T interface{ map[int]int64 }](x T) int64 { x[2] = 43 return x[3] } // But the type of the map keys or values can be parameterized. func Index4[T any](x map[int]T) T { var zero T x[2] = zero return x[3] } func test[T comparable](got, want T) { if got != want { panic(fmt.Sprintf("got %v, want %v", got, want)) } } func main() { x := make([]int64, 4) x[3] = 2 y := [5]int64{1, 2, 3, 4, 5} z := "abcd" w := make([]byte, 4) w[3] = 5 v := make(map[int]int64) v[3] = 18 test(Index1(x), int64(2)) test(Index1(y), int64(4)) test(Index2(z), byte(100)) test(Index2(w), byte(5)) test(Index2a(w), byte(5)) test(Index3(v), int64(18)) test(Index4(v), int64(18)) }	1.52 KB	2024-02-02 18:09
📄 interfacearg.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type I interface{} type _S[T any] struct { x T } // F is a non-generic function, but has a type _S[I] which is instantiated from a // generic type. Test that _S[I] is successfully exported. func F() { v := _S[I]{} if v.x != nil { panic(v) } } // 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) { _ = T.M } func F2() { _F1(&S1{}) _F1(S2{}) _F1(&S2{}) } func main() { F() F2() }	692 B	2024-02-02 18:09
📄 issue23536.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test case where a slice of a user-defined byte type (not uint8 or byte) is // converted to a string. Same for slice of runes. package main type MyByte byte type MyRune rune func f[T []MyByte](x T) string { return string(x) } func g[T []MyRune](x T) string { return string(x) } func main() { var y []MyByte _ = f(y) _ = string(y) var z []MyRune _ = g(z) _ = string(z) }	556 B	2024-02-02 18:09
📄 issue376214.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func add[S ~string \| ~[]byte](buf []byte, s S) { buf = append(*buf, s...) } func main() { var buf []byte add(&buf, "foo") add(&buf, []byte("bar")) if string(buf) != "foobar" { panic("got " + string(buf)) } }	401 B	2024-02-02 18:09
📄 issue39755.go // compile // Copyright 2020 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // copied from cmd/compile/internal/types2/testdata/fixedbugs/issue39755.go package p 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 } } type PathParams[T PathParamsConstraint] struct { t T } func (pp *PathParams[T]) IsNil() bool { return pp.t == nil // this must succeed }	593 B	2024-02-02 18:09
📄 issue42758.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func F[T, U int]() interface{} { switch interface{}(nil) { case int(0), T(0), U(0): } return map[interface{}]int{int(0): 0, T(0): 0, U(0): 0} } func main() { F[int, int]() }	363 B	2024-02-02 18:09
📄 issue44688.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // derived & expanded from cmd/compile/internal/types2/testdata/fixedbugs/issue44688.go2 package main type A1[T any] struct { val T } func (p A1[T]) m1(val T) { p.val = val } type A2[T any] interface { m2(T) } type B1[T any] struct { filler int A1[T] A2[T] } type B2[T any] interface { A2[T] } type ImpA2[T any] struct { f T } func (a2 ImpA2[T]) m2(s T) { a2.f = s } type C[T any] struct { filler1 int filler2 int B1[T] } type D[T any] struct { filler1 int filler2 int filler3 int C[T] } func test1[T any](arg T) { // calling embedded methods var b1 B1[T] b1.A1 = &A1[T]{} b1.A2 = &ImpA2[T]{} b1.A1.m1(arg) b1.m1(arg) b1.A2.m2(arg) b1.m2(arg) var b2 B2[T] b2 = &ImpA2[T]{} b2.m2(arg) // a deeper nesting var d D[T] d.C.B1.A1 = &A1[T]{} d.C.B1.A2 = &ImpA2[T]{} d.m1(arg) d.m2(arg) // calling method expressions m1x := B1[T].m1 m1x(b1, arg) // TODO(khr): reenable these. //m2x := B2[T].m2 //m2x(b2, arg) // calling method values m1v := b1.m1 m1v(arg) m2v := b1.m2 m2v(arg) b2v := b2.m2 b2v(arg) } func test2() { // calling embedded methods var b1 B1[string] b1.A1 = &A1[string]{} b1.A2 = &ImpA2[string]{} b1.A1.m1("") b1.m1("") b1.A2.m2("") b1.m2("") var b2 B2[string] b2 = &ImpA2[string]{} b2.m2("") // a deeper nesting var d D[string] d.C.B1.A1 = &A1[string]{} d.C.B1.A2 = &ImpA2[string]{} d.m1("") d.m2("") // calling method expressions m1x := B1[string].m1 m1x(b1, "") m2x := B2[string].m2 m2x(b2, "") // calling method values m1v := b1.m1 m1v("") m2v := b1.m2 m2v("") b2v := b2.m2 b2v("") } // actual test case from issue type A[T any] struct{} func (A[T]) f(T) {} type B[T any] struct{ A[T] } func test3() { var b B[string] b.A.f("") b.f("") } func main() { test1[string]("") test2() test3() }	1.93 KB	2024-02-02 18:09
📄 issue45547.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p func f[T any]() (f, g T) { return f, g } // Tests for generic function instantiation on the right hande side of multi-value // assignments. func g() { // Multi-value assignment within a function var _, _ = f[int]() } // Multi-value assignment outside a function. var _, _ = f[int]()	471 B	2024-02-02 18:09
📄 issue45722.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" "log" ) func try[T any](v T, err error) T { if err != nil { panic(err) } return v } func handle(handle func(error)) { if issue := recover(); issue != nil { if e, ok := issue.(error); ok && e != nil { handle(e) } else { handle(fmt.Errorf("%v", e)) } } } func main() { defer handle(func(e error) { log.Fatalln(e) }) _ = try(fmt.Print("")) }	562 B	2024-02-02 18:09
📄 issue45738.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main //go:noinline func f[T any]() { x := 5 g := func() int { return x } g() } func main() { f[int]() }	290 B	2024-02-02 18:09
📄 issue45817.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" ) type s[T any] struct { a T } func (x s[T]) f() T { return x.a } func main() { x := s[int]{a: 7} f := x.f if got, want := f(), 7; got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } }	406 B	2024-02-02 18:09
📄 issue46461.go // errorcheck // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p type T[U interface{ M() T[U] }] int // ERROR "invalid recursive type: T refers to itself" type X int func (X) M() T[X] { return 0 }	320 B	2024-02-02 18:09
📁 issue46461b.dir	-	2024-02-02 18:09
📄 issue46461b.go // compiledir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📄 issue46472.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func foo[T any](d T) { switch v := interface{}(d).(type) { case string: if v != "x" { panic("unexpected v: " + v) } } } func main() { foo("x") }	339 B	2024-02-02 18:09
📄 issue46591.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type T[_ any] struct{} var m = map[interface{}]int{ T[struct{ int }]{}: 0, T[struct { int "x" }]{}: 0, } func main() { if len(m) != 2 { panic(len(m)) } }	347 B	2024-02-02 18:09
📄 issue47258.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" ) type Numeric interface { int32 \| int64 \| float64 \| complex64 } //go:noline func inc[T Numeric](x T) T { x++ return x } func main() { if got, want := inc(int32(5)), int32(6); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } if got, want := inc(float64(5)), float64(6.0); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } if got, want := inc(complex64(5)), complex64(6.0); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } }	686 B	2024-02-02 18:09
📄 issue47272.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "errors" "fmt" ) type Option[T any] struct { ok bool val T } func (o Option[T]) String() string { if o.ok { return fmt.Sprintf("Some(%v)", o.val) } return "None" } func Some[T any](val T) Option[T] { return Option[T]{ok: true, val: val} } func None[T any]() Option[T] { return Option[T]{ok: false} } type Result[T, E any] struct { ok bool val T err E } func (r Result[T, E]) String() string { if r.ok { return fmt.Sprintf("Ok(%v)", r.val) } return fmt.Sprintf("Err(%v)", r.err) } func Ok[T, E any](val T) Result[T, E] { return Result[T, E]{ok: true, val: val} } func Err[T, E any](err E) Result[T, E] { return Result[T, E]{ok: false, err: err} } func main() { a := Some[int](1) b := None[int]() fmt.Println(a, b) x := Ok[int, error](1) y := Err[int, error](errors.New("test")) fmt.Println(x, y) // fmt.Println(x) _, _, _, _ = a, b, x, y }	1.05 KB	2024-02-02 18:09
📄 issue47272.out Some(1) None Ok(1) Err(test)	29 B	2024-02-02 18:09
📄 issue47514.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test that closures inside a generic function are not exported, // even though not themselves generic. package main func Do[T any]() { _ = func() string { return "" } } func main() { Do[int]() }	373 B	2024-02-02 18:09
📄 issue47514b.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func Do[T any](do func() (T, string)) { _ = func() (T, string) { return do() } } func main() { Do[int](func() (int, string) { return 3, "3" }) }	336 B	2024-02-02 18:09
📁 issue47514c.dir	-	2024-02-02 18:09
📄 issue47514c.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 issue47631.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p func g[T any]() { type U []T type V []int } type S[T any] struct { } func (s S[T]) m() { type U []T type V []int } func f() { type U []int } type X struct { } func (x X) m() { type U []int }	385 B	2024-02-02 18:09
📄 issue47676.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func main() { d := diff([]int{}, func(int) string { return "foo" }) d() } func diff[T any](previous []T, uniqueKey func(T) string) func() { return func() { newJSON := map[string]T{} for _, prev := range previous { delete(newJSON, uniqueKey(prev)) } } }	452 B	2024-02-02 18:09
📄 issue47684.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func f[G any]() int { return func() int { return func() int { return 0 }() }() } func main() { f[int]() }	299 B	2024-02-02 18:09
📄 issue47684b.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func f[G any]() interface{} { return func() interface{} { return func() interface{} { var x G return x }() }() } func main() { x := f[int]() if v, ok := x.(int); !ok \|\| v != 0 { panic("bad") } }	395 B	2024-02-02 18:09
📄 issue47684c.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func f[G any]() func()func()int { return func() func()int { return func() int { return 0 } } } func main() { f[int]()()() }	317 B	2024-02-02 18:09
📄 issue47708.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type FooType[T any] interface { Foo(BarType[T]) string } type BarType[T any] interface { Bar(FooType[T]) string } // For now, a lone type parameter is not permitted as RHS in a type declaration (issue #45639). // type Baz[T any] T // func (l Baz[T]) Foo(v BarType[T]) string { // return v.Bar(l) // } // type Bob[T any] T // func (l Bob[T]) Bar(v FooType[T]) string { // if v,ok := v.(Baz[T]);ok{ // return fmt.Sprintf("%v%v",v,l) // } // return "" // } func main() { // For now, a lone type parameter is not permitted as RHS in a type declaration (issue #45639). // var baz Baz[int] = 123 // var bob Bob[int] = 456 // // if got, want := baz.Foo(bob), "123456"; got != want { // panic(fmt.Sprintf("got %s want %s", got, want)) // } }	934 B	2024-02-02 18:09
📄 issue47710.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p type FooType[t any] interface { Foo(BarType[t]) } type BarType[t any] interface { Int(IntType[t]) FooType[int] } type IntType[t any] int func (n IntType[t]) Foo(BarType[t]) {} func (n IntType[_]) String() {}	398 B	2024-02-02 18:09
📄 issue47713.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "encoding" "fmt" ) type Seralizable interface { encoding.BinaryMarshaler encoding.BinaryUnmarshaler } type SerDeString string func (s SerDeString) UnmarshalBinary(in []byte) error { s = SerDeString(in) return nil } func (s SerDeString) MarshalBinary() ([]byte, error) { return []byte(s), nil } type GenericSerializable[T Seralizable] struct { Key string Value T } func (g GenericSerializable[T]) Send() { out, err := g.Value.MarshalBinary() if err != nil { panic("bad") } var newval SerDeString newval.UnmarshalBinary(out) fmt.Printf("Sent %s\n", newval) } func main() { val := SerDeString("asdf") x := GenericSerializable[*SerDeString]{ Value: &val, } x.Send() }	888 B	2024-02-02 18:09
📄 issue47713.out Sent asdf	10 B	2024-02-02 18:09
📄 issue47716.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" "unsafe" ) // size returns the size of type T func size[T any](x T) uintptr { return unsafe.Sizeof(x) } // size returns the alignment of type T func align[T any](x T) uintptr { return unsafe.Alignof(x) } type Tstruct[T any] struct { f1 T f2 int } // offset returns the offset of field f2 in the generic type Tstruct func (r *Tstruct[T]) offset() uintptr { return unsafe.Offsetof(r.f2) } func main() { v1 := int(5) if got, want := size(v1), unsafe.Sizeof(v1); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } if got, want := align(v1), unsafe.Alignof(v1); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } v2 := "abc" if got, want := size(v2), unsafe.Sizeof(v2); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } if got, want := align(v2), unsafe.Alignof(v2); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } var v3 Tstruct[int] if got, want := unsafe.Offsetof(v3.f2), unsafe.Sizeof(v1); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } var v4 Tstruct[interface{}] var v5 interface{} if got, want := unsafe.Offsetof(v4.f2), unsafe.Sizeof(v5); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } if got, want := v3.offset(), unsafe.Offsetof(v3.f2); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } if got, want := v4.offset(), unsafe.Offsetof(v4.f2); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } }	1.63 KB	2024-02-02 18:09
📄 issue47723.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func f[_ any]() int { var a [1]int _ = func() int { return func() int { return 0 }() }() return a[func() int { return 0 }()] } func main() { f[int]() }	350 B	2024-02-02 18:09
📄 issue47740.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import "fmt" type Exp[Ty any] interface { Eval() Ty } // For now, a lone type parameter is not permitted as RHS in a type declaration (issue #45639). // type Lit[Ty any] Ty // // func (lit Lit[Ty]) Eval() Ty { return Ty(lit) } // func (lit Lit[Ty]) String() string { return fmt.Sprintf("(lit %v)", Ty(lit)) } type Eq[Ty any] struct { a Exp[Ty] b Exp[Ty] } func (e Eq[Ty]) String() string { return fmt.Sprintf("(eq %v %v)", e.a, e.b) } // For now, a lone type parameter is not permitted as RHS in a type declaration (issue #45639). // var ( // e0 = Eq[int]{Lit[int](128), Lit[int](64)} // e1 = Eq[bool]{Lit[bool](true), Lit[bool](true)} // ) func main() { // For now, a lone type parameter is not permitted as RHS in a type declaration (issue #45639). // fmt.Printf("%v\n", e0) // fmt.Printf("%v\n", e1) }	1008 B	2024-02-02 18:09
📄 issue47740.out	0 B	2024-02-02 18:09
📄 issue47740b.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import "reflect" type S[T any] struct { a interface{} } func (e S[T]) M() { v := reflect.ValueOf(e.a) _, _ = v.Interface().(int) } func main() { e := S[int]{0} e.M() }	358 B	2024-02-02 18:09
📁 issue47775.dir	-	2024-02-02 18:09
📄 issue47775.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 issue47775b.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type C[T any] struct { } func (c *C[T]) reset() { } func New[T any]() { c := &C[T]{} i = c.reset z(c.reset) } var i interface{} func z(interface{}) { } func main() { New[int]() }	370 B	2024-02-02 18:09
📄 issue47797.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p type Foo[T any] struct { Val T } func (f Foo[T]) Bat() {} type Bar struct { Foo[int] } func foo() { var b Bar b.Bat() }	338 B	2024-02-02 18:09
📄 issue47877.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Map[K comparable, V any] struct { m map[K]V } func NewMap[K comparable, V any]() Map[K, V] { return Map[K, V]{m: map[K]V{}} } func (m Map[K, V]) Get(key K) V { return m.m[key] } func main() { _ = NewMap[int, struct{}]() }	444 B	2024-02-02 18:09
📄 issue47878.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Src1[T any] func() Src1[T] func (s Src1[T]) Next() { s = (*s)() } type Src2[T any] []func() Src2[T] func (s Src2[T]) Next() { _ = s[0]() } type Src3[T comparable] map[T]func() Src3[T] func (s Src3[T]) Next() { var a T _ = s[a]() } type Src4[T any] chan func() T func (s Src4[T]) Next() { _ = (<-s)() } type Src5[T any] func() Src5[T] func (s Src5[T]) Next() { var x interface{} = s _ = (x.(Src5[T]))() } func main() { var src1 Src1[int] src1.Next() var src2 Src2[int] src2.Next() var src3 Src3[string] src3.Next() var src4 Src4[int] src4.Next() var src5 Src5[int] src5.Next() }	802 B	2024-02-02 18:09
📁 issue47892.dir	-	2024-02-02 18:09
📄 issue47892.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	186 B	2024-02-02 18:09
📁 issue47892b.dir	-	2024-02-02 18:09
📄 issue47892b.go // compiledir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📄 issue47896.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "database/sql" ) // Collection generic interface which things can be added to. type Collection[T any] interface { Add(T) } // Slice generic slice implementation of a Collection type Slice[T any] []T func (s Slice[T]) Add(t T) { s = append(s, t) } type Scanner interface { Scan(...interface{}) error } type Mapper[T any] func(s Scanner, t T) error type Repository[T any] struct { db sql.DB } func (r Repository[T]) scan(rows sql.Rows, m Mapper[T], c Collection[T]) error { for rows.Next() { t := new(T) if err := m(rows, t); err != nil { return err } c.Add(t) } return rows.Err() } func (r Repository[T]) query(query string, m Mapper[T], c Collection[T]) error { rows, err := r.db.Query(query) if err != nil { return err } if err := r.scan(rows, m, c); err != nil { rows.Close() return err } return rows.Close() } type Actor struct { ActorID uint16 FirstName string LastName string } type ActorRepository struct { r Repository[Actor] } func (ActorRepository) scan(s Scanner, a Actor) error { return s.Scan(&a.ActorID, &a.FirstName, &a.LastName) } func (r ActorRepository) SelectAll(c Collection[Actor]) error { return r.r.query("SELECT `actor_id`, `first_name`, `last_name` FROM `actor` LIMIT 10", r.scan, c) }	1.44 KB	2024-02-02 18:09
📄 issue47901.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Chan[T any] chan Chan[T] func (ch Chan[T]) recv() Chan[T] { return <-ch } func main() { ch := Chan[int](make(chan Chan[int])) go func() { ch <- make(Chan[int]) }() ch.recv() }	372 B	2024-02-02 18:09
📄 issue47924.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p type Cache[K any] struct{} func (c Cache[K]) foo(x interface{}, f func(K) bool) { f(x.(K)) } var _ Cache[int]	296 B	2024-02-02 18:09
📄 issue47925.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type myifacer[T any] interface{ do(T) error } type stuff[T any] struct{} func (s stuff[T]) run() interface{} { var i myifacer[T] return i } func main() { stuff[int]{}.run() }	363 B	2024-02-02 18:09
📄 issue47925b.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type I[T any] interface { foo() } type E[T any] interface { } //go:noinline func f[T I[T]](x T) E[T] { // contains a cast from nonempty to empty interface return E[T](I[T](x)) } type S struct { x int } func (s S) foo() {} func main() { i := f(&S{x: 7}) if i.(S).x != 7 { panic("bad") } }	486 B	2024-02-02 18:09
📄 issue47925c.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type I[T any] interface { foo() } type J[T any] interface { foo() bar() } //go:noinline func f[T J[T]](x T) I[T] { // contains a cast between two nonempty interfaces return I[T](J[T](x)) } type S struct { x int } func (s S) foo() {} func (s S) bar() {} func main() { i := f(&S{x: 7}) if i.(*S).x != 7 { panic("bad") } }	520 B	2024-02-02 18:09
📄 issue47925d.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type I[T any] interface { foo() } type J[T any] interface { foo() bar() } //go:noinline func f[T J[T]](x T, g func(T) T) I[T] { // contains a cast between two nonempty interfaces // Also make sure we don't evaluate g(x) twice. return I[T](J[T](g(x))) } type S struct { x int } func (s S) foo() {} func (s S) bar() {} var cnt int func inc(s S) S { cnt++ return s } func main() { i := f(&S{x: 7}, inc) if i.(*S).x != 7 { panic("bad") } if cnt != 1 { panic("multiple calls") } }	687 B	2024-02-02 18:09
📄 issue47929.go // compile -p=p // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package v4 var sink interface{} //go:noinline func Do(result, body interface{}) { sink = &result } func DataAction(result DataActionResponse, body DataActionRequest) { Do(&result, body) } type DataActionRequest struct { Action interface{} } type DataActionResponse struct { ValidationErrors ValidationError } type ValidationError struct { }	530 B	2024-02-02 18:09
📄 issue47948.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type fun func() func F[T any]() { _ = fun(func() { }) } func main() { F[int]() }	272 B	2024-02-02 18:09
📄 issue47966.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p type C comparable	201 B	2024-02-02 18:09
📄 issue48013.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" "unsafe" ) type S[T any] struct { val T } // Test type substitution where base type is unsafe.Pointer type U[T any] unsafe.Pointer func test[T any]() T { var q U[T] var v struct { // Test derived type that contains an unsafe.Pointer p unsafe.Pointer val T } _ = q return v.val } func main() { want := 0 got := test[int]() if got != want { panic(fmt.Sprintf("got %f, want %f", got, want)) } }	616 B	2024-02-02 18:09
📄 issue48016.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" "strconv" ) func test1[T any](fn func(T) int, v T) int { fn1 := func() int { var i interface{} = v val := fn(i.(T)) return val } return fn1() } func main() { want := 123 got := test1(func(s string) int { r, err := strconv.Atoi(s) if err != nil { return 0 } return r }, "123") if got != want { panic(fmt.Sprintf("got %f, want %f", got, want)) } }	574 B	2024-02-02 18:09
📄 issue48030.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Src[T any] func() Src[T] func Seq[T any]() Src[T] { return nil } func Seq2[T1 any, T2 any](v1 T1, v2 T2) Src[T2] { return nil } func main() { // Type args fully supplied Seq[int]() // Partial inference of type args Seq2[int](5, "abc") // Full inference of type args Seq2(5, "abc") }	481 B	2024-02-02 18:09
📄 issue48042.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" "reflect" ) type G[T any] interface { g() func()(T) } type Foo[T any] struct { } // OCALL func (l Foo[T]) f1() (T) { return g[T]()() } // OCALLFUNC func (l Foo[T]) f2() (T) { var f = g[T] return f()() } // OCALLMETH func (l Foo[T]) f3() (T) { return l.g()() } // OCALLINTER func (l Foo[T]) f4() (T) { var g G[T] = l return g.g()() } // ODYNAMICDOTTYPE func (l Foo[T]) f5() (T) { var x interface{} x = g[T] return x.(func()func()(T))()() } func (l Foo[T]) g() func() (T) { return func() (T) { t := new(T) reflect.ValueOf(t).Elem().SetInt(100) return t } } func g[T any]() func() (T) { return func() (T) { t := new(T) reflect.ValueOf(t).Elem().SetInt(100) return t } } func main() { foo := Foo[int]{} // Make sure the function conversion is correct if n := (foo.f1()) ; n != 100{ panic(fmt.Sprintf("%v",n)) } if n := (foo.f2()) ; n != 100{ panic(fmt.Sprintf("%v",n)) } if n := (foo.f3()) ; n != 100{ panic(fmt.Sprintf("%v",n)) } if n := (foo.f4()) ; n != 100{ panic(fmt.Sprintf("%v",n)) } if n := (foo.f5()) ; n != 100{ panic(fmt.Sprintf("%v",n)) } }	1.29 KB	2024-02-02 18:09
📄 issue48047.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type A[T any] struct { field B[T] } type B[T any] interface { Work(T) } func (a *A[T]) Work(t T) { a.field.Work(t) } type BImpl struct{} func (b BImpl) Work(s string) {} func main() { a := &A[string]{ field: BImpl{}, } a.Work("") }	427 B	2024-02-02 18:09
📄 issue48049.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func main() { Gooer2[byte]() } type Fooer[T any] interface { Foo(p T) } type fooer1[T any] struct{} func (fooer1[T]) Foo(T) {} type fooer2[T any] struct { r []Fooer[T] } //go:noinline func (mr fooer2[T]) Foo(p T) { mr.r[0] = fooer1[T]{} return } func Gooer2[T any]() Fooer[T] { return fooer2[T]{} }	493 B	2024-02-02 18:09
📄 issue48056.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p type B[T any] interface { Work() } type BImpl[T any] struct{} func (b *BImpl[T]) Work() { } type A[T any] struct { B[T] } func f[T any]() { s := &A[T]{ &BImpl[T]{}, } // golang.org/issue/48056 s.Work() }	398 B	2024-02-02 18:09
📁 issue48094.dir	-	2024-02-02 18:09
📄 issue48094.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📁 issue48094b.dir	-	2024-02-02 18:09
📄 issue48094b.go // compiledir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📄 issue48137.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Constraint[T any] interface { ~func() T } func Foo[T Constraint[T]]() T { var t T t = func() T { return t } return t } func main() { type Bar func() Bar Foo[Bar]() }	365 B	2024-02-02 18:09
📁 issue48185a.dir	-	2024-02-02 18:09
📄 issue48185a.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📁 issue48185b.dir	-	2024-02-02 18:09
📄 issue48185b.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 issue48191.go // compile -c=2 // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type I1 interface { int8 \| int16 \| int32 \| int64 \| int \| uint } type I2 interface{ float32 \| float64 } type I3 interface{ string } func F[G1 I1, G2 I2, G3 I3]() { var m0 map[G2]rune var ch0, ch1 chan bool var ast0, ast1 []struct{ s0 G3 } var ai64_2 []int64 var m1, m2, m3 map[bool]map[int]struct { m0 map[G2]byte s1 G3 } var i8_0, i8_1 G1 var i16_0 int16 var am3, am4 []map[float64]map[G2]func(byte, map[uint]int64, G3, struct{}) G2 var pi64_0, pi64_1 int64 var i, i1, i2 int var as5, as6, as7 []G3 var ch2, ch3, ch4 chan uint var m4, m5, m6 map[G1]chan bool if func(G2, int32) byte { return m1[false][30].m0[G2(28.6)] m3[func(bool, uint) bool { return false }(false, uint(94))][31].m0[G2(185.0)] * m1[(true \|\| true) && (false && false)][51-i2].m0[G2(278.6)] }(G2(672.5), int32(35)) < m3[<-m5[func(int64, int64) G1 { return i8_1 }(pi64_0, int64(50))]][15&i1^i2^i2].m0[G2(895.3)] \|\| (func(int64, uint) uint { return uint(94) }(int64(30), uint(95))&^<-ch2^<-ch4)&<-ch2^<-ch4 == <-ch2 { var f0 float64 var pf2 float64 var ch5, ch6 chan int16 var fnc0 func(int64, G2, struct { i8_0 G1 m1 map[float64]bool i64_2 int64 }, map[byte]func(G2, float64, uint, float64) struct{}) complex128 = func(p0 int64, p1 G2, p2 struct { i8_0 G1 m1 map[float64]bool i64_2 int64 }, p3 map[byte]func(G2, float64, uint, float64) struct{}) complex128 { p0 = pi64_1 m5 = map[G1]chan bool{(p2.i8_0 + i8_1 + i8_1 ^ i8_1) * p2.i8_0 / p2.i8_0: m4[p2.i8_0>><-ch2]} return (2.65i - 31.18i) * func(byte, byte) complex128 { return 13.12i - 32.90i + (44.15i - 70.53i - (87.16i92.67i + (24.18i - 9.13i))) + (func(G1, int16) complex128 { return 55.80i }(G1(30), int16(80)) + 8.48i79.18i + (37.30i73.81i + (21.01i - 76.30i)) + func(G3, G2) complex128 { return 35.58i }(G3("2JYizeFiEMvXLkUR"), p1)(81.59i-21.76i)) }(m1[<-m5[G1(37)i8_1<<i8_1%p2.i8_0]][i2].m0[p1], m1[<-ch0][55&i2/i2^i].m0[func(G3, float64) G2 { return G2(619.2) }(G3(""), 954.0)]) } var m7 map[G2]int64 var ch7 chan byte var fnc1 func(bool, func(chan G2, struct { h0 G2 }, int64) rune, int) map[complex128]int32 = func(p0 bool, p1 func(chan G2, struct { h0 G2 }, int64) rune, p2 int) map[complex128]int32 { pf2 = pf2 as7 = as7 return map[complex128]int32{(94.02i - 22.19i) (fnc0(pi64_0, G2(554.1)G2(i1), struct { i8_0 G1 m1 map[float64]bool i64_2 int64 }{G1(68)i8_0 ^ i8_0, map[float64]bool{f0: <-m6[G1(33)]}, (int64(40) ^ ai64_2[77]) % pi64_1}, map[byte]func(G2, float64, uint, float64) struct { }{func(float64, float64) byte { return byte(32) }(878.2, 984.4) + m3[true][12].m0[G2(594.0)]: nil}) - (fnc0(pi64_0, G2(241.1)+G2(i2), struct { i8_0 G1 m1 map[float64]bool i64_2 int64 }{i8_0, map[float64]bool{904.1: false}, int64(83) + m7[G2(357.7)]}, map[byte]func(G2, float64, uint, float64) struct { }{byte(85) \| m1[true][99].m0[G2(372.7)]: nil}) - (fnc0(pi64_0, G2(239.9), struct { i8_0 G1 m1 map[float64]bool i64_2 int64 }{G1(68), map[float64]bool{555.6: false}, int64(0)}, map[byte]func(G2, float64, uint, float64) struct { }{byte(18) & <-ch7: nil}) + (88.17i - 0.55i)))): int32(73) % int32(i)} } as5[54] = as6[(len(func(bool, G2) G3 { return G3("") }(false, G2(190.8)))\|i1^i1)%i1-i1] + m2[68 != i \|\| 'M'&'\xf4'\|'H'&'\u1311' >= '4'&'\uab3e'>>uint(83) && (<-m6[G1(24)%i8_0] && <-ch1)][i].s1 i = len([]G3{ast1[2].s0}) i16_0 = <-ch6 / i16_0 & <-ch6 i = (i1^i\|i2\|i2)/i + i m6 = m4 am3 = am3 m1[G2(869.6) == G2(i2)] = m2[func(float64, rune) byte { return func(G3, byte) byte { return byte(42) }(G3("8iDnlygG194xl"), byte(89)) }(pf2, '\u9cf4')/m1[func(G3, float64) bool { return false }(G3("6MbwBSHYzr9t0zD"), 774.4)][76].m0[G2(508.0)]/m2[<-m4[i8_0]][92&^i2].m0[G2(807.0)] > m3[(int32(39)\|int32(i2))&^int32(i2) < int32(i2)][89i1&i2].m0[G2(327.5)]] m2[<-m4[func(G1, complex128) G1 { return i8_1 }(i8_0, 35.01i)] && <-m4[func(int, G1) G1 { return G1(0) }(10, G1(70))i8_1&i8_1>><-ch2] \|\| fnc0(pi64_0, G2(689.5), struct { i8_0 G1 m1 map[float64]bool i64_2 int64 }{(G1(78)i8_1 - i8_1) / i8_1, map[float64]bool{499.2: <-m6[G1(88)^i8_0]}, int64(83) &^ ai64_2[33] & pi64_1 ai64_2[i1]}, map[byte]func(G2, float64, uint, float64) struct { }{m1[len(G3("bNIJZq")+G3("Fri5pn1MsZzYtsaV7b")) >= i][i^i1].m0[G2(691.7)]: nil}) != 71.77i-34.84i] = map[int]struct { m0 map[G2]byte s1 G3 }{((18+i2)&^i2%i2 ^ i) / i: m3[(G2(267.1)G2(i1) > G2(i2) \|\| (false \|\| true \|\| (true \|\| false))) && func(int32, int64) bool { return <-ch0 }(int32(63), ai64_2[61&^i1&i2])][i\|i^i1]} i2 = 90 - i1 _, _, _, _, _, _, _, _ = f0, pf2, ch5, ch6, fnc0, m7, ch7, fnc1 } else { var m7 map[G1]chan uint var ch5, ch6, ch7 chan G3 var i32_0, i32_1 int32 var m8, m9, m10 map[bool]struct { } pi64_1 = pi64_0 m6[func(G3, G2) G1 { return (G1(35) \| i8_0) << i8_1 / i8_1 &^ i8_1 / i8_1 }(G3("YBiKg"), G2(122.6))] = make(chan bool) ast0 = ast0 i8_1 = (((G1(10)+i8_1)&i8_0+i8_0)&i8_0&i8_1 ^ i8_1) & i8_1 am4 = am3 i32_1 = int32(10) &^ i32_0 m8[func(float64, G3) bool { return func(rune, int16) bool { return (G2(267.0)G2(i2) == G2(i) \|\| func(G2, G3) bool { return <-ch0 }(G2(53.3), <-ch5)) && func(G2, G1) int32 { return int32(63) }(G2(804.8), G1(2))-i32_0 < i32_1 }('\xbd', i16_0) }(370.9, ast0[len([]complex128{})+i-i2].s0) && (G2(245.0)-G2(i1) == G2(i1) \|\| byte(17)&m2[false][26].m0[G2(628.5)] > m3[false][55].m0[G2(608.8)] \|\| func(G1, G1) bool { return true }(G1(24), G1(2)) \|\| (<-m5[G1(38)] \|\| <-ch1) && func(int32, int) bool { return false && true }(int32(6), i1) && '\x26'&'\x27'\|func(G2, G3) rune { return '\x13' }(G2(229.6), G3("ys1msVeg61uSImCDkRG3C")) <= 'V'>>uint(88)-('\xbe'+'\uafd4')) == (53.04i == 37.22i)] = m8[func(byte, int64) bool { return <-ch1 }(m3[false && false][96].m0[G2(147.6)], pi64_0) && 643.5 > float64(i1) && (<-ch0 && <-ch1)] i8_1 = func(byte, uint) G1 { return G1(68) }(m2[<-ch1 \|\| <-m5[G1(96)+i8_0] \|\| func(bool, int32) bool { return func(int, byte) bool { return m1[true][89].s1 <= G3("2ZMnHGOMQnyHSbJ") }(i2, m2[<-m6[G1(47)]][94].m0[G2(981.3)]) }(<-m4[G1(0)&^i8_0&i8_0], i32_0)][i2%i&^i].m0[func(complex128, rune) G2 { return G2(93.1) * G2(i2) }(4.63i, m0[G2(975.8)])], uint(21)) _, _, _, _, _, _, _, _, _ = m7, ch5, ch6, ch7, i32_0, i32_1, m8, m9, m10 } if pi64_0>><-ch3 <= pi64_0 \|\| func(bool, int32) int32 { return (int32(69)&^int32(i2) + int32(i2)) * int32(i2) }(true, int32(49))^int32(i2) >= int32(i) { var ai8_8, ai8_9 []G1 var pi2, pi3, pi4 int var pi8_5, pi8_6 G1 var i64_0, i64_1 int64 m1[754.8float64(i2) != float64(i) && 6.26i == 69.99i] = map[int]struct { m0 map[G2]byte s1 G3 }{len([]G2{G2(935.9) / G2(i2), func(int64, G2) G2 { return G2(720.5) }(int64(36), G2(349.7))})&pi2 + i2 - i1: m1[(uint(29) >= <-ch4 \|\| int64(45)+ai64_2[18] >= pi64_1) == (func(G2, G2) bool { return <-m5[G1(25)] }(G2(447.2), G2(946.6)) \|\| func(int, int16) bool { return true }(40, int16(41)) && byte(51) >= m2[true][13].m0[G2(6.6)])][pi3]} am4 = []map[float64]map[G2]func(byte, map[uint]int64, G3, struct { }) G2{am4[i2%pi3]} pi2 = &i2 pi64_0 = pi64_1 ai8_8[pi3] = pi8_5&ai8_9[(pi4+pi3)%pi3] ^ ai8_8[90+i2\|pi4] ai64_2 = []int64{} m4 = m4 pi2 = &i1 pi3 = &i2 _, _, _, _, _, _, _, _, _ = ai8_8, ai8_9, pi2, pi3, pi4, pi8_5, pi8_6, i64_0, i64_1 } if (true \|\| false \|\| int32(68) > int32(i1) \|\| <-m5[G1(11)-i8_0] && true) && func(int, float64) bool { return <-m5[(G1(83)-i8_1)&^i8_1] }(i1, 886.6) \|\| func(byte, int) bool { return 401.0/float64(i1)/float64(i1)-float64(i) == float64(i2) }(m1[(G1(85)^i8_1)&^i8_1 <= i8_1][72].m0[G2(617.4)], i1) \|\| (<-m6[(G1(3)\|i8_0)>><-ch2%i8_0\|i8_0] \|\| <-ch0) { var ch5 chan map[byte]complex128 var fnc0 func(int32, map[rune]complex128) complex128 var c0 complex128 var st0, st1, st2 struct { } var au8 []uint var st3, st4, st5 struct { ph0 G2 st1 struct { m0 map[rune]complex128 pch1 chan int64 m2 map[bool]byte st3 struct { ch0 chan func(map[G1]struct { pm0 map[bool]int64 h1 G2 }, struct { u0 uint }, uint, float64) struct { ch0 chan map[int16]G2 } i1 int ch2 chan complex128 } } pm2 map[int64]struct { s0 G3 pi1 int st2 struct { m0 map[int]map[rune]int64 r1 rune } } } var am9, am10, am11 []map[uint]int64 m1[G3("E")+(st4.pm2)[pi64_0+<-st3.st1.pch1].s0 < (st4.pm2)[int64(46)].s0+(G3("4Jsp3pv0x")+G3("MTKt98c")+(G3("E6Nxqpl70")+G3("eXhhxb")))+(G3("siISQNeBXoQIHwGB")+G3("CzocwLRWIUD")+(G3("cDWy3E3qpeJOmw1wP9wZ")+G3("S3ZRONdtB7K1LBC"))+func(G1, uint) G3 { return m2[false][74].s1 }(G1(9), uint(26)))+func(G2, int) G3 { return G3("WzncXvaqK4zPn") }(G2(291.6), i)+(ast1[(40^i1+i1)&^st4.st1.st3.i1].s0+func(byte, int64) G3 { return m2[207.7 == float64(i2) && (false \|\| false)][i2].s1 }(byte(34), am11[25][func(int32, float64) uint { return uint(77) }(int32(29), 403.1)]))] = map[int]struct { m0 map[G2]byte s1 G3 }{st3.st1.st3.i1: m2[<-m4[i8_1]][st5.st1.st3.i1-st3.st1.st3.i1-i2]} st1 = struct { }{} pi64_0 = pi64_1 m4 = m6 as7 = as7 m6[(i8_0+i8_0)&^i8_1&^i8_1] = m5[G1(96)^i8_1] st2 = struct { }{} st1 = struct { }{} am10 = []map[uint]int64{am9[len((st4.pm2)[int64(65)].s0)+i], am11[st4.st1.st3.i1%st4.st1.st3.i1^i1]} i2 = st5.st1.st3.i1*i - st5.st1.st3.i1 _, _, _, _, _, _, _, _, _, _, _, _, _ = ch5, fnc0, c0, st0, st1, st2, au8, st3, st4, st5, am9, am10, am11 } } func main() { F[int16, float32, string]() }	9.73 KB	2024-02-02 18:09
📄 issue48198.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p type Foo[T any] struct { } func (foo Foo[T]) Get() { } var( _ = Foo[byte]{} _ = Foo[[]byte]{} _ = Foo[map[byte]rune]{} _ = Foo[rune]{} _ = Foo[[]rune]{} _ = Foo[map[rune]byte]{} )	372 B	2024-02-02 18:09
📄 issue48225.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import "reflect" type Foo[T any] struct { val int } func (foo Foo[T]) Get() T { if foo.val != 1 { panic("bad val field in Foo receiver") } return new(T) } var ( newInt = Foo[int]{val: 1}.Get newString = Foo[string]{val: 1}.Get ) func main() { i := newInt() s := newString() if t := reflect.TypeOf(i).String(); t != "int" { panic(t) } if t := reflect.TypeOf(s).String(); t != "*string" { panic(t) } }	610 B	2024-02-02 18:09
📄 issue48253.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "reflect" ) type A[T any] struct { B[int] } type B[T any] struct { } func (b B[T]) Bat() { t := new(T) if tt := reflect.TypeOf(t); tt.Kind() != reflect.Pointer \|\| tt.Elem().Kind() != reflect.Int { panic("unexpected type, want: *int, got: "+tt.String()) } } type Foo struct { A[string] } func main() { Foo{}.A.Bat() Foo{}.A.B.Bat() Foo{}.Bat() }	551 B	2024-02-02 18:09
📄 issue48276a.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import "fmt" func main() { IsZero[int](0) } func IsZero[T comparable](val T) bool { var zero T fmt.Printf("%v:%v\n", zero, val) return val != zero }	337 B	2024-02-02 18:09
📄 issue48276a.out 0:0	4 B	2024-02-02 18:09
📄 issue48276b.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func main() { f[interface{}](nil) } func f[T any](x T) { var _ interface{} = x }	266 B	2024-02-02 18:09
📁 issue48280.dir	-	2024-02-02 18:09
📄 issue48280.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📁 issue48306.dir	-	2024-02-02 18:09
📄 issue48306.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 issue48317.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "encoding/json" ) type A[T any] struct { F1 string `json:"t1"` F2 T `json:"t2"` B B `json:"t3"` } type B struct { F4 int `json:"t4"` } func a[T any]() { data := `{"t1":"1","t2":2,"t3":{"t4":4}}` a1 := A[T]{} if err := json.Unmarshal([]byte(data), &a1); err != nil { panic(err) } if bytes, err := json.Marshal(&a1); err != nil { panic(err) } else if string(bytes) != data { panic(string(bytes)) } } func main() { a[int]() }	648 B	2024-02-02 18:09
📄 issue48318.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "encoding/xml" "fmt" ) type A[T, U any] struct { Name T `xml:"name"` Data U `xml:"data"` } func main() { src := &A[string, int]{Name: "name", Data: 1} data, err := xml.Marshal(src) if err != nil { panic(err) } dst := &A[string, int]{} err = xml.Unmarshal(data, dst) if err != nil { panic(err) } if src != dst { panic(fmt.Sprintf("wanted %#v got %#v", src, dst)) } }	581 B	2024-02-02 18:09
📁 issue48337a.dir	-	2024-02-02 18:09
📄 issue48337a.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 issue48337a.out this file does import sync	27 B	2024-02-02 18:09
📁 issue48337b.dir	-	2024-02-02 18:09
📄 issue48337b.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 issue48344.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type G[T any] interface { g() } type Foo[T any] struct { } func (foo *Foo[T]) g() { } func f[T any]() { v := []G[T]{} v = append(v, &Foo[T]{}) } func main() { f[int]() }	360 B	2024-02-02 18:09
📄 issue48424.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Smoke test for constraint literals with elided interface // per issue #48424. package main func identity[T int](x T) T { return x } func min[T int \| string](x, y T) T { if x < y { return x } return y } func max[T ~int \| ~float64](x, y T) T { if x > y { return x } return y } func main() { if identity(1) != 1 { panic("identity(1) failed") } if min(2, 3) != 2 { panic("min(2, 3) failed") } if min("foo", "bar") != "bar" { panic(`min("foo", "bar") failed`) } if max(2, 3) != 3 { panic("max(2, 3) failed") } } // Some random type parameter lists with elided interfaces. type ( _[T struct{}] struct{} _[M map[K]V, K comparable, V any] struct{} _[_ interface{} \| int] struct{} )	916 B	2024-02-02 18:09
📄 issue48453.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main //go:noinline func CopyMap[M interface{ ~map[K]V }, K comparable, V any](m M) M { out := make(M, len(m)) for k, v := range m { out[k] = v } return out } func main() { var m map[*string]int CopyMap(m) }	393 B	2024-02-02 18:09
📁 issue48454.dir	-	2024-02-02 18:09
📄 issue48454.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📁 issue48462.dir	-	2024-02-02 18:09
📄 issue48462.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 issue48537.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func main() { } type C interface { map[int]string } func f[A C]() A { return A{ 1: "a", 2: "b", } }	295 B	2024-02-02 18:09
📄 issue48538.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Testing composite literal for a type param constrained to be a struct or a map. package p type C interface { ~struct{ b1, b2 string } } func f[T C]() T { return T{ b1: "a", b2: "b", } } func f2[T ~struct{ b1, b2 string }]() T { return T{ b1: "a", b2: "b", } } type D interface { map[string]string \| S } type S map[string]string func g[T D]() T { b1 := "foo" b2 := "bar" return T{ b1: "a", b2: "b", } } func g2[T map[string]string]() T { b1 := "foo" b2 := "bar" return T{ b1: "a", b2: "b", } } func g3[T S]() T { b1 := "foo" b2 := "bar" return T{ b1: "a", b2: "b", } }	790 B	2024-02-02 18:09
📄 issue48598.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Iterator[T any] interface { Iterate() } type IteratorFunc[T any] func(fn func(T) bool) func (f IteratorFunc[T]) Iterate() { } func FromIterator[T any](it Iterator[T]) { it.Iterate() } func Foo[T, R any]() { FromIterator[R](IteratorFunc[R](nil)) } func main() { Foo[int, int]() }	475 B	2024-02-02 18:09
📄 issue48602.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Iterator[T any] interface { Iterate(fn T) } type IteratorFunc[T any] func(fn T) func (f IteratorFunc[T]) Iterate(fn T) { f(fn) } func Foo[R any]() { var _ Iterator[R] = IteratorFunc[R](nil) } func main() { Foo[int]() }	414 B	2024-02-02 18:09
📄 issue48604.go // build // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Foo[T any] interface { CreateBar() Bar[T] } type Bar[T any] func() Bar[T] func (f Bar[T]) CreateBar() Bar[T] { return f } func abc[R any]() { var _ Foo[R] = Bar[R](nil)() } func main() { abc[int]() }	396 B	2024-02-02 18:09
📄 issue48609.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p func f[T ~chan E, E any](e E) T { ch := make(T) go func() { defer close(ch) ch <- e }() return ch }	291 B	2024-02-02 18:09
📄 issue48617.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Foo[T any] interface { CreateBar() Bar[T] } type Bar[T any] func() Bar[T] func (f Bar[T]) CreateBar() Bar[T] { return f } func abc[T any]() { var b Bar[T] = func() Bar[T] { var b Bar[T] return b } var _ Foo[T] = b() } func main() { abc[int]() }	446 B	2024-02-02 18:09
📄 issue48645a.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" "reflect" ) type Stream[T any] struct { } func (s Stream[T]) DropWhile() Stream[T] { return Pipe[T, T](s) } func Pipe[T, R any](s Stream[T]) Stream[R] { it := func(fn func(R) bool) { } fmt.Println(reflect.TypeOf(it).String()) return Stream[R]{} } func main() { s := Stream[int]{} s = s.DropWhile() }	510 B	2024-02-02 18:09
📄 issue48645a.out func(func(int) bool)	21 B	2024-02-02 18:09
📄 issue48645b.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Iterator[T any] interface { Iterate(fn func(T) bool) } type IteratorFunc[T any] func(fn func(T) bool) func (f IteratorFunc[T]) Iterate(fn func(T) bool) { f(fn) } type Stream[T any] struct { it Iterator[T] } func (s Stream[T]) Iterate(fn func(T) bool) { if s.it == nil { return } s.it.Iterate(fn) } func FromIterator[T any](it Iterator[T]) Stream[T] { return Stream[T]{it: it} } func (s Stream[T]) DropWhile(fn func(T) bool) Stream[T] { return Pipe[T, T](s, func(t T) (T, bool) { return t, true }) } func Pipe[T, R any](s Stream[T], op func(d T) (R, bool)) Stream[R] { it := func(fn func(R) bool) { // XXX Not getting the closure right when converting to interface. // s.it.Iterate(func(t T) bool { // r, ok := op(t) // if !ok { // return true // } // return fn(r) // }) } return FromIterator[R](IteratorFunc[R](it)) } func Reduce[T, U any](s Stream[T], identity U, acc func(U, T) U) (r U) { r = identity s.Iterate(func(t T) bool { r = acc(r, t) return true }) return r } type myIterator struct { } func (myIterator) Iterate(fn func(int) bool) { } func main() { s := Stream[int]{} s.it = myIterator{} s = s.DropWhile(func(i int) bool { return false }) Reduce(s, nil, func(acc []int, e int) []int { return append(acc, e) }) }	1.45 KB	2024-02-02 18:09
📄 issue48711.go // errorcheck // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func f[T interface{ ~[]P }, P any](t T) { // ERROR "instantiation cycle" if t == nil { return } f[[]T, T]([]T{t}) } func main() { f[[]int](nil) }	342 B	2024-02-02 18:09
📁 issue48716.dir	-	2024-02-02 18:09
📄 issue48716.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 issue48838.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func main() { check[string]() } func check[T any]() { var result setter[T] switch result.(type) { case fooA[T]: case fooB[T]: } } type setter[T any] interface { Set(T) } type fooA[T any] struct{} func (fooA[T]) Set(T) {} type fooB[T any] struct{} func (fooB[T]) Set(T) {}	467 B	2024-02-02 18:09
📁 issue48962.dir	-	2024-02-02 18:09
📄 issue48962.go // errorcheckdir // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	194 B	2024-02-02 18:09
📁 issue49027.dir	-	2024-02-02 18:09
📄 issue49027.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 issue49049.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type A[T any] interface { m() } type Z struct { a,b int } func (z *Z) m() { } func test[T any]() { var a A[T] = &Z{} f := a.m f() } func main() { test[string]() }	354 B	2024-02-02 18:09
📁 issue49241.dir	-	2024-02-02 18:09
📄 issue49241.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📁 issue49246.dir	-	2024-02-02 18:09
📄 issue49246.go // compiledir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📄 issue49295.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import "io" type Reader struct { buf []byte } type Token [16]byte func Read[T interface{ ~[16]byte }](r *Reader) (t T, err error) { if n := len(t); len(r.buf) >= n { t = T(r.buf[:n]) r.buf = r.buf[n:] return } err = io.EOF return } func main() { r := &Reader{buf: []byte("0123456789abcdef")} token, err := Read[Token](r) _, _ = token, err }	542 B	2024-02-02 18:09
📄 issue49309.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func genfunc[T any](f func(c T)) { var r T f(r) } func myfunc(c string) { test2(c) } //go:noinline func test2(a interface{}) { _ = a.(string) } func main() { genfunc(myfunc) }	367 B	2024-02-02 18:09
📄 issue49421.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func main() { var a, b foo bar(a, b) } type foo int func (a foo) less(b foo) bool { return a < b } type lesser[T any] interface { less(T) bool comparable } func bar[T lesser[T]](a, b T) { a.less(b) }	392 B	2024-02-02 18:09
📄 issue49432.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Handler func(in ...interface{}) type Foo[T any] struct{} func (b Foo[T]) Bar(in ...interface{}) {} func (b Foo[T]) Init() { _ = Handler(b.Bar) } func main() { c := &Foo[int]{} c.Init() }	387 B	2024-02-02 18:09
📁 issue49497.dir	-	2024-02-02 18:09
📄 issue49497.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 issue49516.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p type Q[T any] struct { s []T } func (q Q[T]) Push(v ...T) { q.s = append(q.s, v...) } func pushN(push func(Q[int], ...int), n int) { var q Q[int] for i := 0; i < n; i++ { push(&q, i) } } func f() { pushN((*Q[int]).Push, 100) }	423 B	2024-02-02 18:09
📁 issue49524.dir	-	2024-02-02 18:09
📄 issue49524.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📁 issue49536.dir	-	2024-02-02 18:09
📄 issue49536.go // compiledir // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📄 issue49538.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p type I interface { M(interface{}) } type a[T any] struct{} func (a[T]) M(interface{}) {} func f[T I](t T) { (t).M(t) } func g() { f(&a[int]{}) }	337 B	2024-02-02 18:09
📄 issue49547.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import "fmt" type foo int func main() { want := "main.F[main.foo]" got := fmt.Sprintf("%T", F[foo]{}) if got != want { fmt.Printf("want: %s, got: %s\n", want, got) } } type F[T any] struct { }	384 B	2024-02-02 18:09
📄 issue49611.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p func f[T any]() { var () }	211 B	2024-02-02 18:09
📁 issue49659.dir	-	2024-02-02 18:09
📄 issue49659.go // compiledir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📄 issue49659b.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Testing that AddrTaken logic doesn't cause problems for function instantiations package main type A[T interface{ []int \| [5]int }] struct { val T } //go:noinline func (a A[T]) F() { _ = &a.val[2] } func main() { var x A[[]int] x.val = make([]int, 4) _ = &x.val[3] x.F() var y A[[5]int] _ = &y.val[3] y.F() }	492 B	2024-02-02 18:09
📁 issue49667.dir	-	2024-02-02 18:09
📄 issue49667.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 issue49875.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p func f(args ...interface{}) {} func g() { var args []any f(args...) }	256 B	2024-02-02 18:09
📁 issue49893.dir	-	2024-02-02 18:09
📄 issue49893.go // compiledir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📄 issue50002.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test for cases where certain instantiations of a generic function (F in this // example) will always fail on a type assertion or mismatch on a type case. package main import "fmt" type S struct{} func (S) M() byte { return 0 } type I[T any] interface { M() T } func F[T, A any](x I[T], shouldMatch bool) { switch x.(type) { case A: if !shouldMatch { fmt.Printf("wanted mis-match, got match") } default: if shouldMatch { fmt.Printf("wanted match, got mismatch") } } _, ok := x.(A) if ok != shouldMatch { fmt.Printf("ok: got %v, wanted %v", ok, shouldMatch) } if !shouldMatch { defer func() { if shouldMatch { fmt.Printf("Shouldn't have panicked") } recover() }() } _ = x.(A) if !shouldMatch { fmt.Printf("Should have panicked") } } func main() { // Test instantiation where the type switch/type asserts can't possibly succeed // (since string does not implement I[byte]). F[byte, string](S{}, false) // Test instantiation where the type switch/type asserts should succeed // (since S does implement I[byte]) F[byte, S](S{}, true) F[byte, S](I[byte](S{}), true) }	1.27 KB	2024-02-02 18:09
📄 issue50109.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" ) type AnyCacher[T any] interface { // Get an item from the cache. Returns the item or nil, and a bool indicating // whether the key was found. Get(k string) (T, bool) // Add an item to the cache, replacing any existing item. Set(k string, x T) } // Item ... type Item[T any] struct { Object T } // AnyCache implements AnyCacher type AnyCache[T any] struct { anyCache[T] } type anyCache[T any] struct { items map[string]Item[T] janitor janitor[T] // Needed for the failure in the issue } // Set adds an item to the cache, replacing any existing item. func (c anyCache[T]) Set(k string, x T) { c.items[k] = Item[T]{ Object: x, } } // Get gets an item from the cache. Returns the item or nil, and a bool indicating // whether the key was found. func (c anyCache[T]) Get(k string) (T, bool) { // "Inlining" of get and Expired item, found := c.items[k] if !found { var ret T return ret, false } return item.Object, true } type janitor[T any] struct { stop chan bool } func newAnyCache[T any](m map[string]Item[T]) anyCache[T] { c := &anyCache[T]{ items: m, } return c } // NewAny[T any](...) returns a new AnyCache[T]. func NewAny[T any]() AnyCache[T] { items := make(map[string]Item[T]) return &AnyCache[T]{newAnyCache(items)} } // NewAnyCacher[T any](...) returns an AnyCacher[T] interface. func NewAnyCacher[T any]() AnyCacher[T] { return NewAny[T]() } type MyStruct struct { Name string } func main() { // Create a generic cache. // All items are cached as interface{} so they need to be cast back to their // original type when retrieved. // Failure in issue doesn't happen with 'any' replaced by 'interface{}' c := NewAnyCacher[any]() myStruct := &MyStruct{"MySuperStruct"} c.Set("MySuperStruct", myStruct) myRawCachedStruct, found := c.Get("MySuperStruct") if found { // Casting the retrieved object back to its original type myCachedStruct := myRawCachedStruct.(*MyStruct) fmt.Printf("%s", myCachedStruct.Name) } else { fmt.Printf("Error: MySuperStruct not found in cache") } // Output: // MySuperStruct }	2.23 KB	2024-02-02 18:09
📄 issue50109.out MySuperStruct	13 B	2024-02-02 18:09
📄 issue50109b.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func main() { F[any]() } func F[T any]() I[T] { return (S1[T])(nil) } type I[T any] interface{} type S1[T any] struct { S2[T] } type S2[T any] struct { S3 *S3[T] } type S3[T any] struct { x int }	390 B	2024-02-02 18:09
📁 issue50121.dir	-	2024-02-02 18:09
📄 issue50121.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📁 issue50121b.dir	-	2024-02-02 18:09
📄 issue50121b.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 issue50147.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p func Foo[T any, U interface{ *T }](x T) { var _ U = &x }	241 B	2024-02-02 18:09
📄 issue50177.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import "fmt" type Fn[T any] func(T) type FnErr[T any] func(T) error // Test that local generic types across functions don't conflict, and they also don't // conflict with local non-generic types and local variables. func caller0() { type X[T any] struct { fn Fn[int] } x := X[int]{func(v int) { fmt.Println(v) }} x.fn(0) } func caller1(val int) { type X[T any] struct { fn FnErr[int] } x := X[int]{func(v int) error { fmt.Println(v); return nil }} x.fn(0) } func caller1a(val int) { type X struct { fn func(float64) error } x := X{func(v float64) error { fmt.Println(v); return nil }} x.fn(float64(3.2)) } func caller1b(val int) { type Y struct { fn func(float64) error } X := Y{func(v float64) error { fmt.Println(v); return nil }} X.fn(float64(3.2)) } // Test that local generic types within different if clauses don't conflict. func caller2(val int) { if val > 2 { type X[T any] struct { fn func(v int) float64 } x := X[int]{func(v int) float64 { fmt.Println(v); return 1.5 }} x.fn(0) } else { type X[T any] struct { fn func(v int) int } x := X[int]{func(v int) int { fmt.Println(v); return 5 }} x.fn(0) } } // Test that local generic types within different cases don't conflict with each // other or with local non-generic types or local variables. func caller3(val int) { switch val { case 0: type X[T any] struct { fn func(v int) float64 } x := X[int]{func(v int) float64 { fmt.Println(v); return 1.5 }} x.fn(0) case 1: type X[T any] struct { fn func(v int) int } x := X[int]{func(v int) int { fmt.Println(v); return 5 }} x.fn(0) case 2: type X struct { fn func(v int) bool } x := X{func(v int) bool { fmt.Println(v); return false }} x.fn(0) case 3: type Y struct { fn func(v int) bool } X := Y{func(v int) bool { fmt.Println(v); return false }} X.fn(0) } }	2.01 KB	2024-02-02 18:09
📄 issue50193.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" ) type Complex interface { ~complex64 \| ~complex128 } func zero[T Complex]() T { return T(0) } func pi[T Complex]() T { return T(3.14) } func sqrtN1[T Complex]() T { return T(-1i) } func main() { fmt.Println(zero[complex128]()) fmt.Println(pi[complex128]()) fmt.Println(sqrtN1[complex128]()) fmt.Println(zero[complex64]()) fmt.Println(pi[complex64]()) fmt.Println(sqrtN1[complex64]()) }	599 B	2024-02-02 18:09
📄 issue50193.out (0+0i) (3.14+0i) (0-1i) (0+0i) (3.14+0i) (0-1i)	48 B	2024-02-02 18:09
📄 issue50259.go // compile // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p var x T[B] type T[_ any] struct{} type A T[B] type B = T[A]	244 B	2024-02-02 18:09
📄 issue50264.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type hello struct{} func main() { _ = Some(hello{}) res := Applicative2(func(a int, b int) int { return 0 }) _ = res } type NoneType[T any] struct{} func (r NoneType[T]) Recover() any { return nil } type Func2[A1, A2, R any] func(a1 A1, a2 A2) R func Some[T any](v T) any { _ = Some2[T](v) return NoneType[T]{}.Recover() } //go:noinline func Some2[T any](v T) any { return v } type Nil struct{} type ApplicativeFunctor2[H, HT, A1, A2, R any] struct { h any } func Applicative2[A1, A2, R any](fn Func2[A1, A2, R]) ApplicativeFunctor2[Nil, Nil, A1, A2, R] { return ApplicativeFunctor2[Nil, Nil, A1, A2, R]{Some(Nil{})} }	822 B	2024-02-02 18:09
📄 issue50317.go // errorcheck // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p type S struct{} func (S) _[_ any]() {} // ERROR "method must have no type parameters" type _ interface { m[_ any]() // ERROR "method must have no type parameters" }	354 B	2024-02-02 18:09
📄 issue50417.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func main() {} // Field accesses through type parameters are disabled // until we have a more thorough understanding of the // implications on the spec. See issue #51576. /* type Sf struct { f int } func f0[P Sf](p P) { _ = p.f p.f = 0 } func f0t[P ~struct{ f int }](p P) { _ = p.f p.f = 0 } var _ = f0[Sf] var _ = f0t[Sf] func f1[P interface { ~struct{ f int } m() }](p P) { _ = p.f p.f = 0 p.m() } var _ = f1[Sfm] type Sm struct{} func (Sm) m() {} type Sfm struct { f int } func (Sfm) m() {} func f2[P interface { Sfm m() }](p P) { _ = p.f p.f = 0 p.m() } var _ = f2[Sfm] // special case: core type is a named pointer type type PSfm Sfm func f3[P interface{ PSfm }](p P) { _ = p.f p.f = 0 } var _ = f3[PSfm] // special case: core type is an unnamed pointer type func f4[P interface{ Sfm }](p P) { _ = p.f p.f = 0 } var _ = f4[Sfm] type A int type B int type C float64 type Int interface { Sf \| A Sf \| B } func f5[P Int](p P) { _ = p.f p.f = 0 } var _ = f5[Sf] type Int2 interface { Sf \| A any Sf \| C } func f6[P Int2](p P) { _ = p.f p.f = 0 } var _ = f6[Sf] type Int3 interface { Sf ~struct{ f int } } func f7[P Int3](p P) { _ = p.f p.f = 0 } var _ = f7[Sf] type Em1 interface { Sf \| A } type Em2 interface { Sf \| B } type Int4 interface { Em1 Em2 any } func f8[P Int4](p P) { _ = p.f p.f = 0 } var _ = f8[Sf] */	1.55 KB	2024-02-02 18:09
📄 issue50417b.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func main() {} // Field accesses through type parameters are disabled // until we have a more thorough understanding of the // implications on the spec. See issue #51576. /* import "fmt" type MyStruct struct { b1, b2 string E } type E struct { val int } type C interface { ~struct { b1, b2 string E } } func f[T C]() T { var x T = T{ b1: "a", b2: "b", } if got, want := x.b2, "b"; got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } x.b1 = "y" x.val = 5 return x } func main() { x := f[MyStruct]() if got, want := x.b1, "y"; got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } if got, want := x.val, 5; got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } } */	921 B	2024-02-02 18:09
📄 issue50419.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test that type substitution works correctly even for a method of a generic type // that has multiple blank type params. package main import ( "fmt" ) func main() { foo := &Foo[string, int]{ valueA: "i am a string", valueB: 123, } if got, want := fmt.Sprintln(foo), "i am a string 123\n"; got != want { panic(fmt.Sprintf("got %s, want %s", got, want)) } } type Foo[T1 any, T2 any] struct { valueA T1 valueB T2 } func (f *Foo[_, _]) String() string { return fmt.Sprintf("%v %v", f.valueA, f.valueB) }	689 B	2024-02-02 18:09
📁 issue50437.dir	-	2024-02-02 18:09
📄 issue50437.go // compiledir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📁 issue50481b.dir	-	2024-02-02 18:09
📄 issue50481b.go // rundir // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📁 issue50481c.dir	-	2024-02-02 18:09
📄 issue50481c.go // rundir // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 issue50481c.out 0	2 B	2024-02-02 18:09
📁 issue50485.dir	-	2024-02-02 18:09
📄 issue50485.go // compiledir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📁 issue50486.dir	-	2024-02-02 18:09
📄 issue50486.go // compiledir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📁 issue50552.dir	-	2024-02-02 18:09
📄 issue50552.go // compiledir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📁 issue50561.dir	-	2024-02-02 18:09
📄 issue50561.go // compiledir // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📁 issue50598.dir	-	2024-02-02 18:09
📄 issue50598.go // rundir // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 issue50642.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import "fmt" type Temp[T any] struct { } var temp, temp1 any var ch any func (it Temp[T]) HasNext() bool { var ok bool temp1 = <-ch.(chan T) // test conversion of T to interface{} during an OAS2RECV temp, ok = <-ch.(chan T) return ok } type MyInt int func (i MyInt) String() string { return "a" } type Stringer interface { String() string } type Temp2[T Stringer] struct { } var temp2 Stringer func (it Temp2[T]) HasNext() string { var x map[int]T var ok bool // test conversion of T to Stringer during an OAS2MAPR temp2, ok = x[43] _ = ok return temp2.String() } func main() { ch1 := make(chan int, 2) ch1 <- 5 ch1 <- 6 ch = ch1 iter := Temp[int]{} iter.HasNext() iter2 := Temp2[MyInt]{} if got, want := iter2.HasNext(), "a"; got != want { panic(fmt.Sprintf("got %v, want %v", got, want)) } }	1013 B	2024-02-02 18:09
📄 issue50690a.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" ) // Numeric expresses a type constraint satisfied by any numeric type. type Numeric interface { ~uint \| ~uint8 \| ~uint16 \| ~uint32 \| ~uint64 \| ~int \| ~int8 \| ~int16 \| ~int32 \| ~int64 \| ~float32 \| ~float64 \| ~complex64 \| ~complex128 } // Sum returns the sum of the provided arguments. func Sum[T Numeric](args ...T) T { var sum T for i := 0; i < len(args); i++ { sum += args[i] } return sum } // Ledger is an identifiable, financial record. type Ledger[T ~string, K Numeric] struct { // ID identifies the ledger. ID_ T // Amounts is a list of monies associated with this ledger. Amounts_ []K // SumFn is a function that can be used to sum the amounts // in this ledger. SumFn_ func(...K) K } // Field accesses through type parameters are disabled // until we have a more thorough understanding of the // implications on the spec. See issue #51576. // Use accessor methods instead. func (l Ledger[T, _]) ID() T { return l.ID_ } func (l Ledger[_, K]) Amounts() []K { return l.Amounts_ } func (l Ledger[_, K]) SumFn() func(...K) K { return l.SumFn_ } func PrintLedger[ T ~string, K Numeric, L interface { ~struct { ID_ T Amounts_ []K SumFn_ func(...K) K } ID() T Amounts() []K SumFn() func(...K) K }, ](l L) { fmt.Printf("%s has a sum of %v\n", l.ID(), l.SumFn()(l.Amounts()...)) } func main() { PrintLedger(Ledger[string, int]{ ID_: "fake", Amounts_: []int{1, 2, 3}, SumFn_: Sum[int], }) }	1.64 KB	2024-02-02 18:09
📄 issue50690a.out fake has a sum of 6	20 B	2024-02-02 18:09
📄 issue50690b.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" ) type Printer[T ~string] struct { PrintFn func(T) } func Print[T ~string](s T) { fmt.Println(s) } func PrintWithPrinter[T ~string, S interface { ~struct { ID T PrintFn_ func(T) } PrintFn() func(T) }](message T, obj S) { obj.PrintFn()(message) } type PrintShop[T ~string] struct { ID T PrintFn_ func(T) } // Field accesses through type parameters are disabled // until we have a more thorough understanding of the // implications on the spec. See issue #51576. // Use accessor method instead. func (s PrintShop[T]) PrintFn() func(T) { return s.PrintFn_ } func main() { PrintWithPrinter( "Hello, world.", PrintShop[string]{ ID: "fake", PrintFn_: Print[string], }, ) }	916 B	2024-02-02 18:09
📄 issue50690b.out Hello, world.	14 B	2024-02-02 18:09
📄 issue50690c.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" ) type Printer[T ~string] struct { PrintFn func(T) } func Print[T ~string](s T) { fmt.Println(s) } func PrintWithPrinter[T ~string, S interface { ~struct { ID T PrintFn_ func(T) } PrintFn() func(T) }](message T, obj S) { obj.PrintFn()(message) } func main() { PrintWithPrinter( "Hello, world.", StructWithPrinter{ID: "fake", PrintFn_: Print[string]}, ) } type StructWithPrinter struct { ID string PrintFn_ func(string) } // Field accesses through type parameters are disabled // until we have a more thorough understanding of the // implications on the spec. See issue #51576. // Use accessor method instead. func (s StructWithPrinter) PrintFn() func(string) { return s.PrintFn_ }	917 B	2024-02-02 18:09
📄 issue50690c.out Hello, world.	14 B	2024-02-02 18:09
📄 issue50833.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type ( S struct{ f int } PS S ) func a() []S { return []S{{f: 1}} } func b() []PS { return []PS{{f: 1}} } func c[P S]() []P { return []P{{f: 1}} } func d[P PS]() []P { return []P{{f: 1}} } func main() { c[*S]() d[PS]() }	415 B	2024-02-02 18:09
📁 issue50841.dir	-	2024-02-02 18:09
📄 issue50841.go // compiledir // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📄 issue50993.go // compile -d=checkptr // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "sync/atomic" "unsafe" ) type Node[T any] struct { Next Node[T] // Prev Node[T] } func LoadPointer[T any](addr *T) (val T) { return (T)( atomic.LoadPointer( (unsafe.Pointer)(unsafe.Pointer(addr)), )) } func (q Node[T]) Pop() { var tail, head Node[T] if head == LoadPointer(&tail) { } } func main() { ch := Node[uint64]{} ch.Pop() }	569 B	2024-02-02 18:09
📁 issue51219.dir	-	2024-02-02 18:09
📄 issue51219.go // rundir // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 issue51219.out {}	3 B	2024-02-02 18:09
📁 issue51219b.dir	-	2024-02-02 18:09
📄 issue51219b.go // compiledir // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📄 issue51232.go // errorcheck // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p type RC[RG any] interface { ~[]RG } type Fn[RCT RC[RG], RG any] func(RCT) type F[RCT RC[RG], RG any] interface { Fn() Fn[RCT] // ERROR "not enough type arguments for type Fn: have 1, want 2" } type concreteF[RCT RC[RG], RG any] struct { makeFn func() Fn[RCT] // ERROR "not enough type arguments for type Fn: have 1, want 2" } func (c *concreteF[RCT, RG]) Fn() Fn[RCT] { // ERROR "not enough type arguments for type Fn: have 1, want 2" return c.makeFn() } func NewConcrete[RCT RC[RG], RG any](Rc RCT) F[RCT] { // ERROR "not enough type arguments for type F: have 1, want 2" return &concreteF[RCT]{ // ERROR "cannot use" "not enough type arguments for type concreteF: have 1, want 2" makeFn: nil, } }	898 B	2024-02-02 18:09
📄 issue51233.go // errorcheck // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p // As of issue #51527, type-type inference has been disabled. type RC[RG any] interface { ~[]RG } type Fn[RCT RC[RG], RG any] func(RCT) type FFn[RCT RC[RG], RG any] func() Fn[RCT] // ERROR "not enough type arguments for type Fn: have 1, want 2" type F[RCT RC[RG], RG any] interface { Fn() Fn[RCT] // ERROR "not enough type arguments for type Fn: have 1, want 2" } type concreteF[RCT RC[RG], RG any] struct { makeFn FFn[RCT] // ERROR "not enough type arguments for type FFn: have 1, want 2" } func (c *concreteF[RCT, RG]) Fn() Fn[RCT] { // ERROR "not enough type arguments for type Fn: have 1, want 2" return c.makeFn() }	816 B	2024-02-02 18:09
📄 issue51236.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type I interface { []byte } func F[T I]() { var t T explodes(t) } func explodes(b []byte) {} func main() { }	298 B	2024-02-02 18:09
📄 issue51245.go // build // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type T[P any] int const C T[int] = 3 type T2 int const C2 T2 = 9 func main() { }	267 B	2024-02-02 18:09
📁 issue51250a.dir	-	2024-02-02 18:09
📄 issue51250a.go // rundir // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 issue51303.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" ) func main() { x := [][]int{{1}} y := [][]int{{2, 3}} IntersectSS(x, y) } type list[E any] interface { ~[]E Equal(x, y E) bool } // ss is a set of sets type ss[E comparable, T []E] []T func (ss[E, T]) Equal(a, b T) bool { return SetEq(a, b) } func IntersectSS[E comparable](x, y [][]E) [][]E { return IntersectT[[]E, ss[E, []E]](ss[E, []E](x), ss[E, []E](y)) } func IntersectT[E any, L list[E]](x, y L) L { var z L outer: for _, xe := range x { fmt.Println("xe", xe) for _, ye := range y { fmt.Println("ye", ye) fmt.Println("x", x) if x.Equal(xe, ye) { fmt.Println("appending") z = append(z, xe) continue outer } } } return z } func SetEq[S []E, E comparable](x, y S) bool { fmt.Println("SetEq", x, y) outer: for _, xe := range x { for _, ye := range y { if xe == ye { continue outer } } return false // xs wasn't found in y } return true }	1.08 KB	2024-02-02 18:09
📄 issue51303.out xe [1] ye [2 3] x [[1]] SetEq [1] [2 3]	40 B	2024-02-02 18:09
📄 issue51355.go // compile // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Cache[E comparable] struct { adder func(...E) } func New[E comparable]() *Cache[E] { c := &Cache[E]{} c.adder = func(elements ...E) { for _, value := range elements { value := value go func() { println(value) }() } } return c } func main() { c := New[string]() c.adder("test") }	498 B	2024-02-02 18:09
📁 issue51367.dir	-	2024-02-02 18:09
📄 issue51367.go // rundir // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📁 issue51423.dir	-	2024-02-02 18:09
📄 issue51423.go // compiledir // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📄 issue51521.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" "strings" ) type I interface{ M() } func F[P I](p P) { defer catch(); p.M() } func G[T any]() { defer catch(); interface{ M() T }.M(nil) } func main() { F[I](nil) G[int]() } func catch() { err := recover() if err, ok := err.(error); ok && strings.Contains(err.Error(), "nil pointer dereference") { return } fmt.Println("FAIL", err) }	546 B	2024-02-02 18:09
📄 issue51522a.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func f[T comparable](i any) { var t T if i != t { println("FAIL: if i != t") } } type myint int func (m myint) foo() { } type fooer interface { foo() } type comparableFoo interface { comparable foo() } func g[T comparableFoo](i fooer) { var t T if i != t { println("FAIL: if i != t") } } func main() { f[int](int(0)) g[myint](myint(0)) }	543 B	2024-02-02 18:09
📄 issue51522b.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func f[T comparable](i any) { var t T switch i { case t: // ok default: println("FAIL: switch i") } switch t { case i: // ok default: println("FAIL: switch t") } } type myint int func (m myint) foo() { } type fooer interface { foo() } type comparableFoo interface { comparable foo() } func g[T comparableFoo](i fooer) { var t T switch i { case t: // ok default: println("FAIL: switch i") } switch t { case i: // ok default: println("FAIL: switch t") } } func main() { f[int](0) g[myint](myint(0)) }	730 B	2024-02-02 18:09
📄 issue51700.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func f[B any](b B) { if b1, ok := any(b).(interface{ m1() }); ok { panic(1) _ = b1.(B) } if b2, ok := any(b).(interface{ m2() }); ok { panic(2) _ = b2.(B) } } type S struct{} func (S) m3() {} func main() { f(S{}) }	413 B	2024-02-02 18:09
📄 issue51765.go // compile // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p type empty[T any] struct{} func (this *empty[T]) Next() (empty T, _ error) { return empty, nil } var _ = &empty[string]{}	308 B	2024-02-02 18:09
📄 issue51832.go // compile // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type F func() F func do[T any]() F { return nil } type G[T any] func() G[T] //go:noinline func dog[T any]() G[T] { return nil } func main() { do[int]() dog[int]() }	359 B	2024-02-02 18:09
📁 issue51836.dir	-	2024-02-02 18:09
📄 issue51836.go // compiledir -s // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	194 B	2024-02-02 18:09
📄 issue51840.go // compile // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Addr struct { hi uint64 lo uint64 z *byte } func EqualMap[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool { for k, v1 := range m1 { if v2, ok := m2[k]; !ok \|\| v1 != v2 { return false } } return true } type Set[T comparable] map[T]struct{} func NewSet[T comparable](items ...T) Set[T] { return nil } func (s Set[T]) Equals(other Set[T]) bool { return EqualMap(s, other) } func main() { NewSet[Addr](Addr{0, 0, nil}) }	635 B	2024-02-02 18:09
📄 issue51909.go // compile // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type None struct{} type Response interface { send(ctx *struct{}) } type HandlerFunc[Input any] func(Input) Response func Operation[Input any](method, path string, h HandlerFunc[Input]) { var input Input h(input) } func Get[Body any](path string, h HandlerFunc[struct{ Body Body }]) { Operation("GET", path, h) } func main() { Get("/", func(req struct{ Body None }) Response { return nil }) }	591 B	2024-02-02 18:09
📄 issue51925.go // compile // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import "fmt" type IntLike interface { ~int \| ~int64 \| ~int32 \| ~int16 \| ~int8 } func Reduce[T any, U any, Uslice ~[]U](function func(T, U) T, sequence Uslice, initial T) T { result := initial for _, x := range sequence { result = function(result, x) } return result } func min[T IntLike](x, y T) T { if x < y { return x } return y } // Min returns the minimum element of `nums`. func Min[T IntLike, NumSlice ~[]T](nums NumSlice) T { if len(nums) == 0 { return T(0) } return Reduce(min[T], nums, nums[0]) } // VarMin is the variadic version of Min. func VarMin[T IntLike](nums ...T) T { return Min(nums) } type myInt int func main() { fmt.Println(VarMin(myInt(1), myInt(2))) seq := []myInt{1, 2} fmt.Println(Min(seq)) fmt.Println(VarMin(seq...)) }	963 B	2024-02-02 18:09
📄 issue52026.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func returnOption[T any](n int) Option[T] { if n == 1 { return Some[T]{} } else { return None{} } } type Option[T any] interface { sealedOption() } type Some[T any] struct { val T } func (s Some[T]) Value() T { return s.val } func (s Some[T]) sealedOption() {} type None struct{} func (s None) sealedOption() {} func main() { s := returnOption[int](1) _ = s.(Some[int]) s = returnOption[int](0) _ = s.(None) switch (any)(s).(type) { case Some[int]: panic("s is a Some[int]") case None: // ok default: panic("oops") } }	735 B	2024-02-02 18:09
📁 issue52117.dir	-	2024-02-02 18:09
📄 issue52117.go // compiledir // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📄 issue52124.go // compile // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p type Any any type IntOrBool interface{ int \| bool } type I interface{ Any \| IntOrBool } var ( X I = 42 Y I = "xxx" Z I = true ) type A interface{ *B \| int } type B interface{ A \| any }	374 B	2024-02-02 18:09
📄 issue52228.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type SomeInterface interface { Whatever() } func X[T any]() T { var m T // for this example, this block should never run if _, ok := any(m).(SomeInterface); ok { var dst SomeInterface _, _ = dst.(T) return dst.(T) } return m } type holder struct{} func main() { X[holder]() }	476 B	2024-02-02 18:09
📄 issue52241.go // compile // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Collector[T any] struct { } func (c *Collector[T]) Collect() { } func TestInOrderIntTree() { collector := Collector[int]{} _ = collector.Collect } func main() { TestInOrderIntTree() }	381 B	2024-02-02 18:09
📄 issue53087.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import "fmt" type I interface { M() } type S struct { str string } func (s S) M() {} var _ I = &S{} type CloningMap[K comparable, V any] struct { inner map[K]V } func (cm CloningMap[K, V]) With(key K, value V) CloningMap[K, V] { result := CloneBad(cm.inner) result[key] = value return CloningMap[K, V]{result} } func CloneBad[M ~map[K]V, K comparable, V any](m M) M { r := make(M, len(m)) for k, v := range m { r[k] = v } return r } func main() { s1 := &S{"one"} s2 := &S{"two"} m := CloningMap[string, I]{inner: make(map[string]I)} m = m.With("a", s1) m = m.With("b", s2) it, found := m.inner["a"] if !found { panic("a not found") } if _, ok := it.(S); !ok { panic(fmt.Sprintf("got %T want *main.S", it)) } }	930 B	2024-02-02 18:09
📄 issue53254.go // compile // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Interface[T any] interface { } func F[T any]() Interface[T] { var i int return i } func main() { F[int]() }	304 B	2024-02-02 18:09
📄 issue53390.go // compile // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p import "unsafe" func F[T any](v T) uintptr { return unsafe.Alignof(func() T { func(any) {}(struct{ _ T }{}) return v }()) } func f() { F(0) }	334 B	2024-02-02 18:09
📄 issue53406.go // compile // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func main() { f[int]() } func f[T1 any]() { var x Outer[T1, int] x.M() } type Outer[T1, T2 any] struct{ Inner[T2] } type Inner[_ any] int func (Inner[_]) M() {}	354 B	2024-02-02 18:09
📄 issue53419.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type T1 struct{} type T2 struct{} type Both struct { T1 T2 } func (T1) m() { panic("FAIL") } func (T2) m() { panic("FAIL") } func (Both) m() {} func f[T interface{ m() }](c T) { c.m() } func main() { var b Both b.m() f(b) }	419 B	2024-02-02 18:09
📄 issue53477.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test that generic interface-interface comparisons resulting from // value switch statements are handled correctly. package main func main() { f[X](0) } type Mer[T any] interface{ M(T) } type MNer[T any] interface { Mer[T] N() } type X int func (X) M(X) {} func (X) N() {} func f[T MNer[T]](t T) { switch Mer[T](t) { case MNer[T](t): // ok default: panic("FAIL") } }	555 B	2024-02-02 18:09
📄 issue53762.go // compile // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Value[T any] interface { } func use[T any](v Value[T]) { _, _ = v.(int) } func main() { use[int](Value[int](1)) }	309 B	2024-02-02 18:09
📄 issue54135.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type Foo struct{} func (Foo) Blanker() {} type Bar[T any] interface { Blanker() } type Baz interface { Some() } func check[T comparable](p Bar[T]) { if x, ok := p.(any); !ok \|\| x != p { panic("FAIL") } if _, ok := p.(Baz); ok { panic("FAIL") } } func main() { check[int](Foo{}) }	478 B	2024-02-02 18:09
📄 issue54225.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func main() { One[TextValue]() } func One[V Value]() { Two[Node[V]]() } func Two[V interface{ contentLen() int }]() { var v V v.contentLen() } type Value interface { Len() int } type Node[V Value] struct{} func (Node[V]) contentLen() int { var value V return value.Len() } type TextValue struct{} func (TextValue) Len() int { return 0 }	532 B	2024-02-02 18:09
📁 issue54302.dir	-	2024-02-02 18:09
📄 issue54302.go // rundir // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p	181 B	2024-02-02 18:09
📄 issue54456.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // The Go 1.18 frontend failed to disambiguate instantiations of // different, locally defined generic types with the same name. // // The unified frontend also exposed the scope-disambiguation mangling // to end users in reflect data. package main import ( "reflect" ) func one() any { type T[_ any] int; return T[int](0) } func two() any { type T[_ any] int; return T[int](0) } func main() { p, q := one(), two() // p and q have different dynamic types; this comparison should // evaluate false. if p == q { panic("bad type identity") } for _, x := range []any{p, q} { // The names here should not contain "·1" or "·2". if name := reflect.TypeOf(x).String(); name != "main.T[int]" { panic(name) } } }	898 B	2024-02-02 18:09
📄 issue54497.go // errorcheck -0 -m // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test that inlining works with generic functions. package testcase type C interface{ ~uint \| ~uint32 \| ~uint64 } func isAligned[T C](x, y T) bool { // ERROR "can inline isAligned\[uint\]" "can inline isAligned\[go\.shape\.uint\]" "inlining call to isAligned\[go\.shape\.uint\]" return x%y == 0 } func foo(x uint) bool { // ERROR "can inline foo" return isAligned(x, 64) // ERROR "inlining call to isAligned\[go\.shape\.uint\]" }	618 B	2024-02-02 18:09
📄 issue54535.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type node[T any] struct { items items[T] children items[node[T]] } func (n node[T]) f(i int, j int) bool { if len(n.children[i].items) < j { return false } return true } type items[T any] []T func main() { _ = node[int]{} _ = f[int] } type s[T, U any] struct { a T c U } func f[T any]() { var x s[struct{ b T }, struct{ d int }] _ = x.a.b _ = x.c.d }	559 B	2024-02-02 18:09
📄 issue54537.go // run // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func main() { _ = F[bool] var x string _ = G(x == "foo") } func F[T ~bool](x string) { var _ T = x == "foo" } func G[T any](t T) *T { return &t }	336 B	2024-02-02 18:09
📄 issue54765.go // errorcheck // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test that not-in-heap types cannot be used as type // arguments. (pointer-to-nih types are okay though.) //go:build cgo package p import ( "runtime/cgo" "sync/atomic" ) var _ atomic.Pointer[cgo.Incomplete] // ERROR "cannot use incomplete \(or unallocatable\) type as a type argument: runtime/cgo\.Incomplete" var _ atomic.Pointer[cgo.Incomplete] // ok func implicit(ptr cgo.Incomplete) { g(ptr) // ERROR "cannot use incomplete \(or unallocatable\) type as a type argument: runtime/cgo\.Incomplete" g(&ptr) // ok } func g[T any](_ *T) {}	729 B	2024-02-02 18:09
📄 issue55101.go // compile // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package p func F() Cache[error] { return nil } type Cache[T any] struct{ l List[entry[T]] } type entry[T any] struct{ value T } type List[T any] struct{ len int } func (c Cache[V]) Len() int { return c.l.Len() } func (l List[T]) Len() int { return l.len }	436 B	2024-02-02 18:09
📄 issue58513.go // run // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Some derived-type expressions require the compiler to synthesize // function literals to plumb sub-dictionaries appropriately. // However, when these expressions are inlined, we were constructing // the function literal bodies with the inline-adjusted positions // instead of the original (inline-free) positions, which could lead // to infinite loops when unwinding the stack. package main import "runtime" func assert[_ any]() { panic(0) } func Assert[To any]() func() { return assert[To] } type asserter[_ any] struct{} func (asserter[_]) assert() { panic(0) } func AssertMV[To any]() func() { return asserter[To]{}.assert } func AssertME[To any]() func(asserter[To]) { return asserter[To].assert } var me = AssertME[string]() var tests = []func(){ Assert[int](), AssertMV[int](), func() { me(asserter[string]{}) }, } func main() { for _, test := range tests { func() { defer func() { recover() // Check that we can unwind the stack without infinite looping. runtime.Caller(1000) }() test() }() } }	1.19 KB	2024-02-02 18:09
📄 list.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" ) type Ordered interface { ~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 } 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 } type OrderedNum interface { ~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 } const Clip = 5 // ClippedLargest returns the largest in the list of OrderNums, but a max of 5. // Test use of untyped constant in an expression with a generically-typed parameter 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 } func main() { i3 := &_List[int]{nil, 1} 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)) } 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)) } 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)) } 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)) } 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)) } 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)) } }	2.42 KB	2024-02-02 18:09
📄 list2.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Package list provides a doubly linked list of some element type // (generic form of the "container/list" package). package main import ( "fmt" "strconv" ) // Element is an element of a linked list. type _Element[T any] struct { // Next and previous pointers in the doubly-linked list of elements. // To simplify the implementation, internally a list l is implemented // as a ring, such that &l.root is both the next element of the last // list element (l.Back()) and the previous element of the first list // element (l.Front()). next, prev _Element[T] // The list to which this element belongs. list _List[T] // The value stored with this element. Value T } // Next returns the next list element or nil. func (e _Element[T]) Next() _Element[T] { if p := e.next; e.list != nil && p != &e.list.root { return p } return nil } // Prev returns the previous list element or nil. func (e _Element[T]) Prev() _Element[T] { if p := e.prev; e.list != nil && p != &e.list.root { return p } return nil } // _List represents a doubly linked list. // 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 } // Init initializes or clears list l. func (l _List[T]) Init() _List[T] { l.root.next = &l.root l.root.prev = &l.root l.len = 0 return l } // New returns an initialized list. func _New[T any]() _List[T] { return new(_List[T]).Init() } // Len returns the number of elements of list l. // The complexity is O(1). func (l _List[_]) Len() int { return l.len } // Front returns the first element of list l or nil if the list is empty. func (l _List[T]) Front() _Element[T] { if l.len == 0 { return nil } return l.root.next } // Back returns the last element of list l or nil if the list is empty. func (l _List[T]) Back() _Element[T] { if l.len == 0 { return nil } return l.root.prev } // lazyInit lazily initializes a zero _List value. func (l _List[_]) lazyInit() { if l.root.next == nil { l.Init() } } // insert inserts e after at, increments l.len, and returns e. func (l _List[T]) insert(e, at _Element[T]) _Element[T] { e.prev = at e.next = at.next e.prev.next = e e.next.prev = e e.list = l l.len++ return e } // insertValue is a convenience wrapper for insert(&_Element[T]{Value: v}, at). func (l _List[T]) insertValue(v T, at _Element[T]) _Element[T] { return l.insert(&_Element[T]{Value: v}, at) } // remove removes e from its list, decrements l.len, and returns e. func (l _List[T]) remove(e _Element[T]) _Element[T] { e.prev.next = e.next e.next.prev = e.prev e.next = nil // avoid memory leaks e.prev = nil // avoid memory leaks e.list = nil l.len-- return e } // move moves e to next to at and returns e. func (l _List[T]) move(e, at _Element[T]) _Element[T] { if e == at { return e } e.prev.next = e.next e.next.prev = e.prev e.prev = at e.next = at.next e.prev.next = e e.next.prev = e return e } // Remove removes e from l if e is an element of list l. // It returns the element value e.Value. // The element must not be nil. func (l _List[T]) Remove(e _Element[T]) T { if e.list == l { // if e.list == l, l must have been initialized when e was inserted // in l or l == nil (e is a zero _Element) and l.remove will crash l.remove(e) } return e.Value } // PushFront inserts a new element e with value v at the front of list l and returns e. func (l _List[T]) PushFront(v T) _Element[T] { l.lazyInit() return l.insertValue(v, &l.root) } // PushBack inserts a new element e with value v at the back of list l and returns e. func (l _List[T]) PushBack(v T) _Element[T] { l.lazyInit() return l.insertValue(v, l.root.prev) } // InsertBefore inserts a new element e with value v immediately before mark and returns e. // If mark is not an element of l, the list is not modified. // The mark must not be nil. func (l _List[T]) InsertBefore(v T, mark _Element[T]) _Element[T] { if mark.list != l { return nil } // see comment in _List.Remove about initialization of l return l.insertValue(v, mark.prev) } // InsertAfter inserts a new element e with value v immediately after mark and returns e. // If mark is not an element of l, the list is not modified. // The mark must not be nil. func (l _List[T]) InsertAfter(v T, mark _Element[T]) _Element[T] { if mark.list != l { return nil } // see comment in _List.Remove about initialization of l return l.insertValue(v, mark) } // MoveToFront moves element e to the front of list l. // If e is not an element of l, the list is not modified. // The element must not be nil. func (l _List[T]) MoveToFront(e _Element[T]) { if e.list != l \|\| l.root.next == e { return } // see comment in _List.Remove about initialization of l l.move(e, &l.root) } // MoveToBack moves element e to the back of list l. // If e is not an element of l, the list is not modified. // The element must not be nil. func (l _List[T]) MoveToBack(e _Element[T]) { if e.list != l \|\| l.root.prev == e { return } // see comment in _List.Remove about initialization of l l.move(e, l.root.prev) } // MoveBefore moves element e to its new position before mark. // If e or mark is not an element of l, or e == mark, the list is not modified. // The element and mark must not be nil. func (l _List[T]) MoveBefore(e, mark _Element[T]) { if e.list != l \|\| e == mark \|\| mark.list != l { return } l.move(e, mark.prev) } // MoveAfter moves element e to its new position after mark. // If e or mark is not an element of l, or e == mark, the list is not modified. // The element and mark must not be nil. func (l _List[T]) MoveAfter(e, mark _Element[T]) { if e.list != l \|\| e == mark \|\| mark.list != l { return } l.move(e, mark) } // PushBackList inserts a copy of an other list at the back of list l. // The lists l and other may be the same. They must not be nil. func (l _List[T]) PushBackList(other _List[T]) { l.lazyInit() for i, e := other.Len(), other.Front(); i > 0; i, e = i-1, e.Next() { l.insertValue(e.Value, l.root.prev) } } // PushFrontList inserts a copy of an other list at the front of list l. // The lists l and other may be the same. They must not be nil. func (l _List[T]) PushFrontList(other _List[T]) { l.lazyInit() for i, e := other.Len(), other.Back(); i > 0; i, e = i-1, e.Prev() { l.insertValue(e.Value, &l.root) } } // Transform runs a transform function on a list returning a new list. func _Transform[TElem1, TElem2 any](lst _List[TElem1], f func(TElem1) TElem2) _List[TElem2] { ret := _New[TElem2]() for p := lst.Front(); p != nil; p = p.Next() { ret.PushBack(f(p.Value)) } return ret } func checkListLen[T any](l _List[T], len int) bool { if n := l.Len(); n != len { panic(fmt.Sprintf("l.Len() = %d, want %d", n, len)) return false } return true } func checkListPointers[T any](l _List[T], es []_Element[T]) { root := &l.root if !checkListLen(l, len(es)) { return } // zero length lists must be the zero value or properly initialized (sentinel circle) if len(es) == 0 { if l.root.next != nil && l.root.next != root \|\| l.root.prev != nil && l.root.prev != root { panic(fmt.Sprintf("l.root.next = %p, l.root.prev = %p; both should both be nil or %p", l.root.next, l.root.prev, root)) } return } // len(es) > 0 // check internal and external prev/next connections for i, e := range es { prev := root Prev := (_Element[T])(nil) if i > 0 { prev = es[i-1] Prev = prev } if p := e.prev; p != prev { panic(fmt.Sprintf("elt[%d](%p).prev = %p, want %p", i, e, p, prev)) } if p := e.Prev(); p != Prev { panic(fmt.Sprintf("elt[%d](%p).Prev() = %p, want %p", i, e, p, Prev)) } next := root Next := (_Element[T])(nil) if i < len(es)-1 { next = es[i+1] Next = next } if n := e.next; n != next { panic(fmt.Sprintf("elt[%d](%p).next = %p, want %p", i, e, n, next)) } if n := e.Next(); n != Next { panic(fmt.Sprintf("elt[%d](%p).Next() = %p, want %p", i, e, n, Next)) } } } func TestList() { l := _New[string]() checkListPointers(l, [](_Element[string]){}) // Single element list e := l.PushFront("a") checkListPointers(l, [](_Element[string]){e}) l.MoveToFront(e) checkListPointers(l, [](_Element[string]){e}) l.MoveToBack(e) checkListPointers(l, [](_Element[string]){e}) l.Remove(e) checkListPointers(l, [](_Element[string]){}) // Bigger list l2 := _New[int]() e2 := l2.PushFront(2) e1 := l2.PushFront(1) e3 := l2.PushBack(3) e4 := l2.PushBack(600) checkListPointers(l2, [](_Element[int]){e1, e2, e3, e4}) l2.Remove(e2) checkListPointers(l2, [](_Element[int]){e1, e3, e4}) l2.MoveToFront(e3) // move from middle checkListPointers(l2, [](_Element[int]){e3, e1, e4}) l2.MoveToFront(e1) l2.MoveToBack(e3) // move from middle checkListPointers(l2, [](_Element[int]){e1, e4, e3}) l2.MoveToFront(e3) // move from back checkListPointers(l2, [](_Element[int]){e3, e1, e4}) l2.MoveToFront(e3) // should be no-op checkListPointers(l2, [](_Element[int]){e3, e1, e4}) l2.MoveToBack(e3) // move from front checkListPointers(l2, [](_Element[int]){e1, e4, e3}) l2.MoveToBack(e3) // should be no-op checkListPointers(l2, [](_Element[int]){e1, e4, e3}) e2 = l2.InsertBefore(2, e1) // insert before front checkListPointers(l2, [](_Element[int]){e2, e1, e4, e3}) l2.Remove(e2) e2 = l2.InsertBefore(2, e4) // insert before middle checkListPointers(l2, [](_Element[int]){e1, e2, e4, e3}) l2.Remove(e2) e2 = l2.InsertBefore(2, e3) // insert before back checkListPointers(l2, [](_Element[int]){e1, e4, e2, e3}) l2.Remove(e2) e2 = l2.InsertAfter(2, e1) // insert after front checkListPointers(l2, [](_Element[int]){e1, e2, e4, e3}) l2.Remove(e2) e2 = l2.InsertAfter(2, e4) // insert after middle checkListPointers(l2, [](_Element[int]){e1, e4, e2, e3}) l2.Remove(e2) e2 = l2.InsertAfter(2, e3) // insert after back checkListPointers(l2, [](_Element[int]){e1, e4, e3, e2}) l2.Remove(e2) // Check standard iteration. sum := 0 for e := l2.Front(); e != nil; e = e.Next() { sum += e.Value } if sum != 604 { panic(fmt.Sprintf("sum over l = %d, want 604", sum)) } // Clear all elements by iterating var next _Element[int] for e := l2.Front(); e != nil; e = next { next = e.Next() l2.Remove(e) } checkListPointers(l2, [](_Element[int]){}) } func checkList[T comparable](l _List[T], es []interface{}) { if !checkListLen(l, len(es)) { return } i := 0 for e := l.Front(); e != nil; e = e.Next() { le := e.Value // Comparison between a generically-typed variable le and an interface. if le != es[i] { panic(fmt.Sprintf("elt[%d].Value = %v, want %v", i, le, es[i])) } i++ } } func TestExtending() { l1 := _New[int]() l2 := _New[int]() l1.PushBack(1) l1.PushBack(2) l1.PushBack(3) l2.PushBack(4) l2.PushBack(5) l3 := _New[int]() l3.PushBackList(l1) checkList(l3, []interface{}{1, 2, 3}) l3.PushBackList(l2) checkList(l3, []interface{}{1, 2, 3, 4, 5}) l3 = _New[int]() l3.PushFrontList(l2) checkList(l3, []interface{}{4, 5}) l3.PushFrontList(l1) checkList(l3, []interface{}{1, 2, 3, 4, 5}) checkList(l1, []interface{}{1, 2, 3}) checkList(l2, []interface{}{4, 5}) l3 = _New[int]() l3.PushBackList(l1) checkList(l3, []interface{}{1, 2, 3}) l3.PushBackList(l3) checkList(l3, []interface{}{1, 2, 3, 1, 2, 3}) l3 = _New[int]() l3.PushFrontList(l1) checkList(l3, []interface{}{1, 2, 3}) l3.PushFrontList(l3) checkList(l3, []interface{}{1, 2, 3, 1, 2, 3}) l3 = _New[int]() l1.PushBackList(l3) checkList(l1, []interface{}{1, 2, 3}) l1.PushFrontList(l3) checkList(l1, []interface{}{1, 2, 3}) } func TestRemove() { l := _New[int]() e1 := l.PushBack(1) e2 := l.PushBack(2) checkListPointers(l, [](_Element[int]){e1, e2}) e := l.Front() l.Remove(e) checkListPointers(l, [](_Element[int]){e2}) l.Remove(e) checkListPointers(l, [](_Element[int]){e2}) } func TestIssue4103() { l1 := _New[int]() l1.PushBack(1) l1.PushBack(2) l2 := _New[int]() l2.PushBack(3) l2.PushBack(4) e := l1.Front() l2.Remove(e) // l2 should not change because e is not an element of l2 if n := l2.Len(); n != 2 { panic(fmt.Sprintf("l2.Len() = %d, want 2", n)) } l1.InsertBefore(8, e) if n := l1.Len(); n != 3 { panic(fmt.Sprintf("l1.Len() = %d, want 3", n)) } } func TestIssue6349() { l := _New[int]() l.PushBack(1) l.PushBack(2) e := l.Front() l.Remove(e) if e.Value != 1 { panic(fmt.Sprintf("e.value = %d, want 1", e.Value)) } if e.Next() != nil { panic(fmt.Sprintf("e.Next() != nil")) } if e.Prev() != nil { panic(fmt.Sprintf("e.Prev() != nil")) } } func TestMove() { l := _New[int]() e1 := l.PushBack(1) e2 := l.PushBack(2) e3 := l.PushBack(3) e4 := l.PushBack(4) l.MoveAfter(e3, e3) checkListPointers(l, [](_Element[int]){e1, e2, e3, e4}) l.MoveBefore(e2, e2) checkListPointers(l, [](_Element[int]){e1, e2, e3, e4}) l.MoveAfter(e3, e2) checkListPointers(l, [](_Element[int]){e1, e2, e3, e4}) l.MoveBefore(e2, e3) checkListPointers(l, [](_Element[int]){e1, e2, e3, e4}) l.MoveBefore(e2, e4) checkListPointers(l, [](_Element[int]){e1, e3, e2, e4}) e2, e3 = e3, e2 l.MoveBefore(e4, e1) checkListPointers(l, [](_Element[int]){e4, e1, e2, e3}) e1, e2, e3, e4 = e4, e1, e2, e3 l.MoveAfter(e4, e1) checkListPointers(l, [](_Element[int]){e1, e4, e2, e3}) e2, e3, e4 = e4, e2, e3 l.MoveAfter(e2, e3) checkListPointers(l, []*(_Element[int]){e1, e3, e2, e4}) e2, e3 = e3, e2 } // Test PushFront, PushBack, PushFrontList, PushBackList with uninitialized _List func TestZeroList() { var l1 = new(_List[int]) l1.PushFront(1) checkList(l1, []interface{}{1}) var l2 = new(_List[int]) l2.PushBack(1) checkList(l2, []interface{}{1}) var l3 = new(_List[int]) l3.PushFrontList(l1) checkList(l3, []interface{}{1}) var l4 = new(_List[int]) l4.PushBackList(l2) checkList(l4, []interface{}{1}) } // Test that a list l is not modified when calling InsertBefore with a mark that is not an element of l. func TestInsertBeforeUnknownMark() { var l _List[int] l.PushBack(1) l.PushBack(2) l.PushBack(3) l.InsertBefore(1, new(_Element[int])) checkList(&l, []interface{}{1, 2, 3}) } // Test that a list l is not modified when calling InsertAfter with a mark that is not an element of l. func TestInsertAfterUnknownMark() { var l _List[int] l.PushBack(1) l.PushBack(2) l.PushBack(3) l.InsertAfter(1, new(_Element[int])) checkList(&l, []interface{}{1, 2, 3}) } // Test that a list l is not modified when calling MoveAfter or MoveBefore with a mark that is not an element of l. func TestMoveUnknownMark() { var l1 _List[int] e1 := l1.PushBack(1) var l2 _List[int] e2 := l2.PushBack(2) l1.MoveAfter(e1, e2) checkList(&l1, []interface{}{1}) checkList(&l2, []interface{}{2}) l1.MoveBefore(e1, e2) checkList(&l1, []interface{}{1}) checkList(&l2, []interface{}{2}) } // Test the Transform function. func TestTransform() { l1 := _New[int]() l1.PushBack(1) l1.PushBack(2) l2 := _Transform(l1, strconv.Itoa) checkList(l2, []interface{}{"1", "2"}) } func main() { TestList() TestExtending() TestRemove() TestIssue4103() TestIssue6349() TestMove() TestZeroList() TestInsertBeforeUnknownMark() TestInsertAfterUnknownMark() TestTransform() }	15.26 KB	2024-02-02 18:09
📁 listimp.dir	-	2024-02-02 18:09
📄 listimp.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📁 listimp2.dir	-	2024-02-02 18:09
📄 listimp2.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 lockable.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import "sync" // 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 mu sync.Mutex } // Get returns the value stored in a Lockable. func (l Lockable[T]) get() T { l.mu.Lock() defer l.mu.Unlock() return l.x } // set sets the value in a Lockable. func (l Lockable[T]) set(v T) { l.mu.Lock() defer l.mu.Unlock() l.x = v } func main() { sl := Lockable[string]{x: "a"} if got := sl.get(); got != "a" { panic(got) } sl.set("b") if got := sl.get(); got != "b" { panic(got) } il := Lockable[int]{x: 1} if got := il.get(); got != 1 { panic(got) } il.set(2) if got := il.get(); got != 2 { panic(got) } }	916 B	2024-02-02 18:09
📄 map.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" "reflect" "strconv" ) // 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 } func main() { got := mapper([]int{1, 2, 3}, strconv.Itoa) want := []string{"1", "2", "3"} if !reflect.DeepEqual(got, want) { panic(fmt.Sprintf("got %s, want %s", got, want)) } fgot := mapper([]float64{2.5, 2.3, 3.5}, func(f float64) string { return strconv.FormatFloat(f, 'f', -1, 64) }) fwant := []string{"2.5", "2.3", "3.5"} if !reflect.DeepEqual(fgot, fwant) { panic(fmt.Sprintf("got %s, want %s", fgot, fwant)) } }	885 B	2024-02-02 18:09
📁 mapimp.dir	-	2024-02-02 18:09
📄 mapimp.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 maps.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" "math" "sort" ) // _Equal reports whether two slices are equal: the same length and all // elements equal. All floating point NaNs are considered equal. func _SliceEqual[Elem comparable](s1, s2 []Elem) bool { if len(s1) != len(s2) { return false } for i, v1 := range s1 { v2 := s2[i] if v1 != v2 { isNaN := func(f Elem) bool { return f != f } if !isNaN(v1) \|\| !isNaN(v2) { return false } } } return true } // _Keys returns the keys of the map m. // The keys will be an indeterminate order. func _Keys[K comparable, V any](m map[K]V) []K { r := make([]K, 0, len(m)) for k := range m { r = append(r, k) } return r } // _Values returns the values of the map m. // The values will be in an indeterminate order. func _Values[K comparable, V any](m map[K]V) []V { r := make([]V, 0, len(m)) for _, v := range m { r = append(r, v) } return r } // _Equal reports whether two maps contain the same key/value pairs. // _Values are compared using ==. func _Equal[K, V comparable](m1, m2 map[K]V) bool { if len(m1) != len(m2) { return false } for k, v1 := range m1 { if v2, ok := m2[k]; !ok \|\| v1 != v2 { return false } } return true } // _Copy returns a copy of m. func _Copy[K comparable, V any](m map[K]V) map[K]V { r := make(map[K]V, len(m)) for k, v := range m { r[k] = v } return r } // _Add adds all key/value pairs in m2 to m1. _Keys in m2 that are already // present in m1 will be overwritten with the value in m2. func _Add[K comparable, V any](m1, m2 map[K]V) { for k, v := range m2 { m1[k] = v } } // _Sub removes all keys in m2 from m1. _Keys in m2 that are not present // in m1 are ignored. The values in m2 are ignored. func _Sub[K comparable, V any](m1, m2 map[K]V) { for k := range m2 { delete(m1, k) } } // _Intersect removes all keys from m1 that are not present in m2. // _Keys in m2 that are not in m1 are ignored. The values in m2 are ignored. func _Intersect[K comparable, V any](m1, m2 map[K]V) { for k := range m1 { if _, ok := m2[k]; !ok { delete(m1, k) } } } // _Filter deletes any key/value pairs from m for which f returns false. func _Filter[K comparable, V any](m map[K]V, f func(K, V) bool) { for k, v := range m { if !f(k, v) { delete(m, k) } } } // _TransformValues applies f to each value in m. The keys remain unchanged. func _TransformValues[K comparable, V any](m map[K]V, f func(V) V) { for k, v := range m { m[k] = f(v) } } var m1 = map[int]int{1: 2, 2: 4, 4: 8, 8: 16} var m2 = map[int]string{1: "2", 2: "4", 4: "8", 8: "16"} func TestKeys() { want := []int{1, 2, 4, 8} got1 := _Keys(m1) sort.Ints(got1) if !_SliceEqual(got1, want) { panic(fmt.Sprintf("_Keys(%v) = %v, want %v", m1, got1, want)) } got2 := _Keys(m2) sort.Ints(got2) if !_SliceEqual(got2, want) { panic(fmt.Sprintf("_Keys(%v) = %v, want %v", m2, got2, want)) } } func TestValues() { got1 := _Values(m1) want1 := []int{2, 4, 8, 16} sort.Ints(got1) if !_SliceEqual(got1, want1) { panic(fmt.Sprintf("_Values(%v) = %v, want %v", m1, got1, want1)) } got2 := _Values(m2) want2 := []string{"16", "2", "4", "8"} sort.Strings(got2) if !_SliceEqual(got2, want2) { panic(fmt.Sprintf("_Values(%v) = %v, want %v", m2, got2, want2)) } } func TestEqual() { if !_Equal(m1, m1) { panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", m1, m1)) } if _Equal(m1, nil) { panic(fmt.Sprintf("_Equal(%v, nil) = true, want false", m1)) } if _Equal(nil, m1) { panic(fmt.Sprintf("_Equal(nil, %v) = true, want false", m1)) } if !_Equal[int, int](nil, nil) { panic("_Equal(nil, nil) = false, want true") } if ms := map[int]int{1: 2}; _Equal(m1, ms) { panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", m1, ms)) } // Comparing NaN for equality is expected to fail. mf := map[int]float64{1: 0, 2: math.NaN()} if _Equal(mf, mf) { panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", mf, mf)) } } func TestCopy() { m2 := _Copy(m1) if !_Equal(m1, m2) { panic(fmt.Sprintf("_Copy(%v) = %v, want %v", m1, m2, m1)) } m2[16] = 32 if _Equal(m1, m2) { panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", m1, m2)) } } func TestAdd() { mc := _Copy(m1) _Add(mc, mc) if !_Equal(mc, m1) { panic(fmt.Sprintf("_Add(%v, %v) = %v, want %v", m1, m1, mc, m1)) } _Add(mc, map[int]int{16: 32}) want := map[int]int{1: 2, 2: 4, 4: 8, 8: 16, 16: 32} if !_Equal(mc, want) { panic(fmt.Sprintf("_Add result = %v, want %v", mc, want)) } } func TestSub() { mc := _Copy(m1) _Sub(mc, mc) if len(mc) > 0 { panic(fmt.Sprintf("_Sub(%v, %v) = %v, want empty map", m1, m1, mc)) } mc = _Copy(m1) _Sub(mc, map[int]int{1: 0}) want := map[int]int{2: 4, 4: 8, 8: 16} if !_Equal(mc, want) { panic(fmt.Sprintf("_Sub result = %v, want %v", mc, want)) } } func TestIntersect() { mc := _Copy(m1) _Intersect(mc, mc) if !_Equal(mc, m1) { panic(fmt.Sprintf("_Intersect(%v, %v) = %v, want %v", m1, m1, mc, m1)) } _Intersect(mc, map[int]int{1: 0, 2: 0}) want := map[int]int{1: 2, 2: 4} if !_Equal(mc, want) { panic(fmt.Sprintf("_Intersect result = %v, want %v", mc, want)) } } func TestFilter() { mc := _Copy(m1) _Filter(mc, func(int, int) bool { return true }) if !_Equal(mc, m1) { panic(fmt.Sprintf("_Filter(%v, true) = %v, want %v", m1, mc, m1)) } _Filter(mc, func(k, v int) bool { return k < 3 }) want := map[int]int{1: 2, 2: 4} if !_Equal(mc, want) { panic(fmt.Sprintf("_Filter result = %v, want %v", mc, want)) } } func TestTransformValues() { mc := _Copy(m1) _TransformValues(mc, func(i int) int { return i / 2 }) want := map[int]int{1: 1, 2: 2, 4: 4, 8: 8} if !_Equal(mc, want) { panic(fmt.Sprintf("_TransformValues result = %v, want %v", mc, want)) } } func main() { TestKeys() TestValues() TestEqual() TestCopy() TestAdd() TestSub() TestIntersect() TestFilter() TestTransformValues() }	5.91 KB	2024-02-02 18:09
📁 mapsimp.dir	-	2024-02-02 18:09
📄 mapsimp.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📁 mdempsky	-	2024-02-02 18:09
📄 metrics.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Package metrics provides tracking arbitrary metrics composed of // values of comparable types. package main import ( "fmt" "sort" "sync" ) // _Metric1 tracks metrics of values of some type. type _Metric1[T comparable] struct { mu sync.Mutex m map[T]int } // Add adds another instance of some value. func (m _Metric1[T]) Add(v T) { m.mu.Lock() defer m.mu.Unlock() if m.m == nil { m.m = make(map[T]int) } m.m[v]++ } // Count returns the number of instances we've seen of v. func (m _Metric1[T]) Count(v T) int { m.mu.Lock() defer m.mu.Unlock() return m.m[v] } // Metrics returns all the values we've seen, in an indeterminate order. func (m _Metric1[T]) Metrics() []T { return _Keys(m.m) } type key2[T1, T2 comparable] struct { f1 T1 f2 T2 } // _Metric2 tracks metrics of pairs of values. type _Metric2[T1, T2 comparable] struct { mu sync.Mutex m map[key2[T1, T2]]int } // Add adds another instance of some pair of values. func (m _Metric2[T1, T2]) Add(v1 T1, v2 T2) { m.mu.Lock() defer m.mu.Unlock() if m.m == nil { m.m = make(map[key2[T1, T2]]int) } m.m[key2[T1, T2]{v1, v2}]++ } // Count returns the number of instances we've seen of v1/v2. func (m _Metric2[T1, T2]) Count(v1 T1, v2 T2) int { m.mu.Lock() defer m.mu.Unlock() return m.m[key2[T1, T2]{v1, v2}] } // Metrics returns all the values we've seen, in an indeterminate order. func (m _Metric2[T1, T2]) Metrics() (r1 []T1, r2 []T2) { for _, k := range _Keys(m.m) { r1 = append(r1, k.f1) r2 = append(r2, k.f2) } return r1, r2 } type key3[T1, T2, T3 comparable] struct { f1 T1 f2 T2 f3 T3 } // _Metric3 tracks metrics of triplets of values. type _Metric3[T1, T2, T3 comparable] struct { mu sync.Mutex m map[key3[T1, T2, T3]]int } // Add adds another instance of some triplet of values. func (m _Metric3[T1, T2, T3]) Add(v1 T1, v2 T2, v3 T3) { m.mu.Lock() defer m.mu.Unlock() if m.m == nil { m.m = make(map[key3[T1, T2, T3]]int) } m.m[key3[T1, T2, T3]{v1, v2, v3}]++ } // Count returns the number of instances we've seen of v1/v2/v3. func (m _Metric3[T1, T2, T3]) Count(v1 T1, v2 T2, v3 T3) int { m.mu.Lock() defer m.mu.Unlock() return m.m[key3[T1, T2, T3]{v1, v2, v3}] } // Metrics returns all the values we've seen, in an indeterminate order. func (m *_Metric3[T1, T2, T3]) Metrics() (r1 []T1, r2 []T2, r3 []T3) { for k := range m.m { r1 = append(r1, k.f1) r2 = append(r2, k.f2) r3 = append(r3, k.f3) } return r1, r2, r3 } type S struct{ a, b, c string } func TestMetrics() { m1 := _Metric1[string]{} if got := m1.Count("a"); got != 0 { panic(fmt.Sprintf("Count(%q) = %d, want 0", "a", got)) } m1.Add("a") m1.Add("a") if got := m1.Count("a"); got != 2 { panic(fmt.Sprintf("Count(%q) = %d, want 2", "a", got)) } if got, want := m1.Metrics(), []string{"a"}; !_SlicesEqual(got, want) { panic(fmt.Sprintf("Metrics = %v, want %v", got, want)) } m2 := _Metric2[int, float64]{} m2.Add(1, 1) m2.Add(2, 2) m2.Add(3, 3) m2.Add(3, 3) k1, k2 := m2.Metrics() sort.Ints(k1) w1 := []int{1, 2, 3} if !_SlicesEqual(k1, w1) { panic(fmt.Sprintf("_Metric2.Metrics first slice = %v, want %v", k1, w1)) } sort.Float64s(k2) w2 := []float64{1, 2, 3} if !_SlicesEqual(k2, w2) { panic(fmt.Sprintf("_Metric2.Metrics first slice = %v, want %v", k2, w2)) } m3 := _Metric3[string, S, S]{} m3.Add("a", S{"d", "e", "f"}, S{"g", "h", "i"}) m3.Add("a", S{"d", "e", "f"}, S{"g", "h", "i"}) m3.Add("a", S{"d", "e", "f"}, S{"g", "h", "i"}) m3.Add("b", S{"d", "e", "f"}, S{"g", "h", "i"}) if got := m3.Count("a", S{"d", "e", "f"}, S{"g", "h", "i"}); got != 3 { panic(fmt.Sprintf("Count(%v, %v, %v) = %d, want 3", "a", S{"d", "e", "f"}, S{"g", "h", "i"}, got)) } } func main() { TestMetrics() } // _Equal reports whether two slices are equal: the same length and all // elements equal. All floating point NaNs are considered equal. func _SlicesEqual[Elem comparable](s1, s2 []Elem) bool { if len(s1) != len(s2) { return false } for i, v1 := range s1 { v2 := s2[i] if v1 != v2 { isNaN := func(f Elem) bool { return f != f } if !isNaN(v1) \|\| !isNaN(v2) { return false } } } return true } // _Keys returns the keys of the map m. // The keys will be an indeterminate order. func _Keys[K comparable, V any](m map[K]V) []K { r := make([]K, 0, len(m)) for k := range m { r = append(r, k) } return r }	4.45 KB	2024-02-02 18:09
📄 min.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" ) type Ordered interface { ~int \| ~int64 \| ~float64 \| ~string } func min[T Ordered](x, y T) T { if x < y { return x } return y } func main() { const want = 2 if got := min[int](2, 3); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } if got := min(2, 3); got != want { panic(fmt.Sprintf("want %d, got %d", want, got)) } if got := min[float64](3.5, 2.0); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } if got := min(3.5, 2.0); got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } const want2 = "ay" if got := min[string]("bb", "ay"); got != want2 { panic(fmt.Sprintf("got %d, want %d", got, want2)) } if got := min("bb", "ay"); got != want2 { panic(fmt.Sprintf("got %d, want %d", got, want2)) } }	979 B	2024-02-02 18:09
📁 mincheck.dir	-	2024-02-02 18:09
📄 mincheck.go // errorcheckdir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	194 B	2024-02-02 18:09
📁 minimp.dir	-	2024-02-02 18:09
📄 minimp.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📁 mutualimp.dir	-	2024-02-02 18:09
📄 mutualimp.go // compiledir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	191 B	2024-02-02 18:09
📄 nested.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // This test case stress tests a number of subtle cases involving // nested type-parameterized declarations. At a high-level, it // declares a generic function that contains a generic type // declaration: // // func F[A intish]() { // type T[B intish] struct{} // // // store reflect.Type tuple (A, B, F[A].T[B]) in tests // } // // It then instantiates this function with a variety of type arguments // for A and B. Particularly tricky things like shadowed types. // // From this data it tests two things: // // 1. Given tuples (A, B, F[A].T[B]) and (A', B', F[A'].T[B']), // F[A].T[B] should be identical to F[A'].T[B'] iff (A, B) is // identical to (A', B'). // // 2. A few of the instantiations are constructed to be identical, and // it tests that exactly these pairs are duplicated (by golden // output comparison to nested.out). // // In both cases, we're effectively using the compiler's existing // runtime.Type handling (which is well tested) of type identity of A // and B as a way to help bootstrap testing and validate its new // runtime.Type handling of F[A].T[B]. // // This isn't perfect, but it smoked out a handful of issues in // gotypes2 and unified IR. package main import ( "fmt" "reflect" ) type test struct { TArgs [2]reflect.Type Instance reflect.Type } var tests []test type intish interface{ ~int } type Int int type GlobalInt = Int // allow access to global Int, even when shadowed func F[A intish]() { add := func(B, T interface{}) { tests = append(tests, test{ TArgs: [2]reflect.Type{ reflect.TypeOf(A(0)), reflect.TypeOf(B), }, Instance: reflect.TypeOf(T), }) } type Int int type T[B intish] struct{} add(int(0), T[int]{}) add(Int(0), T[Int]{}) add(GlobalInt(0), T[GlobalInt]{}) add(A(0), T[A]{}) // NOTE: intentionally dups with int and GlobalInt type U[_ any] int type V U[int] type W V add(U[int](0), T[U[int]]{}) add(U[Int](0), T[U[Int]]{}) add(U[GlobalInt](0), T[U[GlobalInt]]{}) add(U[A](0), T[U[A]]{}) // NOTE: intentionally dups with U[int] and U[GlobalInt] add(V(0), T[V]{}) add(W(0), T[W]{}) } func main() { type Int int F[int]() F[Int]() F[GlobalInt]() type U[_ any] int type V U[int] type W V F[U[int]]() F[U[Int]]() F[U[GlobalInt]]() F[V]() F[W]() type X[A any] U[X[A]] F[X[int]]() F[X[Int]]() F[X[GlobalInt]]() for j, tj := range tests { for i, ti := range tests[:j+1] { if (ti.TArgs == tj.TArgs) != (ti.Instance == tj.Instance) { fmt.Printf("FAIL: %d,%d: %s, but %s\n", i, j, eq(ti.TArgs, tj.TArgs), eq(ti.Instance, tj.Instance)) } // The test is constructed so we should see a few identical types. // See "NOTE" comments above. if i != j && ti.Instance == tj.Instance { fmt.Printf("%d,%d: %v\n", i, j, ti.Instance) } } } } func eq(a, b interface{}) string { op := "==" if a != b { op = "!=" } return fmt.Sprintf("%v %s %v", a, op, b) }	3.01 KB	2024-02-02 18:09
📄 nested.out 0,3: main.T[int;int] 4,7: main.T[int;main.U[int;int]·3] 22,23: main.T[main.Int;main.Int] 26,27: main.T[main.Int;main.U[main.Int;main.Int]·3]	143 B	2024-02-02 18:09
📄 ordered.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" "math" "sort" ) type Ordered interface { ~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]) Less(i, j int) bool { if s[i] < s[j] { return true } isNaN := func(f Elem) bool { return f != f } if isNaN(s[i]) && !isNaN(s[j]) { return true } return false } 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)) } var ints = []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586} var float64s = []float64{74.3, 59.0, math.Inf(1), 238.2, -784.0, 2.3, math.NaN(), math.NaN(), math.Inf(-1), 9845.768, -959.7485, 905, 7.8, 7.8} var strings = []string{"", "Hello", "foo", "bar", "foo", "f00", "%&^&^&", "***"} func TestSortOrderedInts() bool { return testOrdered("ints", ints, sort.Ints) } func TestSortOrderedFloat64s() bool { return testOrdered("float64s", float64s, sort.Float64s) } func TestSortOrderedStrings() bool { return testOrdered("strings", strings, sort.Strings) } func testOrdered[Elem Ordered](name string, s []Elem, sorter func([]Elem)) bool { s1 := make([]Elem, len(s)) copy(s1, s) s2 := make([]Elem, len(s)) copy(s2, s) _OrderedSlice(s1) sorter(s2) ok := true if !sliceEq(s1, s2) { fmt.Printf("%s: got %v, want %v", name, s1, s2) ok = false } 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]) ok = false } } return ok } func sliceEq[Elem Ordered](s1, s2 []Elem) bool { for i, v1 := range s1 { v2 := s2[i] if v1 != v2 { isNaN := func(f Elem) bool { return f != f } if !isNaN(v1) \|\| !isNaN(v2) { return false } } } return true } func main() { if !TestSortOrderedInts() \|\| !TestSortOrderedFloat64s() \|\| !TestSortOrderedStrings() { panic("failure") } }	2.19 KB	2024-02-02 18:09
📄 orderedmap.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Package orderedmap provides an ordered map, implemented as a binary tree. package main import ( "bytes" "context" "fmt" "runtime" ) type Ordered interface { ~int \| ~int8 \| ~int16 \| ~int32 \| ~int64 \| ~uint \| ~uint8 \| ~uint16 \| ~uint32 \| ~uint64 \| ~uintptr \| ~float32 \| ~float64 \| ~string } // _Map is an ordered map. type _Map[K, V any] struct { root node[K, V] compare func(K, K) int } // node is the type of a node in the binary tree. type node[K, V any] struct { key K val V left, right node[K, V] } // _New returns a new map. It takes a comparison function that compares two // keys and returns < 0 if the first is less, == 0 if they are equal, // > 0 if the first is greater. func _New[K, V any](compare func(K, K) int) _Map[K, V] { return &_Map[K, V]{compare: compare} } // _NewOrdered returns a new map whose key is an ordered type. // This is like _New, but does not require providing a compare function. // The map compare function uses the obvious key ordering. func _NewOrdered[K Ordered, V any]() _Map[K, V] { return _New[K, V](func(k1, k2 K) int { switch { case k1 < k2: return -1 case k1 == k2: return 0 default: return 1 } }) } // find looks up key in the map, returning either a pointer to the slot of the // node holding key, or a pointer to the slot where should a node would go. func (m _Map[K, V]) find(key K) node[K, V] { pn := &m.root for pn != nil { switch cmp := m.compare(key, (pn).key); { case cmp < 0: pn = &(pn).left case cmp > 0: pn = &(pn).right default: return pn } } return pn } // Insert inserts a new key/value into the map. // If the key is already present, the value is replaced. // Reports whether this is a new key. func (m _Map[K, V]) Insert(key K, val V) bool { pn := m.find(key) if pn != nil { (pn).val = val return false } pn = &node[K, V]{key: key, val: val} return true } // Find returns the value associated with a key, or the zero value // if not present. The found result reports whether the key was found. func (m _Map[K, V]) Find(key K) (V, bool) { pn := m.find(key) if pn == nil { var zero V return zero, false } return (pn).val, true } // keyValue is a pair of key and value used while iterating. type keyValue[K, V any] struct { key K val V } // iterate returns an iterator that traverses the map. func (m _Map[K, V]) Iterate() _Iterator[K, V] { sender, receiver := _Ranger[keyValue[K, V]]() var f func(node[K, V]) bool f = func(n node[K, V]) bool { if n == nil { return true } // Stop the traversal if Send fails, which means that // nothing is listening to the receiver. return f(n.left) && sender.Send(context.Background(), keyValue[K, V]{n.key, n.val}) && f(n.right) } go func() { f(m.root) sender.Close() }() return &_Iterator[K, V]{receiver} } // _Iterator is used to iterate over the map. type _Iterator[K, V any] struct { r _Receiver[keyValue[K, V]] } // Next returns the next key and value pair, and a boolean that reports // whether they are valid. If not valid, we have reached the end of the map. func (it _Iterator[K, V]) Next() (K, V, bool) { keyval, ok := it.r.Next(context.Background()) if !ok { var zerok K var zerov V return zerok, zerov, false } return keyval.key, keyval.val, true } func TestMap() { m := _New[[]byte, int](bytes.Compare) if _, found := m.Find([]byte("a")); found { panic(fmt.Sprintf("unexpectedly found %q in empty map", []byte("a"))) } if !m.Insert([]byte("a"), 'a') { panic(fmt.Sprintf("key %q unexpectedly already present", []byte("a"))) } if !m.Insert([]byte("c"), 'c') { panic(fmt.Sprintf("key %q unexpectedly already present", []byte("c"))) } if !m.Insert([]byte("b"), 'b') { panic(fmt.Sprintf("key %q unexpectedly already present", []byte("b"))) } if m.Insert([]byte("c"), 'x') { panic(fmt.Sprintf("key %q unexpectedly not present", []byte("c"))) } if v, found := m.Find([]byte("a")); !found { panic(fmt.Sprintf("did not find %q", []byte("a"))) } else if v != 'a' { panic(fmt.Sprintf("key %q returned wrong value %c, expected %c", []byte("a"), v, 'a')) } if v, found := m.Find([]byte("c")); !found { panic(fmt.Sprintf("did not find %q", []byte("c"))) } else if v != 'x' { panic(fmt.Sprintf("key %q returned wrong value %c, expected %c", []byte("c"), v, 'x')) } if _, found := m.Find([]byte("d")); found { panic(fmt.Sprintf("unexpectedly found %q", []byte("d"))) } gather := func(it _Iterator[[]byte, int]) []int { var r []int for { _, v, ok := it.Next() if !ok { return r } r = append(r, v) } } got := gather(m.Iterate()) want := []int{'a', 'b', 'x'} if !_SliceEqual(got, want) { panic(fmt.Sprintf("Iterate returned %v, want %v", got, want)) } } func main() { TestMap() } // _Equal reports whether two slices are equal: the same length and all // elements equal. All floating point NaNs are considered equal. func _SliceEqual[Elem comparable](s1, s2 []Elem) bool { if len(s1) != len(s2) { return false } for i, v1 := range s1 { v2 := s2[i] if v1 != v2 { isNaN := func(f Elem) bool { return f != f } if !isNaN(v1) \|\| !isNaN(v2) { return false } } } return true } // Ranger returns a Sender and a Receiver. The Receiver provides a // Next method to retrieve values. The Sender provides a Send method // to send values and a Close method to stop sending values. The Next // method indicates when the Sender has been closed, and the Send // method indicates when the Receiver has been freed. // // This is a convenient way to exit a goroutine sending values when // the receiver stops reading them. func _Ranger[Elem any]() (_Sender[Elem], _Receiver[Elem]) { c := make(chan Elem) d := make(chan struct{}) s := &_Sender[Elem]{ values: c, done: d, } r := &_Receiver[Elem]{ values: c, done: d, } runtime.SetFinalizer(r, (_Receiver[Elem]).finalize) return s, r } // A _Sender is used to send values to a Receiver. type _Sender[Elem any] struct { values chan<- Elem done <-chan struct{} } // Send sends a value to the receiver. It reports whether the value was sent. // The value will not be sent if the context is closed or the receiver // is freed. func (s _Sender[Elem]) Send(ctx context.Context, v Elem) bool { select { case <-ctx.Done(): return false case s.values <- v: return true case <-s.done: return false } } // Close tells the receiver that no more values will arrive. // After Close is called, the _Sender may no longer be used. func (s _Sender[Elem]) Close() { close(s.values) } // A _Receiver receives values from a _Sender. type _Receiver[Elem any] struct { values <-chan Elem done chan<- struct{} } // Next returns the next value from the channel. The bool result indicates // whether the value is valid. func (r _Receiver[Elem]) Next(ctx context.Context) (v Elem, ok bool) { select { case <-ctx.Done(): case v, ok = <-r.values: } return v, ok } // finalize is a finalizer for the receiver. func (r _Receiver[Elem]) finalize() { close(r.done) }	7.09 KB	2024-02-02 18:09
📁 orderedmapsimp.dir	-	2024-02-02 18:09
📄 orderedmapsimp.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 pair.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" "unsafe" ) type pair[F1, F2 any] struct { f1 F1 f2 F2 } func main() { p := pair[int32, int64]{1, 2} if got, want := unsafe.Sizeof(p.f1), uintptr(4); got != want { panic(fmt.Sprintf("unexpected f1 size == %d, want %d", got, want)) } if got, want := unsafe.Sizeof(p.f2), uintptr(8); got != want { panic(fmt.Sprintf("unexpected f2 size == %d, want %d", got, want)) } 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})) } }	739 B	2024-02-02 18:09
📁 pairimp.dir	-	2024-02-02 18:09
📄 pairimp.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 pragma.go // errorcheck -0 -m // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Make sure the go:noinline pragma makes it from a // generic function to any of its stenciled instances. package main //go:noinline func f[T any](x T) T { return x } func main() { // ERROR "can inline main" println(f(5)) }	411 B	2024-02-02 18:09
📁 recoverimp.dir	-	2024-02-02 18:09
📄 recoverimp.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 recoverimp.out panic: 5.3 panic: hello	24 B	2024-02-02 18:09
📁 select.dir	-	2024-02-02 18:09
📄 select.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 sets.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" "sort" ) // _Equal reports whether two slices are equal: the same length and all // elements equal. All floating point NaNs are considered equal. func _SliceEqual[Elem comparable](s1, s2 []Elem) bool { if len(s1) != len(s2) { return false } for i, v1 := range s1 { v2 := s2[i] if v1 != v2 { isNaN := func(f Elem) bool { return f != f } if !isNaN(v1) \|\| !isNaN(v2) { return false } } } return true } // A _Set is a set of elements of some type. type _Set[Elem comparable] struct { m map[Elem]struct{} } // _Make makes a new set. func _Make[Elem comparable]() _Set[Elem] { return _Set[Elem]{m: make(map[Elem]struct{})} } // Add adds an element to a set. func (s _Set[Elem]) Add(v Elem) { s.m[v] = struct{}{} } // Delete removes an element from a set. If the element is not present // in the set, this does nothing. func (s _Set[Elem]) Delete(v Elem) { delete(s.m, v) } // Contains reports whether v is in the set. func (s _Set[Elem]) Contains(v Elem) bool { _, ok := s.m[v] return ok } // Len returns the number of elements in the set. func (s _Set[Elem]) Len() int { return len(s.m) } // Values returns the values in the set. // The values will be in an indeterminate order. func (s _Set[Elem]) Values() []Elem { r := make([]Elem, 0, len(s.m)) for v := range s.m { r = append(r, v) } return r } // _Equal reports whether two sets contain the same elements. func _Equal[Elem comparable](s1, s2 _Set[Elem]) bool { if len(s1.m) != len(s2.m) { return false } for v1 := range s1.m { if !s2.Contains(v1) { return false } } return true } // Copy returns a copy of s. func (s _Set[Elem]) Copy() _Set[Elem] { r := _Set[Elem]{m: make(map[Elem]struct{}, len(s.m))} for v := range s.m { r.m[v] = struct{}{} } return r } // AddSet adds all the elements of s2 to s. func (s _Set[Elem]) AddSet(s2 _Set[Elem]) { for v := range s2.m { s.m[v] = struct{}{} } } // SubSet removes all elements in s2 from s. // Values in s2 that are not in s are ignored. func (s _Set[Elem]) SubSet(s2 _Set[Elem]) { for v := range s2.m { delete(s.m, v) } } // Intersect removes all elements from s that are not present in s2. // Values in s2 that are not in s are ignored. func (s _Set[Elem]) Intersect(s2 _Set[Elem]) { for v := range s.m { if !s2.Contains(v) { delete(s.m, v) } } } // Iterate calls f on every element in the set. func (s _Set[Elem]) Iterate(f func(Elem)) { for v := range s.m { f(v) } } // Filter deletes any elements from s for which f returns false. func (s _Set[Elem]) Filter(f func(Elem) bool) { for v := range s.m { if !f(v) { delete(s.m, v) } } } func TestSet() { s1 := _Make[int]() if got := s1.Len(); got != 0 { panic(fmt.Sprintf("Len of empty set = %d, want 0", got)) } s1.Add(1) s1.Add(1) s1.Add(1) if got := s1.Len(); got != 1 { panic(fmt.Sprintf("(%v).Len() == %d, want 1", s1, got)) } s1.Add(2) s1.Add(3) s1.Add(4) if got := s1.Len(); got != 4 { panic(fmt.Sprintf("(%v).Len() == %d, want 4", s1, got)) } if !s1.Contains(1) { panic(fmt.Sprintf("(%v).Contains(1) == false, want true", s1)) } if s1.Contains(5) { panic(fmt.Sprintf("(%v).Contains(5) == true, want false", s1)) } vals := s1.Values() sort.Ints(vals) w1 := []int{1, 2, 3, 4} if !_SliceEqual(vals, w1) { panic(fmt.Sprintf("(%v).Values() == %v, want %v", s1, vals, w1)) } } func TestEqual() { s1 := _Make[string]() s2 := _Make[string]() if !_Equal(s1, s2) { panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s1, s2)) } s1.Add("hello") s1.Add("world") if got := s1.Len(); got != 2 { panic(fmt.Sprintf("(%v).Len() == %d, want 2", s1, got)) } if _Equal(s1, s2) { panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", s1, s2)) } } func TestCopy() { s1 := _Make[float64]() s1.Add(0) s2 := s1.Copy() if !_Equal(s1, s2) { panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s1, s2)) } s1.Add(1) if _Equal(s1, s2) { panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", s1, s2)) } } func TestAddSet() { s1 := _Make[int]() s1.Add(1) s1.Add(2) s2 := _Make[int]() s2.Add(2) s2.Add(3) s1.AddSet(s2) if got := s1.Len(); got != 3 { panic(fmt.Sprintf("(%v).Len() == %d, want 3", s1, got)) } s2.Add(1) if !_Equal(s1, s2) { panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s1, s2)) } } func TestSubSet() { s1 := _Make[int]() s1.Add(1) s1.Add(2) s2 := _Make[int]() s2.Add(2) s2.Add(3) s1.SubSet(s2) if got := s1.Len(); got != 1 { panic(fmt.Sprintf("(%v).Len() == %d, want 1", s1, got)) } if vals, want := s1.Values(), []int{1}; !_SliceEqual(vals, want) { panic(fmt.Sprintf("after SubSet got %v, want %v", vals, want)) } } func TestIntersect() { s1 := _Make[int]() s1.Add(1) s1.Add(2) s2 := _Make[int]() s2.Add(2) s2.Add(3) s1.Intersect(s2) if got := s1.Len(); got != 1 { panic(fmt.Sprintf("(%v).Len() == %d, want 1", s1, got)) } if vals, want := s1.Values(), []int{2}; !_SliceEqual(vals, want) { panic(fmt.Sprintf("after Intersect got %v, want %v", vals, want)) } } func TestIterate() { s1 := _Make[int]() s1.Add(1) s1.Add(2) s1.Add(3) s1.Add(4) tot := 0 s1.Iterate(func(i int) { tot += i }) if tot != 10 { panic(fmt.Sprintf("total of %v == %d, want 10", s1, tot)) } } func TestFilter() { s1 := _Make[int]() s1.Add(1) s1.Add(2) s1.Add(3) s1.Filter(func(v int) bool { return v%2 == 0 }) if vals, want := s1.Values(), []int{2}; !_SliceEqual(vals, want) { panic(fmt.Sprintf("after Filter got %v, want %v", vals, want)) } } func main() { TestSet() TestEqual() TestCopy() TestAddSet() TestSubSet() TestIntersect() TestIterate() TestFilter() }	5.7 KB	2024-02-02 18:09
📁 setsimp.dir	-	2024-02-02 18:09
📄 setsimp.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 settable.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" "strconv" ) // Various implementations of fromStrings(). type Setter[B any] interface { Set(string) B } // Takes two type parameters where PT = T func fromStrings1[T any, PT Setter[T]](s []string) []T { result := make([]T, len(s)) for i, v := range s { // The type of &result[i] is T which is in the type list // of Setter, so we can convert it to PT. p := PT(&result[i]) // PT has a Set method. p.Set(v) } return result } func fromStrings1a[T any, PT Setter[T]](s []string) []PT { result := make([]PT, len(s)) for i, v := range s { // The type new(T) is T which is in the type list // of Setter, so we can convert it to PT. result[i] = PT(new(T)) p := result[i] // PT has a Set method. p.Set(v) } 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)) for i, v := range s { set(&results[i], v) } return results } type Setter2 interface { Set(string) } // Takes only one type parameter, but causes a panic (see below) func fromStrings3[T Setter2](s []string) []T { results := make([]T, len(s)) for i, v := range s { // Panics if T is a pointer type because receiver is T(nil). results[i].Set(v) } return results } // Two concrete types with the appropriate Set method. type SettableInt int func (p SettableInt) Set(s string) { i, err := strconv.Atoi(s) if err != nil { panic(err) } p = SettableInt(i) } type SettableString struct { s string } func (x SettableString) Set(s string) { x.s = s } func main() { s := fromStrings1[SettableInt, SettableInt]([]string{"1"}) if len(s) != 1 \|\| s[0] != 1 { panic(fmt.Sprintf("got %v, want %v", s, []int{1})) } s2 := fromStrings1a[SettableInt, SettableInt]([]string{"1"}) if len(s2) != 1 \|\| s2[0] != 1 { x := 1 panic(fmt.Sprintf("got %v, want %v", s2, []int{&x})) } // Test out constraint type inference, which should determine that the second // type param is SettableString. ps := fromStrings1[SettableString]([]string{"x", "y"}) if len(ps) != 2 \|\| ps[0] != (SettableString{"x"}) \|\| ps[1] != (SettableString{"y"}) { panic(s) } s = fromStrings2([]string{"1"}, func(p SettableInt, s string) { p.Set(s) }) if len(s) != 1 \|\| s[0] != 1 { panic(fmt.Sprintf("got %v, want %v", s, []int{1})) } defer func() { if recover() == nil { panic("did not panic as expected") } }() // This should type check but should panic at run time, // because it will make a slice of SettableInt and then call // Set on a nil value. fromStrings3[SettableInt]([]string{"1"}) }	2.75 KB	2024-02-02 18:09
📄 shape1.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type I interface { foo() int } // There should be one instantiation of f for both squarer and doubler. // Similarly, there should be one instantiation of f for both incrementer and decrementer. func f[T I](x T) int { return x.foo() } type squarer int func (x squarer) foo() int { return int(xx) } type doubler int func (x doubler) foo() int { return int(2x) } type incrementer int16 func (x incrementer) foo() int { return int(x+1) } type decrementer int32 func (x decrementer) foo() int{ return int(x-1) } func main() { println(f(squarer(5))) println(f(doubler(5))) var i incrementer = 5 println(f(&i)) var d decrementer = 5 println(f(&d)) }	855 B	2024-02-02 18:09
📄 shape1.out 25 10 6 4	10 B	2024-02-02 18:09
📁 sliceimp.dir	-	2024-02-02 18:09
📄 sliceimp.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 slices.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Package slices provides functions for basic operations on // slices of any element type. package main import ( "fmt" "math" "strings" ) type Ordered interface { ~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 } // 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 } // 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 } // _Equal reports whether two slices are equal: the same length and all // elements equal. All floating point NaNs are considered equal. func _Equal[Elem comparable](s1, s2 []Elem) bool { if len(s1) != len(s2) { return false } for i, v1 := range s1 { v2 := s2[i] if v1 != v2 { isNaN := func(f Elem) bool { return f != f } if !isNaN(v1) \|\| !isNaN(v2) { return false } } } return true } // _EqualFn reports whether two slices are equal using a comparison // function on each element. func _EqualFn[Elem any](s1, s2 []Elem, eq func(Elem, Elem) bool) bool { if len(s1) != len(s2) { return false } for i, v1 := range s1 { v2 := s2[i] if !eq(v1, v2) { return false } } return true } // _Map turns a []Elem1 to a []Elem2 using a mapping function. func _Map[Elem1, Elem2 any](s []Elem1, f func(Elem1) Elem2) []Elem2 { r := make([]Elem2, len(s)) for i, v := range s { r[i] = f(v) } return r } // _Reduce reduces a []Elem1 to a single value of type Elem2 using // a reduction function. func _Reduce[Elem1, Elem2 any](s []Elem1, initializer Elem2, f func(Elem2, Elem1) Elem2) Elem2 { r := initializer for _, v := range s { r = f(r, v) } return r } // _Filter filters values from a slice using a filter function. func _Filter[Elem any](s []Elem, f func(Elem) bool) []Elem { var r []Elem for _, v := range s { if f(v) { r = append(r, v) } } return r } // _Max returns the maximum element in a slice of some ordered type. // If the slice is empty it returns the zero value of the element type. func _SliceMax[Elem Ordered](s []Elem) Elem { if len(s) == 0 { var zero Elem return zero } return _Reduce(s[1:], s[0], _Max[Elem]) } // _Min returns the minimum element in a slice of some ordered type. // If the slice is empty it returns the zero value of the element type. func _SliceMin[Elem Ordered](s []Elem) Elem { if len(s) == 0 { var zero Elem return zero } return _Reduce(s[1:], s[0], _Min[Elem]) } // _Append adds values to the end of a slice, returning a new slice. // This is like the predeclared append function; it's an example // of how to write it using generics. We used to write code like // this before append was added to the language, but we had to write // a separate copy for each type. func _Append[T any](s []T, t ...T) []T { lens := len(s) tot := lens + len(t) if tot <= cap(s) { s = s[:tot] } else { news := make([]T, tot, tot+tot/2) _Copy(news, s) s = news } _Copy(s[lens:tot], t) return s } // _Copy copies values from t to s, stopping when either slice is full, // returning the number of values copied. This is like the predeclared // copy function; it's an example of how to write it using generics. func _Copy[T any](s, t []T) int { i := 0 for ; i < len(s) && i < len(t); i++ { s[i] = t[i] } return i } 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])) } } func offByOne[Elem Integer](a, b Elem) bool { return a == b+1 \|\| a == b-1 } func TestEqualFn() { s1 := []int{1, 2, 3} s2 := []int{2, 3, 4} if _EqualFn(s1, s1, offByOne[int]) { panic(fmt.Sprintf("_EqualFn(%v, %v, offByOne) = true, want false", s1, s1)) } if !_EqualFn(s1, s2, offByOne[int]) { panic(fmt.Sprintf("_EqualFn(%v, %v, offByOne) = false, want true", s1, s2)) } if !_EqualFn(s1[:0], nil, offByOne[int]) { panic(fmt.Sprintf("_EqualFn(%v, nil, offByOne) = false, want true", s1[:0])) } s3 := []string{"a", "b", "c"} s4 := []string{"A", "B", "C"} if !_EqualFn(s3, s4, strings.EqualFold) { panic(fmt.Sprintf("_EqualFn(%v, %v, strings.EqualFold) = false, want true", s3, s4)) } } func TestMap() { s1 := []int{1, 2, 3} s2 := _Map(s1, func(i int) float64 { return float64(i) * 2.5 }) if want := []float64{2.5, 5, 7.5}; !_Equal(s2, want) { panic(fmt.Sprintf("_Map(%v, ...) = %v, want %v", s1, s2, want)) } s3 := []string{"Hello", "World"} s4 := _Map(s3, strings.ToLower) if want := []string{"hello", "world"}; !_Equal(s4, want) { panic(fmt.Sprintf("_Map(%v, strings.ToLower) = %v, want %v", s3, s4, want)) } s5 := _Map(nil, func(i int) int { return i }) if len(s5) != 0 { panic(fmt.Sprintf("_Map(nil, identity) = %v, want empty slice", s5)) } } func TestReduce() { s1 := []int{1, 2, 3} 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 { panic(fmt.Sprintf("_Reduce(nil, 0, add) = %v, want 0", got)) } } func TestFilter() { s1 := []int{1, 2, 3} s2 := _Filter(s1, func(i int) bool { return i%2 == 0 }) if want := []int{2}; !_Equal(s2, want) { panic(fmt.Sprintf("_Filter(%v, even) = %v, want %v", s1, s2, want)) } if s3 := _Filter(s1[:0], func(i int) bool { return true }); len(s3) > 0 { panic(fmt.Sprintf("_Filter(%v, identity) = %v, want empty slice", s1[:0], s3)) } } func TestMax() { s1 := []int{1, 2, 3, -5} if got, want := _SliceMax(s1), 3; got != want { panic(fmt.Sprintf("_Max(%v) = %d, want %d", s1, got, want)) } s2 := []string{"aaa", "a", "aa", "aaaa"} if got, want := _SliceMax(s2), "aaaa"; got != want { panic(fmt.Sprintf("_Max(%v) = %q, want %q", s2, got, want)) } if got, want := _SliceMax(s2[:0]), ""; got != want { panic(fmt.Sprintf("_Max(%v) = %q, want %q", s2[:0], got, want)) } } func TestMin() { s1 := []int{1, 2, 3, -5} if got, want := _SliceMin(s1), -5; got != want { panic(fmt.Sprintf("_Min(%v) = %d, want %d", s1, got, want)) } s2 := []string{"aaa", "a", "aa", "aaaa"} if got, want := _SliceMin(s2), "a"; got != want { panic(fmt.Sprintf("_Min(%v) = %q, want %q", s2, got, want)) } if got, want := _SliceMin(s2[:0]), ""; got != want { panic(fmt.Sprintf("_Min(%v) = %q, want %q", s2[:0], got, want)) } } func TestAppend() { s := []int{1, 2, 3} s = _Append(s, 4, 5, 6) want := []int{1, 2, 3, 4, 5, 6} if !_Equal(s, want) { panic(fmt.Sprintf("after _Append got %v, want %v", s, want)) } } func TestCopy() { s1 := []int{1, 2, 3} s2 := []int{4, 5} if got := _Copy(s1, s2); got != 2 { panic(fmt.Sprintf("_Copy returned %d, want 2", got)) } want := []int{4, 5, 3} if !_Equal(s1, want) { panic(fmt.Sprintf("after _Copy got %v, want %v", s1, want)) } } func main() { TestEqual() TestEqualFn() TestMap() TestReduce() TestFilter() TestMax() TestMin() TestAppend() TestCopy() }	7.79 KB	2024-02-02 18:09
📄 smallest.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" ) type Ordered interface { ~int \| ~int8 \| ~int16 \| ~int32 \| ~int64 \| ~uint \| ~uint8 \| ~uint16 \| ~uint32 \| ~uint64 \| ~uintptr \| ~float32 \| ~float64 \| ~string } func Smallest[T Ordered](s []T) T { r := s[0] // panics if slice is empty for _, v := range s[1:] { if v < r { r = v } } return r } func main() { vec1 := []float64{5.3, 1.2, 32.8} vec2 := []string{"abc", "def", "aaa"} want1 := 1.2 if got := Smallest(vec1); got != want1 { panic(fmt.Sprintf("got %d, want %d", got, want1)) } want2 := "aaa" if got := Smallest(vec2); got != want2 { panic(fmt.Sprintf("got %d, want %d", got, want2)) } }	825 B	2024-02-02 18:09
📄 smoketest.go // compile // Copyright 2020 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // This file checks simple code using type parameters. package smoketest // type parameters for functions func f1[P any]() {} func f2[P1, P2 any, P3 any]() {} func f3[P interface{}](x P, y T1[int]) {} // function instantiations var _ = f1[int] var _ = f2[int, string, struct{}] var _ = f3[bool] // type parameters for types type T1[P any] struct{} type T2[P1, P2 any, P3 any] struct{} type T3[P interface{}] interface{} // type instantiations type _ T1[int] type _ T2[int, string, struct{}] type _ T3[bool] // methods func (T1[P]) m1() {} func (T1[_]) m2() {} func (x T2[P1, P2, P3]) m() {} // type lists type _ interface { m1() m2() int \| float32 \| string m3() } // embedded instantiated types type _ struct { f1, f2 int T1[int] T2[int, string, struct{}] T3[bool] } type _ interface { m1() m2() T3[bool] }	1019 B	2024-02-02 18:09
📄 stringable.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" "strconv" "strings" ) type Stringer interface { String() string } // StringableList is a slice of some type, where the type // must have a String method. type StringableList[T Stringer] []T func (s StringableList[T]) String() string { var sb strings.Builder for i, v := range s { if i > 0 { sb.WriteString(", ") } sb.WriteString(v.String()) } return sb.String() } type myint int func (a myint) String() string { return strconv.Itoa(int(a)) } func main() { 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)) } }	833 B	2024-02-02 18:09
📄 stringer.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test method calls on type parameters package main import ( "fmt" "reflect" "strconv" ) // Simple constraint type Stringer interface { String() string } func stringify[T Stringer](s []T) (ret []string) { for _, v := range s { ret = append(ret, v.String()) } return ret } type myint int func (i myint) String() string { return strconv.Itoa(int(i)) } // Constraint with an embedded interface, but still only requires String() type Stringer2 interface { CanBeStringer2() int SubStringer2 } type SubStringer2 interface { CanBeSubStringer2() int String() string } func stringify2[T Stringer2](s []T) (ret []string) { for _, v := range s { ret = append(ret, v.String()) } return ret } func (myint) CanBeStringer2() int { return 0 } func (myint) CanBeSubStringer2() int { return 0 } // Test use of method values that are not called func stringify3[T Stringer](s []T) (ret []string) { for _, v := range s { f := v.String ret = append(ret, f()) } return ret } func main() { 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 = stringify2(x) if !reflect.DeepEqual(got, want) { panic(fmt.Sprintf("got %s, want %s", got, want)) } got = stringify3(x) if !reflect.DeepEqual(got, want) { panic(fmt.Sprintf("got %s, want %s", got, want)) } }	1.55 KB	2024-02-02 18:09
📁 stringerimp.dir	-	2024-02-02 18:09
📄 stringerimp.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 struct.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" ) type E[T any] struct { v T } type S1 struct { E[int] v string } type Eint = E[int] type Ebool = E[bool] type S2 struct { Eint Ebool v string } type S3 struct { *E[int] } 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)) } 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)) } 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)) } }	783 B	2024-02-02 18:09
📁 structinit.dir	-	2024-02-02 18:09
📄 structinit.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 subdict.go // run // Copyright 2021 The Go Authors. All rights reserved. // 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 // we are calling a method on a fully-instantiated type or a fully-instantiated function. // (probably not common situations, of course) package main import ( "fmt" ) type C comparable type value[T C] struct { val T } func (v value[T]) test(def T) bool { return (v.val == def) } func (v value[T]) get(def T) T { var c value[int] if c.test(32) { return def } else if v.test(def) { return def } else { return v.val } } func main() { var s value[string] if got, want := s.get("ab"), ""; got != want { panic(fmt.Sprintf("get() == %d, want %d", got, want)) } }	842 B	2024-02-02 18:09
📄 sum.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "fmt" ) func Sum[T interface{ int \| float64 }](vec []T) T { var sum T for _, elt := range vec { sum = sum + elt } return sum } func Abs(f float64) float64 { if f < 0.0 { return -f } return f } func main() { vec1 := []int{3, 4} vec2 := []float64{5.8, 9.6} got := Sum[int](vec1) want := vec1[0] + vec1[1] if got != want { panic(fmt.Sprintf("got %d, want %d", got, want)) } got = Sum(vec1) if want != got { panic(fmt.Sprintf("got %d, want %d", got, want)) } fwant := vec2[0] + vec2[1] fgot := Sum[float64](vec2) if Abs(fgot-fwant) > 1e-10 { panic(fmt.Sprintf("got %f, want %f", fgot, fwant)) } fgot = Sum(vec2) if Abs(fgot-fwant) > 1e-10 { panic(fmt.Sprintf("got %f, want %f", fgot, fwant)) } }	923 B	2024-02-02 18:09
📄 tparam1.go // errorcheck // Copyright 2020 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Basic type parameter list type-checking (not syntax) errors. package tparam1 // The predeclared identifier "any" may be used in place of interface{}. var _ any func _(_ any) type _[_ any] 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{} ) func _[T any]() {} func _[T, T any]() {} // ERROR "T redeclared" func _[T1, T2 any](x T1) T2 { panic(0) } // Type parameters are visible from opening [ to end of function. type C interface{} func _[T interface{}]() {} func _[T C]() {} func _[T struct{}]() {} // ok if #48424 is accepted func _[T interface{ m() T }]() {} func _[T1 interface{ m() T2 }, T2 interface{ m() T1 }]() { var _ T1 } // TODO(gri) expand this	1.06 KB	2024-02-02 18:09
📄 typelist.go // compile // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // This file tests type lists & constraints with core types. // Note: This test has been adjusted to use the new // type set notation rather than type lists. package p // Assignability of an unnamed pointer type to a type parameter that // has a matching underlying type. func _[T interface{}, PT interface{ ~T }](x T) PT { return &x } // Indexing of generic types containing type parameters in their type list: func at[T interface{ ~[]E }, E any](x T, i int) E { 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{ ~int }](x T) { var _ int = int(x) var _ T = 42 var _ T = T(myint(42)) } // TODO: put this type declaration back inside the above function when issue 47631 is fixed. type myint int // Indexing a generic type which has a an array as core type. func _[T interface{ ~[10]int }](x T) { _ = x[9] // ok } // Dereference of a generic type which has a pointer as core type. func _[T interface{ ~int }](p T) int { return p } // Channel send and receive on a generic type which has a channel as core type. func _[T interface{ ~chan int }](ch T) int { // This would deadlock if executed (but ok for a compile test) ch <- 0 return <-ch } // Calling of a generic type which has a function as core type. func _[T interface{ ~func() }](f T) { f() go f() } // Same, but function has a parameter and return value. func _[T interface{ ~func(string) int }](f T) int { return f("hello") } // Map access of a generic type which has a map as core type. func _[V any, T interface{ ~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. // Cannot embed stand-alone type parameters. Disabled for now. / func f0[A any, B interface{type C}, C interface{type D}, D interface{type A}](A, B, C, D) func f0x() { f := f0[string] f("a", "b", "c", "d") f0("a", "b", "c", "d") } func f1[A any, B interface{type A}](A, B) func f1x() { f := f1[int] f(int(0), int(0)) f1(int(0), int(0)) f(0, 0) f1(0, 0) } / func f2[A any, B interface{ []A }](_ A, _ B) {} func f2x() { f := f2[byte] f(byte(0), []byte{}) f2(byte(0), []byte{}) f(0, []byte{}) // f2(0, []byte{}) - this one doesn't work } // Cannot embed stand-alone type parameters. Disabled for now. / func f3[A any, B interface{type C}, C interface{type A}](a A, _ B, c C) func f3x() { f := f3[int] var x int f(x, &x, &x) f3(x, &x, &x) } / func f4[A any, B interface{ []C }, C interface{ A }](_ A, _ B, c C) {} func f4x() { f := f4[int] var x int f(x, []int{}, &x) f4(x, []int{}, &x) } func f5[A interface { struct { b B c C } }, B any, C interface{ B }](x B) A { panic(0) } func f5x() { x := f5(1.2) var _ float64 = x.b var _ float64 = *x.c } func f6[A any, B interface{ ~struct{ f []A } }](B) A { panic(0) } func f6x() { x := f6(struct{ f []string }{}) var _ string = x }	3.23 KB	2024-02-02 18:09
📄 typeswitch1.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func f[T any](i interface{}) { switch i.(type) { case T: println("T") case int: println("int") case int32, int16: println("int32/int16") case struct{ a, b T }: println("struct{T,T}") default: println("other") } } func main() { f[float64](float64(6)) f[float64](int(7)) f[float64](int32(8)) f[float64](struct{ a, b float64 }{a: 1, b: 2}) f[float64](int8(9)) f[int32](int32(7)) f[int](int32(7)) f[any](int(10)) f[interface{ M() }](int(11)) }	648 B	2024-02-02 18:09
📄 typeswitch1.out T int int32/int16 struct{T,T} other T int32/int16 T int	56 B	2024-02-02 18:09
📄 typeswitch2.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import "fmt" func f[T any](i interface{}) { switch x := i.(type) { case T: fmt.Println("T", x) case int: fmt.Println("int", x) case int32, int16: fmt.Println("int32/int16", x) case struct{ a, b T }: fmt.Println("struct{T,T}", x.a, x.b) default: fmt.Println("other", x) } } func main() { f[float64](float64(6)) f[float64](int(7)) f[float64](int32(8)) f[float64](struct{ a, b float64 }{a: 1, b: 2}) f[float64](int8(9)) f[int32](int32(7)) f[int](int32(7)) f[any](int(10)) f[interface{ M() }](int(11)) }	709 B	2024-02-02 18:09
📄 typeswitch2.out T 6 int 7 int32/int16 8 struct{T,T} 1 2 other 9 T 7 int32/int16 7 T 10 int 11	78 B	2024-02-02 18:09
📄 typeswitch3.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type I interface{ foo() int } type J interface { I bar() } type myint int func (x myint) foo() int { return int(x) } type myfloat float64 func (x myfloat) foo() int { return int(x) } type myint32 int32 func (x myint32) foo() int { return int(x) } func (x myint32) bar() {} func f[T I](i I) { switch x := i.(type) { case T: println("T", x.foo()) case myint: println("myint", x.foo()) default: println("other", x.foo()) } } func main() { f[myfloat](myint(6)) f[myfloat](myfloat(7)) f[myfloat](myint32(8)) f[myint32](myint32(8)) f[myint32](myfloat(7)) f[myint](myint32(9)) f[I](myint(10)) f[J](myint(11)) f[J](myint32(12)) }	837 B	2024-02-02 18:09
📄 typeswitch3.out myint 6 T 7 other 8 T 8 other 7 other 9 T 10 myint 11 T 12	59 B	2024-02-02 18:09
📄 typeswitch4.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type I interface{ foo() int } type J interface { I bar() } type myint int func (x myint) foo() int { return int(x) } type myfloat float64 func (x myfloat) foo() int { return int(x) } type myint32 int32 func (x myint32) foo() int { return int(x) } func (x myint32) bar() {} func f[T I](i I) { switch x := i.(type) { case T, myint32: println("T/myint32", x.foo()) default: println("other", x.foo()) } } func main() { f[myfloat](myint(6)) f[myfloat](myfloat(7)) f[myfloat](myint32(8)) f[myint32](myint32(9)) f[myint](myint32(10)) f[myint](myfloat(42)) f[I](myint(10)) f[J](myint(11)) f[J](myint32(12)) }	813 B	2024-02-02 18:09
📄 typeswitch4.out other 6 T/myint32 7 T/myint32 8 T/myint32 9 T/myint32 10 other 42 T/myint32 10 other 11 T/myint32 12	101 B	2024-02-02 18:09
📄 typeswitch5.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main type myint int func (x myint) foo() int {return int(x)} type myfloat float64 func (x myfloat) foo() float64 {return float64(x) } func f[T any](i interface{}) { switch x := i.(type) { case interface { foo() T }: println("fooer", x.foo()) default: println("other") } } func main() { f[int](myint(6)) f[int](myfloat(7)) f[float64](myint(8)) f[float64](myfloat(9)) }	559 B	2024-02-02 18:09
📄 typeswitch5.out fooer 6 other other fooer +9.000000e+000	41 B	2024-02-02 18:09
📄 typeswitch6.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func f[T any](i interface{}) { switch i.(type) { case T: println("T") case int: println("int") default: println("other") } } type myint int func (myint) foo() { } func main() { f[interface{}](nil) f[interface{}](6) f[interface{foo()}](nil) f[interface{foo()}](7) f[interface{foo()}](myint(8)) }	495 B	2024-02-02 18:09
📄 typeswitch6.out other T other int T	20 B	2024-02-02 18:09
📄 typeswitch7.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main func f[T any](i interface{foo()}) { switch i.(type) { case interface{bar() T}: println("barT") case myint: println("myint") case myfloat: println("myfloat") default: println("other") } } type myint int func (myint) foo() { } func (x myint) bar() int { return int(x) } type myfloat float64 func (myfloat) foo() { } func main() { f[int](nil) f[int](myint(6)) f[int](myfloat(7)) }	581 B	2024-02-02 18:09
📄 typeswitch7.out other barT myfloat	19 B	2024-02-02 18:09
📁 valimp.dir	-	2024-02-02 18:09
📄 valimp.go // rundir // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ignored	187 B	2024-02-02 18:09
📄 value.go // run // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import "fmt" type value[T any] struct { val T } func get[T any](v value[T]) T { return v.val } func set[T any](v value[T], val T) { v.val = val } func (v value[T]) set(val T) { v.val = val } func (v value[T]) get() T { return v.val } func main() { var v1 value[int] set(&v1, 1) if got, want := 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(value[int]) set(v1p, 3) if got, want := 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 value[string] set(&v2, "a") if got, want := get(&v2), "a"; got != want { panic(fmt.Sprintf("get() == %q, want %q", got, want)) } v2.set("b") if got, want := get(&v2), "b"; got != want { panic(fmt.Sprintf("get() == %q, want %q", got, want)) } v2p := new(value[string]) set(v2p, "c") if got, want := 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)) } }	1.45 KB	2024-02-02 18:09

Edit File:

Terminal