generics

type AliasType Baz[other.Three]

type Bar[T any, R any] interface {
	One(string) string
	Two(T) string
	Three(T) R
	Four(T) Foo[T, R]
	Five(T) Baz[T]
	Six(T) *Baz[T]
	Seven(T) other.One[T]
	Eight(T) other.Two[T, R]
	Nine(Iface[T])
	Ten(*T)
	Eleven() (*other.One[T], error)
	Twelve() (*other.Two[T, R], error)
	Thirteen() (Baz[StructType], error)
	Fourteen() (*Foo[StructType, StructType2], error)
	Fifteen() (Iface[StructType], error)
	Sixteen() (Baz[other.Three], error)
	Seventeen() (*Foo[other.Three, other.Four], error)
	Eighteen() (Iface[*other.Five], error)
	Nineteen() AliasType
}

type Baz[T any] struct{}

type Earth[R any] interface {
	Water(R) []R
}

type EmbeddingIface[T constraints.Integer, R constraints.Float] interface {
	io.Reader
	Generator[R]
	Earth[Generator[T]]
	other.Either[R, StructType, other.Five, Generator[T]]
	ExternalConstraint[T, R]
}

type ExternalConstraint[I constraints.Integer, F any] interface {
	One(string) string
	Two(I) string
	Three(I) F
	Four(I) Foo[I, F]
	Five(I) Baz[F]
	Six(I) *Baz[F]
	Seven(I) other.One[I]
	Eight(F) other.Two[I, F]
	Nine(Iface[I])
	Ten(*I)
	Eleven() map[string]I
	Twelve(ctx context.Context) <-chan []I
	Thirteen(...I) *F
}

type Foo[T any, R any] struct{}

type Generator[T any] interface {
	Generate() T
}

type Group[T Generator[any]] interface {
	Join(ctx context.Context) []T
}

type Iface[T any] any

type MilkyWay[R constraints.Integer] interface {
	SolarSystem[R]
}

type SolarSystem[T constraints.Ordered] interface {
	Earth[T]
}

type StructType struct{}

type StructType2 struct{}

type Universe[T constraints.Signed] interface {
	MilkyWay[T]
}

type UnsignedInteger interface {
	~uint | ~uint32 | ~uint64
}

type Water[R any, C UnsignedInteger] interface {
	Fish(R) []C
}