README
¶
channels 
channel utilities
Documentation
¶
Index ¶
- func Apply[T1, T2 any](n uint16, in []T1, f func(T1) T2) []T2
- func Batch[T any](in <-chan T, size int) <-chan []T
- func Count[T any](in <-chan T) int
- func Drain[T any](c <-chan T)
- func FanIn[T any](channels ...<-chan T) <-chan T
- func FanOut[T any](n uint16, in <-chan T) []<-chan T
- func Filter[T any](in <-chan T, keep func(T) bool) <-chan T
- func Map[T1, T2 any](in <-chan T1, f func(T1) T2) <-chan T2
- func Receive[T any](c <-chan T) iter.Seq[T]
- func Send[T any](iter iter.Seq[T]) <-chan T
- func Take[T any](in <-chan T, n int) <-chan T
- func Workers[T1, T2 any](n uint16, in <-chan T1, f func(T1) (T2, bool)) <-chan T2
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Apply ¶
Example ¶
package main
import (
"fmt"
"github.com/crhntr/channels"
)
func main() {
out := channels.Apply(2, []int{1, 2, 3, 4}, func(v int) int { return v * v })
fmt.Println(out)
}
Output: [1 4 9 16]
func Batch ¶
Example ¶
package main
import (
"fmt"
"slices"
"github.com/crhntr/channels"
)
func main() {
in := channels.Send(slices.Values([]int{1, 2, 3, 4, 5}))
for batch := range channels.Batch(in, 2) {
fmt.Println(batch)
}
}
Output: [1 2] [3 4] [5]
func Count ¶
Example ¶
package main
import (
"fmt"
"slices"
"github.com/crhntr/channels"
)
func main() {
in := channels.Send(slices.Values([]int{1, 2, 3, 4, 5}))
fmt.Println(channels.Count(in))
}
Output: 5
func Drain ¶
func Drain[T any](c <-chan T)
Example ¶
package main
import (
"fmt"
"slices"
"github.com/crhntr/channels"
)
func main() {
in := channels.Send(slices.Values([]int{1, 2, 3}))
channels.Drain(in)
fmt.Println("done")
}
Output: done
func FanIn ¶
func FanIn[T any](channels ...<-chan T) <-chan T
Example ¶
package main
import (
"fmt"
"slices"
"github.com/crhntr/channels"
)
func main() {
a := channels.Send(slices.Values([]int{1, 2, 3}))
b := channels.Send(slices.Values([]int{4, 5, 6}))
got := slices.Collect(channels.Receive(channels.FanIn(a, b)))
slices.Sort(got)
fmt.Println(got)
}
Output: [1 2 3 4 5 6]
func FanOut ¶
Example ¶
package main
import (
"fmt"
"slices"
"github.com/crhntr/channels"
)
func main() {
in := channels.Send(slices.Values([]int{1, 2, 3}))
outs := channels.FanOut(2, in)
got := slices.Collect(channels.Receive(channels.FanIn(outs...)))
slices.Sort(got)
fmt.Println(got)
}
Output: [1 1 2 2 3 3]
Example (Tee) ¶
package main
import (
"fmt"
"slices"
"github.com/crhntr/channels"
)
func main() {
in := channels.Send(slices.Values([]int{1, 2, 3}))
outs := channels.FanOut(2, in)
doubled := channels.Map(outs[0], func(v int) int { return v * 2 })
got := slices.Collect(channels.Receive(channels.FanIn(doubled, outs[1])))
slices.Sort(got)
fmt.Println(got)
}
Output: [1 2 2 3 4 6]
func Filter ¶
Example ¶
package main
import (
"fmt"
"slices"
"github.com/crhntr/channels"
)
func main() {
in := channels.Send(slices.Values([]int{1, 2, 3, 4, 5, 6}))
for v := range channels.Filter(in, func(v int) bool { return v%2 == 0 }) {
fmt.Println(v)
}
}
Output: 2 4 6
func Map ¶
func Map[T1, T2 any](in <-chan T1, f func(T1) T2) <-chan T2
Example ¶
package main
import (
"fmt"
"slices"
"strconv"
"github.com/crhntr/channels"
)
func main() {
in := channels.Send(slices.Values([]int{1, 2, 3}))
for v := range channels.Map(in, strconv.Itoa) {
fmt.Println(v)
}
}
Output: 1 2 3
func Receive ¶
Example ¶
package main
import (
"fmt"
"github.com/crhntr/channels"
)
func main() {
ch := make(chan string, 3)
ch <- "a"
ch <- "b"
ch <- "c"
close(ch)
for v := range channels.Receive(ch) {
fmt.Println(v)
}
}
Output: a b c
Example (Reduce) ¶
package main
import (
"fmt"
"slices"
"github.com/crhntr/channels"
)
func main() {
in := channels.Send(slices.Values([]int{1, 2, 3, 4, 5}))
sum := 0
for v := range channels.Receive(in) {
sum += v
}
fmt.Println(sum)
}
Output: 15
func Send ¶
Example ¶
package main
import (
"fmt"
"slices"
"github.com/crhntr/channels"
)
func main() {
ch := channels.Send(slices.Values([]int{1, 2, 3}))
for v := range ch {
fmt.Println(v)
}
}
Output: 1 2 3
func Take ¶
Example ¶
package main
import (
"fmt"
"slices"
"github.com/crhntr/channels"
)
func main() {
in := channels.Send(slices.Values([]int{10, 20, 30, 40, 50}))
for v := range channels.Take(in, 3) {
fmt.Println(v)
}
channels.Drain(in)
}
Output: 10 20 30
func Workers ¶
Workers creates a channel that receives the output of f applied to each element of in. When f returns false, the result is not sent on the channel.
Example ¶
package main
import (
"fmt"
"slices"
"github.com/crhntr/channels"
)
func main() {
in := channels.Send(slices.Values([]int{1, 2, 3, 4}))
out := channels.Workers(2, in, func(v int) (int, bool) {
return v * v, true
})
got := slices.Collect(channels.Receive(out))
slices.Sort(got)
fmt.Println(got)
}
Output: [1 4 9 16]
Types ¶
This section is empty.
Source Files
Click to show internal directories.
Click to hide internal directories.