Test TinyGo goroutine on wio terminal

TinyGoGoRoutine.go

package main

import (
	"fmt"
	"machine"
	"math/rand"
	"sync"
	"time"
)

func main() {
	repeatFn := func(
		done <-chan interface{},
		fn func() interface{},
	) <-chan interface{} {
		vStream := make(chan interface{})
		go func() {
			defer close(vStream)
			for {
				select {
				case <-done:
					return
				case vStream <- fn():
				}
			}
		}()
		return vStream
	}
	take := func(
		done <-chan interface{},
		vStream <-chan interface{},
		num int,
	) <-chan interface{} {
		tStream := make(chan interface{})
		go func() {
			defer close(tStream)
			for i := 0; i < num; i++ {
				select {
				case <-done:
					return
				case tStream <- <-vStream:
				}
			}
		}()
		return tStream
	}
	toInt := func(
		done <-chan interface{},
		vStream <-chan interface{},
	) <-chan int {
		iStream := make(chan int)
		go func() {
			defer close(iStream)
			for v := range vStream {
				select {
				case <-done:
					return
				case iStream <- v.(int):
				}
			}
		}()
		return iStream
	}
	primeFinder := func(
		done <-chan interface{},
		iStream <-chan int,
	) <-chan interface{} {
		pStream := make(chan interface{})
		go func() {
			defer close(pStream)
			for iV := range iStream {
				iV -= 1
				prime := true
				for d := iV - 1; d > 1; d-- {
					if iV%d == 0 {
						prime = false
						break
					}
				}
				if prime {
					select {
					case <-done:
						return
					case pStream <- iV:
					}
				}
			}
		}()
		return pStream
	}
	fanIn := func(
		done <-chan interface{},
		chs ...<-chan interface{},
	) <-chan interface{} {
		var wg sync.WaitGroup
		mStream := make(chan interface{})

		mux := func(c <-chan interface{}) {
			defer wg.Done()
			for i := range c {
				select {
				case <-done:
					return
				case mStream <- i:
				}
			}
		}
		wg.Add(len(chs))
		for _, c := range chs {
			go mux(c)
		}

		go func() {
			wg.Wait()
			close(mStream)
		}()

		return mStream
	}

	done := make(chan interface{})
	defer close(done)

	start := time.Now()
	go lite()
	rand := func() interface{} { return rand.Intn(50000000) }
	rStream := toInt(done,
		repeatFn(done, rand))

	numFinder := 1
	fmt.Printf("Spinning up %d prime finders.\n", numFinder)
	finders := make([]<-chan interface{}, numFinder)
	for i := 0; i < numFinder; i++ {
		finders[i] = primeFinder(done, rStream)
	}
	for prime := range take(done, fanIn(done, finders...), 10) {
		fmt.Printf("%d\n\r", prime)
		fmt.Printf("Search took: %v", time.Since(start))
	}
	fmt.Printf("Search took: %v", time.Since(start))
}

func lite() {
	led := machine.LED
	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
	count := 1
	for {
		led.Low()
		time.Sleep(time.Millisecond * 500)
		fmt.Printf("%d\n\r", count)
		count += 1
		led.High()
		time.Sleep(time.Millisecond * 500)
	}
}