package main

type Getter(type T) interface {
	Get() T
}

type Impl struct {
	v string
}

func (i Impl) Get() string {
	return i.v
}

func Bug(type G Getter(T), T interface{})(g G) G {
	return g
}

func main() {
	i := Impl{v: "example"}
	Bug(Impl, string)(i)
}

package main

import (
	"fmt"
)

type F(type T) interface {
	X() T
}

func callx(type T)(f F(T)) T {
	return f.X()
}

type foo struct{}

func (foo) X() int {
	return 99
}

func main() {
	// fmt.Println(callx(foo{})) // this should be made to work also
	fmt.Println(callx(int)(foo{}))
}

// Ordered is a type constraint that matches all ordered types.
// (An ordered type is one that supports the < <= >= > operators.)
// In practice this type constraint would likely be defined in
// a standard library package.
// Taken from the proposal
type Ordered interface {
    type int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr, float32, float64, string
}

/* package quicksort */

// QuickSortable is the generic interface required to use the QuickSort
// function.  This interface allows arbitrary user defined types
// to take advantage of the generic sorting algorithm.
type QuickSortable(type T Ordered) interface {
    Orderable() T
}

// partition runs a single sorting iteration.  Given a slice to sort,
// partition begins at the low index, and while iterating to the high index
// swapping out of place elements on the way.
func partition(type O Ordered, Q QuickSortable(O))(q []Q, lowIdx int, highIdx int) (int, error) {...}

// quickSort is the recursive component of the quicksort implementation.
// It delegates down to partition to run a single iteration
// and exhausts itself when the low index is greater than the high index.
func quickSort(type O Ordered, Q QuickSortable(O))(q []Q, lowIdx int, highIdx int) error {...}

// QuickSort is the generic outer shell, which delegates to the
// private quickSort function, that is exported as the public API.
// type O Ordered is used so that the operator <= is legal.
// type Q is used to produce an instance of type O via the call to Orderable(),
// which allows any user defined type to take advantage of QuickSort.
// The type signature is propagated down to the internal functions.
func QuickSort(type O Ordered, Q QuickSortable(O))(q []Q) error {...}

// QSInt is a type alias of int, which allows a slice of QSInt
// to utilize quicksort.
type QSInt int

// Orderable implements the QuickSortable interface so that QSInt
// can be used in the QuickSort function.
func (q QSInt) Orderable() int {
    return int(q)
}

// Guest is a domain object of some application that needs sorting
type Guest struct {
    name string
    age  int
}

// Orderable implements the QuickSortable interface so that Guest
// can be used in the quicksort function.
func (g Guest) Orderable() int {
    return int(g.age)
}

var sortList []QuickSortable(int)
// other code
err := QuickSort(int, QuickSortable(int))(sortList)

var guestList []QuickSortable(int)
// other code
err = QuickSort(int, QuickSortable(int))(guestList)

func partition(type Q QuickSortable(int))(q []Q, lowIdx int, highIdx int) (int, error) {}
func quickSort(type Q QuickSortable(int))(q []Q, lowIdx int, highIdx int) error {}
func QuickSort(type Q QuickSortable(int))(q []Q) error {}
// ...
var guestList []QuickSortable(int)
// ...
err = QuickSort(QuickSortable(int))(guestList)

package main

type Getter[T any] interface {
	Get() T
}

type Impl struct {
	v string
}

func (i Impl) Get() string {
	return i.v
}

func Bug[G Getter[T], T interface{}](g G) {
}

func main() {
	i := Impl{v: "example"}
	Bug(i)
}