stream

package module
v0.0.0-...-11759f2 Latest Latest
Warning

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

Go to latest
Published: May 22, 2023 License: MIT Imports: 10 Imported by: 0

README

stream

go stream lib based on generics

Installation

# golang 1.18+ required
go get -u github.com/go-park/stream@latest

Quick Start

The Go Stream API is a powerful tool for processing collections and streams of data in a functional way.

  1. Create a stream: To get started with the tool, you need to create a stream. You can create a stream from a slice, an array, or by generating elements dynamically. Here's an example of creating a stream from a slice:

    slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    s := stream.From(slice...)
    
  2. Use stream operations: Once you have a stream, you can use a variety of stream operations to manipulate and process the data. Stream operations are divided into intermediate and terminal operations. Intermediate operations return a new stream, while terminal operations return a result or a side-effect. Here are some examples of stream operations:

    slice := []int{1, 2, 3, 4, 5, 61, 7, 8, 9, 10, 11, 19}
    val := stream.From(slice...).
    	Filter(func(t int) bool { return t > 2 }).
    	Skip(2).Limit(2).
    	Map(func(i int) int {
    		return i + 1
    	}).
    	Reduce(func(i1, i2 int) int { return i1 + i2 })
    val.IfNotEmptyOrElse(
    	func(v int) { assert.Equal(t, v, 5+1+61+1) },
    	func() { t.Error("empty") })
    
  3. Close the stream: When you're done processing the stream, you need to close it. This releases any resources associated with the stream. You can close a stream using the Close() method or by using a terminal operation that automatically closes the stream, such as ForEach().

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Builder

func Builder[T any]() builder[T]

func GetParallelism

func GetParallelism() int

func Max

func Max[T constraints.Ordered](s Stream[T]) optional.Value[T]

func Min

func Min[T constraints.Ordered](s Stream[T]) optional.Value[T]

func ToList

func ToList[T, V any](s Stream[T], conv function.Func[T, V]) []V

func ToMap

func ToMap[T, V any, R comparable](s Stream[T], source function.Func[T, R], after function.Func[T, V]) map[R]V

Types

type FastPipline

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

func (*FastPipline[T]) AllMatch

func (p *FastPipline[T]) AllMatch(pred function.Predicate[T]) bool

func (*FastPipline[T]) AnyMatch

func (p *FastPipline[T]) AnyMatch(pred function.Predicate[T]) bool

func (*FastPipline[T]) Close

func (p *FastPipline[T]) Close()

func (*FastPipline[T]) Count

func (p *FastPipline[T]) Count() int

func (*FastPipline[T]) Distinct

func (p *FastPipline[T]) Distinct(equals function.BiPredicate[T, T]) Stream[T]

func (*FastPipline[T]) Filter

func (p *FastPipline[T]) Filter(pred function.Predicate[T]) Stream[T]

func (*FastPipline[T]) FindAny

func (p *FastPipline[T]) FindAny() optional.Value[T]

func (*FastPipline[T]) ForEach

func (p *FastPipline[T]) ForEach(fn function.Consumer[T])

func (*FastPipline[T]) Limit

func (p *FastPipline[T]) Limit(i uint) Stream[T]

func (*FastPipline[T]) Map

func (p *FastPipline[T]) Map(mapper function.Func[T, T]) Stream[T]

func (*FastPipline[T]) MapToAny

func (p *FastPipline[T]) MapToAny(mapper function.Func[T, any]) Stream[any]

func (*FastPipline[T]) MapToFloat

func (p *FastPipline[T]) MapToFloat(mapper function.Func[T, float64]) Stream[float64]

func (*FastPipline[T]) MapToInt

func (p *FastPipline[T]) MapToInt(mapper function.Func[T, int]) Stream[int]

func (*FastPipline[T]) MapToString

func (p *FastPipline[T]) MapToString(mapper function.Func[T, string]) Stream[string]

func (*FastPipline[T]) Max

func (p *FastPipline[T]) Max(less function.BiPredicate[T, T]) optional.Value[T]

func (*FastPipline[T]) Min

func (p *FastPipline[T]) Min(less function.BiPredicate[T, T]) optional.Value[T]

func (*FastPipline[T]) NoneMatch

func (p *FastPipline[T]) NoneMatch(pred function.Predicate[T]) bool

func (*FastPipline[T]) Parallel

func (p *FastPipline[T]) Parallel() Stream[T]

func (*FastPipline[T]) Reduce

func (p *FastPipline[T]) Reduce(acc function.BiFunc[T, T, T]) optional.Value[T]

func (*FastPipline[T]) Reverse

func (p *FastPipline[T]) Reverse() Stream[T]

func (*FastPipline[T]) Sequential

func (p *FastPipline[T]) Sequential() Stream[T]

func (*FastPipline[T]) Skip

func (p *FastPipline[T]) Skip(i uint) Stream[T]

func (*FastPipline[T]) Sort

func (p *FastPipline[T]) Sort(less function.BiPredicate[T, T]) Stream[T]

func (*FastPipline[T]) ToSlice

func (p *FastPipline[T]) ToSlice() []T

type ParallelPipline

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

func (ParallelPipline[T]) AllMatch

func (p ParallelPipline[T]) AllMatch(pred function.Predicate[T]) bool

func (ParallelPipline[T]) AnyMatch

func (p ParallelPipline[T]) AnyMatch(pred function.Predicate[T]) bool

func (ParallelPipline[T]) Close

func (p ParallelPipline[T]) Close()

func (ParallelPipline[T]) Count

func (p ParallelPipline[T]) Count() int

func (ParallelPipline[T]) Distinct

func (p ParallelPipline[T]) Distinct(equals function.BiPredicate[T, T]) Stream[T]

func (ParallelPipline[T]) Filter

func (p ParallelPipline[T]) Filter(pred function.Predicate[T]) Stream[T]

func (ParallelPipline[T]) FindAny

func (p ParallelPipline[T]) FindAny() optional.Value[T]

func (ParallelPipline[T]) ForEach

func (p ParallelPipline[T]) ForEach(consumer function.Consumer[T])

func (ParallelPipline[T]) Limit

func (p ParallelPipline[T]) Limit(i uint) Stream[T]

func (ParallelPipline[T]) Map

func (p ParallelPipline[T]) Map(mapper function.Func[T, T]) Stream[T]

func (ParallelPipline[T]) MapToAny

func (p ParallelPipline[T]) MapToAny(mapper function.Func[T, any]) Stream[any]

func (ParallelPipline[T]) MapToFloat

func (p ParallelPipline[T]) MapToFloat(mapper function.Func[T, float64]) Stream[float64]

func (ParallelPipline[T]) MapToInt

func (p ParallelPipline[T]) MapToInt(mapper function.Func[T, int]) Stream[int]

func (ParallelPipline[T]) MapToString

func (p ParallelPipline[T]) MapToString(mapper function.Func[T, string]) Stream[string]

func (ParallelPipline[T]) Max

func (p ParallelPipline[T]) Max(less function.BiPredicate[T, T]) optional.Value[T]

func (ParallelPipline[T]) Min

func (p ParallelPipline[T]) Min(less function.BiPredicate[T, T]) optional.Value[T]

func (ParallelPipline[T]) NoneMatch

func (p ParallelPipline[T]) NoneMatch(pred function.Predicate[T]) bool

func (ParallelPipline[T]) Parallel

func (p ParallelPipline[T]) Parallel() Stream[T]

func (ParallelPipline[T]) Reduce

func (p ParallelPipline[T]) Reduce(acc function.BiFunc[T, T, T]) optional.Value[T]

func (ParallelPipline[T]) Reverse

func (p ParallelPipline[T]) Reverse() Stream[T]

func (ParallelPipline[T]) Sequential

func (p ParallelPipline[T]) Sequential() Stream[T]

func (ParallelPipline[T]) Skip

func (p ParallelPipline[T]) Skip(i uint) Stream[T]

func (ParallelPipline[T]) Sort

func (p ParallelPipline[T]) Sort(less function.BiPredicate[T, T]) Stream[T]

func (ParallelPipline[T]) ToSlice

func (p ParallelPipline[T]) ToSlice() []T

type SimplePipline

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

func (SimplePipline[T]) AllMatch

func (p SimplePipline[T]) AllMatch(pred function.Predicate[T]) bool

func (SimplePipline[T]) AnyMatch

func (p SimplePipline[T]) AnyMatch(pred function.Predicate[T]) bool

func (SimplePipline[T]) Close

func (p SimplePipline[T]) Close()

func (SimplePipline[T]) Count

func (p SimplePipline[T]) Count() int

func (SimplePipline[T]) Distinct

func (p SimplePipline[T]) Distinct(equals function.BiPredicate[T, T]) Stream[T]

func (SimplePipline[T]) Filter

func (p SimplePipline[T]) Filter(pred function.Predicate[T]) Stream[T]

func (SimplePipline[T]) FindAny

func (p SimplePipline[T]) FindAny() optional.Value[T]

func (SimplePipline[T]) ForEach

func (p SimplePipline[T]) ForEach(fn function.Consumer[T])

func (SimplePipline[T]) Limit

func (p SimplePipline[T]) Limit(i uint) Stream[T]

func (SimplePipline[T]) Map

func (p SimplePipline[T]) Map(mapper function.Func[T, T]) Stream[T]

func (SimplePipline[T]) MapToAny

func (p SimplePipline[T]) MapToAny(mapper function.Func[T, any]) Stream[any]

func (SimplePipline[T]) MapToFloat

func (p SimplePipline[T]) MapToFloat(mapper function.Func[T, float64]) Stream[float64]

func (SimplePipline[T]) MapToInt

func (p SimplePipline[T]) MapToInt(mapper function.Func[T, int]) Stream[int]

func (SimplePipline[T]) MapToString

func (p SimplePipline[T]) MapToString(mapper function.Func[T, string]) Stream[string]

func (SimplePipline[T]) Max

func (p SimplePipline[T]) Max(less function.BiPredicate[T, T]) optional.Value[T]

func (SimplePipline[T]) Min

func (p SimplePipline[T]) Min(less function.BiPredicate[T, T]) optional.Value[T]

func (SimplePipline[T]) NoneMatch

func (p SimplePipline[T]) NoneMatch(pred function.Predicate[T]) bool

func (SimplePipline[T]) Parallel

func (p SimplePipline[T]) Parallel() Stream[T]

func (SimplePipline[T]) Reduce

func (p SimplePipline[T]) Reduce(acc function.BiFunc[T, T, T]) optional.Value[T]

func (SimplePipline[T]) Reverse

func (p SimplePipline[T]) Reverse() Stream[T]

func (SimplePipline[T]) Sequential

func (p SimplePipline[T]) Sequential() Stream[T]

func (SimplePipline[T]) Skip

func (p SimplePipline[T]) Skip(i uint) Stream[T]

func (SimplePipline[T]) Sort

func (p SimplePipline[T]) Sort(less function.BiPredicate[T, T]) Stream[T]

func (SimplePipline[T]) ToSlice

func (p SimplePipline[T]) ToSlice() []T

type Stream

type Stream[T any] interface {
	Close()
	Count() int
	ToSlice() []T
	ForEach(consumer function.Consumer[T])
	Parallel() Stream[T]
	Sequential() Stream[T]
	Filter(pred function.Predicate[T]) Stream[T]
	Limit(i uint) Stream[T]
	Skip(i uint) Stream[T]
	Distinct(equals function.BiPredicate[T, T]) Stream[T]
	Sort(less function.BiPredicate[T, T]) Stream[T]
	Reverse() Stream[T]
	Max(less function.BiPredicate[T, T]) optional.Value[T]
	Min(less function.BiPredicate[T, T]) optional.Value[T]
	Map(mapper function.Func[T, T]) Stream[T]
	Reduce(acc function.BiFunc[T, T, T]) optional.Value[T]
	MapToAny(mapper function.Func[T, any]) Stream[any]
	MapToString(mapper function.Func[T, string]) Stream[string]
	MapToInt(mapper function.Func[T, int]) Stream[int]
	MapToFloat(mapper function.Func[T, float64]) Stream[float64]
	AnyMatch(pred function.Predicate[T]) bool
	AllMatch(pred function.Predicate[T]) bool
	NoneMatch(pred function.Predicate[T]) bool
	FindAny() optional.Value[T]
}

func Distinct

func Distinct[T comparable](s Stream[T]) Stream[T]

func From

func From[T any](list ...T) Stream[T]

func FromMap

func FromMap[M ~map[K]V, K comparable, V any](m M) Stream[collections.Entry[K, V]]

func Range

func Range[T constraints.Integer](start, end T) Stream[T]

func Sort

func Sort[T constraints.Ordered](s Stream[T]) Stream[T]

Directories

Path Synopsis
internal
support

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL