go-linq

You can chain methods to perform queries. The basic pattern is: From(data) .Where(predicate) .Select(selector) .Union(data).

Note that when using standard methods, you must use any and type assertions. For example, to find owners of cars manufactured after 2015:

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

type Car struct {
    year int
    owner, model string
}

var owners []string

FromSlice(cars).Where(func(c any) bool {
	return c.(Car).year >= 2015
}).Select(func(c any) any {
	return c.(Car).owner
}).ToSlice(&owners)

To avoid any and type assertions, use methods with a T suffix (e.g., WhereT, SelectT). This makes the code more readable but introduces a performance penalty (approximately 5x-10x slower).

Example using WhereT and SelectT with a Car struct:

var owners []string

FromSlice(cars).WhereT(func(c Car) bool {
	return c.year >= 2015
}).SelectT(func(c Car) string {
	return c.owner
}).ToSlice(&owners)

To use go-linq with Go modules, use the following import path:

go get github.com/ahmetb/go-linq/v4

For older versions of Go using different dependency management tools, use:

go get gopkg.in/ahmetb/go-linq.v4

In go-linq v4, the Query type exposes an Iterate field of type iter.Seq[any]. This allows you to use the standard Go for ... range loop to iterate over query results.

q := FromSlice([]int{1, 2, 3, 4})

for v := range q.Iterate {
	fmt.Println(v)
}

For better performance and type safety, use the specific From* constructors instead of the generic From function. The From* constructors are optimized for their specific input types and avoid reflection overhead.

Available constructors:

• FromSlice: creates a query from a slice
• FromMap: creates a query from a map
• FromChannel: creates a query from a channel
• FromChannelWithContext: creates a query from a channel with Context support
• FromString: creates a query from a string (iterating over runes)
• FromIterable: creates a query from a custom collection implementing the Iterable interface

The TakeWhileT(predicateFn any) method is the typed version of TakeWhile. It accepts a predicate function of type func(TSource) bool.

Note: TakeWhile has better performance than TakeWhileT.

func (q Query) TakeWhileT(predicateFn any) Query

The Join method correlates elements from two collections based on matching keys. It preserves the order of the outer collection and, for each outer element, the order of matching elements in the inner collection. This is a single-call operation that combines two information sources via a common key.

Parameters:

• inner: The Query representing the inner collection.
• outerKeySelector: A function func(any) any that extracts the key from an element in the outer collection.
• innerKeySelector: A function func(any) any that extracts the key from an element in the inner collection.
• resultSelector: A function func(outer any, inner any) any that defines how to combine the matched outer and inner elements into a result.

The Aggregate method performs a calculation over a sequence of values. It uses the first element of the source as the initial accumulator value and calls the provided function f(accumulator, item any) any for each subsequent element. If the source is empty, it returns nil.

func (q Query) Aggregate(f func(accumulator, item any) any) any

Use SelectManyIndexed to flatten collections while accessing the zero-based index of the element in the source collection. The selector function receives two arguments: index int and outer any.

func (q Query) SelectManyIndexed(selector func(index int, outer any) Query) Query

Use OrderBy on a Query to sort elements in ascending order based on a key selected by a selector function. The selector function must take an any and return an any representing the sort key.

For better performance, use the non-generic OrderBy over the typed OrderByT version.

func (q Query) OrderBy(selector func(any) any) OrderedQuery