go-linq: github.com/ahmetb/go-linq Index | Examples | Files

package linq

import "github.com/ahmetb/go-linq"

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

Package Files

aggregate.go compare.go concat.go convert.go distinct.go doc.go except.go from.go genericfunc.go groupby.go groupjoin.go intersect.go join.go orderby.go result.go reverse.go select.go selectmany.go skip.go take.go union.go where.go zip.go

type Comparable Uses

type Comparable interface {
    CompareTo(Comparable) int
}

Comparable is an interface that has to be implemented by a custom collection elements 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 Uses

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

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

type Iterable Uses

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 Uses

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

Iterator is an alias for function to iterate over data.

type KeyValue Uses

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.

Code:

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

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

Output:

[{10 true}]

Code:

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

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

fmt.Println(m)

Output:

map[10:true]

type OrderedQuery Uses

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

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

func (OrderedQuery) Distinct Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

type Query struct {
    Iterate func() Iterator
}

Query is the type returned from query functions. It can be iterated manually as shown in the 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 Uses

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 Uses

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

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

func FromIterable Uses

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 Uses

func FromString(source string) Query

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

func Range Uses

func Range(start, count int) Query

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

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 Uses

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

Repeat generates a sequence that contains one repeated value.

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 Uses

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().

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 Uses

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.

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 Uses

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().

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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

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

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 Uses

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.

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 Uses

func (q Query) Any() bool

Any determines whether any element of a collection exists.

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 Uses

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

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

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 Uses

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.

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 Uses

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

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

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 Uses

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

Average computes the average of a collection of numeric values.

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 Uses

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.

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 Uses

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

Contains determines whether a collection contains a specified element.

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 Uses

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

Count returns the number of elements in a collection.

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 Uses

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.

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 Uses

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.

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 Uses

func (q Query) Distinct() Query

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

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

func (q Query) First() interface{}

First returns the first element of a collection.

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 Uses

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

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

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 Uses

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.

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 Uses

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

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

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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

Last returns the last element of a collection.

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 Uses

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

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

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 Uses

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.

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 Uses

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

Max returns the maximum value in a collection of values.

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 Uses

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

Min returns the minimum value in a collection of values.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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

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

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 Uses

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

Results iterates over a collection and returnes slice of interfaces

func (Query) Reverse Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

func (q Query) SequenceEqual(q2 Query) bool

SequenceEqual determines whether two collections are equal.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

func (q Query) Skip(count int) Query

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

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

func (q Query) Take(count int) Query

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

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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

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

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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

Where filters a collection of values based on a predicate.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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 Uses

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.

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]]

Package linq imports 5 packages (graph). Updated 2017-04-26. Refresh now. Tools for package owners.