go2linq

https://learn.microsoft.com/dotnet/csharp/programming-guide/concepts/linq/partitioning-data#example

chunkNumber := 0
enr1 := ChunkMust(RangeMust(0, 8), 3).GetEnumerator()
for enr1.MoveNext() {
	chunkNumber++
	fmt.Printf("Chunk %d:", chunkNumber)
	chunk := enr1.Current()
	enr2 := NewEnSlice(chunk...).GetEnumerator()
	for enr2.MoveNext() {
		item := enr2.Current()
		fmt.Printf(" %d", item)
	}
	fmt.Println()
}

Output:

Chunk 1: 0 1 2
Chunk 2: 3 4 5
Chunk 3: 6 7

see ConcatEx1 example from Enumerable.Concat help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.concat#examples

cats := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
}
dogs := []Pet{
	{Name: "Bounder", Age: 3},
	{Name: "Snoopy", Age: 14},
	{Name: "Fido", Age: 9},
}
query := ConcatMust(
	SelectMust(
		NewEnSliceEn(cats...),
		func(cat Pet) string { return cat.Name },
	),
	SelectMust(
		NewEnSliceEn(dogs...),
		func(dog Pet) string { return dog.Name },
	),
)
enr := query.GetEnumerator()
for enr.MoveNext() {
	name := enr.Current()
	fmt.Println(name)
}

Output:

Barley
Boots
Whiskers
Bounder
Snoopy
Fido

see DefaultIfEmptyEx2 example from Enumerable.DefaultIfEmpty help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.defaultifempty

defaultPet := Pet{Name: "Default Pet", Age: 0}
pets1 := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
}
enr1 := DefaultIfEmptyDefMust(NewEnSliceEn(pets1...), defaultPet).GetEnumerator()
for enr1.MoveNext() {
	pet := enr1.Current()
	fmt.Printf("Name: %s\n", pet.Name)
}
pets2 := []Pet{}
enr2 := DefaultIfEmptyDefMust(NewEnSliceEn(pets2...), defaultPet).GetEnumerator()
for enr2.MoveNext() {
	pet := enr2.Current()
	fmt.Printf("\nName: %s\n", pet.Name)
}

Output:

Name: Barley
Name: Boots
Name: Whiskers

Name: Default Pet

see the last example from Enumerable.DefaultIfEmpty help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.defaultifempty

numbers := DefaultIfEmptyMust(NewEnSliceEn([]int{}...))
enr := numbers.GetEnumerator()
for enr.MoveNext() {
	number := enr.Current()
	fmt.Println(number)
}

Output:

0

see DefaultIfEmptyEx1 example from Enumerable.DefaultIfEmpty help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.defaultifempty

pets := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
}
enr := DefaultIfEmptyMust(NewEnSliceEn(pets...)).GetEnumerator()
for enr.MoveNext() {
	pet := enr.Current()
	fmt.Println(pet.Name)
}

Output:

Barley
Boots
Whiskers

see the last two examples from Enumerable.Distinct help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.distinct

products := []Product{
	{Name: "apple", Code: 9},
	{Name: "orange", Code: 4},
	{Name: "Apple", Code: 9},
	{Name: "lemon", Code: 12},
}
var eqf collate.Equaler[Product] = collate.EqualerFunc[Product](
	func(p1, p2 Product) bool {
		return p1.Code == p2.Code && strings.EqualFold(p1.Name, p2.Name)
	},
)
//Exclude duplicates.
distinctEq := DistinctEqMust(NewEnSliceEn(products...), eqf)
enr := distinctEq.GetEnumerator()
for enr.MoveNext() {
	product := enr.Current()
	fmt.Printf("%s %d\n", product.Name, product.Code)
}

Output:

apple 9
orange 4
lemon 12

see the first example from Enumerable.Distinct help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.distinct

ages := []int{21, 46, 46, 55, 17, 21, 55, 55}
distinct := DistinctMust(NewEnSliceEn(ages...))
fmt.Println("Distinct ages:")
enr := distinct.GetEnumerator()
for enr.MoveNext() {
	age := enr.Current()
	fmt.Println(age)
}

Output:

Distinct ages:
21
46
55
17

see the example from Enumerable.Empty help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.empty#examples

names1 := []string{"Hartono, Tommy"}
names2 := []string{"Adams, Terry", "Andersen, Henriette Thaulow", "Hedlund, Magnus", "Ito, Shu"}
names3 := []string{"Solanki, Ajay", "Hoeing, Helge", "Andersen, Henriette Thaulow", "Potra, Cristina", "Iallo, Lucio"}
namesList := []Enumerable[string]{
	NewEnSliceEn(names1...),
	NewEnSliceEn(names2...),
	NewEnSliceEn(names3...),
}
allNames := AggregateSeedMust(
	NewEnSliceEn(namesList...),
	Empty[string](),
	func(current, next Enumerable[string]) Enumerable[string] {
		// Only include arrays that have four or more elements
		if CountMust(next) > 3 {
			return UnionMust(current, next)
		}
		return current
	},
)
enr := allNames.GetEnumerator()
for enr.MoveNext() {
	name := enr.Current()
	fmt.Println(name)
}

Output:

Adams, Terry
Andersen, Henriette Thaulow
Hedlund, Magnus
Ito, Shu
Solanki, Ajay
Hoeing, Helge
Potra, Cristina
Iallo, Lucio

see the last two examples from Enumerable.Except help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.except

fruits1 := []Product{
	{Name: "apple", Code: 9},
	{Name: "orange", Code: 4},
	{Name: "lemon", Code: 12},
}
fruits2 := []Product{
	{Name: "APPLE", Code: 9},
}
var equaler collate.Equaler[Product] = collate.EqualerFunc[Product](
	func(p1, p2 Product) bool {
		return p1.Code == p2.Code && strings.EqualFold(p1.Name, p2.Name)
	},
)
//Get all the elements from the first array except for the elements from the second array.
except := ExceptEqMust(
	NewEnSliceEn(fruits1...),
	NewEnSliceEn(fruits2...),
	equaler,
)
enr := except.GetEnumerator()
for enr.MoveNext() {
	product := enr.Current()
	fmt.Printf("%s %d\n", product.Name, product.Code)
}

Output:

orange 4
lemon 12

see the first example from Enumerable.Except help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.except

numbers1 := NewEnSliceEn(2.0, 2.0, 2.1, 2.2, 2.3, 2.3, 2.4, 2.5)
numbers2 := NewEnSliceEn(2.2)
except := ExceptMust(numbers1, numbers2)
enr := except.GetEnumerator()
for enr.MoveNext() {
	number := enr.Current()
	fmt.Println(number)
}

Output:

2
2.1
2.3
2.4
2.5

https://learn.microsoft.com/dotnet/csharp/programming-guide/concepts/linq/grouping-data#query-expression-syntax-example

numbers := []int{35, 44, 200, 84, 3987, 4, 199, 329, 446, 208}
query := GroupByMust(
	NewEnSliceEn(numbers...),
	func(i int) int { return i % 2 },
)
enr := query.GetEnumerator()
for enr.MoveNext() {
	group := enr.Current()
	if group.Key() == 0 {
		fmt.Println("\nEven numbers:")
	} else {
		fmt.Println("\nOdd numbers:")
	}
	enrGroup := group.GetEnumerator()
	for enrGroup.MoveNext() {
		i := enrGroup.Current()
		fmt.Println(i)
	}
}

Output:

Odd numbers:
35
3987
199
329

Even numbers:
44
200
84
4
446
208

see GroupByEx3 example from Enumerable.GroupBy help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.groupby

pets := []PetF{
	{Name: "Barley", Age: 8.3},
	{Name: "Boots", Age: 4.9},
	{Name: "Whiskers", Age: 1.5},
	{Name: "Daisy", Age: 4.3},
}
// Group PetF objects by the math.Floor of their Age.
// Then project a Result type from each group that consists of the Key,
// the Count of the group's elements, and the minimum and maximum Age in the group.
query := GroupByResMust(
	NewEnSliceEn(pets...),
	func(pet PetF) float64 { return math.Floor(pet.Age) },
	func(age float64, pets Enumerable[PetF]) Result {
		count := CountMust(pets)
		mn := MinSelMust(pets, func(pet PetF) float64 { return pet.Age })
		mx := MaxSelMust(pets, func(pet PetF) float64 { return pet.Age })
		return Result{Key: age, Count: count, Min: mn, Max: mx}
	},
)
enr := query.GetEnumerator()
for enr.MoveNext() {
	result := enr.Current()
	fmt.Printf("\nAge group: %g\n", result.Key)
	fmt.Printf("Number of pets in this age group: %d\n", result.Count)
	fmt.Printf("Minimum age: %g\n", result.Min)
	fmt.Printf("Maximum age: %g\n", result.Max)
}

Output:

Age group: 8
Number of pets in this age group: 1
Minimum age: 8.3
Maximum age: 8.3

Age group: 4
Number of pets in this age group: 2
Minimum age: 4.3
Maximum age: 4.9

Age group: 1
Number of pets in this age group: 1
Minimum age: 1.5
Maximum age: 1.5

see GroupByEx1 example from Enumerable.GroupBy help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.groupby

pets := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
	{Name: "Daisy", Age: 4},
}
// Group the pets using Age as the key value and selecting only the Pet's Name for each value.
query := GroupBySelMust(
	NewEnSliceEn(pets...),
	func(pet Pet) int { return pet.Age },
	func(pet Pet) string { return pet.Name },
)
// Iterate over each Grouping in the collection.
enr := query.GetEnumerator()
for enr.MoveNext() {
	petGroup := enr.Current()
	// Print the key value of the Grouping.
	fmt.Println(petGroup.Key())
	enrNames := petGroup.GetEnumerator()
	// Iterate over each value in the Grouping and print the value.
	for enrNames.MoveNext() {
		name := enrNames.Current()
		fmt.Printf("  %s\n", name)
	}
}

Output:

8
  Barley
4
  Boots
  Daisy
1
  Whiskers

see GroupByEx4 example from Enumerable.GroupBy help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.groupby

pets := []PetF{
	{Name: "Barley", Age: 8.3},
	{Name: "Boots", Age: 4.9},
	{Name: "Whiskers", Age: 1.5},
	{Name: "Daisy", Age: 4.3},
}
// Group PetF.Age values by the math.Floor of the age.
// Then project a Result type from each group that consists of the Key,
// the Count of the group's elements, and the minimum and maximum Age in the group.
query := GroupBySelResMust(
	NewEnSliceEn(pets...),
	func(pet PetF) float64 { return math.Floor(pet.Age) },
	func(pet PetF) float64 { return pet.Age },
	func(baseAge float64, ages Enumerable[float64]) Result {
		count := CountMust(ages)
		min := MinMust(ages)
		max := MaxMust(ages)
		return Result{Key: baseAge, Count: count, Min: min, Max: max}
	},
)
enr := query.GetEnumerator()
for enr.MoveNext() {
	result := enr.Current()
	fmt.Printf("\nAge group: %g\n", result.Key)
	fmt.Printf("Number of pets in this age group: %d\n", result.Count)
	fmt.Printf("Minimum age: %g\n", result.Min)
	fmt.Printf("Maximum age: %g\n", result.Max)
}

Output:

Age group: 8
Number of pets in this age group: 1
Minimum age: 8.3
Maximum age: 8.3

Age group: 4
Number of pets in this age group: 2
Minimum age: 4.3
Maximum age: 4.9

Age group: 1
Number of pets in this age group: 1
Minimum age: 1.5
Maximum age: 1.5

see GroupJoinEx1 example from Enumerable.GroupJoin help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.groupjoin

magnus := Person{Name: "Hedlund, Magnus"}
terry := Person{Name: "Adams, Terry"}
charlotte := Person{Name: "Weiss, Charlotte"}

barley := Pet{Name: "Barley", Owner: terry}
boots := Pet{Name: "Boots", Owner: terry}
whiskers := Pet{Name: "Whiskers", Owner: charlotte}
daisy := Pet{Name: "Daisy", Owner: magnus}

// Create a list where each element is an OwnerAndPets type that contains a person's name and
// a collection of names of the pets they own.
people := []Person{magnus, terry, charlotte}
pets := []Pet{barley, boots, whiskers, daisy}

query := GroupJoinMust(
	NewEnSliceEn(people...),
	NewEnSliceEn(pets...),
	Identity[Person],
	func(pet Pet) Person { return pet.Owner },
	func(person Person, pets Enumerable[Pet]) OwnerAndPets {
		return OwnerAndPets{
			OwnerName: person.Name,
			Pets:      SelectMust(pets, func(pet Pet) string { return pet.Name })}
	},
)
enr := query.GetEnumerator()
for enr.MoveNext() {
	obj := enr.Current()
	// Output the owner's name.
	fmt.Printf("%s:\n", obj.OwnerName)
	// Output each of the owner's pet's names.
	enrPets := obj.Pets.GetEnumerator()
	for enrPets.MoveNext() {
		pet := enrPets.Current()
		fmt.Printf("  %s\n", pet)
	}
}

Output:

Hedlund, Magnus:
  Daisy
Adams, Terry:
  Barley
  Boots
Weiss, Charlotte:
  Whiskers

https://learn.microsoft.com/dotnet/csharp/programming-guide/concepts/linq/join-operations#query-expression-syntax-examples https://learn.microsoft.com/dotnet/csharp/programming-guide/concepts/linq/join-operations#groupjoin

products := []Product{
	{Name: "Cola", CategoryId: 0},
	{Name: "Tea", CategoryId: 0},
	{Name: "Apple", CategoryId: 1},
	{Name: "Kiwi", CategoryId: 1},
	{Name: "Carrot", CategoryId: 2},
}
categories := []Category{
	{Id: 0, CategoryName: "Beverage"},
	{Id: 1, CategoryName: "Fruit"},
	{Id: 2, CategoryName: "Vegetable"},
}
// Join categories and product based on CategoryId and grouping result
productGroups := GroupJoinMust(
	NewEnSliceEn(categories...),
	NewEnSliceEn(products...),
	func(category Category) int { return category.Id },
	func(product Product) int { return product.CategoryId },
	func(category Category, products Enumerable[Product]) Enumerable[Product] {
		return products
	},
)
enrGroupJoin := productGroups.GetEnumerator()
for enrGroupJoin.MoveNext() {
	fmt.Println("Group")
	productGroup := enrGroupJoin.Current()
	enrProductGroup := productGroup.GetEnumerator()
	for enrProductGroup.MoveNext() {
		product := enrProductGroup.Current()
		fmt.Printf("%8s\n", product.Name)
	}
}

Output:

Group
    Cola
     Tea
Group
   Apple
    Kiwi
Group
  Carrot

see the second and third examples from Enumerable.Intersect help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.intersect

store1 := []Product{
	{Name: "apple", Code: 9},
	{Name: "orange", Code: 4},
}
store2 := []Product{
	{Name: "apple", Code: 9},
	{Name: "lemon", Code: 12},
}
// Get the products from the first array that have duplicates in the second array.
var equaler collate.Equaler[Product] = collate.EqualerFunc[Product](
	func(p1, p2 Product) bool {
		return p1.Name == p2.Name && p1.Code == p2.Code
	},
)
intersectEq := IntersectEqMust(
	NewEnSliceEn(store1...),
	NewEnSliceEn(store2...),
	equaler,
)
enr := intersectEq.GetEnumerator()
for enr.MoveNext() {
	product := enr.Current()
	fmt.Printf("%s %d\n", product.Name, product.Code)
}

Output:

apple 9

see the first example from Enumerable.Intersect help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.intersect

id1 := NewEnSliceEn(44, 26, 92, 30, 71, 38)
id2 := NewEnSliceEn(39, 59, 83, 47, 26, 4, 30)
intersect := IntersectMust(id1, id2)
enr := intersect.GetEnumerator()
for enr.MoveNext() {
	id := enr.Current()
	fmt.Println(id)
}

Output:

26
30

see JoinEx1 example from Enumerable.Join help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.join

magnus := Person{Name: "Hedlund, Magnus"}
terry := Person{Name: "Adams, Terry"}
charlotte := Person{Name: "Weiss, Charlotte"}

barley := Pet{Name: "Barley", Owner: terry}
boots := Pet{Name: "Boots", Owner: terry}
whiskers := Pet{Name: "Whiskers", Owner: charlotte}
daisy := Pet{Name: "Daisy", Owner: magnus}

people := []Person{magnus, terry, charlotte}
pets := []Pet{barley, boots, whiskers, daisy}

// Create a list of Person-Pet pairs where each element is an OwnerNameAndPetName type that contains a
// Pet's name and the name of the Person that owns the Pet.
join := JoinMust(
	NewEnSliceEn(people...),
	NewEnSliceEn(pets...),
	Identity[Person],
	func(pet Pet) Person { return pet.Owner },
	func(person Person, pet Pet) OwnerNameAndPetName {
		return OwnerNameAndPetName{Owner: person.Name, Pet: pet.Name}
	},
)
enr := join.GetEnumerator()
for enr.MoveNext() {
	obj := enr.Current()
	fmt.Printf("%s - %s\n", obj.Owner, obj.Pet)
}

Output:

Hedlund, Magnus - Daisy
Adams, Terry - Barley
Adams, Terry - Boots
Weiss, Charlotte - Whiskers

https://learn.microsoft.com/dotnet/csharp/programming-guide/concepts/linq/join-operations#query-expression-syntax-examples https://learn.microsoft.com/dotnet/csharp/programming-guide/concepts/linq/join-operations#join

products := []Product{
	{Name: "Cola", CategoryId: 0},
	{Name: "Tea", CategoryId: 0},
	{Name: "Apple", CategoryId: 1},
	{Name: "Kiwi", CategoryId: 1},
	{Name: "Carrot", CategoryId: 2},
}
categories := []Category{
	{Id: 0, CategoryName: "Beverage"},
	{Id: 1, CategoryName: "Fruit"},
	{Id: 2, CategoryName: "Vegetable"},
}
// Join products and categories based on CategoryId
join := JoinMust(
	NewEnSliceEn(products...),
	NewEnSliceEn(categories...),
	func(product Product) int { return product.CategoryId },
	func(category Category) int { return category.Id },
	func(product Product, category Category) string {
		return fmt.Sprintf("%s - %s", product.Name, category.CategoryName)
	},
)
enr := join.GetEnumerator()
for enr.MoveNext() {
	item := enr.Current()
	fmt.Println(item)
}

Output:

Cola - Beverage
Tea - Beverage
Apple - Fruit
Kiwi - Fruit
Carrot - Vegetable

see the example from Enumerable.Range help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.range#examples

// Generate a sequence of integers from 1 to 10 and then select their squares.
squares := SelectMust(RangeMust(1, 10), func(x int) int { return x * x })
enr := squares.GetEnumerator()
for enr.MoveNext() {
	num := enr.Current()
	fmt.Println(num)
}

Output:

1
4
9
16
25
36
49
64
81
100

see the example from Enumerable.Repeat help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.repeat#examples

strs := RepeatMust("I like programming.", 4)
enr := strs.GetEnumerator()
for enr.MoveNext() {
	str := enr.Current()
	fmt.Println(str)
}

Output:

I like programming.
I like programming.
I like programming.
I like programming.

see the example from Enumerable.Reverse help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.reverse#examples

apple := []string{"a", "p", "p", "l", "e"}
reverse := ReverseMust(
	NewEnSliceEn(apple...),
)
enr := reverse.GetEnumerator()
for enr.MoveNext() {
	chr := enr.Current()
	fmt.Printf("%v ", chr)
}
fmt.Println()

Output:

e l p p a

fruits := []string{"apple", "banana", "mango", "orange", "passionfruit", "grape"}
query := SelectIdxMust(
	NewEnSliceEn(fruits...),
	func(fruit string, index int) indexstr {
		return indexstr{index: index, str: fruit[:index]}
	},
)
enr := query.GetEnumerator()
for enr.MoveNext() {
	obj := enr.Current()
	fmt.Printf("%+v\n", obj)
}

Output:

{index:0 str:}
{index:1 str:b}
{index:2 str:ma}
{index:3 str:ora}
{index:4 str:pass}
{index:5 str:grape}

see SelectManyEx3 example from Enumerable.SelectMany help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.selectmany

petOwners := []PetOwner{
	{Name: "Higa", Pets: []string{"Scruffy", "Sam"}},
	{Name: "Ashkenazi", Pets: []string{"Walker", "Sugar"}},
	{Name: "Price", Pets: []string{"Scratches", "Diesel"}},
	{Name: "Hines", Pets: []string{"Dusty"}},
}
// Project all pet's names together with the pet's owner.
selectMany := SelectManyCollMust(
	NewEnSliceEn(petOwners...),
	func(petOwner PetOwner) Enumerable[string] {
		return NewEnSlice(petOwner.Pets...)
	},
	func(petOwner PetOwner, petName string) OwnerAndPet {
		return OwnerAndPet{petOwner: petOwner, petName: petName}
	},
)
// Filter only pet's names that start with S.
where := WhereMust(selectMany,
	func(ownerAndPet OwnerAndPet) bool {
		return strings.HasPrefix(ownerAndPet.petName, "S")
	},
)
// Project the pet owner's name and the pet's name.
selectEn := SelectMust(where,
	func(ownerAndPet OwnerAndPet) OwnerNameAndPetName {
		return OwnerNameAndPetName{Owner: ownerAndPet.petOwner.Name, Pet: ownerAndPet.petName}
	},
)
enr := selectEn.GetEnumerator()
for enr.MoveNext() {
	obj := enr.Current()
	fmt.Printf("%+v\n", obj)
}

Output:

{Owner:Higa Pet:Scruffy}
{Owner:Higa Pet:Sam}
{Owner:Ashkenazi Pet:Sugar}
{Owner:Price Pet:Scratches}

see SelectManyEx2 example from Enumerable.SelectMany help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.selectmany

petOwners := []PetOwner{
	{Name: "Higa, Sidney", Pets: []string{"Scruffy", "Sam"}},
	{Name: "Ashkenazi, Ronen", Pets: []string{"Walker", "Sugar"}},
	{Name: "Price, Vernette", Pets: []string{"Scratches", "Diesel"}},
	{Name: "Hines, Patrick", Pets: []string{"Dusty"}},
}
// Project the items in the array by appending the index of each PetOwner
// to each pet's name in that petOwner's array of pets.
query := SelectManyIdxMust(
	NewEnSliceEn(petOwners...),
	func(petOwner PetOwner, index int) Enumerable[string] {
		return SelectMust(
			NewEnSliceEn(petOwner.Pets...),
			func(pet string) string { return strconv.Itoa(index) + pet },
		)
	},
)
enr := query.GetEnumerator()
for enr.MoveNext() {
	pet := enr.Current()
	fmt.Println(pet)
}

Output:

0Scruffy
0Sam
1Walker
1Sugar
2Scratches
2Diesel
3Dusty

see the second example from Enumerable.Concat help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.concat#examples

cats := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
}
dogs := []Pet{
	{Name: "Bounder", Age: 3},
	{Name: "Snoopy", Age: 14},
	{Name: "Fido", Age: 9},
}
query := SelectManyMust(
	NewEnSliceEn(
		SelectMust(
			NewEnSliceEn(cats...),
			func(cat Pet) string { return cat.Name },
		),
		SelectMust(
			NewEnSliceEn(dogs...),
			func(dog Pet) string { return dog.Name },
		),
	),
	Identity[Enumerable[string]],
)
enr := query.GetEnumerator()
for enr.MoveNext() {
	name := enr.Current()
	fmt.Println(name)
}

Output:

Barley
Boots
Whiskers
Bounder
Snoopy
Fido

see SelectManyEx1 example from Enumerable.SelectMany help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.selectmany

petOwners := []PetOwner{
	{Name: "Higa, Sidney", Pets: []string{"Scruffy", "Sam"}},
	{Name: "Ashkenazi, Ronen", Pets: []string{"Walker", "Sugar"}},
	{Name: "Price, Vernette", Pets: []string{"Scratches", "Diesel"}},
}

// Query using SelectMany().
query1 := SelectManyMust(
	NewEnSliceEn(petOwners...),
	func(petOwner PetOwner) Enumerable[string] { return NewEnSlice(petOwner.Pets...) },
)
fmt.Println("Using SelectMany():")
// Only one for loop is required to iterate through the results since it is a one-dimensional collection.
enr1 := query1.GetEnumerator()
for enr1.MoveNext() {
	pet := enr1.Current()
	fmt.Println(pet)
}

// This code shows how to use Select() instead of SelectMany().
query2 := SelectMust(
	NewEnSliceEn(petOwners...),
	func(petOwner PetOwner) Enumerable[string] {
		return NewEnSlice(petOwner.Pets...)
	},
)
fmt.Println("\nUsing Select():")
// Notice that two foreach loops are required to iterate through the results
// because the query returns a collection of arrays.
enr2 := query2.GetEnumerator()
for enr2.MoveNext() {
	petList := enr2.Current()
	enrPetList := petList.GetEnumerator()
	for enrPetList.MoveNext() {
		pet := enrPetList.Current()
		fmt.Println(pet)
	}
	fmt.Println()
}

Output:

Using SelectMany():
Scruffy
Sam
Walker
Sugar
Scratches
Diesel

Using Select():
Scruffy
Sam

Walker
Sugar

Scratches
Diesel

see the first example from Enumerable.Select help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.select

squares := SelectMust(
	RangeMust(1, 10),
	func(x int) int { return x * x },
)
enr := squares.GetEnumerator()
for enr.MoveNext() {
	num := enr.Current()
	fmt.Println(num)
}

Output:

1
4
9
16
25
36
49
64
81
100

numbers := []string{"one", "two", "three", "four", "five"}
fmt.Println(ToStringDef(
	SelectMust(
		NewEnSliceEn(numbers...),
		func(s string) string {
			return string(s[0]) + string(s[len(s)-1])
		},
	),
))
fmt.Println(ToStringDef(
	SelectMust(
		NewEnSliceEn(numbers...),
		func(s string) string {
			runes := []rune(s)
			reversedRunes := ToSliceMust(
				ReverseMust(
					NewEnSliceEn(runes...),
				),
			)
			return string(reversedRunes)
		},
	),
))

Output:

[oe to te fr fe]
[eno owt eerht ruof evif]

see the example from Enumerable.Skip help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.skip#examples

grades := []int{59, 82, 70, 56, 92, 98, 85}
orderedGrades := OrderByDescMust(
	NewEnSliceEn(grades...),
)
lowerGrades := SkipMust[int](orderedGrades, 3)
fmt.Println("All grades except the top three are:")
enr := lowerGrades.GetEnumerator()
for enr.MoveNext() {
	grade := enr.Current()
	fmt.Println(grade)
}

Output:

All grades except the top three are:
82
70
59
56

see the first example from Enumerable.SkipWhile help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.skipwhile

amounts := []int{5000, 2500, 9000, 8000, 6500, 4000, 1500, 5500}
skipWhileIdx := SkipWhileIdxMust(
	NewEnSliceEn(amounts...),
	func(amount, index int) bool { return amount > index*1000 },
)
enr := skipWhileIdx.GetEnumerator()
for enr.MoveNext() {
	amount := enr.Current()
	fmt.Println(amount)
}

Output:

4000
1500
5500

see the second example from Enumerable.SkipWhile help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.skipwhile

grades := []int{59, 82, 70, 56, 92, 98, 85}
orderedGrades := OrderByDescMust(
	NewEnSliceEn(grades...),
)
lowerGrades := SkipWhileMust[int](orderedGrades,
	func(grade int) bool { return grade >= 80 },
)
fmt.Println("All grades below 80:")
enr := lowerGrades.GetEnumerator()
for enr.MoveNext() {
	grade := enr.Current()
	fmt.Println(grade)
}

Output:

All grades below 80:
70
59
56

see the example from Enumerable.Take help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.take

grades := []int{59, 82, 70, 56, 92, 98, 85}
orderedGrades := OrderByDescMust(
	NewEnSliceEn(grades...),
)
topThreeGrades := TakeMust[int](orderedGrades, 3)
fmt.Println("The top three grades are:")
enr := topThreeGrades.GetEnumerator()
for enr.MoveNext() {
	grade := enr.Current()
	fmt.Println(grade)
}

Output:

The top three grades are:
98
92
85

see the first example from Enumerable.TakeWhile help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.takewhile

fruits := []string{"apple", "passionfruit", "banana", "mango", "orange", "blueberry", "grape", "strawberry"}
takeWhileIdx := TakeWhileIdxMust(
	NewEnSliceEn(fruits...),
	func(fruit string, index int) bool {
		return len(fruit) >= index
	},
)
enr := takeWhileIdx.GetEnumerator()
for enr.MoveNext() {
	fruit := enr.Current()
	fmt.Println(fruit)
}

Output:

apple
passionfruit
banana
mango
orange
blueberry

see the second example from Enumerable.TakeWhile help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.takewhile

fruits := []string{"apple", "banana", "mango", "orange", "passionfruit", "grape"}
takeWhile := TakeWhileMust(
	NewEnSliceEn(fruits...),
	func(fruit string) bool {
		return collate.CaseInsensitiveComparer.Compare("orange", fruit) != 0
	},
)
enr := takeWhile.GetEnumerator()
for enr.MoveNext() {
	fruit := enr.Current()
	fmt.Println(fruit)
}

Output:

apple
banana
mango

see the last example from Enumerable.Union help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.union

store1 := []Product{
	{Name: "apple", Code: 9},
	{Name: "orange", Code: 4},
}
store2 := []Product{
	{Name: "apple", Code: 9},
	{Name: "lemon", Code: 12},
}
//Get the products from the both arrays excluding duplicates.
var equaler collate.Equaler[Product] = collate.EqualerFunc[Product](
	func(p1, p2 Product) bool {
		return p1.Code == p2.Code && p1.Name == p2.Name
	},
)
unionEq := UnionEqMust(
	NewEnSliceEn(store1...),
	NewEnSliceEn(store2...),
	equaler,
)
enr := unionEq.GetEnumerator()
for enr.MoveNext() {
	product := enr.Current()
	fmt.Printf("%s %d\n", product.Name, product.Code)
}

Output:

apple 9
orange 4
lemon 12

see the first example from Enumerable.Union help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.union

ints1 := []int{5, 3, 9, 7, 5, 9, 3, 7}
ints2 := []int{8, 3, 6, 4, 4, 9, 1, 0}
union := UnionMust(
	NewEnSliceEn(ints1...),
	NewEnSliceEn(ints2...),
)
enr := union.GetEnumerator()
for enr.MoveNext() {
	num := enr.Current()
	fmt.Printf("%d ", num)
}

Output:

5 3 9 7 8 6 4 1 0

see the last example from Enumerable.Where help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.where

numbers := []int{0, 30, 20, 15, 90, 85, 40, 75}
query := WhereIdxMust(
	NewEnSliceEn(numbers...),
	func(number, index int) bool { return number <= index*10 },
)
ForEach(context.Background(), query,
	func(number int) error {
		fmt.Println(number)
		return nil
	},
)

Output:

0
20
15
40

fmt.Println(ToStringDef(
	WhereIdxMust(
		NewEnSliceEn("one", "two", "three", "four", "five"),
		func(s string, i int) bool { return len(s) == i },
	),
))
fmt.Println(ToStringDef(
	WhereIdxMust(
		ReverseMust(
			NewEnSliceEn("one", "two", "three", "four", "five"),
		),
		func(s string, i int) bool { return len(s) == i },
	),
))
fmt.Println(ToStringDef(
	WhereIdxMust[string](
		OrderByMust(
			NewEnSliceEn("one", "two", "three", "four", "five"),
		),
		func(s string, i int) bool { return len(s) > i },
	),
))

Output:

[five]
[two]
[five four one three]

see the first example from Enumerable.Where help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.where

fruits := []string{"apple", "passionfruit", "banana", "mango", "orange", "blueberry", "grape", "strawberry"}
where := WhereMust(
	NewEnSliceEn(fruits...),
	func(fruit string) bool { return len(fruit) < 6 },
)
enr := where.GetEnumerator()
for enr.MoveNext() {
	fruit := enr.Current()
	fmt.Println(fruit)
}

Output:

apple
mango
grape

fmt.Println(ToStringDef(
	WhereMust(
		RangeMust(1, 10),
		func(i int) bool { return i%2 == 0 },
	),
))
fmt.Println(ToStringDef(
	WhereMust(
		NewEnSliceEn("one", "two", "three", "four", "five"),
		func(s string) bool { return strings.HasSuffix(s, "e") },
	),
))

Output:

[2 4 6 8 10]
[one three five]

see the example from Enumerable.Zip help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.zip

numbers := []int{1, 2, 3, 4}
words := []string{"one", "two", "three"}
zip := ZipMust(
	NewEnSliceEn(numbers...),
	NewEnSliceEn(words...),
	func(first int, second string) string { return fmt.Sprintf("%d %s", first, second) },
)
enr := zip.GetEnumerator()
for enr.MoveNext() {
	item := enr.Current()
	fmt.Println(item)
}

Output:

1 one
2 two
3 three

see LookupExample from Lookup Class help https://learn.microsoft.com/dotnet/api/system.linq.Lookup-2#examples

// Create a list of Packages to put into a Lookup data structure.
packages := []Package{
	{Company: "Coho Vineyard", Weight: 25.2, TrackingNumber: 89453312},
	{Company: "Lucerne Publishing", Weight: 18.7, TrackingNumber: 89112755},
	{Company: "Wingtip Toys", Weight: 6.0, TrackingNumber: 299456122},
	{Company: "Contoso Pharmaceuticals", Weight: 9.3, TrackingNumber: 670053128},
	{Company: "Wide World Importers", Weight: 33.8, TrackingNumber: 4665518773},
}
// Create a Lookup to organize the packages.
// Use the first character of Company as the key value.
// Select Company appended to TrackingNumber for each element value in the Lookup.
lookup := ToLookupSelMust(
	NewEnSliceEn(packages...),
	func(p Package) rune {
		return []rune(p.Company)[0]
	},
	func(p Package) string {
		return fmt.Sprintf("%s %d", p.Company, p.TrackingNumber)
	},
)

// Iterate through each Grouping in the Lookup and output the contents.
enrLookup := lookup.GetEnumerator()
for enrLookup.MoveNext() {
	packageGroup := enrLookup.Current()
	// Print the key value of the Grouping.
	fmt.Println(string(packageGroup.Key()))
	// Iterate through each value in the Grouping and print its value.
	enGr := packageGroup.GetEnumerator()
	for enGr.MoveNext() {
		str := enGr.Current()
		fmt.Printf("    %s\n", str)
	}
}

// Get the number of key-collection pairs in the Lookup.
count := lookup.Count()
fmt.Printf("\n%d\n", count)

// Select a collection of Packages by indexing directly into the Lookup.
cgroup := lookup.Item('C')
// Output the results.
fmt.Println("\nPackages that have a key of 'C'")
enrCgroup := cgroup.GetEnumerator()
for enrCgroup.MoveNext() {
	str := enrCgroup.Current()
	fmt.Println(str)
}

// Determine if there is a key with the value 'G' in the Lookup.
hasG := lookup.Contains('G')
fmt.Printf("\n%t\n", hasG)

Output:

C
    Coho Vineyard 89453312
    Contoso Pharmaceuticals 670053128
L
    Lucerne Publishing 89112755
W
    Wingtip Toys 299456122
    Wide World Importers 4665518773

3

Packages that have a key of 'C'
Coho Vineyard 89453312
Contoso Pharmaceuticals 670053128

false

fmt.Println(ToStringDef[string](
	OrderByDescKeyMust(
		NewEnSliceEn("zero", "one", "two", "three", "four", "five"),
		func(s string) int { return len(s) },
	),
))

Output:

[three zero four five one two]

see OrderByDescendingEx1 example from Enumerable.OrderByDescending help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.orderbydescending

decimals := []float64{6.2, 8.3, 0.5, 1.3, 6.3, 9.7}
var ls collate.Lesser[float64] = collate.LesserFunc[float64](
	func(f1, f2 float64) bool {
		_, fr1 := math.Modf(f1)
		_, fr2 := math.Modf(f2)
		if math.Abs(fr1-fr2) < 0.001 {
			return f1 < f2
		}
		return fr1 < fr2
	},
)
query := OrderByDescLsMust(
	NewEnSliceEn(decimals...),
	ls,
)
enr := query.GetEnumerator()
for enr.MoveNext() {
	num := enr.Current()
	fmt.Println(num)
}

Output:

9.7
0.5
8.3
6.3
1.3
6.2

see OrderByEx1 example from Enumerable.OrderBy help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.orderby

pets := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
}
var ls collate.Lesser[Pet] = collate.LesserFunc[Pet](func(p1, p2 Pet) bool { return p1.Age < p2.Age })
query := OrderByLsMust(
	NewEnSliceEn(pets...),
	ls,
)
enr := query.GetEnumerator()
for enr.MoveNext() {
	pet := enr.Current()
	fmt.Printf("%s - %d\n", pet.Name, pet.Age)
}

Output:

Whiskers - 1
Boots - 4
Barley - 8

fmt.Println(ToStringDef[string](
	OrderByMust(
		NewEnSliceEn("zero", "one", "two", "three", "four", "five"),
	),
))

Output:

[five four one three two zero]

see ThenByDescendingEx1 example from Enumerable.ThenByDescending help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.thenbydescending

fruits := []string{"apPLe", "baNanA", "apple", "APple", "orange", "BAnana", "ORANGE", "apPLE"}
// Sort the strings first ascending by their length and then descending using a custom case insensitive comparer.
query := ThenByDescLsMust(
	OrderByKeyMust(
		NewEnSliceEn(fruits...),
		func(fruit string) int { return len(fruit) },
	),
	collate.CaseInsensitiveLesser,
)
enr := query.GetEnumerator()
for enr.MoveNext() {
	fruit := enr.Current()
	fmt.Println(fruit)
}

Output:

apPLe
apple
APple
apPLE
orange
ORANGE
baNanA
BAnana

see the example from Enumerable.ThenBy help https://learn.microsoft.com/dotnet/api/system.linq.enumerable.thenby

fruits := []string{"grape", "passionfruit", "banana", "mango", "orange", "raspberry", "apple", "blueberry"}
// Sort the strings first by their length and then alphabetically.
query := ThenByMust(
	OrderByKeyMust(
		NewEnSliceEn(fruits...),
		func(fruit string) int { return len(fruit) },
	),
)
enr := query.GetEnumerator()
for enr.MoveNext() {
	fruit := enr.Current()
	fmt.Println(fruit)
}

Output:

apple
grape
mango
banana
orange
blueberry
raspberry
passionfruit