glinq

package module
v0.0.0-...-92667b2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 21, 2024 License: MIT Imports: 8 Imported by: 0

README

glinq

Go port of DotNet LINQ using generics introduced in Go 1.18

Currently implemented

  • Where
  • Select
  • Range
  • Foreach
  • Min(By)
  • Max(By)
  • Average
  • Sum
  • First
  • Last
  • Skip(While)
  • Take(While)
  • Contains
  • Any
  • Join

(OrderBy And GroupBy will always access all items. For performance and ease of use reason I'll not implement them in IEnumerable way. Please use glinq/garray package instead)

Adapters:

  • FromSlice

  • FromMap

  • ReadLines (wrapping bufio.NewScanner)

  • sqlxq.Queryx (wrapping sqlx.Queryx)

  • ToSlice

  • ToMap

Also some similar utilities directly for slices in the glinq/garray package. These are more handful, without FromSlice/ToSlice conversion.

  • Sort(Descending)
  • SortBy(Descending)
  • Map
  • ToMap
  • Filter
  • Apply
  • RemoveIf
  • Contains
  • (Last)IndexOf
  • (Last)IndexWhere
  • First, Last
  • Concat
  • ShallowCopy
  • Sum
  • Average
  • GroupBy
  • Count
  • Reverse

Also a generic SyncMap type (should I separate it in another repository?)

  • Load
  • Store
  • Range(E)
  • Delete(If)
  • LoadAndDelete
  • LoadOrStore
  • LoadOrNew
  • LoadAndUpdate
  • ToSlice
  • Keys
  • Len
  • Clear
  • PopAll

And more to come...

usage example

package main

import (
	"fmt"

	"github.com/szmcdull/glinq/garray"
	. "github.com/szmcdull/glinq/unsafe"
)

func main() {
	numbers := garray.Concat([]int{1, 2, 3, 4, 5}, []int{6, 7, 8, 9, 10})
	numbersToRemove := Where(FromSlice(numbers), func(x int) bool {
		return x > 5
	})
	Do(numbersToRemove, func(x int) { fmt.Printf(`%d `, x) }) // 6 7 8 9 10
	fmt.Println(``)
	numbers = ToSlice(Where(FromSlice(numbers), func(x int) bool {
		return !Contains(numbersToRemove, x)
	}))
	fmt.Println(Any(Where(FromSlice(numbers), func(x int) bool { return x > 5 }))) // false
	Do(FromSlice(numbers), func(x int) { fmt.Printf(`%d `, x) })                   // 1 2 3 4 5
	fmt.Println(``)

	// Sorting
	l := []int{8, 6, 4, 2, 5, 3, 1}

	garray.Sort(l)
	fmt.Printf("%v\n", l) // [1 2 3 4 5 6 8]

	l2 := []string{`the`, `lazy`, `dog`, `jumps`, `over`, `the`, `silver`, `fox`}
	garray.SortByDescending(l2, func(x string) byte { return x[len(x)-1] }) // sort descending by the last character
	fmt.Printf("%v\n", l2)                                                  // [lazy fox jumps silver over dog the the]
}

More examples:

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrInvalidState = errors.New(`invalid state`)
)

Functions

func Any 

func Any[T any](q IEnumerable[T]) bool

func Average 

func Average[T Number](q IEnumerable[T]) (T, error)

func Contains 

func Contains[T comparable](q IEnumerable[T], v T) (bool, error)

func Do 

func Do[T any](q IEnumerable[T], f func(T)) error

Apply f() to all items in q

func First 

func First[T any](source IEnumerable[T], err *error) T

func FirstWhere 

func FirstWhere[T any](source IEnumerable[T], pred func(T) bool, err *error) T

func Foreach 

func Foreach[T any](q IEnumerable[T], f func(T) error) error

Apply f() to all items in q, break when f() returns false

func ForeachI 

func ForeachI[T any](q IEnumerable[T], f func(int, T) error) error

Apply f() to all items in q, break when f() returns false. A counted index is passed to f()

func Last 

func Last[T any](source IEnumerable[T], err *error) T

func LastWhere 

func LastWhere[T any](source IEnumerable[T], pred func(T) bool, err *error) T

func Max 

func Max[T constraints.Ordered](q IEnumerable[T]) (T, error)

func MaxBy 

func MaxBy[T any, K constraints.Ordered](q IEnumerable[T], selector func(T) K) (result T, err error)

func Min 

func Min[T constraints.Ordered](q IEnumerable[T]) (T, error)

func MinBy 

func MinBy[T any, K constraints.Ordered](q IEnumerable[T], selector func(T) K) (result T, err error)

func Sum 

func Sum[T Number](q IEnumerable[T]) (T, error)

func ToMap 

func ToMap[T any, K comparable, V any](
	me IEnumerable[T], keyFunc func(T) K, valFunc func(T) V) (map[K]V, error)

func ToSlice 

func ToSlice[T any](me IEnumerable[T]) ([]T, error)

Types

type ICount 

type ICount[T any] interface {
	Count() int
}

type IEnumerable 

type IEnumerable[T any] interface {
	GetEnumerator() IEnumerator[T]
	Count() int // returns -1 when not supported by underlying data source
	Any() bool
}

func Abs 

func Abs[T Number](q IEnumerable[T]) IEnumerable[T]

func Clamp 

func Clamp[T constraints.Ordered](q IEnumerable[T], min, max T) IEnumerable[T]

func FromMap 

func FromMap[K comparable, V any](v map[K]V) IEnumerable[Pair[K, V]]

func FromMapCopy 

func FromMapCopy[K comparable, V any](v map[K]V) IEnumerable[Pair[K, V]]

先复制出一个 []Pair[K,V]，再转成 IEnumerable，不适用于map很大的情况

func FromMapReflect 

func FromMapReflect[K comparable, V any](v map[K]V) IEnumerable[Pair[K, V]]

通过 reflect.MapRange 遍历 map，线性读取快，随机访问慢

func FromSlice 

func FromSlice[T any](v []T) IEnumerable[T]

func Join 

func Join[Outer, Inner, Result any](
	outer IEnumerable[Outer],
	inner IEnumerable[Inner],
	pred func(Outer, Inner) (selected bool, result Result)) IEnumerable[Result]

func Range 

func Range[T constraints.Integer | constraints.Float](start, end T) IEnumerable[T]

func RangeStep 

func RangeStep[T constraints.Integer | constraints.Float](start, end, step T) IEnumerable[T]

func Select 

func Select[T any, T2 any](source IEnumerable[T], selector func(T) T2) IEnumerable[T2]

func Skip 

func Skip[T any](source IEnumerable[T], n int) IEnumerable[T]

func SkipWhile 

func SkipWhile[T any](source IEnumerable[T], pred func(T) bool) IEnumerable[T]

func Take 

func Take[T any](source IEnumerable[T], n int) IEnumerable[T]

func TakeWhile 

func TakeWhile[T any](source IEnumerable[T], pred func(T) bool) IEnumerable[T]

func Where 

func Where[T any](source IEnumerable[T], pred func(T) bool) IEnumerable[T]

type IEnumerableAndEnumerator 

type IEnumerableAndEnumerator[T any] interface {
	IEnumerable[T]
	IEnumerator[T]
}

type IEnumerator 

type IEnumerator[T any] interface {
	Current() T
	MoveNext() error // nil=success, io.EOF=reached last item, other=error occurred

}

type IGetAt 

type IGetAt[T any] interface {
	GetAt(i int) (T, error)
}

type IRangeEnumerator 

type IRangeEnumerator[T any] interface {
	ICount[T]
	IGetAt[T]
	SeekOnce(i int) error // can only seek once
}

type JoinEnumerableIterator 

type JoinEnumerableIterator[Outer, Inner, Result any] struct {
	// contains filtered or unexported fields
}

func NewJoinIterator 

func NewJoinIterator[Outer, Inner, Result any](
	outer IEnumerable[Outer],
	inner IEnumerable[Inner],
	pred func(Outer, Inner) (selected bool, result Result)) *JoinEnumerableIterator[Outer, Inner, Result]

func (*JoinEnumerableIterator[Outer, Inner, Result]) Any 

func (me *JoinEnumerableIterator[Outer, Inner, Result]) Any() bool

func (*JoinEnumerableIterator[Outer, Inner, Result]) Clone 

func (me *JoinEnumerableIterator[Outer, Inner, Result]) Clone() IEnumerator[Result]

func (*JoinEnumerableIterator[Outer, Inner, Result]) Count 

func (me *JoinEnumerableIterator[Outer, Inner, Result]) Count() int

func (*JoinEnumerableIterator) Current 

func (me *JoinEnumerableIterator) Current() T

func (*JoinEnumerableIterator) GetEnumerator 

func (me *JoinEnumerableIterator) GetEnumerator() IEnumerator[T]

func (*JoinEnumerableIterator[Outer, Inner, Result]) MoveNext 

func (me *JoinEnumerableIterator[Outer, Inner, Result]) MoveNext() error

type LineEnumerator 

type LineEnumerator struct {
	// contains filtered or unexported fields
}

func ReadLines 

func ReadLines(reader io.Reader) *LineEnumerator

func (*LineEnumerator) Any 

func (me *LineEnumerator) Any() bool

func (*LineEnumerator) Count 

func (me *LineEnumerator) Count() int

func (*LineEnumerator) Current 

func (me *LineEnumerator) Current() string

func (*LineEnumerator) GetEnumerator 

func (me *LineEnumerator) GetEnumerator() IEnumerator[string]

func (*LineEnumerator) MoveNext 

func (me *LineEnumerator) MoveNext() error

type Map 

type Map[K comparable, V any] map[K]V

func (Map[K, V]) Any 

func (me Map[K, V]) Any() bool

func (Map[K, V]) Count 

func (me Map[K, V]) Count() int

func (Map[K, V]) GetEnumerator 

func (me Map[K, V]) GetEnumerator() IEnumerator[Pair[K, V]]

type MapEnumerator 

type MapEnumerator[K comparable, V any] struct {
	// contains filtered or unexported fields
}

func (*MapEnumerator[K, V]) Current 

func (me *MapEnumerator[K, V]) Current() Pair[K, V]

func (*MapEnumerator[K, V]) MoveNext 

func (me *MapEnumerator[K, V]) MoveNext() error

func (*MapEnumerator[K, V]) Reset 

func (me *MapEnumerator[K, V]) Reset() error

type Number 

type Number interface {
	constraints.Integer | constraints.Float
}

type OrderIterator 

type OrderIterator[T any] struct {
	// contains filtered or unexported fields
}

func (*OrderIterator) Current 

func (me *OrderIterator) Current() T

func (*OrderIterator) GetEnumerator 

func (me *OrderIterator) GetEnumerator() IEnumerator[T]

func (*OrderIterator) MoveNext 

func (me *OrderIterator) MoveNext() error

type Pair 

type Pair[K comparable, V any] struct {
	Key   K
	Value V
}

type RangeIterator 

type RangeIterator[T constraints.Integer | constraints.Float] struct {
	// contains filtered or unexported fields
}

func NewRangeIterator 

func NewRangeIterator[T constraints.Integer | constraints.Float](start, end, step T) *RangeIterator[T]

func (*RangeIterator[T]) Any 

func (me *RangeIterator[T]) Any() bool

func (*RangeIterator[T]) Clone 

func (me *RangeIterator[T]) Clone() IEnumerator[T]

func (*RangeIterator[T]) Count 

func (me *RangeIterator[T]) Count() int

func (*RangeIterator) Current 

func (me *RangeIterator) Current() T

func (*RangeIterator[T]) GetAt 

func (me *RangeIterator[T]) GetAt(pos int) (result T, err error)

func (*RangeIterator) GetEnumerator 

func (me *RangeIterator) GetEnumerator() IEnumerator[T]

func (*RangeIterator[T]) MoveNext 

func (me *RangeIterator[T]) MoveNext() error

func (*RangeIterator[T]) SeekOnce 

func (me *RangeIterator[T]) SeekOnce(pos int) error

type SelectEnumerableIterator 

type SelectEnumerableIterator[T any, T2 any] struct {
	// contains filtered or unexported fields
}

func NewSelectIterator 

func NewSelectIterator[T any, T2 any](source IEnumerable[T], selector func(T) T2) *SelectEnumerableIterator[T, T2]

func (*SelectEnumerableIterator[T, T2]) Any 

func (me *SelectEnumerableIterator[T, T2]) Any() bool

func (*SelectEnumerableIterator[T, T2]) Clone 

func (me *SelectEnumerableIterator[T, T2]) Clone() IEnumerator[T2]

func (*SelectEnumerableIterator[T, T2]) Count 

func (me *SelectEnumerableIterator[T, T2]) Count() int

func (*SelectEnumerableIterator) Current 

func (me *SelectEnumerableIterator) Current() T

func (*SelectEnumerableIterator) GetEnumerator 

func (me *SelectEnumerableIterator) GetEnumerator() IEnumerator[T]

func (*SelectEnumerableIterator[T, T2]) MoveNext 

func (me *SelectEnumerableIterator[T, T2]) MoveNext() error

type SkipIterator 

type SkipIterator[T any] struct {
	// contains filtered or unexported fields
}

func NewSkipIterator 

func NewSkipIterator[T any](source IEnumerable[T], n int) *SkipIterator[T]

func (*SkipIterator[T]) Any 

func (me *SkipIterator[T]) Any() bool

func (*SkipIterator[T]) Clone 

func (me *SkipIterator[T]) Clone() IEnumerator[T]

func (*SkipIterator[T]) Count 

func (me *SkipIterator[T]) Count() int

func (*SkipIterator) Current 

func (me *SkipIterator) Current() T

func (*SkipIterator) GetEnumerator 

func (me *SkipIterator) GetEnumerator() IEnumerator[T]

func (*SkipIterator[T]) MoveNext 

func (me *SkipIterator[T]) MoveNext() error

type SkipWhileIterator 

type SkipWhileIterator[T any] struct {
	// contains filtered or unexported fields
}

func NewSkipWhileIterator 

func NewSkipWhileIterator[T any](source IEnumerable[T], pred func(T) bool) *SkipWhileIterator[T]

func (*SkipWhileIterator[T]) Any 

func (me *SkipWhileIterator[T]) Any() bool

func (*SkipWhileIterator[T]) Clone 

func (me *SkipWhileIterator[T]) Clone() IEnumerator[T]

func (*SkipWhileIterator[T]) Count 

func (me *SkipWhileIterator[T]) Count() int

func (*SkipWhileIterator) Current 

func (me *SkipWhileIterator) Current() T

func (*SkipWhileIterator) GetEnumerator 

func (me *SkipWhileIterator) GetEnumerator() IEnumerator[T]

func (*SkipWhileIterator[T]) MoveNext 

func (me *SkipWhileIterator[T]) MoveNext() error

type Slice 

type Slice[T any] []T

func (Slice[T]) Any 

func (me Slice[T]) Any() bool

func (Slice[T]) Count 

func (me Slice[T]) Count() int

func (Slice[T]) GetAt 

func (me Slice[T]) GetAt(i int) (v T, err error)

func (Slice[T]) GetEnumerator 

func (me Slice[T]) GetEnumerator() IEnumerator[T]

type SliceEnumerator 

type SliceEnumerator[T any] struct {
	// contains filtered or unexported fields
}

func (*SliceEnumerator[T]) Current 

func (me *SliceEnumerator[T]) Current() T

func (*SliceEnumerator[T]) GetAt 

func (me *SliceEnumerator[T]) GetAt(pos int) (v T, err error)

func (*SliceEnumerator[T]) MoveNext 

func (me *SliceEnumerator[T]) MoveNext() error

func (*SliceEnumerator[T]) Reset 

func (me *SliceEnumerator[T]) Reset() error

func (*SliceEnumerator[T]) SeekOnce 

func (me *SliceEnumerator[T]) SeekOnce(pos int) error

type TakeIterator 

type TakeIterator[T any] struct {
	// contains filtered or unexported fields
}

func NewTakeIterator 

func NewTakeIterator[T any](source IEnumerable[T], n int) *TakeIterator[T]

func (*TakeIterator[T]) Any 

func (me *TakeIterator[T]) Any() bool

func (*TakeIterator[T]) Clone 

func (me *TakeIterator[T]) Clone() IEnumerator[T]

func (*TakeIterator[T]) Count 

func (me *TakeIterator[T]) Count() int

func (*TakeIterator) Current 

func (me *TakeIterator) Current() T

func (*TakeIterator) GetEnumerator 

func (me *TakeIterator) GetEnumerator() IEnumerator[T]

func (*TakeIterator[T]) MoveNext 

func (me *TakeIterator[T]) MoveNext() error

type TakeWhileIterator 

type TakeWhileIterator[T any] struct {
	// contains filtered or unexported fields
}

func NewTakeWhileIterator 

func NewTakeWhileIterator[T any](source IEnumerable[T], pred func(T) bool) *TakeWhileIterator[T]

func (*TakeWhileIterator[T]) Any 

func (me *TakeWhileIterator[T]) Any() bool

func (*TakeWhileIterator[T]) Clone 

func (me *TakeWhileIterator[T]) Clone() IEnumerator[T]

func (*TakeWhileIterator[T]) Count 

func (me *TakeWhileIterator[T]) Count() int

func (*TakeWhileIterator) Current 

func (me *TakeWhileIterator) Current() T

func (*TakeWhileIterator) GetEnumerator 

func (me *TakeWhileIterator) GetEnumerator() IEnumerator[T]

func (*TakeWhileIterator[T]) MoveNext 

func (me *TakeWhileIterator[T]) MoveNext() error

type WhereEnumerableIterator 

type WhereEnumerableIterator[T any] struct {
	// contains filtered or unexported fields
}

func NewWhereIterator 

func NewWhereIterator[T any](source IEnumerable[T], pred func(T) bool) *WhereEnumerableIterator[T]

func (*WhereEnumerableIterator[T]) Any 

func (me *WhereEnumerableIterator[T]) Any() bool

func (*WhereEnumerableIterator[T]) Clone 

func (me *WhereEnumerableIterator[T]) Clone() IEnumerator[T]

func (*WhereEnumerableIterator[T]) Count 

func (me *WhereEnumerableIterator[T]) Count() int

func (*WhereEnumerableIterator) Current 

func (me *WhereEnumerableIterator) Current() T

func (*WhereEnumerableIterator) GetEnumerator 

func (me *WhereEnumerableIterator) GetEnumerator() IEnumerator[T]

func (*WhereEnumerableIterator[T]) MoveNext 

func (me *WhereEnumerableIterator[T]) MoveNext() error

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.