piter

package module
v0.1.1 Latest Latest
Warning

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

 Go to latest Published: Mar 31, 2025 License: Apache-2.0 Imports: 4 Imported by: 0

README

piter

Pipeline and Fun-Out/In patterns using the iter package

install

go get "github.com/yyyoichi/piter"

How to use

func main() {
    var strSrc iter.Seq[string] = func(yield func(string) bool) {
        _ = yield("1")
        _ = yield("2")
        _ = yield("a")
        _ = yield("10")
    }
    var ns = make([]int, 0, 4)
    for n, err := range piter.Pipeline12(ctx, strSrc, strconv.Atoi) {
        if err != nil {
            break
        }
        ns = append(ns, n)
    }
    for _, n := range ns {
        fmt.Println(n)
    } 

    // Output:
    // 1
    // 2
}

Documentation

Overview

Example 
package main

import (
	"context"
	"fmt"
	"iter"
	"strconv"

	"github.com/yyyoichi/piter"
)

func main() {
	ctx := context.Background()

	twice := func(i int) int {
		return i * 2
	}
	var src iter.Seq[int] = func(yield func(int) bool) {
		_ = yield(2)
		_ = yield(3)
		_ = yield(4)
	}
	d1 := piter.Iter11(ctx, src, twice)
	d2 := piter.Pipeline11(ctx, d1, twice)
	d3 := piter.FunOut11(ctx, d2, twice)

	for d := range d3 {
		fmt.Println(d)
	}

	var strSrc iter.Seq[string] = func(yield func(string) bool) {
		_ = yield("a")
		_ = yield("2")
		_ = yield("4")
	}
	var ns = make([]int, 0, 3)
	for n, err := range piter.Pipeline12(ctx, strSrc, strconv.Atoi) {
		if err != nil {
			break
		}
		ns = append(ns, n)
	}
	for _, n := range ns {
		// Expect no output
		fmt.Println(n)
	}

}

Output:

16
24
32

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func FunIn 

func FunIn[T any](cxt context.Context, channels ...chan T) <-chan T

func FunOut added in v0.1.1 

func FunOut[I, O any](ctx context.Context, src <-chan I, fn func(I) O) <-chan O

func FunOut11 

func FunOut11[I, O any](ctx context.Context, src iter.Seq[I], fn func(I) O) iter.Seq[O]
Example 
package main

import (
	"context"
	"fmt"
	"iter"
	"strconv"

	"github.com/yyyoichi/piter"
)

func main() {
	ctx := context.Background()
	src := toIter(1, 2, 3)
	dist := piter.Iter11(ctx, src, func(i int) string {
		return strconv.Itoa(i*10) + "kg"
	})
	for d := range dist {
		fmt.Println(d)
	}
}

func toIter[T any](src ...T) iter.Seq[T] {
	return func(yield func(T) bool) {
		for _, s := range src {
			_ = yield(s)
		}
	}
}

Output:

10kg
20kg
30kg

func FunOut12 

func FunOut12[I, O any](ctx context.Context, src iter.Seq[I], fn func(I) (O, error)) iter.Seq2[O, error]
Example 
ctx := context.Background()
src := toIter("10", "20kg", "30")
dist := piter.Pipeline12(ctx, src, func(i string) (int, error) {
	return strconv.Atoi(i)
})
for d, err := range dist {
	if err != nil {
		fmt.Println("err")
	} else {
		fmt.Println(d)
	}
}

Output:

10
err
30

func FunOut22 

func FunOut22[I, O any](ctx context.Context, src iter.Seq2[I, error], fn func(I) (O, error)) iter.Seq2[O, error]
Example 
package main

import (
	"context"
	"fmt"
	"iter"
	"strconv"

	"github.com/yyyoichi/piter"
)

func main() {
	ctx := context.Background()
	src := toIter2("10", "20kg", "30")
	dist := piter.Iter22(ctx, src, func(i string) (int, error) {
		return strconv.Atoi(i)
	})
	for d, err := range dist {
		if err != nil {
			fmt.Println("err")
		} else {
			fmt.Println(d)
		}
	}
}

func toIter2[T any](src ...T) iter.Seq2[T, error] {
	return func(yield func(T, error) bool) {
		for _, s := range src {
			_ = yield(s, nil)
		}
	}
}

Output:

10
err
30

func Iter11 

func Iter11[I, O any](ctx context.Context, src iter.Seq[I], fn func(I) O) iter.Seq[O]
Example 
package main

import (
	"context"
	"fmt"
	"iter"
	"strconv"

	"github.com/yyyoichi/piter"
)

func main() {
	ctx := context.Background()
	src := toIter(1, 2, 3)
	dist := piter.Iter11(ctx, src, func(i int) string {
		return strconv.Itoa(i*10) + "kg"
	})
	for d := range dist {
		fmt.Println(d)
	}
}

func toIter[T any](src ...T) iter.Seq[T] {
	return func(yield func(T) bool) {
		for _, s := range src {
			_ = yield(s)
		}
	}
}

Output:

10kg
20kg
30kg

func Iter12 

func Iter12[I, O any](ctx context.Context, src iter.Seq[I], fn func(I) (O, error)) iter.Seq2[O, error]
Example 
ctx := context.Background()
src := toIter("10", "20kg", "30")
dist := piter.Iter12(ctx, src, func(i string) (int, error) {
	return strconv.Atoi(i)
})
for d, err := range dist {
	if err != nil {
		fmt.Println("err")
	} else {
		fmt.Println(d)
	}
}

Output:

10
err
30

func Iter22 

func Iter22[I, O any](ctx context.Context, src iter.Seq2[I, error], fn func(I) (O, error)) iter.Seq2[O, error]
Example 
package main

import (
	"context"
	"fmt"
	"iter"
	"strconv"

	"github.com/yyyoichi/piter"
)

func main() {
	ctx := context.Background()
	src := toIter2("10", "20kg", "30")
	dist := piter.Iter22(ctx, src, func(i string) (int, error) {
		return strconv.Atoi(i)
	})
	for d, err := range dist {
		if err != nil {
			fmt.Println("err")
		} else {
			fmt.Println(d)
		}
	}
}

func toIter2[T any](src ...T) iter.Seq2[T, error] {
	return func(yield func(T, error) bool) {
		for _, s := range src {
			_ = yield(s, nil)
		}
	}
}

Output:

10
err
30

func Pipeline11 

func Pipeline11[I, O any](ctx context.Context, src iter.Seq[I], fn func(I) O) iter.Seq[O]
Example 
package main

import (
	"context"
	"fmt"
	"iter"
	"strconv"

	"github.com/yyyoichi/piter"
)

func main() {
	ctx := context.Background()
	src := toIter(1, 2, 3)
	dist := piter.Pipeline11(ctx, src, func(i int) string {
		return strconv.Itoa(i*10) + "kg"
	})
	for d := range dist {
		fmt.Println(d)
	}
}

func toIter[T any](src ...T) iter.Seq[T] {
	return func(yield func(T) bool) {
		for _, s := range src {
			_ = yield(s)
		}
	}
}

Output:

10kg
20kg
30kg

func Pipeline12 

func Pipeline12[I, O any](ctx context.Context, src iter.Seq[I], fn func(I) (O, error)) iter.Seq2[O, error]
Example 
ctx := context.Background()
src := toIter("10", "20kg", "30")
dist := piter.Pipeline12(ctx, src, func(i string) (int, error) {
	return strconv.Atoi(i)
})
for d, err := range dist {
	if err != nil {
		fmt.Println("err")
	} else {
		fmt.Println(d)
	}
}

Output:

10
err
30

func Pipeline22 

func Pipeline22[I, O any](ctx context.Context, src iter.Seq2[I, error], fn func(I) (O, error)) iter.Seq2[O, error]
Example 
package main

import (
	"context"
	"fmt"
	"iter"
	"strconv"

	"github.com/yyyoichi/piter"
)

func main() {
	ctx := context.Background()
	src := toIter2("10", "20kg", "30")
	dist := piter.Iter22(ctx, src, func(i string) (int, error) {
		return strconv.Atoi(i)
	})
	for d, err := range dist {
		if err != nil {
			fmt.Println("err")
		} else {
			fmt.Println(d)
		}
	}
}

func toIter2[T any](src ...T) iter.Seq2[T, error] {
	return func(yield func(T, error) bool) {
		for _, s := range src {
			_ = yield(s, nil)
		}
	}
}

Output:

10
err
30

Types

This section is empty.

Source Files

View all Source files

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.