package types

// Methods is a go1.23 iterator over all the methods of an interface,
// ordered by Id.
//
// Example: for m := range t.Methods { ... }
func (t *Interface) Methods(yield func(*Func) bool) {
	for i := range t.NumMethods() {
		if !yield(t.Method(i)) {
			break
		}
	}
}

// ExplicitMethods is a go1.23 iterator over the explicit methods of an interface.
//
// Example: for m := range t.ExplicitMethods { ... }
func (t *Interface) ExplicitMethods(yield func(*Func) bool) {
	for i := range t.NumExplicitMethods() {
		if !yield(t.ExplicitMethod(i)) {
			break
		}
	}
}

// EmbeddedTypes is a go1.23 iterator over the types embedded within an interface.
//
// Example: for e := range t.EmbeddedTypes { ... }
func (t *Interface) EmbeddedTypes(yield func(Type) bool) {
	for i := range t.NumEmbeddeds() {
		if !yield(t.EmbeddedType(i)) {
			break
		}
	}
}

// Methods is a go1.23 iterator over the declared methods of a named type.
//
// Example: for m := range t.Methods { ... }
func (t *Named) Methods(yield func(*Func) bool) {
	for i := range t.NumMethods() {
		if !yield(t.Method(i)) {
			break
		}
	}
}

// Children is a go1.23 iterator over the child scopes nested within scope s.
//
// Example: for child := range scope.Children { ... }
func (s *Scope) Children(yield func(*Scope) bool) {
	for i := range s.NumChildren() {
		if !yield(s.Child(i)) {
			break
		}
	}
}

// Fields is a go1.23 iterator over the fields of a struct type.
//
// Example: for f := range s.Fields { ... }
func (s *Struct) Fields(yield func(*Var) bool) {
	for i := range s.NumFields() {
		if !yield(s.Field(i)) {
			break
		}
	}
}


// Variables is a go1.23 iterator over the variables of a tuple type.
//
// Example: for v := range tuple.Variables { ... }
func (t *Tuple) Variables(yield func(*Var) bool) {
	for i := range t.Len() {
		if !yield(t.At(i)) {
			break
		}
	}
}

// MethodSet is a go1.23 iterator over the methods of a method set.
//
// Example: for v := range tuple.Methods { ... }
func (s *MethodSet) Methods(yield func(*Selection) bool) {
	for i := range s.Len() {
		if !yield(s.At(i)) {
			break
		}
	}
}

// Terms is a go1.23 iterator over the terms of a union.
//
// Example: for term := range union.Terms { ... }
func (u *Union) Terms(yield func(*Term) bool) {
	for i := range u.Len() {
		if !yield(u.Term(i)) {
			break
		}
	}
}

// TypeParams is a go1.23 iterator over a list of type parameters.
//
// Example: for tparam := range l.TypeParams { ... }
func (l *TypeParamList) TypeParams(yield func(*TypeParam) bool) {
	for i := range l.Len() {
		if !yield(l.At(i)) {
			break
		}
	}
}

// Types is a go1.23 iterator over the elements of a list of type parameters.
//
// Example: for t := range l.Types { ... }
func (l *TypeList) Types(yield func(Type) bool) {
	for i := range l.Len() {
		if !yield(l.At(i)) {
			break
		}
	}
}