go2linq

last example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.aggregate

sentence := "the quick brown fox jumps over the lazy dog"
// Split the string into individual words.
words := strings.Fields(sentence)
// Prepend each word to the beginning of the new sentence to reverse the word order.
reversed, _ := Aggregate(
	SliceAll(words),
	func(workingSentence, next string) string { return next + " " + workingSentence },
)
fmt.Println(reversed)

Output:

dog lazy the over jumps fox brown quick the

second example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.aggregate

ints := []int{4, 8, 8, 3, 9, 0, 7, 8, 2}
// Count the even numbers in the array, using a seed value of 0.
numEven, _ := AggregateSeed(
	SliceAll(ints),
	0,
	func(total, next int) int {
		if next%2 == 0 {
			return total + 1
		}
		return total
	},
)
fmt.Printf("The number of even integers is: %d\n", numEven)

Output:

The number of even integers is: 6

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.aggregate

fruits := []string{"apple", "mango", "orange", "passionfruit", "grape"}
// Determine whether any string in the array is longer than "banana".
longestName, _ := AggregateSeedSel(
	SliceAll(fruits),
	"banana",
	func(longest, next string) string {
		if len(next) > len(longest) {
			return next
		}
		return longest
	},
	// Return the final result as an upper case string.
	func(fruit string) string { return strings.ToUpper(fruit) },
)
fmt.Printf("The fruit with the longest name is %s.\n", longestName)

Output:

The fruit with the longest name is PASSIONFRUIT.

AllEx example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.all#examples

pets := []Pet{
	{Name: "Barley", Age: 10},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 6},
}
// Determine whether all Pet names in the array start with 'B'.
allStartWithB, _ := All(
	SliceAll(pets),
	func(pet Pet) bool { return strings.HasPrefix(pet.Name, "B") },
)
var what string
if allStartWithB {
	what = "All"
} else {
	what = "Not all"
}
fmt.Printf("%s pet names start with 'B'.\n", what)

Output:

Not all pet names start with 'B'.

AllEx2 example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.all#examples

people := []Person{
	{
		LastName: "Haas",
		Pets: []Pet{
			{Name: "Barley", Age: 10},
			{Name: "Boots", Age: 14},
			{Name: "Whiskers", Age: 6},
		},
	},
	{
		LastName: "Fakhouri",
		Pets: []Pet{
			{Name: "Snowball", Age: 1},
		},
	},
	{
		LastName: "Antebi",
		Pets: []Pet{
			{Name: "Belle", Age: 8},
		},
	},
	{
		LastName: "Philips",
		Pets: []Pet{
			{Name: "Sweetie", Age: 2},
			{Name: "Rover", Age: 13},
		},
	},
}
// Determine which people have Pets that are all older than 5.
where, _ := Where(
	SliceAll(people),
	func(person Person) bool {
		return errorhelper.Must(All(
			SliceAll(person.Pets),
			func(pet Pet) bool { return pet.Age > 5 },
		))
	},
)
names, _ := Select(
	where,
	func(person Person) string { return person.LastName },
)
for name := range names {
	fmt.Println(name)
}

Output:

Haas
Antebi

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

markets := []Market{
	{Name: "Emily's", Items: []string{"kiwi", "cheery", "banana"}},
	{Name: "Kim's", Items: []string{"melon", "mango", "olive"}},
	{Name: "Adam's", Items: []string{"kiwi", "apple", "orange"}},
}
where, _ := Where(
	SliceAll(markets),
	func(m Market) bool {
		return errorhelper.Must(All(
			SliceAll(m.Items),
			func(item string) bool { return len(item) == 5 },
		))
	},
)
names, _ := Select(where, func(m Market) string { return m.Name })
for name := range names {
	fmt.Printf("%s market\n", name)
}

Output:

Kim's market

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.any

numbers := []int{1, 2}
hasElements, _ := Any(VarAll(numbers...))
var what string
if hasElements {
	what = "is not"
} else {
	what = "is"
}
fmt.Printf("The list %s empty.\n", what)

Output:

The list is not empty.

AnyEx2 example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.any

people := []Person{
	{
		LastName: "Haas",
		Pets: []Pet{
			{Name: "Barley", Age: 10},
			{Name: "Boots", Age: 14},
			{Name: "Whiskers", Age: 6},
		},
	},
	{
		LastName: "Fakhouri",
		Pets: []Pet{
			{Name: "Snowball", Age: 1},
		},
	},
	{
		LastName: "Antebi",
		Pets:     []Pet{},
	},
	{
		LastName: "Philips",
		Pets: []Pet{
			{Name: "Sweetie", Age: 2},
			{Name: "Rover", Age: 13},
		},
	},
}
// Determine which people have a non-empty Pet array.
where, _ := Where(
	SliceAll(people),
	func(person Person) bool { return errorhelper.Must(Any(SliceAll(person.Pets))) },
)
names, _ := Select(
	where,
	func(person Person) string { return person.LastName },
)
for name := range names {
	fmt.Println(name)
}

Output:

Haas
Fakhouri
Philips

AnyEx3 example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.any

pets := []Pet{
	{Name: "Barley", Age: 8, Vaccinated: true},
	{Name: "Boots", Age: 4, Vaccinated: false},
	{Name: "Whiskers", Age: 1, Vaccinated: false},
}
// Determine whether any pets over Age 1 are also unvaccinated.
unvaccinated, _ := AnyPred(
	SliceAll(pets),
	func(pet Pet) bool { return pet.Age > 1 && pet.Vaccinated == false },
)
var what string
if unvaccinated {
	what = "are"
} else {
	what = "are not any"
}
fmt.Printf("There %s unvaccinated animals over age one.\n", what)

Output:

There are unvaccinated animals over age one.

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

markets := []Market{
	{Name: "Emily's", Items: []string{"kiwi", "cheery", "banana"}},
	{Name: "Kim's", Items: []string{"melon", "mango", "olive"}},
	{Name: "Adam's", Items: []string{"kiwi", "apple", "orange"}},
}
where, _ := Where(
	SliceAll(markets),
	func(m Market) bool {
		return errorhelper.Must(AnyPred(
			SliceAll(m.Items),
			func(item string) bool { return strings.HasPrefix(item, "o") },
		))
	},
)
names, _ := Select(where, func(m Market) string { return m.Name })
for name := range names {
	fmt.Printf("%s market\n", name)
}

Output:

Kim's market
Adam's market

example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.average

grades := []int{78, 92, 100, 37, 81}
average, _ := Average(SliceAll(grades))
fmt.Printf("The average grade is %g.\n", average)

Output:

The average grade is 77.6.

example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.average

numbers := []string{"10007", "37", "299846234235"}
average, _ := AverageSel(
	SliceAll(numbers),
	func(e string) int {
		r, _ := strconv.Atoi(e)
		return r
	},
)
fmt.Printf("The average is %.f.\n", average)

Output:

The average is 99948748093.

example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.average

fruits := []string{"apple", "banana", "mango", "orange", "passionfruit", "grape"}
average, _ := AverageSel(
	SliceAll(fruits),
	func(e string) int { return len(e) },
)
fmt.Printf("The average string length is %g.\n", average)

Output:

The average string length is 6.5.

seq1 := ChanAll[int](chn3())
seq2, _ := Select[int](seq1, func(i int) int { return 12 / i })
first1, _ := First[int](seq2)
fmt.Println(first1)
skip, _ := Skip[int](seq2, 2)
first2, _ := First[int](skip)
fmt.Println(first2)

Output:

3
12

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

chunkNumber := 0
rng, _ := Range(0, 8)
chunk, _ := Chunk(rng, 3)
for ii := range chunk {
	chunkNumber++
	fmt.Printf("Chunk %d:%v\n", chunkNumber, ii)
}

Output:

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

ConcatEx1 example from 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},
}
concat, _ := Concat(
	errorhelper.Must(Select(
		SliceAll(cats),
		func(cat Pet) string { return cat.Name },
	)),
	errorhelper.Must(Select(
		SliceAll(dogs),
		func(dog Pet) string { return dog.Name },
	)),
)
for name := range concat {
	fmt.Println(name)
}

Output:

Barley
Boots
Whiskers
Bounder
Snoopy
Fido

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.contains

fruits := []string{"apple", "banana", "mango", "orange", "passionfruit", "grape"}
fruit := "mango"
hasMango, _ := Contains(SliceAll(fruits), fruit)
var what string
if hasMango {
	what = "does"
} else {
	what = "does not"
}
fmt.Printf("The array %s contain '%s'.\n", what, fruit)

Output:

The array does contain 'mango'.

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

markets := []Market{
	{Name: "Emily's", Items: []string{"kiwi", "cheery", "banana"}},
	{Name: "Kim's", Items: []string{"melon", "mango", "olive"}},
	{Name: "Adam's", Items: []string{"kiwi", "apple", "orange"}},
}
where, _ := Where(
	SliceAll(markets),
	func(m Market) bool {
		return errorhelper.Must(Contains(SliceAll(m.Items), "kiwi"))
	},
)
names, _ := Select(where, func(m Market) string { return m.Name })
for name := range names {
	fmt.Printf("%s market\n", name)
}

Output:

Emily's market
Adam's market

second example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.contains

fruits := []Product{
	{Name: "apple", Code: 9},
	{Name: "orange", Code: 4},
	{Name: "lemon", Code: 12},
}
apple := Product{Name: "apple", Code: 9}
kiwi := Product{Name: "kiwi", Code: 8}
var equal = func(p1, p2 Product) bool {
	return p1.Code == p2.Code && p1.Name == p2.Name
}
hasApple, _ := ContainsEq(VarAll(fruits...), apple, equal)
hasKiwi, _ := ContainsEq(VarAll(fruits...), kiwi, equal)
fmt.Printf("Apple? %t\n", hasApple)
fmt.Printf("Kiwi? %t\n", hasKiwi)

Output:

Apple? true
Kiwi? false

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.count

fruits := []string{"apple", "banana", "mango", "orange", "passionfruit", "grape"}
numberOfFruits, _ := Count(SliceAll(fruits))
fmt.Printf("There are %d fruits in the collection.\n", numberOfFruits)

Output:

There are 6 fruits in the collection.

CountEx2 example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.count

pets := []Pet{
	{Name: "Barley", Vaccinated: true},
	{Name: "Boots", Vaccinated: false},
	{Name: "Whiskers", Vaccinated: false},
}
numberUnvaccinated, _ := CountPred(
	SliceAll(pets),
	func(p Pet) bool { return p.Vaccinated == false },
)
fmt.Printf("There are %d unvaccinated animals.\n", numberUnvaccinated)

Output:

There are 2 unvaccinated animals.

LongCountEx2 example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.longcount

pets := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
}
const Age = 3
count, _ := CountPred(
	SliceAll(pets),
	func(pet Pet) bool { return pet.Age > Age },
)
fmt.Printf("There are %d animals over age %d.\n", count, Age)

Output:

There are 2 animals over age 3.

last example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.defaultifempty

numbers, _ := DefaultIfEmpty(SliceAll([]int{}))
for number := range numbers {
	fmt.Println(number)
}

Output:

0

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

pets := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
}
defaultIfEmpty, _ := DefaultIfEmpty(SliceAll(pets))
for pet := range defaultIfEmpty {
	fmt.Println(pet.Name)
}

Output:

Barley
Boots
Whiskers

DefaultIfEmptyEx2 example from 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},
}
defaultIfEmptyDef1, _ := DefaultIfEmptyDef(SliceAll(pets1), defaultPet)
for pet := range defaultIfEmptyDef1 {
	fmt.Printf("Name: %s\n", pet.Name)
}
pets2 := []Pet{}
defaultIfEmptyDef2, _ := DefaultIfEmptyDef(SliceAll(pets2), defaultPet)
for pet := range defaultIfEmptyDef2 {
	fmt.Printf("\nName: %s\n", pet.Name)
}

Output:

Name: Barley
Name: Boots
Name: Whiskers

Name: Default Pet

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.distinct

ages := []int{21, 46, 46, 55, 17, 21, 55, 55}
distinct, _ := Distinct(SliceAll(ages))
fmt.Println("Distinct ages:")
for age := range distinct {
	fmt.Println(age)
}

Output:

Distinct ages:
21
46
55
17

last two examples from 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},
}
//Exclude duplicates.
distinctEq, _ := DistinctEq(SliceAll(products), func(p1, p2 Product) bool {
	return p1.Code == p2.Code && strings.EqualFold(p1.Name, p2.Name)
})
for product := range distinctEq {
	fmt.Printf("%s %d\n", product.Name, product.Code)
}

Output:

apple 9
orange 4
lemon 12

example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.elementat

names := []string{"Hartono, Tommy", "Adams, Terry", "Andersen, Henriette Thaulow", "Hedlund, Magnus", "Ito, Shu"}
r := rand.New(rand.NewSource(623))
name, _ := ElementAt(SliceAll(names), r.Intn(len(names)))
fmt.Printf("The name chosen at random is '%s'.\n", name)

Output:

The name chosen at random is 'Hedlund, Magnus'.

example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.elementatordefault

names := []string{"Hartono, Tommy", "Adams, Terry", "Andersen, Henriette Thaulow", "Hedlund, Magnus", "Ito, Shu"}
index := 20
name, _ := ElementAtOrDefault(SliceAll(names), index)
var what string
if name == "" {
	what = "<no name at this index>"
} else {
	what = name
}
fmt.Printf("The name chosen at index %d is '%s'.\n", index, what)

Output:

The name chosen at index 20 is '<no name at this index>'.

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.except

numbers1 := VarAll(2.0, 2.0, 2.1, 2.2, 2.3, 2.3, 2.4, 2.5)
numbers2 := VarAll(2.2)
except, _ := Except(numbers1, numbers2)
for number := range except {
	fmt.Println(number)
}

Output:

2
2.1
2.3
2.4
2.5

last two examples from 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 equal = func(p1, p2 Product) bool {
	return p1.Code == p2.Code && strings.EqualFold(p1.Name, p2.Name)
}
// Get all the elements from the first array exceptEq for the elements from the second array.
exceptEq, _ := ExceptEq(
	VarAll(fruits1...),
	VarAll(fruits2...),
	equal,
)
for product := range exceptEq {
	fmt.Printf("%s %d\n", product.Name, product.Code)
}

Output:

orange 4
lemon 12

second example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.first

numbers := []int{9, 34, 65, 92, 87, 435, 3, 54, 83, 23, 87, 435, 67, 12, 19}
first, _ := First(SliceAll(numbers))
fmt.Println(first)

Output:

9

first two examples from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.firstordefault

numbers := []int{}
firstOrDefault1, _ := FirstOrDefault(SliceAll(numbers))
fmt.Println(firstOrDefault1)

months := []int{}
// Setting the default value to 1 after the query.
firstOrDefault2, _ := FirstOrDefault(VarAll(months...))
if firstOrDefault2 == 0 {
	firstOrDefault2 = 1
}
fmt.Printf("The value of the firstMonth1 variable is %v\n", firstOrDefault2)

// Setting the default value to 1 by using DefaultIfEmptyDef() in the query.
defaultIfEmptyDef, _ := DefaultIfEmptyDef(SliceAll(months), 1)
first, _ := First(defaultIfEmptyDef)
fmt.Printf("The value of the firstMonth2 variable is %v\n", first)

Output:

0
The value of the firstMonth1 variable is 1
The value of the firstMonth2 variable is 1

last example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.firstordefault

names := []string{"Hartono, Tommy", "Adams, Terry", "Andersen, Henriette Thaulow", "Hedlund, Magnus", "Ito, Shu"}
firstLongName, _ := FirstOrDefaultPred(
	SliceAll(names),
	func(name string) bool { return len(name) > 20 },
)
fmt.Printf("The first long name is '%v'.\n", firstLongName)

firstVeryLongName, _ := FirstOrDefaultPred(
	SliceAll(names),
	func(name string) bool { return len(name) > 30 },
)
var what string
if firstVeryLongName == "" {
	what = "not a"
} else {
	what = "a"
}
fmt.Printf("There is %v name longer than 30 characters.\n", what)

Output:

The first long name is 'Andersen, Henriette Thaulow'.
There is not a name longer than 30 characters.

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.first

numbers := []int{9, 34, 65, 92, 87, 435, 3, 54, 83, 23, 87, 435, 67, 12, 19}
firstPred, _ := FirstPred(
	SliceAll(numbers),
	func(number int) bool { return number > 80 },
)
fmt.Println(firstPred)

Output:

92

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

groupBy, _ := GroupBy(
	VarAll(35, 44, 200, 84, 3987, 4, 199, 329, 446, 208),
	func(i int) int { return i % 2 },
)
for group := range groupBy {
	if group.Key() == 0 {
		fmt.Println("\nEven numbers:")
	} else {
		fmt.Println("\nOdd numbers:")
	}
	for i := range group.Values() {
		fmt.Println(i)
	}
}

Output:

Odd numbers:
35
3987
199
329

Even numbers:
44
200
84
4
446
208

GroupByEx3 example from 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,
// Count of the group's elements, and the minimum and maximum Age in the group.
groupByRes, _ := GroupByRes(
	SliceAll(pets),
	func(pet PetF) float64 { return math.Floor(pet.Age) },
	func(age float64, pets iter.Seq[PetF]) Result {
		count, _ := Count(pets)
		min, _ := MinSel(pets, func(pet PetF) float64 { return pet.Age })
		max, _ := MaxSel(pets, func(pet PetF) float64 { return pet.Age })
		return Result{Key: age, Count: count, Min: min, Max: max}
	},
)
for result := range groupByRes {
	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

GroupByEx1 example from 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.
groupBySel, _ := GroupBySel(
	SliceAll(pets),
	func(pet Pet) int { return pet.Age },
	func(pet Pet) string { return pet.Name },
)
// Iterate over each Grouping in the collection.
for petGroup := range groupBySel {
	// Print the key value of the Grouping.
	fmt.Println(petGroup.Key())
	// Iterate over each value in the Grouping and print the value.
	for name := range petGroup.Values() {
		fmt.Printf("  %s\n", name)
	}
}

Output:

8
  Barley
4
  Boots
  Daisy
1
  Whiskers

GroupByEx4 example from 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,
// Count of the group's elements, and the minimum and maximum Age in the group.
groupBySelRes, _ := GroupBySelRes(
	SliceAll(pets),
	func(pet PetF) float64 { return math.Floor(pet.Age) },
	func(pet PetF) float64 { return pet.Age },
	func(baseAge float64, ages iter.Seq[float64]) Result {
		count, _ := Count(ages)
		min, _ := Min(ages)
		max, _ := Max(ages)
		return Result{Key: baseAge, Count: count, Min: min, Max: max}
	},
)
for result := range groupBySelRes {
	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

GroupJoinEx1 example from 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}

groupJoin, _ := GroupJoin(
	SliceAll(people),
	SliceAll(pets),
	Identity[Person],
	func(pet Pet) Person { return pet.Owner },
	func(person Person, pets iter.Seq[Pet]) OwnerAndPets {
		return OwnerAndPets{
			OwnerName: person.Name,
			Pets:      errorhelper.Must(Select(pets, func(pet Pet) string { return pet.Name }))}
	},
)
for obj := range groupJoin {
	// Output the owner's name.
	fmt.Printf("%s:\n", obj.OwnerName)
	// Output each of the owner's pet's names.
	for pet := range obj.Pets {
		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, _ := GroupJoin(
	SliceAll(categories),
	SliceAll(products),
	func(category Category) int { return category.Id },
	func(product Product) int { return product.CategoryId },
	func(category Category, products iter.Seq[Product]) iter.Seq[Product] {
		return products
	},
)
for productGroup := range productGroups {
	fmt.Println("Group")
	for product := range productGroup {
		fmt.Printf("%8s\n", product.Name)
	}
}

Output:

Group
    Cola
     Tea
Group
   Apple
    Kiwi
Group
  Carrot

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.intersect

id1 := VarAll(44, 26, 92, 30, 71, 38)
id2 := VarAll(39, 59, 83, 47, 26, 4, 30)
intersect, _ := Intersect(id1, id2)
for id := range intersect {
	fmt.Println(id)
}

Output:

26
30

second and third examples from 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.
equal := func(p1, p2 Product) bool {
	return p1.Name == p2.Name && p1.Code == p2.Code
}
intersectEq, _ := IntersectEq(SliceAll(store1), SliceAll(store2), equal)
for product := range intersectEq {
	fmt.Printf("%s %d\n", product.Name, product.Code)
}

Output:

apple 9

JoinEx1 example from 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}

// 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, _ := Join(
	VarAll(magnus, terry, charlotte),
	VarAll(barley, boots, whiskers, daisy),
	Identity[Person],
	func(pet Pet) Person { return pet.Owner },
	func(person Person, pet Pet) OwnerNameAndPetName {
		return OwnerNameAndPetName{Owner: person.Name, Pet: pet.Name}
	},
)
for obj := range join {
	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, _ := Join(
	SliceAll(products),
	SliceAll(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)
	},
)
for item := range join {
	fmt.Println(item)
}

Output:

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

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.last

numbers := []int{9, 34, 65, 92, 87, 435, 3, 54, 83, 23, 87, 67, 12, 19}
last, _ := Last(SliceAll(numbers))
fmt.Println(last)

Output:

19

first two examples from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.lastordefault

fruits := []string{}
last, _ := LastOrDefault(SliceAll(fruits))
if last == "" {
	fmt.Println("<string is empty>")
} else {
	fmt.Println(last)
}

daysOfMonth := []int{}
// Setting the default value to 1 after the query.
lastDay1, _ := LastOrDefault(SliceAll(daysOfMonth))
if lastDay1 == 0 {
	lastDay1 = 1
}
fmt.Printf("The value of the lastDay1 variable is %v\n", lastDay1)

// Setting the default value to 1 by using DefaultIfEmptyDef() in the query.
defaultIfEmptyDef, _ := DefaultIfEmptyDef(SliceAll(daysOfMonth), 1)
lastDay2, _ := Last(defaultIfEmptyDef)
fmt.Printf("The value of the lastDay2 variable is %d\n", lastDay2)

Output:

<string is empty>
The value of the lastDay1 variable is 1
The value of the lastDay2 variable is 1

last example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.lastordefault

numbers := []float64{49.6, 52.3, 51.0, 49.4, 50.2, 48.3}
last50, _ := LastOrDefaultPred(
	SliceAll(numbers),
	func(n float64) bool { return math.Round(n) == 50.0 },
)
fmt.Printf("The last number that rounds to 50 is %v.\n", last50)

last40, _ := LastOrDefaultPred(
	SliceAll(numbers),
	func(n float64) bool { return math.Round(n) == 40.0 },
)
var what string
if last40 == 0.0 {
	what = "<DOES NOT EXIST>"
} else {
	what = fmt.Sprint(last40)
}
fmt.Printf("The last number that rounds to 40 is %v.\n", what)

Output:

The last number that rounds to 50 is 50.2.
The last number that rounds to 40 is <DOES NOT EXIST>.

last example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.last

numbers := []int{9, 34, 65, 92, 87, 435, 3, 54, 83, 23, 87, 67, 12, 19}
lastPred, _ := LastPred(
	SliceAll(numbers),
	func(number int) bool { return number > 80 },
)
fmt.Println(lastPred)

Output:

87

m := map[int]string{1: "one", 2: "two", 3: "three", 4: "four"}
for i, s := range MapAll(m) {
	fmt.Println(i, s)
}

Output:

1 one
2 two
3 three
4 four

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.max

longs := []int{4294967296, 466855135, 81125}
max, _ := Max(SliceAll(longs))
fmt.Printf("The largest number is %d.\n", max)

Output:

The largest number is 4294967296.

maxBySel1, _ := MaxBySel(
	errorhelper.Must(Range(1, 10)),
	func(i int) int { return i * i % 10 },
)
fmt.Println(maxBySel1)
maxBySel2, _ := MaxBySel(
	VarAll("one", "two", "three", "four", "five"),
	func(s string) int { return len(s) },
)
fmt.Println(maxBySel2)

Output:

3
three

MaxEx3 example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.max

pets := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
}
maxLs, _ := MaxLs(
	SliceAll(pets),
	// Compares Pets by summing each Pet's age and name length.
	func(p1, p2 Pet) bool { return p1.Age+len(p1.Name) < p2.Age+len(p2.Name) },
)
fmt.Printf("The 'maximum' animal is %s.\n", maxLs.Name)

Output:

The 'maximum' animal is Barley.

MaxEx4 example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.max

pets := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
}
maxSel, _ := MaxSel(SliceAll(pets), func(pet Pet) int { return pet.Age + len(pet.Name) })
fmt.Printf("The maximum pet age plus name length is %d.\n", maxSel)

Output:

The maximum pet age plus name length is 14.

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.min

doubles := []float64{1.5e+104, 9e+103, -2e+103}
min, _ := Min(SliceAll(doubles))
fmt.Printf("The smallest number is %G.\n", min)

Output:

The smallest number is -2E+103.

minBySel1, _ := MinBySel(
	errorhelper.Must(Range(1, 10)),
	func(i int) int { return i * i % 10 },
)
fmt.Println(minBySel1)
minBySel2, _ := MinBySel(
	VarAll("one", "two", "three", "four", "five"),
	func(s string) int { return len(s) },
)
fmt.Println(minBySel2)

Output:

10
one

MinEx3 example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.min

pets := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
}
minLs, _ := MinLs(
	SliceAll(pets),
	// Compares Pet's ages.
	func(p1, p2 Pet) bool { return p1.Age < p2.Age },
)
fmt.Printf("The 'minimum' animal is %s.\n", minLs.Name)

Output:

The 'minimum' animal is Whiskers.

MinEx4 example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.min

pets := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
}
minSel, _ := MinSel(SliceAll(pets), func(pet Pet) int { return pet.Age })
fmt.Printf("The youngest animal is age %d.\n", minSel)

Output:

The youngest animal is age 1.

fmt.Println(StringDef[string](
	errorhelper.Must(OrderBy(VarAll("zero", "one", "two", "three", "four", "five"))),
))

Output:

[five four one three two zero]

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

decimals := []float64{6.2, 8.3, 0.5, 1.3, 6.3, 9.7}
less := 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
}
orderByDescLs, _ := OrderByDescLs(SliceAll(decimals), less)
for num := range orderByDescLs {
	fmt.Println(num)
}

Output:

9.7
0.5
8.3
6.3
1.3
6.2

fmt.Println(StringDef[string](
	errorhelper.Must(OrderByKeyDesc(
		VarAll("zero", "one", "two", "three", "four", "five"),
		func(s string) int { return len(s) },
	)),
))

Output:

[three zero four five one two]

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

pets := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
}
orderByLs, _ := OrderByLs(SliceAll(pets), func(p1, p2 Pet) bool { return p1.Age < p2.Age })
for pet := range orderByLs {
	fmt.Printf("%s - %d\n", pet.Name, pet.Age)
}

Output:

Whiskers - 1
Boots - 4
Barley - 8

example from 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.
rnge, _ := Range(1, 10)
squares, _ := Select(rnge, func(x int) int { return x * x })
for num := range squares {
	fmt.Println(num)
}

Output:

1
4
9
16
25
36
49
64
81
100

example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.repeat#examples

ss, _ := Repeat("I like programming.", 4)
for s := range ss {
	fmt.Println(s)
}

Output:

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

example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.reverse#examples

apple := []string{"a", "p", "p", "l", "e"}
reverse, _ := Reverse(SliceAll(apple))
for num := range reverse {
	fmt.Print(num)
}
fmt.Println()

Output:

elppa

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.select

rnge, _ := Range(1, 10)
squares, _ := Select(rnge, func(x int) int { return x * x })
for num := range squares {
	fmt.Println(num)
}

Output:

1
4
9
16
25
36
49
64
81
100

numbers := []string{"one", "two", "three", "four", "five"}
select1, _ := Select(
	SliceAll(numbers),
	func(s string) string {
		return string(s[0]) + string(s[len(s)-1])
	},
)
fmt.Println(StringDef(select1))
select2, _ := Select(
	SliceAll(numbers),
	func(s string) string {
		runes := []rune(s)
		reversedRunes, _ := ToSlice(errorhelper.Must(Reverse(SliceAll(runes))))
		return string(reversedRunes)
	},
)
fmt.Println(StringDef(select2))

Output:

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

fruits := []string{"apple", "banana", "mango", "orange", "passionfruit", "grape"}
selectIdx, _ := SelectIdx(
	SliceAll(fruits),
	func(fruit string, index int) indexStr {
		return indexStr{index: index, str: fruit[:index]}
	},
)
for is := range selectIdx {
	fmt.Printf("%+v\n", is)
}

Output:

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

second example from 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},
}
select1, _ := Select(SliceAll(cats), func(cat Pet) string { return cat.Name })
select2, _ := Select(SliceAll(dogs), func(dog Pet) string { return dog.Name })
selectMany, _ := SelectMany(VarAll(select1, select2), Identity[iter.Seq[string]])
for name := range selectMany {
	fmt.Println(name)
}

Output:

Barley
Boots
Whiskers
Bounder
Snoopy
Fido

SelectManyEx1 example from 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().
selectMany, _ := SelectMany(
	SliceAll(petOwners),
	func(petOwner PetOwner) iter.Seq[string] { return SliceAll(petOwner.Pets) },
)
fmt.Println("Using SelectMany():")
// Only one loop is required to iterate through the results since it is a one-dimensional collection.
for pet := range selectMany {
	fmt.Println(pet)
}

// This code shows how to use Select() instead of SelectMany().
petLists, _ := Select(
	SliceAll(petOwners),
	func(petOwner PetOwner) iter.Seq[string] {
		return SliceAll(petOwner.Pets)
	},
)
fmt.Println("\nUsing Select():")
// Notice that two loops are required to iterate through the results
// because the query returns a collection of sequences.
for petList := range petLists {
	for pet := range petList {
		fmt.Println(pet)
	}
	fmt.Println()
}

Output:

Using SelectMany():
Scruffy
Sam
Walker
Sugar
Scratches
Diesel

Using Select():
Scruffy
Sam

Walker
Sugar

Scratches
Diesel

SelectManyEx3 example from 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.
selectManyColl, _ := SelectManyColl(
	SliceAll(petOwners),
	func(petOwner PetOwner) iter.Seq[string] {
		return SliceAll(petOwner.Pets)
	},
	func(petOwner PetOwner, petName string) OwnerAndPet {
		return OwnerAndPet{petOwner: petOwner, petName: petName}
	},
)
// Filter only pet's names that start with S.
where, _ := Where(selectManyColl,
	func(ownerAndPet OwnerAndPet) bool {
		return strings.HasPrefix(ownerAndPet.petName, "S")
	},
)
// Project the pet owner's name and the pet's name.
ownerPetNames, _ := Select(where,
	func(ownerAndPet OwnerAndPet) OwnerNameAndPetName {
		return OwnerNameAndPetName{Owner: ownerAndPet.petOwner.Name, Pet: ownerAndPet.petName}
	},
)
for ownerPetName := range ownerPetNames {
	fmt.Printf("%+v\n", ownerPetName)
}

Output:

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

SelectManyEx2 example from 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 slice of pets.
selectManyIdx, _ := SelectManyIdx(
	SliceAll(petOwners),
	func(petOwner PetOwner, index int) iter.Seq[string] {
		return errorhelper.Must(
			Select(
				SliceAll(petOwner.Pets),
				func(pet string) string { return strconv.Itoa(index) + pet },
			),
		)
	},
)
for pet := range selectManyIdx {
	fmt.Println(pet)
}

Output:

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

SequenceEqualEx1 example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.sequenceequal

pet1 := Pet{Name: "Turbo", Age: 2}
pet2 := Pet{Name: "Peanut", Age: 8}
pets1 := []Pet{pet1, pet2}
pets2 := []Pet{pet1, pet2}
sequenceEqual, _ := SequenceEqual(SliceAll(pets1), SliceAll(pets2))
var what string
if sequenceEqual {
	what = "are"
} else {
	what = "are not"
}
fmt.Printf("The lists %s equal.\n", what)

Output:

The lists are equal.

last example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.sequenceequal

storeA := []Product{
	{Name: "apple", Code: 9},
	{Name: "orange", Code: 4},
}
storeB := []Product{
	{Name: "apple", Code: 9},
	{Name: "orange", Code: 4},
}
equalEq, _ := SequenceEqualEq(
	SliceAll(storeA),
	SliceAll(storeB),
	func(p1, p2 Product) bool {
		return p1.Code == p2.Code && p1.Name == p2.Name
	},
)
fmt.Printf("Equal? %t\n", equalEq)

Output:

Equal? true

second example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.single

fruits := []string{"orange", "apple"}
fruit, err := Single(SliceAll(fruits))
if errors.Is(err, ErrMultipleElements) {
	fmt.Println("The collection does not contain exactly one element.")
} else {
	fmt.Println(fruit)
}

Output:

The collection does not contain exactly one element.

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.single

fruits := []string{"orange"}
fruit, _ := Single(SliceAll(fruits))
fmt.Println(fruit)

Output:

orange

third example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.singleordefault

pageNumbers := []int{}
// Setting the default value to 1 by using DefaultIfEmpty() in the query.
pageNumber, _ := Single(errorhelper.Must(DefaultIfEmptyDef(SliceAll(pageNumbers), 1)))
fmt.Printf("The value of the pageNumber2 variable is %d\n", pageNumber)

Output:

The value of the pageNumber2 variable is 1

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.singleordefault

fruits := []string{"orange"}
fruit, _ := SingleOrDefault(SliceAll(fruits))
fmt.Println(fruit)

Output:

orange

second example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.singleordefault

fruits := []string{}
fruit, _ := SingleOrDefault(SliceAll(fruits))
var what string
if fruit == "" {
	what = "No such string!"
} else {
	what = fruit
}
fmt.Println(what)

Output:

No such string!

third example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.singleordefault

var pageNumbers []int = nil
// Setting the default value to 1 after the query.
pageNumber, _ := SingleOrDefault(SliceAll(pageNumbers))
if pageNumber == 0 {
	pageNumber = 1
}
fmt.Printf("The value of the pageNumber1 variable is %d\n", pageNumber)

Output:

The value of the pageNumber1 variable is 1

fourth and fifth examples from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.singleordefault

fruits := []string{"apple", "banana", "mango", "orange", "passionfruit", "grape"}
fruit1, _ := SingleOrDefaultPred(SliceAll(fruits), func(fr string) bool { return len(fr) > 10 })
fmt.Println(fruit1)

fruit2, _ := SingleOrDefaultPred(SliceAll(fruits), func(fr string) bool { return len(fr) > 15 })
var what string
if fruit2 == "" {
	what = "No such string!"
} else {
	what = fruit2
}
fmt.Println(what)

Output:

passionfruit
No such string!

third and fourth examples from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.single

fruits := []string{"apple", "banana", "mango", "orange", "passionfruit", "grape"}

fruit1, _ := SinglePred(SliceAll(fruits), func(fr string) bool { return len(fr) > 10 })
fmt.Println(fruit1)

fruit2, err := SinglePred(SliceAll(fruits), func(fr string) bool { return len(fr) > 15 })
if errors.Is(err, ErrNoMatch) {
	fmt.Println("The collection does not contain exactly one element whose length is greater than 15.")
} else {
	fmt.Println(fruit2)
}

fruit3, err := SinglePred(
	SliceAll(fruits),
	func(fr string) bool { return len(fr) > 5 },
)
if errors.Is(err, ErrMultipleMatch) {
	fmt.Println("The collection does not contain exactly one element whose length is greater than 5.")
} else {
	fmt.Println(fruit3)
}

Output:

passionfruit
The collection does not contain exactly one element whose length is greater than 15.
The collection does not contain exactly one element whose length is greater than 5.

example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.skip#examples

grades := []int{59, 82, 70, 56, 92, 98, 85}
orderedGrades, _ := OrderByDesc(SliceAll(grades))
lowerGrades, _ := Skip(orderedGrades, 3)
fmt.Println("All grades except the top three are:")
for grade := range lowerGrades {
	fmt.Println(grade)
}

Output:

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

second example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.skipwhile

grades := []int{59, 82, 70, 56, 92, 98, 85}
orderedGrades, _ := OrderByDesc(SliceAll(grades))
lowerGrades, _ := SkipWhile[int](orderedGrades, func(grade int) bool { return grade >= 80 })
fmt.Println("All grades below 80:")
for grade := range lowerGrades {
	fmt.Println(grade)
}

Output:

All grades below 80:
70
59
56

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.skipwhile

amounts := []int{5000, 2500, 9000, 8000, 6500, 4000, 1500, 5500}
skipWhileIdx, _ := SkipWhileIdx(SliceAll(amounts), func(amount, index int) bool { return amount > index*1000 })
for amount := range skipWhileIdx {
	fmt.Println(amount)
}

Output:

4000
1500
5500

example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.sum

numbers := []float64{43.68, 1.25, 583.7, 6.5}
sum, _ := Sum(SliceAll(numbers))
fmt.Printf("The sum of the numbers is %g.\n", sum)

Output:

The sum of the numbers is 635.13.

SumEx1 example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.sum

packages := []Package{
	{Company: "Coho Vineyard", Weight: 25.2},
	{Company: "Lucerne Publishing", Weight: 18.7},
	{Company: "Wingtip Toys", Weight: 6.0},
	{Company: "Adventure Works", Weight: 33.8},
}
totalWeight, _ := SumSel(
	SliceAll(packages),
	func(pkg Package) float64 { return pkg.Weight },
)
fmt.Printf("The total weight of the packages is: %.1f\n", totalWeight)

Output:

The total weight of the packages is: 83.7

example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.take

grades := []int{59, 82, 70, 56, 92, 98, 85}
orderedGrades, _ := OrderByDesc(SliceAll(grades))
topThreeGrades, _ := Take[int](orderedGrades, 3)
fmt.Println("The top three grades are:")
for grade := range topThreeGrades {
	fmt.Println(grade)
}

Output:

The top three grades are:
98
92
85

second example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.takewhile

fruits := []string{"apple", "banana", "mango", "orange", "passionfruit", "grape"}
takeWhile, _ := TakeWhile(
	SliceAll(fruits),
	func(fruit string) bool { return fruit != "orange" },
)
for fruit := range takeWhile {
	fmt.Println(fruit)
}

Output:

apple
banana
mango

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.takewhile

fruits := []string{"apple", "passionfruit", "banana", "mango", "orange", "blueberry", "grape", "strawberry"}
takeWhileIdx, _ := TakeWhileIdx(
	SliceAll(fruits),
	func(fruit string, index int) bool {
		return len(fruit) >= index
	},
)
for fruit := range takeWhileIdx {
	fmt.Println(fruit)
}

Output:

apple
passionfruit
banana
mango
orange
blueberry

ToDictionaryEx1 example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.todictionary

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: "Adventure Works", Weight: 33.8, TrackingNumber: 4665518773},
}
// Create a map of Package objects, using TrackingNumber as the key.
dictionary, _ := ToMap(
	SliceAll(packages),
	func(p Package) int64 { return p.TrackingNumber },
)
for k, p := range dictionary {
	fmt.Printf("Key %d: %s, %g pounds\n", k, p.Company, p.Weight)
}

Output:

Key 89453312: Coho Vineyard, 25.2 pounds
Key 89112755: Lucerne Publishing, 18.7 pounds
Key 299456122: Wingtip Toys, 6 pounds
Key 4665518773: Adventure Works, 33.8 pounds

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.union

union, _ := Union(VarAll(5, 3, 9, 7, 5, 9, 3, 7), VarAll(8, 3, 6, 4, 4, 9, 1, 0))
for num := range union {
	fmt.Printf("%d ", num)
}

Output:

5 3 9 7 8 6 4 1 0

last example from 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.
equal := func(p1, p2 Product) bool { return p1.Code == p2.Code && p1.Name == p2.Name }
unionEq, _ := UnionEq(SliceAll(store1), SliceAll(store2), equal)
for product := range unionEq {
	fmt.Printf("%s %d\n", product.Name, product.Code)
}

Output:

apple 9
orange 4
lemon 12

first example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.where

fruits := []string{"apple", "passionfruit", "banana", "mango", "orange", "blueberry", "grape", "strawberry"}
where, _ := Where(
	SliceAll(fruits),
	func(fruit string) bool { return len(fruit) < 6 },
)
for fruit := range where {
	fmt.Println(fruit)
}

Output:

apple
mango
grape

range1, _ := Range(1, 10)
where1, _ := Where(
	range1,
	func(i int) bool { return i%2 == 0 },
)
fmt.Println(StringDef(where1))
where2, _ := Where(
	VarAll("one", "two", "three", "four", "five"),
	func(s string) bool { return strings.HasSuffix(s, "e") },
)
fmt.Println(StringDef(where2))

Output:

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

last example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.where

numbers := []int{0, 30, 20, 15, 90, 85, 40, 75}
whereIdx, _ := WhereIdx(
	SliceAll(numbers),
	func(number, index int) bool { return number <= index*10 },
)
for number := range whereIdx {
	fmt.Println(number)
}

Output:

0
20
15
40

whereIdx1, _ := WhereIdx(
	VarAll("one", "two", "three", "four", "five"),
	func(s string, i int) bool { return len(s) == i },
)
fmt.Println(StringDef(whereIdx1))
reverse2, _ := Reverse(VarAll("one", "two", "three", "four", "five"))
whereIdx2, _ := WhereIdx(
	reverse2,
	func(s string, i int) bool { return len(s) == i },
)
fmt.Println(StringDef(whereIdx2))
orderBy, _ := OrderBy(VarAll("one", "two", "three", "four", "five"))
whereIdx3, _ := WhereIdx(
	orderBy,
	func(s string, i int) bool { return len(s) > i },
)
fmt.Println(StringDef(whereIdx3))

Output:

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

example from https://learn.microsoft.com/dotnet/api/system.linq.enumerable.zip

numbers := []int{1, 2, 3, 4}
words := []string{"one", "two", "three"}
zip, _ := Zip(SliceAll(numbers), SliceAll(words),
	func(first int, second string) string { return fmt.Sprintf("%d %s", first, second) },
)
for item := range zip {
	fmt.Println(item)
}

Output:

1 one
2 two
3 three