stream

package module

v0.1.1 Latest Latest Go to latest Published: Jul 16, 2024 License: BSD-3-Clause Imports: 2 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/AlexanderYastrebov/stream

Links

Open Source Insights

README ¶

A Go library of functional-style generic filter-map-reduce operations on slices.

See example_test.go

Documentation ¶

Overview ¶

Example ¶

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"

	"github.com/AlexanderYastrebov/stream"
)

func print[T any](x T) {
	fmt.Println(x)
}

func main() {
	f, _ := os.Open("testdata/lorem.txt")
	defer f.Close()

	scanner := bufio.NewScanner(f)
	scanner.Split(bufio.ScanWords)

	stream.While(scanner.Scan, scanner.Text).
		Map(strings.ToLower).
		Map(func(s string) string { return strings.TrimRight(s, ".,") }).
		Filter(stream.Distinct[string]()).
		Sorted(stream.NaturalOrder).
		Limit(10).
		ForEach(print)

}

Output:

ad
adipiscing
aliqua
aliquip
amet
anim
aute
cillum
commodo
consectetur

Index ¶

func Collect[T, A any](st Stream[T], identity A, accumulator func(A, T)) A
func Distinct[T comparable]() func(T) bool
func DistinctUsing[T any, C comparable](mapper func(T) C) func(T) bool
func NaturalOrder[T constraints.Ordered](a, b T) bool
func ReverseOrder[T constraints.Ordered](a, b T) bool
type Stream

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

func Collect ¶

func Collect[T, A any](st Stream[T], identity A, accumulator func(A, T)) A

Example (GroupBy) ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func main() {
	type result struct {
		name  string
		grade string
	}

	s := stream.Slice([]result{
		{"Alice", "A"},
		{"Bob", "B"},
		{"Charlie", "C"},
		{"Alan", "A"},
		{"Barbie", "B"},
		{"Carl", "C"},
	})

	g := stream.Collect(s, make(map[string][]string), func(m map[string][]string, r result) {
		m[r.grade] = append(m[r.grade], r.name)
	})
	fmt.Println(g)

}

Output:

map[A:[Alice Alan] B:[Bob Barbie] C:[Charlie Carl]]

func Distinct ¶

func Distinct[T comparable]() func(T) bool

Example ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func print[T any](x T) {
	fmt.Println(x)
}

func main() {
	stream.Of("a", "bb", "bb", "a", "ccc", "a", "dddd").
		Filter(stream.Distinct[string]()).
		ForEach(print)

}

Output:

a
bb
ccc
dddd

func DistinctUsing ¶

func DistinctUsing[T any, C comparable](mapper func(T) C) func(T) bool

Example ¶

package main

import (
	"fmt"
	"strings"

	"github.com/AlexanderYastrebov/stream"
)

func print[T any](x T) {
	fmt.Println(x)
}

func main() {
	concat := func(s []string) string {
		return strings.Join(s, " ")
	}

	stream.Of(
		[]string{"a"},
		[]string{"b", "b"},
		[]string{"b", "b"},
		[]string{"a"},
		[]string{"c", "c", "c"},
		[]string{"a"},
		[]string{"d", "d", "d", "d"}).
		Filter(stream.DistinctUsing(concat)).
		ForEach(print)

}

Output:

[a]
[b b]
[c c c]
[d d d d]

func NaturalOrder ¶

func NaturalOrder[T constraints.Ordered](a, b T) bool

func ReverseOrder ¶

func ReverseOrder[T constraints.Ordered](a, b T) bool

Types ¶

type Stream ¶

type Stream[T any] interface {
	Filter(predicate func(element T) bool) Stream[T]
	Map(mapper func(element T) T) Stream[T]
	FlatMap(mapper func(element T) Stream[T]) Stream[T]
	Peek(consumer func(element T)) Stream[T]
	Limit(n int) Stream[T]
	Skip(n int) Stream[T]
	Sorted(less func(T, T) bool) Stream[T]
	Append(Stream[T]) Stream[T]

	ForEach(consumer func(element T))
	Reduce(accumulator func(T, T) T) (T, bool)
	AllMatch(predicate func(element T) bool) bool
	AnyMatch(predicate func(element T) bool) bool
	NoneMatch(predicate func(element T) bool) bool
	FindFirst() (T, bool)
	Min(less func(T, T) bool) (T, bool)
	Max(less func(T, T) bool) (T, bool)
	Count() int
	ToSlice() []T
	// contains filtered or unexported methods
}

Example (AllMatch) ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func main() {
	m := stream.Of("a", "bb", "ccc", "dddd", "eeeee").
		AllMatch(func(s string) bool {
			return len(s) > 3
		})

	fmt.Println(m)

	m = stream.Of("a", "bb", "ccc", "dddd", "eeeee").
		AllMatch(func(s string) bool {
			return len(s) > 0
		})

	fmt.Println(m)

}

Output:

false
true

Example (AnyMatch) ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func main() {
	m := stream.Of("a", "bb", "ccc", "dddd", "eeeee").
		AnyMatch(func(s string) bool {
			return len(s) > 3
		})

	fmt.Println(m)

	m = stream.Of("a", "bb", "ccc", "dddd", "eeeee").
		AnyMatch(func(s string) bool {
			return len(s) > 10
		})

	fmt.Println(m)

}

Output:

true
false

Example (Append) ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func print[T any](x T) {
	fmt.Println(x)
}

func main() {
	stream.Of(1, 2, 3).
		Append(stream.Of(4, 5, 6)).
		Filter(func(x int) bool {
			return x%2 == 0
		}).
		ForEach(print)

	stream.Of("a", "bb").
		Append(stream.Of("ccc").Peek(func(string) { panic("oops") })).
		Limit(2). // appended stream is not evaluated
		ForEach(print)

}

Output:

2
4
6
a
bb

Example (Filter) ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func print[T any](x T) {
	fmt.Println(x)
}

func main() {
	n := stream.Of("a", "bb", "ccc", "dddd", "eeeee").
		Filter(func(s string) bool {
			return len(s) > 2
		}).
		Peek(print).
		Count()

	fmt.Println(n)

}

Output:

ccc
dddd
eeeee
3

Example (FilterAllButLast) ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func main() {
	input := []string{"foo", "bar", "baz", "bar", "goo", "bar", "gaz"}
	bars := stream.Slice(input).
		Filter(func(s string) bool {
			return s == "bar"
		}).
		Count()
	fmt.Println("bars:", bars)

	result := stream.Slice(input).
		Filter(func(s string) bool {
			if s == "bar" {
				bars--
				return bars == 0
			}
			return true
		}).
		ToSlice()

	fmt.Println(result)

}

Output:

bars: 3
[foo baz goo bar gaz]

Example (FindFirst) ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func main() {
	x, ok := stream.Of("a", "bb", "ccc", "dddd", "eeeee").
		Filter(func(s string) bool {
			return len(s) > 2
		}).
		FindFirst()

	fmt.Println(x, ok)

	_, ok = stream.Of("a", "bb", "ccc", "dddd", "eeeee").
		Filter(func(s string) bool {
			return len(s) > 10
		}).
		FindFirst()

	fmt.Println(ok)

}

Output:

ccc true
false

Example (ForEach) ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func print[T any](x T) {
	fmt.Println(x)
}

func main() {
	stream.Of("a", "bb", "ccc", "dddd", "eeeee").
		Filter(func(s string) bool {
			return len(s) > 2
		}).
		ForEach(print)

}

Output:

ccc
dddd
eeeee

Example (Map) ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func print[T any](x T) {
	fmt.Println(x)
}

func main() {
	stream.Of("a", "bb", "ccc").
		Map(func(s string) string {
			return s + s
		}).
		ForEach(print)

}

Output:

aa
bbbb
cccccc

Example (MinMax) ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func main() {
	x, ok := stream.Of(2, 5, 1, 4, 3).
		Max(stream.NaturalOrder[int])

	fmt.Println(x, ok)

	x, ok = stream.Of(2, 5, 1, 4, 3).
		Min(stream.NaturalOrder[int])

	fmt.Println(x, ok)

	x, ok = stream.Of[int]().
		Min(stream.NaturalOrder[int])

	fmt.Println(x, ok)

}

Output:

5 true
1 true
0 false

Example (NoneMatch) ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func main() {
	m := stream.Of("a", "bb", "ccc", "dddd", "eeeee").
		NoneMatch(func(s string) bool {
			return len(s) > 3
		})

	fmt.Println(m)

	m = stream.Of("a", "bb", "ccc", "dddd", "eeeee").
		NoneMatch(func(s string) bool {
			return len(s) > 10
		})

	fmt.Println(m)

}

Output:

false
true

Example (Reduce) ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func main() {
	s := stream.Of("a", "bb", "ccc", "dddd")
	n, ok := stream.Map(s, func(s string) int { return len(s) }).
		Reduce(func(a, b int) int { return a + b })

	fmt.Println(n, ok)

}

Output:

10 true

Example (SkipLimit) ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func print[T any](x T) {
	fmt.Println(x)
}

func main() {
	n := stream.Of("a", "bb", "ccc", "dddd", "eeeee").
		Skip(1).
		Limit(3).
		Peek(print).
		Count()

	fmt.Println(n)

	n = stream.Of("a", "bb", "ccc", "dddd", "eeeee").
		Limit(0).
		Peek(print).
		Count()

	fmt.Println(n)

}

Output:

bb
ccc
dddd
3
0

Example (Sorted) ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func print[T any](x T) {
	fmt.Println(x)
}

func main() {
	stream.Of("bb", "a", "dddd", "ccc").
		Sorted(stream.NaturalOrder[string]).
		ForEach(print)

	stream.Of("bb", "a", "dddd", "ccc").
		Sorted(stream.ReverseOrder[string]).
		ForEach(print)

}

Output:

a
bb
ccc
dddd
dddd
ccc
bb
a

func FlatMap ¶

func FlatMap[T, R any](st Stream[T], mapper func(element T) Stream[R]) Stream[R]

Example ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func print[T any](x T) {
	fmt.Println(x)
}

func main() {
	runes := func(s string) stream.Stream[rune] {
		return stream.Slice([]rune(s))
	}

	s := stream.Of("a", "bb", "ccc", "dddd")
	stream.FlatMap(s, runes).
		Limit(4).
		ForEach(print)

}

Output:

97
98
98
99

Example (SameType) ¶

package main

import (
	"fmt"
	"strings"

	"github.com/AlexanderYastrebov/stream"
)

func print[T any](x T) {
	fmt.Println(x)
}

func main() {
	split := func(s string) stream.Stream[string] {
		return stream.Slice(strings.Split(s, ""))
	}

	stream.Of("a", "bb", "ccc", "dddd").
		FlatMap(split).
		Limit(4).
		ForEach(print)

}

Output:

a
b
b
c

func Generate ¶

func Generate[T any](generator func() T) Stream[T]

Example ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func print[T any](x T) {
	fmt.Println(x)
}

func main() {
	stream.Generate(func() string { return "a" }).
		Limit(3).
		ForEach(print)

}

Output:

a
a
a

func Iterate ¶

func Iterate[T any](seed T, operator func(T) T) Stream[T]

Example ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func print[T any](x T) {
	fmt.Println(x)
}

func main() {
	stream.Iterate(3, func(x int) int { return x + 2 }).
		Limit(4).
		ForEach(print)

}

Output:

3
5
7
9

Example (Fibonacci) ¶

package main

import (
	"fmt"

	"github.com/AlexanderYastrebov/stream"
)

func print[T any](x T) {
	fmt.Println(x)
}

func main() {
	pairs := stream.Iterate([]int{0, 1}, func(x []int) []int {
		return []int{x[1], x[0] + x[1]}
	})

	stream.Map(pairs, func(x []int) int { return x[0] }).
		Limit(10).
		ForEach(print)

}

Output:

0
1
1
2
3
5
8
13
21
34

func Map ¶

func Map[T, R any](st Stream[T], mapper func(element T) R) Stream[R]

func Of ¶

func Of[T any](x ...T) Stream[T]

func Slice ¶

func Slice[T any](x []T) Stream[T]

func While ¶

func While[T any](hasNext func() bool, supplier func() T) Stream[T]

Source Files ¶

View all Source files

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

README ¶

Documentation ¶

Overview ¶

Index ¶

Examples ¶

Constants ¶

Variables ¶

Functions ¶

func Collect ¶

func Distinct ¶

func DistinctUsing ¶

func NaturalOrder ¶

func ReverseOrder ¶

Types ¶

type Stream ¶

func FlatMap ¶

func Generate ¶

func Iterate ¶

func Map ¶

func Of ¶

func Slice ¶

func While ¶

Source Files ¶