add codegen examples + wrap up efficient/inefficient fan-in-out examples

Author: steevehook

.gitignore

@@ -1,2 +1,3 @@
 .idea/
 .DS_Store
+*_generated.go

patterns/codegen/main.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"text/template"
+	"time"
+
+	"concurrency/patterns/codegen/templates"
+)
+
+type data struct {
+	Tpl  string
+	Pkg  string
+	Type string
+}
+
+func main() {
+	dataTpl := flag.String("tpl", "", "the template name")
+	dataType := flag.String("type", "interface{}", "the built-in type for generator")
+	dataPackage := flag.String("pkg", "main", "the package, the generated code belongs to")
+	flag.Parse()
+	d := data{
+		Tpl:  *dataTpl,
+		Pkg:  *dataPackage,
+		Type: *dataType,
+	}
+
+	var t string
+	switch d.Tpl {
+	case "fanin":
+		t = templates.FanInTpl
+	case "repeat":
+		t = templates.RepeatTpl
+	case "repeatfn":
+		t = templates.RepeatFnTpl
+	case "take":
+		t = templates.TakeTpl
+	default:
+		log.Fatalf("could not find: %v", d.Tpl)
+	}
+	header := fmt.Sprintf(
+		"// Code generated by go generate; DO NOT EDIT.\n"+
+			"// This file was generated by the matrix at:\n// %s\n",
+		time.Now(),
+	)
+	t = header + t + "\n"
+
+	tpl := template.Must(template.New(d.Tpl).Parse(t))
+	file, err := os.Create(d.Tpl + "_generated.go")
+	if err != nil {
+		log.Fatalf("could not create file: %v", err)
+	}
+
+	err = tpl.Execute(file, d)
+	if err != nil {
+		log.Fatalf("could not execute template: %v", err)
+	}
+}

patterns/codegen/templates/fanin.go

@@ -0,0 +1,30 @@
+package templates
+
+const FanInTpl = `package {{.Pkg}}
+
+import "sync"
+
+func FanIn(done chan struct{}, inputs ...<-chan {{.Type}}) <-chan {{.Type}} {
+	out := make(chan {{.Type}})
+	var wg sync.WaitGroup
+	wg.Add(len(inputs))
+
+	for _, in := range inputs {
+		go func(numbers <-chan {{.Type}}) {
+			defer wg.Done()
+			for n := range numbers {
+				select {
+				case <-done:
+					return
+				case out <- n:
+				}
+			}
+		}(in)
+	}
+	go func() {
+		wg.Wait()
+		close(out)
+	}()
+
+	return out
+}`

patterns/codegen/templates/repeat.go

@@ -0,0 +1,20 @@
+package templates
+
+const RepeatTpl = `package {{.Pkg}}
+
+func Repeat(done <-chan struct{}, values ...{{.Type}}) <-chan {{.Type}} {
+	out := make(chan {{.Type}})
+	go func() {
+		defer close(out)
+		for {
+			for _, v := range values {
+				select {
+				case <-done:
+					return
+				case out <- v:
+				}
+			}
+		}
+	}()
+	return out
+}`

patterns/codegen/templates/repeatfn.go

@@ -0,0 +1,18 @@
+package templates
+
+const RepeatFnTpl = `package {{.Pkg}}
+
+func RepeatFn(done <-chan struct{}, fn func() {{.Type}}) <-chan {{.Type}} {
+	out := make(chan {{.Type}})
+	go func() {
+		defer close(out)
+		for {
+			select {
+			case <-done:
+				return
+			case out <- fn():
+			}
+		}
+	}()
+	return out
+}`

patterns/codegen/templates/take.go

@@ -0,0 +1,18 @@
+package templates
+
+const TakeTpl = `package {{.Pkg}}
+
+func Take(done <-chan struct{}, in <-chan {{.Type}}, num int) <-chan {{.Type}} {
+	out := make(chan {{.Type}})
+	go func() {
+		defer close(out)
+		for i := 0; i < num; i++ {
+			select {
+			case <-done:
+				return
+			case out <- <-in:
+			}
+		}
+	}()
+	return out
+}`

patterns/fan-in-out/efficient/main.go

@@ -1,44 +1,40 @@
+//go:generate go run ../../codegen/main.go -tpl=fanin -type=int
+//go:generate go run ../../codegen/main.go -tpl=repeatfn -type=int
+//go:generate go run ../../codegen/main.go -tpl=take -type=int
 package main
 
 import (
-	"concurrency/patterns/fanin"
 	"fmt"
 	"math/rand"
 	"runtime"
 	"time"
-
-	"concurrency/patterns/generators"
-)
-
-var (
-	take     = generators.Take
-	toInt    = generators.ToInt
-	repeatFn = generators.RepeatFn
 )
 
+// before running main.go, make sure to run:
+// go generate main.go
 func main() {
 	done := make(chan struct{})
 	defer close(done)
-	random := func() interface{} {
+	random := func() int {
 		return rand.Intn(50000000)
 	}
 	start := time.Now()
-	randIntStream := toInt(done, repeatFn(done, random))
+	randIntStream := RepeatFn(done, random)
 	numFinders := runtime.NumCPU()
 	finders := make([]<-chan int, numFinders)
 	for i := 0; i < numFinders; i++ {
-		finders[i] = toInt(done, primeFinder(done, randIntStream))
+		finders[i] = primeFinder(done, randIntStream)
 	}
 
 	fmt.Println("primes:")
-	for prime := range take(done, fanin.FanIn(done, finders...), 10) {
+	for prime := range Take(done, FanIn(done, finders...), 10) {
 		fmt.Println("prime:", prime)
 	}
 	fmt.Printf("search took: %v", time.Since(start))
 }
 
-func primeFinder(done <-chan struct{}, intStream <-chan int) <-chan interface{} {
-	primeStream := make(chan interface{})
+func primeFinder(done <-chan struct{}, intStream <-chan int) <-chan int {
+	primeStream := make(chan int)
 	go func() {
 		defer close(primeStream)
 		for integer := range intStream {

patterns/fan-in-out/inefficient/main.go

@@ -1,37 +1,31 @@
+//go:generate go run ../../codegen/main.go -tpl=repeatfn -type=int
+//go:generate go run ../../codegen/main.go -tpl=take -type=int
 package main
 
 import (
 	"fmt"
 	"math/rand"
 	"time"
-
-	"concurrency/patterns/generators"
-)
-
-var (
-	take     = generators.Take
-	toInt    = generators.ToInt
-	repeatFn = generators.RepeatFn
 )
 
 func main() {
 	done := make(chan struct{})
 	defer close(done)
-	random := func() interface{} {
+	random := func() int {
 		return rand.Intn(50000000)
 	}
 	start := time.Now()
 
-	randIntStream := toInt(done, repeatFn(done, random))
+	randIntStream := RepeatFn(done, random)
 	fmt.Println("primes:")
-	for prime := range take(done, primeFinder(done, randIntStream), 10) {
+	for prime := range Take(done, primeFinder(done, randIntStream), 10) {
 		fmt.Println("prime:", prime)
 	}
 	fmt.Printf("search took: %v", time.Since(start))
 }
 
-func primeFinder(done <-chan struct{}, intStream <-chan int) <-chan interface{} {
-	primeStream := make(chan interface{})
+func primeFinder(done <-chan struct{}, intStream <-chan int) <-chan int {
+	primeStream := make(chan int)
 	go func() {
 		defer close(primeStream)
 		for integer := range intStream {