ez

Example_complex demonstrates complex stream transformations including filtering, mapping, and operations like shuffle, reverse, distinct, sortOrdered, and reduce using a sequence generated from the Fibonacci series.

rng := rand.New(rand.NewChaCha8([32]byte{}))
stream := ez.Convert(
	ez.Pipe(fibonacci,
		ez.Filter(func(i int) bool {
			return i > 5
		}),
		ez.Map(func(i int) int {
			return i / 2
		}),
		ez.Skip[int](10),
		ez.Take[int](10),
		ez.ShuffleWithRand[int](rng),
		ez.Reverse[int],
	), func(i int) float64 {
		return math.Round(math.Sqrt(float64(i)) * math.Sin(float64(i)))
	})
values := ez.Collect(stream)
fmt.Println("m:", values)
sorted := ez.Collect(ez.Pipe(ez.SliceStream(values), ez.Ordered[float64]))
fmt.Println("sorted:", sorted)
distinct := ez.Collect(ez.Pipe(ez.SliceStream(sorted), ez.Distinct[float64]))
fmt.Println("distinct:", distinct)
sum := ez.Reduce(stream, 0, func(a float64, b float64) float64 {
	return a + b
})
fmt.Println("sum:", sum)

Output:

m: [86 -34 -124 86 25 1 190 -26 5 58]
sorted: [-124 -34 -26 1 5 25 58 86 86 190]
distinct: [-124 -34 -26 1 5 25 58 86 190]
sum: 267

Example demonstrates the usage of various stream operations such as filtering, mapping, skipping, and taking elements from streams.

package main

import (
	"fmt"
	"github.com/justenwalker/ez"
	"math"
)

// Example Streams
var (
	fibonacci = ez.InfiniteStream(func(yield func(int) bool) {
		a := 0
		if !yield(a) {
			return
		}
		b := 1
		for yield(b) {
			a, b = b, b+a
		}
	})

	oneToTen = ez.FiniteStream(func(yield func(int) bool) {
		for i := range 10 {
			if !yield(i + 1) {
				return
			}
		}
	})
)

func main() {
	// convert a slice to a stream
	sliceStream := ez.SliceStream([]int{1, 2, 3, 4, 5, 6, 7})

	// Pipe stream operations together with the `Pipe` function
	intStream := ez.Pipe(fibonacci,
		ez.Filter(func(i int) bool { return i > 5 }),
		ez.Map(func(i int) int { return i / 2 }),
		ez.Skip[int](10),
		ez.Take[int](10),
		ez.Reverse[int],
	)

	// Convert from a stream of one type to another
	float64Stream := ez.Convert(intStream, func(i int) float64 {
		return math.Round(math.Sqrt(float64(i)))
	})

	// Collect m into a slice from a Finite Stream.
	values := ez.Collect(float64Stream)
	fmt.Println("m:", values)

	// Concatenate several streams together:
	concat := ez.Concat(
		oneToTen,
		sliceStream,
		ez.Pipe(fibonacci, ez.Take[int](10)),
	)

	// Reduce a stream to a single value
	sum := ez.Reduce(concat, 0, func(acc int, v int) int { return acc + v })
	fmt.Println("sum:", sum)
}

Output:

m: [194 152 120 94 74 58 46 36 28 22]
sum: 171

Example demonstrates the usage of various stream operations such as filtering, mapping, skipping, and taking elements from streams.

package main

import (
	"fmt"
	"github.com/justenwalker/ez"
	"math"
)

// Example Streams
var fibonacci = ez.InfiniteStream(func(yield func(int) bool) {
	a := 0
	if !yield(a) {
		return
	}
	b := 1
	for yield(b) {
		a, b = b, b+a
	}
})

func main() {
	zipStream2 := ez.Zip(
		ez.InfiniteStream(func(yield func(int) bool) {
			i := 0
			for {
				if !yield(i) {
					return
				}
				i++
			}
		}),
		fibonacci,
	)

	// Pipe stream operations together with the `Pipe` function
	intStream := ez.Pipe2(zipStream2,
		ez.Filter2(func(l, r int) bool { return r > 5 }),
		ez.Map2(func(l, r int) (int, int) { return l, r * 2 }),
		ez.Skip2[int, int](10),
		ez.Take2[int, int](10),
		ez.Reverse2[int, int],
	)

	// Convert from a stream of one type to another
	float64Stream := ez.Convert2(intStream, func(l, r int) (int, float64) {
		return l, math.Round(math.Sqrt(float64(r)))
	})

	// Collect m into a slice from a Finite Stream.
	leftValues, rightValues := ez.Collect2(float64Stream)
	fmt.Println("left:", leftValues)
	fmt.Println("right:", rightValues)

	// Concatenate several streams together:
	concat := ez.Concat2(
		ez.Pipe2(zipStream2, ez.Take2[int, int](3)),
		ez.Pipe2(zipStream2, ez.Skip2[int, int](3), ez.Take2[int, int](3)),
		ez.Pipe2(zipStream2, ez.Skip2[int, int](6), ez.Take2[int, int](3)),
	)

	// Reduce a stream to a single value
	leftSum := ez.Reduce(ez.Left(concat), 0, func(acc int, v int) int { return acc + v })
	fmt.Println("leftSum:", leftSum)
	rightSum := ez.Reduce(ez.Right(concat), 0, func(acc int, v int) int { return acc + v })
	fmt.Println("rightSum:", rightSum)
}

Output:

left: [25 24 23 22 21 20 19 18 17 16]
right: [387 305 239 188 148 116 91 72 57 44]
leftSum: 36
rightSum: 54