Back to godoc.org
github.com/ahmetb/go-linq

package linq

v3.0.0+incompatible
Latest Go to latest
Published: Jan 10, 2017 | License: Apache-2.0 | Module: github.com/ahmetb/go-linq

Overview

Package linq provides methods for querying and manipulating slices, arrays, maps, strings, channels and collections.

Authors: Alexander Kalankhodzhaev (kalan), Ahmet Alp Balkan, Cleiton Marques Souza.

Index

Examples

type Comparable

type Comparable interface {
	CompareTo(Comparable) int
}

Comparable is an interface that has to be implemented by a custom collection elememts in order to work with linq.

Example:

func (f foo) CompareTo(c Comparable) int {
	a, b := f.f1, c.(foo).f1

	if a < b {
		return -1
	} else if a > b {
		return 1
	}

	return 0
}

type Group

type Group struct {
	Key   interface{}
	Group []interface{}
}

Group is a type that is used to store the result of GroupBy method.

type Iterable

type Iterable interface {
	Iterate() Iterator
}

Iterable is an interface that has to be implemented by a custom collection in order to work with linq.

type Iterator

type Iterator func() (item interface{}, ok bool)

Iterator is an alias for function to iterate over data.

type KeyValue

type KeyValue struct {
	Key   interface{}
	Value interface{}
}

KeyValue is a type that is used to iterate over a map (if query is created from a map). This type is also used by ToMap() method to output result of a query into a map.

Example

Code:

m := make(map[int]bool)
m[10] = true

fmt.Println(From(m).Results())

Output:

[{10 true}]
Example (Second)

Code:

input := []KeyValue{
	{10, true},
}

m := make(map[int]bool)
From(input).
	ToMap(&m)

fmt.Println(m)

Output:

map[10:true]

type OrderedQuery

type OrderedQuery struct {
	Query
	// contains filtered or unexported fields
}

OrderedQuery is the type returned from OrderBy, OrderByDescending ThenBy and ThenByDescending functions.

func (OrderedQuery) Distinct

func (oq OrderedQuery) Distinct() OrderedQuery

Distinct method returns distinct elements from a collection. The result is an ordered collection that contains no duplicate values.

NOTE: Distinct method on OrderedQuery type has better performance than Distinct method on Query type.

Example

The following code example demonstrates how to use Distinct to return distinct elements from a slice of integers.

Code:

ages := []int{21, 46, 46, 55, 17, 21, 55, 55}

var distinctAges []int
From(ages).
	OrderBy(
		func(item interface{}) interface{} { return item },
	).
	Distinct().
	ToSlice(&distinctAges)

fmt.Println(distinctAges)

Output:

[17 21 46 55]

func (OrderedQuery) ThenBy

func (oq OrderedQuery) ThenBy(
	selector func(interface{}) interface{}) OrderedQuery

ThenBy performs a subsequent ordering of the elements in a collection in ascending order. This method enables you to specify multiple sort criteria by applying any number of ThenBy or ThenByDescending methods.

Example

The following code example demonstrates how to use ThenBy to perform a secondary ordering of the elements in a slice.

Code:

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

// Sort the strings first by their length and then
//alphabetically by passing the identity selector function.
var query []string
From(fruits).
	OrderBy(
		func(fruit interface{}) interface{} { return len(fruit.(string)) },
	).
	ThenBy(
		func(fruit interface{}) interface{} { return fruit },
	).
	ToSlice(&query)

for _, fruit := range query {
	fmt.Println(fruit)
}

Output:

apple
grape
mango
banana
orange
blueberry
raspberry
passionfruit

func (OrderedQuery) ThenByDescending

func (oq OrderedQuery) ThenByDescending(selector func(interface{}) interface{}) OrderedQuery

ThenByDescending performs a subsequent ordering of the elements in a collection in descending order. This method enables you to specify multiple sort criteria by applying any number of ThenBy or ThenByDescending methods.

Example

The following code example demonstrates how to use ThenByDescending to perform a secondary ordering of the elements in a slice in descending order.

Code:

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.
var query []string
From(fruits).
	OrderBy(
		func(fruit interface{}) interface{} { return len(fruit.(string)) },
	).
	ThenByDescending(
		func(fruit interface{}) interface{} { return fruit.(string)[0] },
	).
	ToSlice(&query)

for _, fruit := range query {
	fmt.Println(fruit)
}

Output:

apPLe
apPLE
apple
APple
orange
baNanA
ORANGE
BAnana

func (OrderedQuery) ThenByDescendingT

func (oq OrderedQuery) ThenByDescendingT(selectorFn interface{}) OrderedQuery

ThenByDescendingT is the typed version of ThenByDescending.

- selectorFn is of type "func(TSource) TKey"

NOTE: ThenByDescending has better performance than ThenByDescendingT.

Example

The following code example demonstrates how to use ThenByDescendingT to perform a order in a slice of dates by year, and then by month descending.

Code:

dates := []time.Time{
	time.Date(2015, 3, 23, 0, 0, 0, 0, time.Local),
	time.Date(2014, 7, 11, 0, 0, 0, 0, time.Local),
	time.Date(2013, 5, 4, 0, 0, 0, 0, time.Local),
	time.Date(2015, 1, 2, 0, 0, 0, 0, time.Local),
	time.Date(2015, 7, 10, 0, 0, 0, 0, time.Local),
}

var orderedDates []time.Time
From(dates).
	OrderByT(
		func(date time.Time) int {
			return date.Year()
		}).
	ThenByDescendingT(
		func(date time.Time) int { return int(date.Month()) },
	).
	ToSlice(&orderedDates)

for _, date := range orderedDates {
	fmt.Println(date.Format("2006-Jan-02"))
}

Output:

2013-May-04
2014-Jul-11
2015-Jul-10
2015-Mar-23
2015-Jan-02

func (OrderedQuery) ThenByT

func (oq OrderedQuery) ThenByT(selectorFn interface{}) OrderedQuery

ThenByT is the typed version of ThenBy.

- selectorFn is of type "func(TSource) TKey"

NOTE: ThenBy has better performance than ThenByT.

Example

The following code example demonstrates how to use ThenByT to perform a orders in a slice of dates by year, and then by day.

Code:

dates := []time.Time{
	time.Date(2015, 3, 23, 0, 0, 0, 0, time.Local),
	time.Date(2014, 7, 11, 0, 0, 0, 0, time.Local),
	time.Date(2013, 5, 4, 0, 0, 0, 0, time.Local),
	time.Date(2015, 1, 2, 0, 0, 0, 0, time.Local),
	time.Date(2015, 7, 10, 0, 0, 0, 0, time.Local),
}

var orderedDates []time.Time
From(dates).
	OrderByT(
		func(date time.Time) int { return date.Year() },
	).
	ThenByT(
		func(date time.Time) int { return int(date.Day()) },
	).
	ToSlice(&orderedDates)

for _, date := range orderedDates {
	fmt.Println(date.Format("2006-Jan-02"))
}

Output:

2013-May-04
2014-Jul-11
2015-Jan-02
2015-Jul-10
2015-Mar-23

type Query

type Query struct {
	Iterate func() Iterator
}

Query is the type returned from query functions. It can be iterated manually as shown in the example.

Example

Code:

query := From([]int{1, 2, 3, 4, 5}).Where(func(i interface{}) bool {
	return i.(int) <= 3
})

next := query.Iterate()
for item, ok := next(); ok; item, ok = next() {
	fmt.Println(item)
}

Output:

1
2
3

func From

func From(source interface{}) Query

From initializes a linq query with passed slice, array or map as the source. String, channel or struct implementing Iterable interface can be used as an input. In this case From delegates it to FromString, FromChannel and FromIterable internally.

func FromChannel

func FromChannel(source <-chan interface{}) Query

FromChannel initializes a linq query with passed channel, linq iterates over channel until it is closed.

func FromIterable

func FromIterable(source Iterable) Query

FromIterable initializes a linq query with custom collection passed. This collection has to implement Iterable interface, linq iterates over items, that has to implement Comparable interface or be basic types.

func FromString

func FromString(source string) Query

FromString initializes a linq query with passed string, linq iterates over runes of string.

func Range

func Range(start, count int) Query

Range generates a sequence of integral numbers within a specified range.

Example

The following code example demonstrates how to use Range to generate a slice of values.

Code:

// Generate a slice of integers from 1 to 10
// and then select their squares.
var squares []int
Range(1, 10).
	SelectT(
		func(x int) int { return x * x },
	).
	ToSlice(&squares)

for _, num := range squares {
	fmt.Println(num)
}

Output:

1
4
9
16
25
36
49
64
81
100

func Repeat

func Repeat(value interface{}, count int) Query

Repeat generates a sequence that contains one repeated value.

Example

The following code example demonstrates how to use Repeat to generate a slice of a repeated value.

Code:

var slice []string
Repeat("I like programming.", 5).
	ToSlice(&slice)

for _, str := range slice {
	fmt.Println(str)
}

Output:

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

func (Query) Aggregate

func (q Query) Aggregate(f func(interface{}, interface{}) interface{}) interface{}

Aggregate applies an accumulator function over a sequence.

Aggregate method makes it simple to perform a calculation over a sequence of values. This method works by calling f() one time for each element in source except the first one. Each time f() is called, Aggregate passes both the element from the sequence and an aggregated value (as the first argument to f()). The first element of source is used as the initial aggregate value. The result of f() replaces the previous aggregated value.

Aggregate returns the final result of f().

Example

The following code example demonstrates how to use Aggregate function

Code:

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

// Determine which string in the slice is the longest.
longestName := From(fruits).
	Aggregate(
		func(r interface{}, i interface{}) interface{} {
			if len(r.(string)) > len(i.(string)) {
				return r
			}
			return i
		},
	)

fmt.Println(longestName)

Output:

passionfruit

func (Query) AggregateT

func (q Query) AggregateT(f interface{}) interface{}

AggregateT is the typed version of Aggregate.

- f is of type: func(TSource, TSource) TSource

NOTE: Aggregate has better performance than AggregateT.

Example

The following code example demonstrates how to reverse the order of words in a string using AggregateT.

Code:

sentence := "the quick brown fox jumps over the lazy dog"
// Split the string into individual words.
words := strings.Split(sentence, " ")

// Prepend each word to the beginning of the
// new sentence to reverse the word order.
reversed := From(words).AggregateT(
	func(workingSentence string, next string) string { return next + " " + workingSentence },
)

fmt.Println(reversed)

Output:

dog lazy the over jumps fox brown quick the

func (Query) AggregateWithSeed

func (q Query) AggregateWithSeed(seed interface{},
	f func(interface{}, interface{}) interface{}) interface{}

AggregateWithSeed applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value.

Aggregate method makes it simple to perform a calculation over a sequence of values. This method works by calling f() one time for each element in source except the first one. Each time f() is called, Aggregate passes both the element from the sequence and an aggregated value (as the first argument to f()). The value of the seed parameter is used as the initial aggregate value. The result of f() replaces the previous aggregated value.

Aggregate returns the final result of f().

Example

The following code example demonstrates how to use AggregateWithSeed function

Code:

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 := From(ints).
	AggregateWithSeed(0,
		func(total, next interface{}) interface{} {
			if next.(int)%2 == 0 {
				return total.(int) + 1
			}
			return total
		},
	)

fmt.Printf("The number of even integers is: %d", numEven)

Output:

The number of even integers is: 6

func (Query) AggregateWithSeedBy

func (q Query) AggregateWithSeedBy(seed interface{},
	f func(interface{}, interface{}) interface{},
	resultSelector func(interface{}) interface{}) interface{}

AggregateWithSeedBy applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.

Aggregate method makes it simple to perform a calculation over a sequence of values. This method works by calling f() one time for each element in source. Each time func is called, Aggregate passes both the element from the sequence and an aggregated value (as the first argument to func). The value of the seed parameter is used as the initial aggregate value. The result of func replaces the previous aggregated value.

The final result of func is passed to resultSelector to obtain the final result of Aggregate.

Example

The following code example demonstrates how to use AggregateWithSeedBy function

Code:

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

// Determine whether any string in the array is longer than "banana".
longestName := From(input).
	AggregateWithSeedBy("banana",
		func(longest interface{}, next interface{}) interface{} {
			if len(longest.(string)) > len(next.(string)) {
				return longest
			}
			return next

		},
		// Return the final result
		func(result interface{}) interface{} {
			return fmt.Sprintf("The fruit with the longest name is %s.", result)
		},
	)

fmt.Println(longestName)

Output:

The fruit with the longest name is passionfruit.

func (Query) AggregateWithSeedByT

func (q Query) AggregateWithSeedByT(seed interface{},
	f interface{},
	resultSelectorFn interface{}) interface{}

AggregateWithSeedByT is the typed version of AggregateWithSeedBy.

- f is of type "func(TAccumulate, TSource) TAccumulate"
- resultSelectorFn is of type "func(TAccumulate) TResult"

NOTE: AggregateWithSeedBy has better performance than AggregateWithSeedByT.

Example

The following code example demonstrates how to use AggregateWithSeedByT function

Code:

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

// Determine whether any string in the array is longer than "banana".
longestName := From(input).AggregateWithSeedByT("banana",
	func(longest string, next string) string {
		if len(longest) > len(next) {
			return longest
		}
		return next

	},
	// Return the final result
	func(result string) string {
		return fmt.Sprintf("The fruit with the longest name is %s.", result)
	},
)

fmt.Println(longestName)

Output:

The fruit with the longest name is passionfruit.

func (Query) AggregateWithSeedT

func (q Query) AggregateWithSeedT(seed interface{},
	f interface{}) interface{}

AggregateWithSeedT is the typed version of AggregateWithSeed.

- f is of type "func(TAccumulate, TSource) TAccumulate"

NOTE: AggregateWithSeed has better performance than AggregateWithSeedT.

Example

The following code example demonstrates how to use AggregateWithSeed function

Code:

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

// Determine whether any string in the array is longer than "banana".
longestName := From(fruits).
	AggregateWithSeedT("banana",
		func(longest, next string) string {
			if len(next) > len(longest) {
				return next
			}
			return longest
		},
	)

fmt.Printf("The fruit with the longest name is %s.", longestName)

Output:

The fruit with the longest name is passionfruit.

func (Query) All

func (q Query) All(predicate func(interface{}) bool) bool

All determines whether all elements of a collection satisfy a condition.

Example

The following code example demonstrates how to use All to determine whether all the elements in a slice satisfy a condition. Variable allStartWithB is true if all the pet names start with "B" or if the pets array is empty.

Code:

type Pet struct {
	Name string
	Age  int
}

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 := From(pets).
	All(
		func(pet interface{}) bool { return strings.HasPrefix(pet.(Pet).Name, "B") },
	)

fmt.Printf("All pet names start with 'B'? %t", allStartWithB)

Output:


 All pet names start with 'B'? false

func (Query) AllT

func (q Query) AllT(predicateFn interface{}) bool

AllT is the typed version of All.

- predicateFn is of type "func(TSource) bool"

NOTE: All has better performance than AllT.

Example

The following code example demonstrates how to use AllT to get the students having all marks greater than 70.

Code:

type Student struct {
	Name  string
	Marks []int
}

students := []Student{
	{Name: "Hugo", Marks: []int{91, 88, 76, 93}},
	{Name: "Rick", Marks: []int{70, 73, 66, 90}},
	{Name: "Michael", Marks: []int{73, 80, 75, 88}},
	{Name: "Fadi", Marks: []int{82, 75, 66, 84}},
	{Name: "Peter", Marks: []int{67, 78, 70, 82}},
}

var approvedStudents []Student
From(students).
	WhereT(
		func(student Student) bool {
			return From(student.Marks).
				AllT(
					func(mark int) bool { return mark > 70 },
				)
		},
	).
	ToSlice(&approvedStudents)

//List of approved students
for _, student := range approvedStudents {
	fmt.Println(student.Name)
}

Output:

Hugo
Michael

func (Query) Any

func (q Query) Any() bool

Any determines whether any element of a collection exists.

Example

The following code example demonstrates how to use Any to determine whether a slice contains any elements.

Code:

numbers := []int{1, 2}
hasElements := From(numbers).Any()

fmt.Printf("Are there any element in the list? %t", hasElements)

Output:

Are there any element in the list? true

func (Query) AnyWith

func (q Query) AnyWith(predicate func(interface{}) bool) bool

AnyWith determines whether any element of a collection satisfies a condition.

Example

The following code example demonstrates how to use AnyWith to determine whether any element in a slice satisfies a condition.

Code:

type Pet struct {
	Name       string
	Age        int
	Vaccinated bool
}

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 := From(pets).
	AnyWith(
		func(p interface{}) bool {
			return p.(Pet).Age > 1 && p.(Pet).Vaccinated == false
		},
	)

fmt.Printf("Are there any unvaccinated animals over age one? %t", unvaccinated)

Output:


Are there any unvaccinated animals over age one? true

func (Query) AnyWithT

func (q Query) AnyWithT(predicateFn interface{}) bool

AnyWithT is the typed version of AnyWith.

- predicateFn is of type "func(TSource) bool"

NOTE: AnyWith has better performance than AnyWithT.

Example

The following code example demonstrates how to use AnyWithT to get the students with any mark lower than 70.

Code:

type Student struct {
	Name  string
	Marks []int
}

students := []Student{
	{Name: "Hugo", Marks: []int{91, 88, 76, 93}},
	{Name: "Rick", Marks: []int{70, 73, 66, 90}},
	{Name: "Michael", Marks: []int{73, 80, 75, 88}},
	{Name: "Fadi", Marks: []int{82, 75, 66, 84}},
	{Name: "Peter", Marks: []int{67, 78, 70, 82}},
}

var studentsWithAnyMarkLt70 []Student
From(students).
	WhereT(
		func(student Student) bool {
			return From(student.Marks).
				AnyWithT(
					func(mark int) bool { return mark < 70 },
				)
		},
	).
	ToSlice(&studentsWithAnyMarkLt70)

//List of students with any mark lower than 70
for _, student := range studentsWithAnyMarkLt70 {
	fmt.Println(student.Name)
}

Output:

Rick
Fadi
Peter

func (Query) Append

func (q Query) Append(item interface{}) Query

Append inserts an item to the end of a collection, so it becomes the last item.

Example

The following code example demonstrates how to use Append to include an elements in the last position of a slice.

Code:

input := []int{1, 2, 3, 4}

q := From(input).Append(5)

last := q.Last()

fmt.Println(last)

Output:

5

func (Query) Average

func (q Query) Average() (r float64)

Average computes the average of a collection of numeric values.

Example

The following code example demonstrates how to use Average to calculate the average of a slice of values.

Code:

grades := []int{78, 92, 100, 37, 81}
average := From(grades).Average()

fmt.Println(average)

Output:

77.6

func (Query) Concat

func (q Query) Concat(q2 Query) Query

Concat concatenates two collections.

The Concat method differs from the Union method because the Concat method returns all the original elements in the input sequences. The Union method returns only unique elements.

Example

The following code example demonstrates how to use Concat to concatenate two slices.

Code:

q := From([]int{1, 2, 3}).
	Concat(From([]int{4, 5, 6}))

fmt.Println(q.Results())

Output:

[1 2 3 4 5 6]

func (Query) Contains

func (q Query) Contains(value interface{}) bool

Contains determines whether a collection contains a specified element.

Example

The following code example demonstrates how to use Contains to determine whether a slice contains a specific element.

Code:

slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

has5 := From(slice).Contains(5)

fmt.Printf("Does the slice contains 5? %t", has5)

Output:

Does the slice contains 5? true

func (Query) Count

func (q Query) Count() (r int)

Count returns the number of elements in a collection.

Example

The following code example demonstrates how to use Count to count the elements in an array.

Code:

fruits := []string{"apple", "banana", "mango", "orange", "passionfruit", "grape"}
numberOfFruits := From(fruits).Count()

fmt.Println(numberOfFruits)

Output:

6

func (Query) CountWith

func (q Query) CountWith(predicate func(interface{}) bool) (r int)

CountWith returns a number that represents how many elements in the specified collection satisfy a condition.

Example

The following code example demonstrates how to use CountWith to count the even numbers in an array.

Code:

slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

evenCount := From(slice).
	CountWith(
		func(item interface{}) bool { return item.(int)%2 == 0 },
	)

fmt.Println(evenCount)

Output:

6

func (Query) CountWithT

func (q Query) CountWithT(predicateFn interface{}) int

CountWithT is the typed version of CountWith.

- predicateFn is of type "func(TSource) bool"

NOTE: CountWith has better performance than CountWithT.

Example

The following code example demonstrates how to use CountWithT to count the elements in an slice that satisfy a condition.

Code:

type Pet struct {
	Name       string
	Vaccinated bool
}

pets := []Pet{
	{Name: "Barley", Vaccinated: true},
	{Name: "Boots", Vaccinated: false},
	{Name: "Whiskers", Vaccinated: false},
}

numberUnvaccinated := From(pets).
	CountWithT(
		func(p Pet) bool { return p.Vaccinated == false },
	)

fmt.Printf("There are %d unvaccinated animals.", numberUnvaccinated)

Output:

There are 2 unvaccinated animals.

func (Query) Distinct

func (q Query) Distinct() Query

Distinct method returns distinct elements from a collection. The result is an unordered collection that contains no duplicate values.

Example

The following code example demonstrates how to use Distinct to return distinct elements from a slice of integers.

Code:

ages := []int{21, 46, 46, 55, 17, 21, 55, 55}

var distinctAges []int
From(ages).
	Distinct().
	ToSlice(&distinctAges)

fmt.Println(distinctAges)

Output:

[21 46 55 17]

func (Query) DistinctBy

func (q Query) DistinctBy(selector func(interface{}) interface{}) Query

DistinctBy method returns distinct elements from a collection. This method executes selector function for each element to determine a value to compare. The result is an unordered collection that contains no duplicate values.

Example

The following code example demonstrates how to use DistinctBy to return distinct elements from a ordered slice of elements.

Code:

type Product struct {
	Name string
	Code int
}

products := []Product{
	{Name: "orange", Code: 4},
	{Name: "apple", Code: 9},
	{Name: "lemon", Code: 12},
	{Name: "apple", Code: 9},
}

//Order and exclude duplicates.
var noduplicates []Product
From(products).
	DistinctBy(
		func(item interface{}) interface{} { return item.(Product).Code },
	).
	ToSlice(&noduplicates)

for _, product := range noduplicates {
	fmt.Printf("%s %d\n", product.Name, product.Code)
}

Output:

orange 4
apple 9
lemon 12

func (Query) DistinctByT

func (q Query) DistinctByT(selectorFn interface{}) Query

DistinctByT is the typed version of DistinctBy.

- selectorFn is of type "func(TSource) TSource".

NOTE: DistinctBy has better performance than DistinctByT.

Example

The following code example demonstrates how to use DistinctByT to return distinct elements from a slice of structs.

Code:

type Product struct {
	Name string
	Code int
}

products := []Product{
	{Name: "apple", Code: 9},
	{Name: "orange", Code: 4},
	{Name: "apple", Code: 9},
	{Name: "lemon", Code: 12},
}

//Exclude duplicates.
var noduplicates []Product
From(products).
	DistinctByT(
		func(item Product) int { return item.Code },
	).
	ToSlice(&noduplicates)

for _, product := range noduplicates {
	fmt.Printf("%s %d\n", product.Name, product.Code)
}

Output:

apple 9
orange 4
lemon 12

func (Query) Except

func (q Query) Except(q2 Query) Query

Except produces the set difference of two sequences. The set difference is the members of the first sequence that don't appear in the second sequence.

Example

The following code example demonstrates how to use the Except method to compare two slices of numbers and return elements that appear only in the first slice.

Code:

numbers1 := []float32{2.0, 2.1, 2.2, 2.3, 2.4, 2.5}
numbers2 := []float32{2.2}

var onlyInFirstSet []float32
From(numbers1).
	Except(From(numbers2)).
	ToSlice(&onlyInFirstSet)

for _, number := range onlyInFirstSet {
	fmt.Println(number)
}

Output:

2
2.1
2.3
2.4
2.5

func (Query) ExceptBy

func (q Query) ExceptBy(q2 Query,
	selector func(interface{}) interface{}) Query

ExceptBy invokes a transform function on each element of a collection and produces the set difference of two sequences. The set difference is the members of the first sequence that don't appear in the second sequence.

Example

The following code example demonstrates how to use the Except method to compare two slices of numbers and return elements that appear only in the first slice.

Code:

type Product struct {
	Name string
	Code int
}

fruits1 := []Product{
	{Name: "orange", Code: 4},
	{Name: "apple", Code: 9},
	{Name: "lemon", Code: 12},
	{Name: "apple", Code: 9},
}

fruits2 := []Product{
	{Name: "apple", Code: 9},
}

//Order and exclude duplicates.
var except []Product
From(fruits1).
	ExceptBy(From(fruits2),
		func(item interface{}) interface{} { return item.(Product).Code },
	).
	ToSlice(&except)

for _, product := range except {
	fmt.Printf("%s %d\n", product.Name, product.Code)
}

Output:

orange 4
lemon 12

func (Query) ExceptByT

func (q Query) ExceptByT(q2 Query,
	selectorFn interface{}) Query

ExceptByT is the typed version of ExceptBy.

- selectorFn is of type "func(TSource) TSource"

NOTE: ExceptBy has better performance than ExceptByT.

Example

The following code example demonstrates how to use ExceptByT

Code:

type Product struct {
	Name string
	Code int
}

fruits1 := []Product{
	{Name: "orange", Code: 4},
	{Name: "apple", Code: 9},
	{Name: "lemon", Code: 12},
	{Name: "apple", Code: 9},
}

fruits2 := []Product{
	{Name: "apple", Code: 9},
}

//Order and exclude duplicates.
var except []Product
From(fruits1).
	ExceptByT(From(fruits2),
		func(item Product) int { return item.Code },
	).
	ToSlice(&except)

for _, product := range except {
	fmt.Printf("%s %d\n", product.Name, product.Code)
}

Output:

orange 4
lemon 12

func (Query) First

func (q Query) First() interface{}

First returns the first element of a collection.

Example

The following code example demonstrates how to use First to return the first element of an array.

Code:

numbers := []int{9, 34, 65, 92, 87, 435, 3, 54, 83, 23, 87, 435, 67, 12, 19}

first := From(numbers).First()

fmt.Println(first)

Output:

9

func (Query) FirstWith

func (q Query) FirstWith(predicate func(interface{}) bool) interface{}

FirstWith returns the first element of a collection that satisfies a specified condition.

Example

The following code example demonstrates how to use FirstWith to return the first element of an array that satisfies a condition.

Code:

numbers := []int{9, 34, 65, 92, 87, 435, 3, 54, 83, 23, 87, 435, 67, 12, 19}

first := From(numbers).
	FirstWith(
		func(item interface{}) bool { return item.(int) > 80 },
	)

fmt.Println(first)

Output:

92

func (Query) FirstWithT

func (q Query) FirstWithT(predicateFn interface{}) interface{}

FirstWithT is the typed version of FirstWith.

- predicateFn is of type "func(TSource) bool"

NOTE: FirstWith has better performance than FirstWithT.

Example

The following code example demonstrates how to use FirstWithT to return the first element of an array that satisfies a condition.

Code:

numbers := []int{9, 34, 65, 92, 87, 435, 3, 54, 83, 23, 87, 435, 67, 12, 19}

first := From(numbers).
	FirstWithT(
		func(item int) bool { return item > 80 },
	)

fmt.Println(first)

Output:

92

func (Query) ForEach

func (q Query) ForEach(action func(interface{}))

ForEach performs the specified action on each element of a collection.

Example

The following code example demonstrates how to use ForEach to output all elements of an array.

Code:

fruits := []string{"orange", "apple", "lemon", "apple"}

From(fruits).ForEach(func(fruit interface{}) {
	fmt.Println(fruit)
})

Output:

orange
apple
lemon
apple

func (Query) ForEachIndexed

func (q Query) ForEachIndexed(action func(int, interface{}))

ForEachIndexed performs the specified action on each element of a collection.

The first argument to action represents the zero-based index of that element in the source collection. This can be useful if the elements are in a known order and you want to do something with an element at a particular index, for example. It can also be useful if you want to retrieve the index of one or more elements. The second argument to action represents the element to process.

Example

The following code example demonstrates how to use ForEachIndexed to output all elements of an array with its index.

Code:

fruits := []string{"orange", "apple", "lemon", "apple"}

From(fruits).ForEachIndexed(func(i int, fruit interface{}) {
	fmt.Printf("%d.%s\n", i, fruit)
})

Output:

0.orange
1.apple
2.lemon
3.apple

func (Query) ForEachIndexedT

func (q Query) ForEachIndexedT(actionFn interface{})

ForEachIndexedT is the typed version of ForEachIndexed.

- actionFn is of type "func(int, TSource)"

NOTE: ForEachIndexed has better performance than ForEachIndexedT.

Example

The following code example demonstrates how to use ForEachIndexedT to output all elements of an array with its index.

Code:

fruits := []string{"orange", "apple", "lemon", "apple"}

From(fruits).ForEachIndexedT(func(i int, fruit string) {
	fmt.Printf("%d.%s\n", i, fruit)
})

Output:

0.orange
1.apple
2.lemon
3.apple

func (Query) ForEachT

func (q Query) ForEachT(actionFn interface{})

ForEachT is the typed version of ForEach.

- actionFn is of type "func(TSource)"

NOTE: ForEach has better performance than ForEachT.

Example

The following code example demonstrates how to use ForEachT to output all elements of an array.

Code:

fruits := []string{"orange", "apple", "lemon", "apple"}

From(fruits).ForEachT(func(fruit string) {
	fmt.Println(fruit)
})

Output:

orange
apple
lemon
apple

func (Query) GroupBy

func (q Query) GroupBy(keySelector func(interface{}) interface{},
	elementSelector func(interface{}) interface{}) Query

GroupBy method groups the elements of a collection according to a specified key selector function and projects the elements for each group by using a specified function.

Example

Code:

input := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}

q := From(input).GroupBy(
	func(i interface{}) interface{} { return i.(int) % 2 },
	func(i interface{}) interface{} { return i.(int) })

fmt.Println(q.OrderBy(func(i interface{}) interface{} {
	return i.(Group).Key
}).Results())

Output:

[{0 [2 4 6 8]} {1 [1 3 5 7 9]}]

func (Query) GroupByT

func (q Query) GroupByT(keySelectorFn interface{},
	elementSelectorFn interface{}) Query

GroupByT is the typed version of GroupBy.

- keySelectorFn is of type "func(TSource) TKey"
- elementSelectorFn is of type "func(TSource) TElement"

NOTE: GroupBy has better performance than GroupByT.

Example

The following code example demonstrates how to use GroupByT to group the elements of a slice.

Code:

type Pet struct {
	Name string
	Age  int
}
// Create a list of pets.
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.
var query []Group
From(pets).GroupByT(
	func(p Pet) int { return p.Age },
	func(p Pet) string { return p.Name },
).OrderByT(
	func(g Group) int { return g.Key.(int) },
).ToSlice(&query)

for _, petGroup := range query {
	fmt.Printf("%d\n", petGroup.Key)
	for _, petName := range petGroup.Group {
		fmt.Printf("  %s\n", petName)
	}

}

Output:

1
  Whiskers
4
  Boots
  Daisy
8
  Barley

func (Query) GroupJoin

func (q Query) GroupJoin(inner Query,
	outerKeySelector func(interface{}) interface{},
	innerKeySelector func(interface{}) interface{},
	resultSelector func(outer interface{}, inners []interface{}) interface{}) Query

GroupJoin correlates the elements of two collections based on key equality, and groups the results.

This method produces hierarchical results, which means that elements from outer query are paired with collections of matching elements from inner. GroupJoin enables you to base your results on a whole set of matches for each element of outer query.

The resultSelector function is called only one time for each outer element together with a collection of all the inner elements that match the outer element. This differs from the Join method, in which the result selector function is invoked on pairs that contain one element from outer and one element from inner.

GroupJoin preserves the order of the elements of outer, and for each element of outer, the order of the matching elements from inner.

Example

The following code example demonstrates how to use GroupJoin to perform a grouped join on two slices

Code:

fruits := []string{
	"apple",
	"banana",
	"apricot",
	"cherry",
	"clementine",
}

q := FromString("abc").
	GroupJoin(From(fruits),
		func(i interface{}) interface{} { return i },
		func(i interface{}) interface{} { return []rune(i.(string))[0] },
		func(outer interface{}, inners []interface{}) interface{} {
			return KeyValue{string(outer.(rune)), inners}
		},
	)

fmt.Println(q.Results())

Output:

[{a [apple apricot]} {b [banana]} {c [cherry clementine]}]

func (Query) GroupJoinT

func (q Query) GroupJoinT(inner Query,
	outerKeySelectorFn interface{},
	innerKeySelectorFn interface{},
	resultSelectorFn interface{}) Query

GroupJoinT is the typed version of GroupJoin.

- inner: The query to join to the outer query.
- outerKeySelectorFn is of type "func(TOuter) TKey"
- innerKeySelectorFn is of type "func(TInner) TKey"
- resultSelectorFn: is of type "func(TOuter, inners []TInner) TResult"

NOTE: GroupJoin has better performance than GroupJoinT.

Example

The following code example demonstrates how to use GroupJoinT

to perform a grouped join on two slices.

Code:

type Person struct {
	Name string
}

type Pet struct {
	Name  string
	Owner Person
}

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 slice where each element is a KeyValue
// that contains a person's name as the key and a slice of strings
// of names of the pets they own as a value.

q := []KeyValue{}
From(people).
	GroupJoinT(From(pets),
		func(p Person) Person { return p },
		func(p Pet) Person { return p.Owner },
		func(person Person, pets []Pet) KeyValue {
			var petNames []string
			From(pets).
				SelectT(
					func(pet Pet) string { return pet.Name },
				).
				ToSlice(&petNames)
			return KeyValue{person.Name, petNames}
		},
	).ToSlice(&q)

for _, obj := range q {
	// Output the owner's name.
	fmt.Printf("%s:\n", obj.Key)
	// Output each of the owner's pet's names.
	for _, petName := range obj.Value.([]string) {
		fmt.Printf("  %s\n", petName)
	}
}

Output:

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

func (Query) Intersect

func (q Query) Intersect(q2 Query) Query

Intersect produces the set intersection of the source collection and the provided input collection. The intersection of two sets A and B is defined as the set that contains all the elements of A that also appear in B, but no other elements.

Example

The following code example demonstrates how to use Intersect to return the elements that appear in each of two slices of integers.

Code:

id1 := []int{44, 26, 92, 30, 71, 38}
id2 := []int{39, 59, 83, 47, 26, 4, 30}

var both []int
From(id1).
	Intersect(From(id2)).
	ToSlice(&both)

for _, id := range both {
	fmt.Println(id)
}

Output:

26
30

func (Query) IntersectBy

func (q Query) IntersectBy(q2 Query,
	selector func(interface{}) interface{}) Query

IntersectBy produces the set intersection of the source collection and the provided input collection. The intersection of two sets A and B is defined as the set that contains all the elements of A that also appear in B, but no other elements.

IntersectBy invokes a transform function on each element of both collections.

Example

The following code example demonstrates how to use IntersectBy to return the elements that appear in each of two slices of products with same Code.

Code:

type Product struct {
	Name string
	Code int
}

store1 := []Product{
	{Name: "orange", Code: 4},
	{Name: "apple", Code: 9},
}

store2 := []Product{
	{Name: "lemon", Code: 12},
	{Name: "apple", Code: 9},
}

var duplicates []Product
From(store1).
	IntersectBy(From(store2),
		func(p interface{}) interface{} { return p.(Product).Code },
	).
	ToSlice(&duplicates)

for _, p := range duplicates {
	fmt.Println(p.Name, "", p.Code)
}

Output:

apple  9

func (Query) IntersectByT

func (q Query) IntersectByT(q2 Query,
	selectorFn interface{}) Query

IntersectByT is the typed version of IntersectBy.

- selectorFn is of type "func(TSource) TSource"

NOTE: IntersectBy has better performance than IntersectByT.

Example

The following code example demonstrates how to use IntersectByT to return the elements that appear in each of two slices of products with same Code.

Code:

type Product struct {
	Name string
	Code int
}

store1 := []Product{
	{Name: "orange", Code: 4},
	{Name: "apple", Code: 9},
}

store2 := []Product{
	{Name: "lemon", Code: 12},
	{Name: "apple", Code: 9},
}

var duplicates []Product
From(store1).
	IntersectByT(From(store2),
		func(p Product) int { return p.Code },
	).
	ToSlice(&duplicates)

for _, p := range duplicates {
	fmt.Println(p.Name, "", p.Code)
}

Output:

apple  9

func (Query) Join

func (q Query) Join(inner Query,
	outerKeySelector func(interface{}) interface{},
	innerKeySelector func(interface{}) interface{},
	resultSelector func(outer interface{}, inner interface{}) interface{}) Query

Join correlates the elements of two collection based on matching keys.

A join refers to the operation of correlating the elements of two sources of information based on a common key. Join brings the two information sources and the keys by which they are matched together in one method call. This differs from the use of SelectMany, which requires more than one method call to perform the same operation.

Join preserves the order of the elements of outer collection, and for each of these elements, the order of the matching elements of inner.

Example

The following code example demonstrates how to use Join to perform an inner join of two slices based on a common key.

Code:

fruits := []string{
	"apple",
	"banana",
	"apricot",
	"cherry",
	"clementine",
}

q := Range(1, 10).
	Join(From(fruits),
		func(i interface{}) interface{} { return i },
		func(i interface{}) interface{} { return len(i.(string)) },
		func(outer interface{}, inner interface{}) interface{} {
			return KeyValue{outer, inner}
		},
	)

fmt.Println(q.Results())

Output:

[{5 apple} {6 banana} {6 cherry} {7 apricot} {10 clementine}]

func (Query) JoinT

func (q Query) JoinT(inner Query,
	outerKeySelectorFn interface{},
	innerKeySelectorFn interface{},
	resultSelectorFn interface{}) Query

JoinT is the typed version of Join.

- outerKeySelectorFn is of type "func(TOuter) TKey"
- innerKeySelectorFn is of type "func(TInner) TKey"
- resultSelectorFn is of type "func(TOuter,TInner) TResult"

NOTE: Join has better performance than JoinT.

Example

The following code example demonstrates how to use JoinT to perform an inner join of two slices based on a common key.

Code:

type Person struct {
	Name string
}

type Pet struct {
	Name  string
	Owner Person
}

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 anonymous type that contains a
// Pet's name and the name of the Person that owns the Pet.

query := []string{}
From(people).
	JoinT(From(pets),
		func(person Person) Person { return person },
		func(pet Pet) Person { return pet.Owner },
		func(person Person, pet Pet) string { return fmt.Sprintf("%s - %s", person.Name, pet.Name) },
	).ToSlice(&query)

for _, line := range query {
	fmt.Println(line)
}

Output:

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

func (Query) Last

func (q Query) Last() (r interface{})

Last returns the last element of a collection.

Example

The following code example demonstrates how to use Last to return the last element of an array.

Code:

numbers := []int{9, 34, 65, 92, 87, 435, 3, 54,
	83, 23, 87, 67, 12, 19}

last := From(numbers).Last()

fmt.Println(last)

Output:

19

func (Query) LastWith

func (q Query) LastWith(predicate func(interface{}) bool) (r interface{})

LastWith returns the last element of a collection that satisfies a specified condition.

Example

The following code example demonstrates how to use LastWith to return the last element of an array.

Code:

numbers := []int{9, 34, 65, 92, 87, 435, 3, 54,
	83, 23, 87, 67, 12, 19}

last := From(numbers).
	LastWith(
		func(n interface{}) bool { return n.(int) > 80 },
	)

fmt.Println(last)

Output:

87

func (Query) LastWithT

func (q Query) LastWithT(predicateFn interface{}) interface{}

LastWithT is the typed version of LastWith.

- predicateFn is of type "func(TSource) bool"

NOTE: LastWith has better performance than LastWithT.

Example

The following code example demonstrates how to use LastWithT to return the last element of an array.

Code:

numbers := []int{9, 34, 65, 92, 87, 435, 3, 54,
	83, 23, 87, 67, 12, 19}

last := From(numbers).
	LastWithT(
		func(n int) bool { return n > 80 },
	)

fmt.Println(last)

Output:

87

func (Query) Max

func (q Query) Max() (r interface{})

Max returns the maximum value in a collection of values.

Example

The following code example demonstrates how to use Max to determine the maximum value in a slice.

Code:

numbers := []int64{4294967296, 466855135, 81125}

last := From(numbers).Max()

fmt.Println(last)

Output:

4294967296

func (Query) Min

func (q Query) Min() (r interface{})

Min returns the minimum value in a collection of values.

Example

The following code example demonstrates how to use Min to determine the minimum value in a slice.

Code:

grades := []int{78, 92, 99, 37, 81}

min := From(grades).Min()

fmt.Println(min)

Output:

37

func (Query) OrderBy

func (q Query) OrderBy(selector func(interface{}) interface{}) OrderedQuery

OrderBy sorts the elements of a collection in ascending order. Elements are sorted according to a key.

Example

The following code example demonstrates how to use OrderBy to sort the elements of a slice.

Code:

q := Range(1, 10).
	OrderBy(
		func(i interface{}) interface{} { return i.(int) % 2 },
	).
	ThenByDescending(
		func(i interface{}) interface{} { return i },
	)

fmt.Println(q.Results())

Output:

[10 8 6 4 2 9 7 5 3 1]

func (Query) OrderByDescending

func (q Query) OrderByDescending(selector func(interface{}) interface{}) OrderedQuery

OrderByDescending sorts the elements of a collection in descending order. Elements are sorted according to a key.

Example

The following code example demonstrates how to use OrderByDescending to sort the elements of a slice in descending order by using a selector function

Code:

names := []string{"Ned", "Ben", "Susan"}

var result []string
From(names).
	OrderByDescending(
		func(n interface{}) interface{} { return n },
	).ToSlice(&result)

fmt.Println(result)

Output:

[Susan Ned Ben]

func (Query) OrderByDescendingT

func (q Query) OrderByDescendingT(selectorFn interface{}) OrderedQuery

OrderByDescendingT is the typed version of OrderByDescending.

- selectorFn is of type "func(TSource) TKey"

NOTE: OrderByDescending has better performance than OrderByDescendingT.

Example

The following code example demonstrates how to use OrderByDescendingT to order an slice.

Code:

type Player struct {
	Name   string
	Points int64
}

players := []Player{
	{Name: "Hugo", Points: 4757},
	{Name: "Rick", Points: 7365},
	{Name: "Michael", Points: 2857},
	{Name: "Fadi", Points: 85897},
	{Name: "Peter", Points: 48576},
}

//Order and get the top 3 players
var top3Players []KeyValue
From(players).
	OrderByDescendingT(
		func(p Player) int64 { return p.Points },
	).
	Take(3).
	SelectIndexedT(
		func(i int, p Player) KeyValue { return KeyValue{Key: i + 1, Value: p} },
	).
	ToSlice(&top3Players)

for _, rank := range top3Players {
	fmt.Printf(
		"Rank: #%d - Player: %s - Points: %d\n",
		rank.Key,
		rank.Value.(Player).Name,
		rank.Value.(Player).Points,
	)

}

Output:

Rank: #1 - Player: Fadi - Points: 85897
Rank: #2 - Player: Peter - Points: 48576
Rank: #3 - Player: Rick - Points: 7365

func (Query) OrderByT

func (q Query) OrderByT(selectorFn interface{}) OrderedQuery

OrderByT is the typed version of OrderBy.

- selectorFn is of type "func(TSource) TKey"

NOTE: OrderBy has better performance than OrderByT.

Example

The following code example demonstrates how to use OrderByT to sort the elements of a slice.

Code:

type Pet struct {
	Name string
	Age  int
}
// Create a list of pets.
pets := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
	{Name: "Daisy", Age: 4},
}

var orderedPets []Pet
From(pets).
	OrderByT(
		func(pet Pet) int { return pet.Age },
	).
	ToSlice(&orderedPets)

for _, pet := range orderedPets {
	fmt.Println(pet.Name, "-", pet.Age)
}

Output:

Whiskers - 1
Boots - 4
Daisy - 4
Barley - 8

func (Query) Prepend

func (q Query) Prepend(item interface{}) Query

Prepend inserts an item to the beginning of a collection, so it becomes the first item.

Example

The following code example demonstrates how to use Prepend to include an elements in the first position of a slice.

Code:

input := []int{2, 3, 4, 5}

q := From(input).Prepend(1)
first := q.First()

fmt.Println(first)

Output:

1

func (Query) Results

func (q Query) Results() (r []interface{})

Results iterates over a collection and returnes slice of interfaces

func (Query) Reverse

func (q Query) Reverse() Query

Reverse inverts the order of the elements in a collection.

Unlike OrderBy, this sorting method does not consider the actual values themselves in determining the order. Rather, it just returns the elements in the reverse order from which they are produced by the underlying source.

Example

The following code example demonstrates how to use Reverse to reverse the order of elements in a string.

Code:

input := "apple"

var output []rune
From(input).
	Reverse().
	ToSlice(&output)

fmt.Println(string(output))

Output:

elppa

func (Query) Select

func (q Query) Select(selector func(interface{}) interface{}) Query

Select projects each element of a collection into a new form. Returns a query with the result of invoking the transform function on each element of original source.

This projection method requires the transform function, selector, to produce one value for each value in the source collection. If selector returns a value that is itself a collection, it is up to the consumer to traverse the subcollections manually. In such a situation, it might be better for your query to return a single coalesced collection of values. To achieve this, use the SelectMany method instead of Select. Although SelectMany works similarly to Select, it differs in that the transform function returns a collection that is then expanded by SelectMany before it is returned.

Example

The following code example demonstrates how to use Select to project over a slice of values.

Code:

squares := []int{}

Range(1, 10).
	Select(
		func(x interface{}) interface{} { return x.(int) * x.(int) },
	).
	ToSlice(&squares)

fmt.Println(squares)

Output:

[1 4 9 16 25 36 49 64 81 100]

func (Query) SelectIndexed

func (q Query) SelectIndexed(selector func(int, interface{}) interface{}) Query

SelectIndexed projects each element of a collection into a new form by incorporating the element's index. Returns a query with the result of invoking the transform function on each element of original source.

The first argument to selector represents the zero-based index of that element in the source collection. This can be useful if the elements are in a known order and you want to do something with an element at a particular index, for example. It can also be useful if you want to retrieve the index of one or more elements. The second argument to selector represents the element to process.

This projection method requires the transform function, selector, to produce one value for each value in the source collection. If selector returns a value that is itself a collection, it is up to the consumer to traverse the subcollections manually. In such a situation, it might be better for your query to return a single coalesced collection of values. To achieve this, use the SelectMany method instead of Select. Although SelectMany works similarly to Select, it differs in that the transform function returns a collection that is then expanded by SelectMany before it is returned.

Example

The following code example demonstrates how to use Select to project over a slice of values and use the index of each element.

Code:

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

result := []string{}
From(fruits).
	SelectIndexed(
		func(index int, fruit interface{}) interface{} { return fruit.(string)[:index] },
	).
	ToSlice(&result)

fmt.Println(result)

Output:

[ b ma ora pass grape]

func (Query) SelectIndexedT

func (q Query) SelectIndexedT(selectorFn interface{}) Query

SelectIndexedT is the typed version of SelectIndexed.

- selectorFn is of type "func(int,TSource)TResult"

NOTE: SelectIndexed has better performance than SelectIndexedT.

Example

The following code example demonstrates how to use SelectIndexedT to determine if the value in a slice of int match their position in the slice.

Code:

numbers := []int{5, 4, 1, 3, 9, 8, 6, 7, 2, 0}

var numsInPlace []KeyValue

From(numbers).
	SelectIndexedT(
		func(index, num int) KeyValue { return KeyValue{Key: num, Value: (num == index)} },
	).
	ToSlice(&numsInPlace)

fmt.Println("Number: In-place?")
for _, n := range numsInPlace {
	fmt.Printf("%d: %t\n", n.Key, n.Value)
}

Output:

Number: In-place?
5: false
4: false
1: false
3: true
9: false
8: false
6: true
7: true
2: false
0: false

func (Query) SelectMany

func (q Query) SelectMany(selector func(interface{}) Query) Query

SelectMany projects each element of a collection to a Query, iterates and flattens the resulting collection into one collection.

Example

Code:

input := [][]int{{1, 2, 3}, {4, 5, 6, 7}}

q := From(input).
	SelectMany(
		func(i interface{}) Query { return From(i) },
	)

fmt.Println(q.Results())

Output:

[1 2 3 4 5 6 7]

func (Query) SelectManyBy

func (q Query) SelectManyBy(selector func(interface{}) Query,
	resultSelector func(interface{}, interface{}) interface{}) Query

SelectManyBy projects each element of a collection to a Query, iterates and flattens the resulting collection into one collection, and invokes a result selector function on each element therein.

Example

The following code example demonstrates how to use SelectMany to perform a one-to-many projection over a slice

Code:

type Pet struct {
	Name string
}

type Person struct {
	Name string
	Pets []Pet
}

magnus := Person{
	Name: "Hedlund, Magnus",
	Pets: []Pet{{Name: "Daisy"}},
}

terry := Person{
	Name: "Adams, Terry",
	Pets: []Pet{{Name: "Barley"}, {Name: "Boots"}},
}
charlotte := Person{
	Name: "Weiss, Charlotte",
	Pets: []Pet{{Name: "Whiskers"}},
}

people := []Person{magnus, terry, charlotte}
var results []string
From(people).
	SelectManyBy(
		func(person interface{}) Query { return From(person.(Person).Pets) },
		func(pet, person interface{}) interface{} {
			return fmt.Sprintf("Owner: %s, Pet: %s", person.(Person).Name, pet.(Pet).Name)
		},
	).
	ToSlice(&results)

for _, result := range results {
	fmt.Println(result)
}

Output:

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

func (Query) SelectManyByIndexed

func (q Query) SelectManyByIndexed(selector func(int, interface{}) Query,
	resultSelector func(interface{}, interface{}) interface{}) Query

SelectManyByIndexed projects each element of a collection to a Query, iterates and flattens the resulting collection into one collection, and invokes a result selector function on each element therein. The index of each source element is used in the intermediate projected form of that element.

Example

The following code example demonstrates how to use SelectManyByIndexed to perform a one-to-many projection over an array and use the index of each outer element.

Code:

type Pet struct {
	Name string
}

type Person struct {
	Name string
	Pets []Pet
}

magnus := Person{
	Name: "Hedlund, Magnus",
	Pets: []Pet{{Name: "Daisy"}},
}

terry := Person{
	Name: "Adams, Terry",
	Pets: []Pet{{Name: "Barley"}, {Name: "Boots"}},
}
charlotte := Person{
	Name: "Weiss, Charlotte",
	Pets: []Pet{{Name: "Whiskers"}},
}

people := []Person{magnus, terry, charlotte}
var results []string

From(people).
	SelectManyByIndexed(
		func(index int, person interface{}) Query {
			return From(person.(Person).Pets).
				Select(func(pet interface{}) interface{} {
					return fmt.Sprintf("%d - %s", index, pet.(Pet).Name)
				})
		},
		func(indexedPet, person interface{}) interface{} {
			return fmt.Sprintf("Pet: %s, Owner: %s", indexedPet, person.(Person).Name)
		},
	).
	ToSlice(&results)

for _, result := range results {
	fmt.Println(result)
}

Output:

Pet: 0 - Daisy, Owner: Hedlund, Magnus
Pet: 1 - Barley, Owner: Adams, Terry
Pet: 1 - Boots, Owner: Adams, Terry
Pet: 2 - Whiskers, Owner: Weiss, Charlotte

func (Query) SelectManyByIndexedT

func (q Query) SelectManyByIndexedT(selectorFn interface{},
	resultSelectorFn interface{}) Query

SelectManyByIndexedT is the typed version of SelectManyByIndexed.

- selectorFn is of type "func(int,TSource)Query"
- resultSelectorFn is of type "func(TSource,TCollection)TResult"

NOTE: SelectManyByIndexed has better performance than SelectManyByIndexedT.

Example

The following code example demonstrates how to use SelectManyByIndexedT to perform a one-to-many projection over an array and use the index of each outer element.

Code:

type Pet struct {
	Name string
}

type Person struct {
	Name string
	Pets []Pet
}

magnus := Person{
	Name: "Hedlund, Magnus",
	Pets: []Pet{{Name: "Daisy"}},
}

terry := Person{
	Name: "Adams, Terry",
	Pets: []Pet{{Name: "Barley"}, {Name: "Boots"}},
}
charlotte := Person{
	Name: "Weiss, Charlotte",
	Pets: []Pet{{Name: "Whiskers"}},
}

people := []Person{magnus, terry, charlotte}
var results []string

From(people).
	SelectManyByIndexedT(
		func(index int, person Person) Query {
			return From(person.Pets).
				SelectT(func(pet Pet) string {
					return fmt.Sprintf("%d - %s", index, pet.Name)
				})
		},
		func(indexedPet string, person Person) string {
			return fmt.Sprintf("Pet: %s, Owner: %s", indexedPet, person.Name)
		},
	).
	ToSlice(&results)

for _, result := range results {
	fmt.Println(result)
}

Output:

Pet: 0 - Daisy, Owner: Hedlund, Magnus
Pet: 1 - Barley, Owner: Adams, Terry
Pet: 1 - Boots, Owner: Adams, Terry
Pet: 2 - Whiskers, Owner: Weiss, Charlotte

func (Query) SelectManyByT

func (q Query) SelectManyByT(selectorFn interface{},
	resultSelectorFn interface{}) Query

SelectManyByT is the typed version of SelectManyBy.

- selectorFn is of type "func(TSource)Query"
- resultSelectorFn is of type "func(TSource,TCollection)TResult"

NOTE: SelectManyBy has better performance than SelectManyByT.

Example

The following code example demonstrates how to use SelectManyT to perform a one-to-many projection over a slice

Code:

type Pet struct {
	Name string
}

type Person struct {
	Name string
	Pets []Pet
}

magnus := Person{
	Name: "Hedlund, Magnus",
	Pets: []Pet{{Name: "Daisy"}},
}

terry := Person{
	Name: "Adams, Terry",
	Pets: []Pet{{Name: "Barley"}, {Name: "Boots"}},
}
charlotte := Person{
	Name: "Weiss, Charlotte",
	Pets: []Pet{{Name: "Whiskers"}},
}

people := []Person{magnus, terry, charlotte}
var results []string
From(people).
	SelectManyByT(
		func(person Person) Query { return From(person.Pets) },
		func(pet Pet, person Person) interface{} {
			return fmt.Sprintf("Owner: %s, Pet: %s", person.Name, pet.Name)
		},
	).
	ToSlice(&results)

for _, result := range results {
	fmt.Println(result)
}

Output:

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

func (Query) SelectManyIndexed

func (q Query) SelectManyIndexed(selector func(int, interface{}) Query) Query

SelectManyIndexed projects each element of a collection to a Query, iterates and flattens the resulting collection into one collection.

The first argument to selector represents the zero-based index of that element in the source collection. This can be useful if the elements are in a known order and you want to do something with an element at a particular index, for example. It can also be useful if you want to retrieve the index of one or more elements. The second argument to selector represents the element to process.

Example

The following code example demonstrates how to use SelectManyIndexed to perform a one-to-many projection over an slice of log data and print out their contents.

Code:

type LogFile struct {
	Name  string
	Lines []string
}

file1 := LogFile{
	Name: "file1.log",
	Lines: []string{
		"INFO: 2013/11/05 18:11:01 main.go:44: Special Information",
		"WARNING: 2013/11/05 18:11:01 main.go:45: There is something you need to know about",
		"ERROR: 2013/11/05 18:11:01 main.go:46: Something has failed",
	},
}

file2 := LogFile{
	Name: "file2.log",
	Lines: []string{
		"INFO: 2013/11/05 18:11:01 main.go:46: Everything is ok",
	},
}

file3 := LogFile{
	Name: "file3.log",
	Lines: []string{
		"2013/11/05 18:42:26 Hello World",
	},
}

logFiles := []LogFile{file1, file2, file3}
var results []string

From(logFiles).
	SelectManyIndexedT(func(fileIndex int, file LogFile) Query {
		return From(file.Lines).
			SelectIndexedT(func(lineIndex int, line string) string {
				return fmt.Sprintf("File:[%d] - %s => line: %d - %s", fileIndex+1, file.Name, lineIndex+1, line)
			})
	}).
	ToSlice(&results)

for _, result := range results {
	fmt.Println(result)
}

Output:

File:[1] - file1.log => line: 1 - INFO: 2013/11/05 18:11:01 main.go:44: Special Information
File:[1] - file1.log => line: 2 - WARNING: 2013/11/05 18:11:01 main.go:45: There is something you need to know about
File:[1] - file1.log => line: 3 - ERROR: 2013/11/05 18:11:01 main.go:46: Something has failed
File:[2] - file2.log => line: 1 - INFO: 2013/11/05 18:11:01 main.go:46: Everything is ok
File:[3] - file3.log => line: 1 - 2013/11/05 18:42:26 Hello World

func (Query) SelectManyIndexedT

func (q Query) SelectManyIndexedT(selectorFn interface{}) Query

SelectManyIndexedT is the typed version of SelectManyIndexed.

- selectorFn is of type "func(int,TSource)Query"

NOTE: SelectManyIndexed has better performance than SelectManyIndexedT.

Example

The following code example demonstrates how to use SelectManyIndexedT to perform a one-to-many projection over an slice of log files and print out their contents.

Code:

type LogFile struct {
	Name  string
	Lines []string
}

file1 := LogFile{
	Name: "file1.log",
	Lines: []string{
		"INFO: 2013/11/05 18:11:01 main.go:44: Special Information",
		"WARNING: 2013/11/05 18:11:01 main.go:45: There is something you need to know about",
		"ERROR: 2013/11/05 18:11:01 main.go:46: Something has failed",
	},
}

file2 := LogFile{
	Name: "file2.log",
	Lines: []string{
		"INFO: 2013/11/05 18:11:01 main.go:46: Everything is ok",
	},
}

file3 := LogFile{
	Name: "file3.log",
	Lines: []string{
		"2013/11/05 18:42:26 Hello World",
	},
}

logFiles := []LogFile{file1, file2, file3}
var results []string

From(logFiles).
	SelectManyIndexedT(func(fileIndex int, file LogFile) Query {
		return From(file.Lines).
			SelectIndexedT(func(lineIndex int, line string) string {
				return fmt.Sprintf("File:[%d] - %s => line: %d - %s", fileIndex+1, file.Name, lineIndex+1, line)
			})
	}).
	ToSlice(&results)

for _, result := range results {
	fmt.Println(result)
}

Output:

File:[1] - file1.log => line: 1 - INFO: 2013/11/05 18:11:01 main.go:44: Special Information
File:[1] - file1.log => line: 2 - WARNING: 2013/11/05 18:11:01 main.go:45: There is something you need to know about
File:[1] - file1.log => line: 3 - ERROR: 2013/11/05 18:11:01 main.go:46: Something has failed
File:[2] - file2.log => line: 1 - INFO: 2013/11/05 18:11:01 main.go:46: Everything is ok
File:[3] - file3.log => line: 1 - 2013/11/05 18:42:26 Hello World

func (Query) SelectManyT

func (q Query) SelectManyT(selectorFn interface{}) Query

SelectManyT is the typed version of SelectMany.

- selectorFn is of type "func(TSource)Query"

NOTE: SelectMany has better performance than SelectManyT.

Example

The following code example demonstrates how to use SelectManyT to perform a projection over a list of sentences and rank the top 5 most used words

Code:

sentences := []string{
	"the quick brown fox jumps over the lazy dog",
	"pack my box with five dozen liquor jugs",
	"several fabulous dixieland jazz groups played with quick tempo",
	"back in my quaint garden jaunty zinnias vie with flaunting phlox",
	"five or six big jet planes zoomed quickly by the new tower",
	"I quickly explained that many big jobs involve few hazards",
	"The wizard quickly jinxed the gnomes before they vaporized",
}

var results []string
From(sentences).
	//Split the sentences in words
	SelectManyT(func(sentence string) Query {
		return From(strings.Split(sentence, " "))
	}).
	//Grouping by word
	GroupByT(
		func(word string) string { return word },
		func(word string) string { return word },
	).
	//Ordering by word counts
	OrderByDescendingT(func(wordGroup Group) int {
		return len(wordGroup.Group)
	}).
	//Then order by word
	ThenByT(func(wordGroup Group) string {
		return wordGroup.Key.(string)
	}).
	//Take the top 5
	Take(5).
	//Project the words using the index as rank
	SelectIndexedT(func(index int, wordGroup Group) string {
		return fmt.Sprintf("Rank: #%d, Word: %s, Counts: %d", index+1, wordGroup.Key, len(wordGroup.Group))
	}).
	ToSlice(&results)

for _, result := range results {
	fmt.Println(result)
}

Output:

Rank: #1, Word: the, Counts: 4
Rank: #2, Word: quickly, Counts: 3
Rank: #3, Word: with, Counts: 3
Rank: #4, Word: big, Counts: 2
Rank: #5, Word: five, Counts: 2

func (Query) SelectT

func (q Query) SelectT(selectorFn interface{}) Query

SelectT is the typed version of Select.

- selectorFn is of type "func(TSource)TResult"

NOTE: Select has better performance than SelectT.

Example

The following code example demonstrates how to use SelectT to project over a slice.

Code:

squares := []int{}

Range(1, 10).
	SelectT(
		func(x int) int { return x * x },
	).
	ToSlice(&squares)

fmt.Println(squares)

Output:

[1 4 9 16 25 36 49 64 81 100]

func (Query) SequenceEqual

func (q Query) SequenceEqual(q2 Query) bool

SequenceEqual determines whether two collections are equal.

Example

The following code example demonstrates how to use SequenceEqual to determine whether two slices are equal.

Code:

type Pet struct {
	Name string
	Age  int
}

pets1 := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
	{Name: "Daisy", Age: 4},
}

pets2 := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
	{Name: "Daisy", Age: 4},
}

equal := From(pets1).SequenceEqual(From(pets2))

fmt.Printf("Are the lists equals? %t", equal)

Output:

Are the lists equals? true

func (Query) Single

func (q Query) Single() interface{}

Single returns the only element of a collection, and nil if there is not exactly one element in the collection.

Example

The following code example demonstrates how to use Single to select the only element of a slice.

Code:

fruits1 := []string{"orange"}

fruit1 := From(fruits1).Single()

fmt.Println(fruit1)

Output:

orange

func (Query) SingleWith

func (q Query) SingleWith(predicate func(interface{}) bool) (r interface{})

SingleWith returns the only element of a collection that satisfies a specified condition, and nil if more than one such element exists.

Example

The following code example demonstrates how to use SingleWith to select the only element of a slice that satisfies a condition.

Code:

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

fruit := From(fruits).
	SingleWith(
		func(f interface{}) bool { return len(f.(string)) > 10 },
	)

fmt.Println(fruit)

Output:

passionfruit

func (Query) SingleWithT

func (q Query) SingleWithT(predicateFn interface{}) interface{}

SingleWithT is the typed version of SingleWith.

- predicateFn is of type "func(TSource) bool"

NOTE: SingleWith has better performance than SingleWithT.

Example

The following code example demonstrates how to use SingleWithT to select the only element of a slice that satisfies a condition.

Code:

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

fruit := From(fruits).
	SingleWithT(
		func(f string) bool { return len(f) > 10 },
	)

fmt.Println(fruit)

Output:

passionfruit

func (Query) Skip

func (q Query) Skip(count int) Query

Skip bypasses a specified number of elements in a collection and then returns the remaining elements.

Example

The following code example demonstrates how to use Skip to skip a specified number of elements in a sorted array and return the remaining elements.

Code:

grades := []int{59, 82, 70, 56, 92, 98, 85}
var lowerGrades []int
From(grades).
	OrderByDescending(
		func(g interface{}) interface{} { return g },
	).
	Skip(3).
	ToSlice(&lowerGrades)

//All grades except the top three are:
fmt.Println(lowerGrades)

Output:

[82 70 59 56]

func (Query) SkipWhile

func (q Query) SkipWhile(predicate func(interface{}) bool) Query

SkipWhile bypasses elements in a collection as long as a specified condition is true and then returns the remaining elements.

This method tests each element by using predicate and skips the element if the result is true. After the predicate function returns false for an element, that element and the remaining elements in source are returned and there are no more invocations of predicate.

Example

The following code example demonstrates how to use SkipWhile to skip elements of an array as long as a condition is true.

Code:

grades := []int{59, 82, 70, 56, 92, 98, 85}
var lowerGrades []int
From(grades).
	OrderByDescending(
		func(g interface{}) interface{} { return g },
	).
	SkipWhile(
		func(g interface{}) bool { return g.(int) >= 80 },
	).
	ToSlice(&lowerGrades)

// All grades below 80:
fmt.Println(lowerGrades)

Output:

[70 59 56]

func (Query) SkipWhileIndexed

func (q Query) SkipWhileIndexed(predicate func(int, interface{}) bool) Query

SkipWhileIndexed bypasses elements in a collection as long as a specified condition is true and then returns the remaining elements. The element's index is used in the logic of the predicate function.

This method tests each element by using predicate and skips the element if the result is true. After the predicate function returns false for an element, that element and the remaining elements in source are returned and there are no more invocations of predicate.

Example

The following code example demonstrates how to use SkipWhileIndexed to skip elements of an array as long as a condition that depends on the element's index is true.

Code:

amounts := []int{5000, 2500, 9000, 8000, 6500, 4000, 1500, 5500}

var query []int
From(amounts).
	SkipWhileIndexed(
		func(index int, amount interface{}) bool { return amount.(int) > index*1000 },
	).
	ToSlice(&query)

fmt.Println(query)

Output:

[4000 1500 5500]

func (Query) SkipWhileIndexedT

func (q Query) SkipWhileIndexedT(predicateFn interface{}) Query

SkipWhileIndexedT is the typed version of SkipWhileIndexed.

- predicateFn is of type "func(int,TSource)bool"

NOTE: SkipWhileIndexed has better performance than SkipWhileIndexedT.

Example

The following code example demonstrates how to use SkipWhileIndexedT to skip elements of an array as long as a condition that depends on the element's index is true.

Code:

amounts := []int{5000, 2500, 9000, 8000, 6500, 4000, 1500, 5500}

var query []int
From(amounts).
	SkipWhileIndexedT(
		func(index int, amount int) bool { return amount > index*1000 },
	).
	ToSlice(&query)

fmt.Println(query)

Output:

[4000 1500 5500]

func (Query) SkipWhileT

func (q Query) SkipWhileT(predicateFn interface{}) Query

SkipWhileT is the typed version of SkipWhile.

- predicateFn is of type "func(TSource)bool"

NOTE: SkipWhile has better performance than SkipWhileT.

Example

The following code example demonstrates how to use SkipWhileT to skip elements of an array as long as a condition is true.

Code:

grades := []int{59, 82, 70, 56, 92, 98, 85}
var lowerGrades []int
From(grades).
	OrderByDescendingT(
		func(g int) int { return g },
	).
	SkipWhileT(
		func(g int) bool { return g >= 80 },
	).
	ToSlice(&lowerGrades)

//"All grades below 80:
fmt.Println(lowerGrades)

Output:

[70 59 56]

func (Query) Sort

func (q Query) Sort(less func(i, j interface{}) bool) Query

Sort returns a new query by sorting elements with provided less function in ascending order. The comparer function should return true if the parameter i is less than j. While this method is uglier than chaining OrderBy, OrderByDescending, ThenBy and ThenByDescending methods, it's performance is much better.

Example

The following code example demonstrates how to use Sort to order elements of an slice.

Code:

amounts := []int{5000, 2500, 9000, 8000, 6500, 4000, 1500, 5500}

var query []int
From(amounts).
	Sort(
		func(i interface{}, j interface{}) bool { return i.(int) < j.(int) },
	).
	ToSlice(&query)

fmt.Println(query)

Output:

[1500 2500 4000 5000 5500 6500 8000 9000]

func (Query) SortT

func (q Query) SortT(lessFn interface{}) Query

SortT is the typed version of Sort.

- lessFn is of type "func(TSource,TSource) bool"

NOTE: Sort has better performance than SortT.

Example

The following code example demonstrates how to use SortT to order elements of an slice.

Code:

type Pet struct {
	Name string
	Age  int
}
// Create a list of pets.
pets := []Pet{
	{Name: "Barley", Age: 8},
	{Name: "Boots", Age: 4},
	{Name: "Whiskers", Age: 1},
	{Name: "Daisy", Age: 4},
}

orderedPets := []Pet{}
From(pets).
	SortT(
		func(pet1 Pet, pet2 Pet) bool { return pet1.Age < pet2.Age },
	).
	ToSlice(&orderedPets)

for _, pet := range orderedPets {
	fmt.Println(pet.Name, "-", pet.Age)
}

Output:

Whiskers - 1
Boots - 4
Daisy - 4
Barley - 8

func (Query) SumFloats

func (q Query) SumFloats() (r float64)

SumFloats computes the sum of a collection of numeric values.

Values can be of any float type: float32 or float64. The result is float64. Method returns zero if collection contains no elements.

Example

The following code example demonstrates how to use SumFloats to sum the values of a slice.

Code:

numbers := []float64{43.68, 1.25, 583.7, 6.5}

sum := From(numbers).SumFloats()

fmt.Printf("The sum of the numbers is %f.", sum)

Output:

The sum of the numbers is 635.130000.

func (Query) SumInts

func (q Query) SumInts() (r int64)

SumInts computes the sum of a collection of numeric values.

Values can be of any integer type: int, int8, int16, int32, int64. The result is int64. Method returns zero if collection contains no elements.

Example

The following code example demonstrates how to use SumInts to sum the values of a slice.

Code:

numbers := []int{43, 1, 583, 6}

sum := From(numbers).SumInts()

fmt.Printf("The sum of the numbers is %d.", sum)

Output:

The sum of the numbers is 633.

func (Query) SumUInts

func (q Query) SumUInts() (r uint64)

SumUInts computes the sum of a collection of numeric values.

Values can be of any unsigned integer type: uint, uint8, uint16, uint32, uint64. The result is uint64. Method returns zero if collection contains no elements.

Example

The following code example demonstrates how to use SumUInts to sum the values of a slice.

Code:

numbers := []uint{43, 1, 583, 6}

sum := From(numbers).SumUInts()

fmt.Printf("The sum of the numbers is %d.", sum)

Output:

The sum of the numbers is 633.

func (Query) Take

func (q Query) Take(count int) Query

Take returns a specified number of contiguous elements from the start of a collection.

Example

The following code example demonstrates how to use Take

to return elements from the start of a slice.

Code:

grades := []int{59, 82, 70, 56, 92, 98, 85}

var topThreeGrades []int
From(grades).
	OrderByDescending(
		func(grade interface{}) interface{} { return grade },
	).
	Take(3).
	ToSlice(&topThreeGrades)

fmt.Printf("The top three grades are: %v", topThreeGrades)

Output:

The top three grades are: [98 92 85]

func (Query) TakeWhile

func (q Query) TakeWhile(predicate func(interface{}) bool) Query

TakeWhile returns elements from a collection as long as a specified condition is true, and then skips the remaining elements.

Example

The following code example demonstrates how to use TakeWhile to return elements from the start of a slice.

Code:

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

var query []string
From(fruits).
	TakeWhile(
		func(fruit interface{}) bool { return fruit.(string) != "orange" },
	).
	ToSlice(&query)

fmt.Println(query)

Output:

[apple banana mango]

func (Query) TakeWhileIndexed

func (q Query) TakeWhileIndexed(predicate func(int, interface{}) bool) Query

TakeWhileIndexed returns elements from a collection as long as a specified condition is true. The element's index is used in the logic of the predicate function. The first argument of predicate represents the zero-based index of the element within collection. The second argument represents the element to test.

Example

The following code example demonstrates how to use TakeWhileIndexed to return elements from the start of a slice as long as a condition that uses the element's index is true.

Code:

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

var query []string
From(fruits).
	TakeWhileIndexed(
		func(index int, fruit interface{}) bool { return len(fruit.(string)) >= index },
	).
	ToSlice(&query)

fmt.Println(query)

Output:

[apple passionfruit banana mango orange blueberry]

func (Query) TakeWhileIndexedT

func (q Query) TakeWhileIndexedT(predicateFn interface{}) Query

TakeWhileIndexedT is the typed version of TakeWhileIndexed.

- predicateFn is of type "func(int,TSource)bool"

NOTE: TakeWhileIndexed has better performance than TakeWhileIndexedT.

Example

The following code example demonstrates how to use TakeWhileIndexedT to return elements from the start of a slice as long asa condition that uses the element's index is true.

Code:

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

var query []string
From(fruits).
	TakeWhileIndexedT(
		func(index int, fruit string) bool { return len(fruit) >= index },
	).
	ToSlice(&query)

fmt.Println(query)

Output:

[apple passionfruit banana mango orange blueberry]

func (Query) TakeWhileT

func (q Query) TakeWhileT(predicateFn interface{}) Query

TakeWhileT is the typed version of TakeWhile.

- predicateFn is of type "func(TSource)bool"

NOTE: TakeWhile has better performance than TakeWhileT.

Example

The following code example demonstrates how to use TakeWhileT to return elements from the start of a slice.

Code:

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

var query []string
From(fruits).
	TakeWhileT(
		func(fruit string) bool { return fruit != "orange" },
	).
	ToSlice(&query)

fmt.Println(query)

Output:

[apple banana mango]

func (Query) ToChannel

func (q Query) ToChannel(result chan<- interface{})

ToChannel iterates over a collection and outputs each element to a channel, then closes it.

Example

The following code example demonstrates how to use ToChannel to send a slice to a channel.

Code:

c := make(chan interface{})

go func() {
	Repeat(10, 3).ToChannel(c)
}()

for i := range c {
	fmt.Println(i)
}

Output:

10
10
10

func (Query) ToMap

func (q Query) ToMap(result interface{})

ToMap iterates over a collection and populates result map with elements. Collection elements have to be of KeyValue type to use this method. To populate a map with elements of different type use ToMapBy method. ToMap doesn't empty the result map before populating it.

Example

The following code example demonstrates how to use ToMap to populate a map.

Code:

type Product struct {
	Name string
	Code int
}

products := []Product{
	{Name: "orange", Code: 4},
	{Name: "apple", Code: 9},
	{Name: "lemon", Code: 12},
	{Name: "apple", Code: 9},
}

map1 := map[int]string{}
From(products).
	SelectT(
		func(item Product) KeyValue { return KeyValue{Key: item.Code, Value: item.Name} },
	).
	ToMap(&map1)

fmt.Println(map1[4])
fmt.Println(map1[9])
fmt.Println(map1[12])

Output:

orange
apple
lemon

func (Query) ToMapBy

func (q Query) ToMapBy(result interface{},
	keySelector func(interface{}) interface{},
	valueSelector func(interface{}) interface{})

ToMapBy iterates over a collection and populates the result map with elements. Functions keySelector and valueSelector are executed for each element of the collection to generate key and value for the map. Generated key and value types must be assignable to the map's key and value types. ToMapBy doesn't empty the result map before populating it.

Example

The following code example demonstrates how to use ToMapBy by using a key and value selectors to populate a map.

Code:

input := [][]interface{}{{1, true}}

result := make(map[int]bool)
From(input).
	ToMapBy(&result,
		func(i interface{}) interface{} {
			return i.([]interface{})[0]
		},
		func(i interface{}) interface{} {
			return i.([]interface{})[1]
		},
	)

fmt.Println(result)

Output:

map[1:true]

func (Query) ToMapByT

func (q Query) ToMapByT(result interface{},
	keySelectorFn interface{}, valueSelectorFn interface{})

ToMapByT is the typed version of ToMapBy.

- keySelectorFn is of type "func(TSource)TKey"
- valueSelectorFn is of type "func(TSource)TValue"

NOTE: ToMapBy has better performance than ToMapByT.

Example

The following code example demonstrates how to use ToMapBy by using a key and value selectors to populate a map.

Code:

type Product struct {
	Name string
	Code int
}

products := []Product{
	{Name: "orange", Code: 4},
	{Name: "apple", Code: 9},
	{Name: "lemon", Code: 12},
	{Name: "apple", Code: 9},
}

map1 := map[int]string{}
From(products).
	ToMapByT(&map1,
		func(item Product) int { return item.Code },
		func(item Product) string { return item.Name },
	)

fmt.Println(map1[4])
fmt.Println(map1[9])
fmt.Println(map1[12])

Output:

orange
apple
lemon

func (Query) ToSlice

func (q Query) ToSlice(v interface{})

ToSlice iterates over a collection and saves the results in the slice pointed by v. It overwrites the existing slice, starting from index 0.

If the slice pointed by v has sufficient capacity, v will be pointed to a resliced slice. If it does not, a new underlying array will be allocated and v will point to it.

Example

The following code example demonstrates how to use ToSlice to populate a slice.

Code:

var result []int
Range(1, 10).ToSlice(&result)

fmt.Println(result)

Output:

[1 2 3 4 5 6 7 8 9 10]

func (Query) Union

func (q Query) Union(q2 Query) Query

Union produces the set union of two collections.

This method excludes duplicates from the return set. This is different behavior to the Concat method, which returns all the elements in the input collection including duplicates.

Example

The following code example demonstrates how to use Union to obtain the union of two slices of integers.

Code:

q := Range(1, 10).Union(Range(6, 10))

fmt.Println(q.Results())

Output:

[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]

func (Query) Where

func (q Query) Where(predicate func(interface{}) bool) Query

Where filters a collection of values based on a predicate.

Example

The following code example demonstrates how to use Where to filter a slices.

Code:

fruits := []string{"apple", "passionfruit", "banana", "mango",
	"orange", "blueberry", "grape", "strawberry"}
var query []string
From(fruits).
	Where(
		func(f interface{}) bool { return len(f.(string)) > 6 },
	).
	ToSlice(&query)

fmt.Println(query)

Output:

[passionfruit blueberry strawberry]

func (Query) WhereIndexed

func (q Query) WhereIndexed(predicate func(int, interface{}) bool) Query

WhereIndexed filters a collection of values based on a predicate. Each element's index is used in the logic of the predicate function.

The first argument represents the zero-based index of the element within collection. The second argument of predicate represents the element to test.

Example

The following code example demonstrates how to use WhereIndexed to filter a slice based on a predicate that involves the index of each element.

Code:

numbers := []int{0, 30, 20, 15, 90, 85, 40, 75}

var query []int
From(numbers).
	WhereIndexed(
		func(index int, number interface{}) bool { return number.(int) <= index*10 },
	).
	ToSlice(&query)

fmt.Println(query)

Output:

[0 15 40]

func (Query) WhereIndexedT

func (q Query) WhereIndexedT(predicateFn interface{}) Query

WhereIndexedT is the typed version of WhereIndexed.

- predicateFn is of type "func(int,TSource)bool"

NOTE: WhereIndexed has better performance than WhereIndexedT.

Example

The following code example demonstrates how to use WhereIndexedT to filter a slice based on a predicate that involves the index of each element.

Code:

numbers := []int{0, 30, 20, 15, 90, 85, 40, 75}

var query []int
From(numbers).
	WhereIndexedT(
		func(index int, number int) bool { return number <= index*10 },
	).
	ToSlice(&query)

fmt.Println(query)

Output:

[0 15 40]

func (Query) WhereT

func (q Query) WhereT(predicateFn interface{}) Query

WhereT is the typed version of Where.

- predicateFn is of type "func(TSource)bool"

NOTE: Where has better performance than WhereT.

Example

The following code example demonstrates how to use WhereT to filter a slices.

Code:

fruits := []string{"apple", "passionfruit", "banana", "mango",
	"orange", "blueberry", "grape", "strawberry"}
var query []string
From(fruits).
	WhereT(
		func(f string) bool { return len(f) > 6 },
	).
	ToSlice(&query)

fmt.Println(query)

Output:

[passionfruit blueberry strawberry]

func (Query) Zip

func (q Query) Zip(q2 Query,
	resultSelector func(interface{}, interface{}) interface{}) Query

Zip applies a specified function to the corresponding elements of two collections, producing a collection of the results.

The method steps through the two input collections, applying function resultSelector to corresponding elements of the two collections. The method returns a collection of the values that are returned by resultSelector. If the input collections do not have the same number of elements, the method combines elements until it reaches the end of one of the collections. For example, if one collection has three elements and the other one has four, the result collection has only three elements.

Example

The following code example demonstrates how to use the Zip method to merge two slices.

Code:

number := []int{1, 2, 3, 4, 5}
words := []string{"one", "two", "three"}

q := From(number).
	Zip(From(words),
		func(a interface{}, b interface{}) interface{} { return []interface{}{a, b} },
	)

fmt.Println(q.Results())

Output:

[[1 one] [2 two] [3 three]]

func (Query) ZipT

func (q Query) ZipT(q2 Query,
	resultSelectorFn interface{}) Query

ZipT is the typed version of Zip.

- resultSelectorFn is of type "func(TFirst,TSecond)TResult"

NOTE: Zip has better performance than ZipT.

Example

The following code example demonstrates how to use the Zip method to merge two slices.

Code:

number := []int{1, 2, 3, 4, 5}
words := []string{"one", "two", "three"}

q := From(number).
	ZipT(From(words),
		func(a int, b string) []interface{} { return []interface{}{a, b} },
	)

fmt.Println(q.Results())

Output:

[[1 one] [2 two] [3 three]]
Documentation was rendered with GOOS=linux and GOARCH=amd64.

Jump to identifier

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to identifier