generics

Documentation

Index

• type AliasType
• type Bar
• type Baz
• type Clonable
• type EmbeddedW
• type EmbeddedX
• type EmbeddedY
• type EmbeddedZ
• type EmbeddingIface
• type ExternalConstraint
• type Finder
• type Foo
• type Iface
• type StructType
• type StructType2
• type TwentyFour
• type TwentyOne
• type TwentyTwo
• type UpdateNotifier

Types

type AliasType

type AliasType Baz[other.Three]

type Bar

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
	other.Twenty[any, any, any, *other.Four]
}

type Baz

type Baz[T any] struct{}

type Clonable

type Clonable[T any] interface {
	Clone() T
}

type EmbeddedW

type EmbeddedW[W StructType] interface {
	EmbeddedY[W]
}

type EmbeddedX

type EmbeddedX[X StructType] interface {
	EmbeddedY[X]
}

type EmbeddedY

type EmbeddedY[Y StructType] interface {
	EmbeddedZ[Y]
}

type EmbeddedZ

type EmbeddedZ[Z any] interface {
	EmbeddedZ(Z)
}

type EmbeddingIface

type EmbeddingIface[T constraints.Integer, R constraints.Float] interface {
	other.Twenty[T, StructType, R, other.Five]
	TwentyTwo[StructType]
	other.TwentyThree[TwentyTwo[R], TwentyTwo[T]]
	TwentyFour[other.StructType]
	Foo() error
	ExternalConstraint[T, R]
}

type ExternalConstraint

type ExternalConstraint[I constraints.Integer, F constraints.Float] 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)
}

type Finder

type Finder[T Clonable[T]] interface {
	Find(ctx context.Context) ([]T, error)
}

type Foo

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

type Iface

type Iface[T any] interface{}

type StructType

type StructType struct{}

type StructType2

type StructType2 struct{}

type TwentyFour

type TwentyFour[T other.StructType] interface {
	TwentyFour() T
}

type TwentyOne

type TwentyOne[T any] interface {
	TwentyOne() T
}

type TwentyTwo

type TwentyTwo[T any] interface {
	TwentyTwo() T
}

type UpdateNotifier

type UpdateNotifier[T any] interface {
	NotifyC(ctx context.Context) <-chan []T

	Refresh(ctx context.Context)
}