[go][training]fizzbuzz with channel

fizzbuzz.go

package main

import (
        "fmt"
)

func fizzbuzz(n int) string {
        switch f, b := n % 5 == 0, n % 3 == 0; {
        case f && b: return "FizzBuzz"
        case f: return "Fizz"
        case b: return "Buzz"
        default: return fmt.Sprintf("%v", n)
        }
}

func main() {
        channel, quit := make(chan string), make(chan bool)

        go func(in <-chan string) {
                for s := range in {
			fmt.Println(s)
                }
                close(quit)
        }(channel)

        go func(out chan<- string) {
                for i := 1; i <= 100; i++ {
                        out <- fizzbuzz(i)
                }
                close(out)
        }(channel)

        <- quit
}

fizzbuzz2.go

package main

import (
        "fmt"
)

func fizzbuzz(n int) string {
	switch f, b := n % 5 == 0, n % 3 == 0; {
	case f && b: return "FizzBuzz"
	case f: return "Fizz"
	case b: return "Buzz"
	default: return fmt.Sprintf("%v", n)
	}
}


func agent() (chan<- int, <-chan string) {
        in, out := make(chan int), make(chan string)
        go func() {
                for n := range in {
                        out <- fizzbuzz(n)
                }
                close(out)
        }()
        return in, out
}
func producer(in chan<- int) <-chan bool {
        quit := make(chan bool)
        go func() {
                for i := 1; i <= 100; i++ {
                        in <- i
                }
                close(in)
                close(quit)
        }()
        return quit
}
func consumer(out <-chan string) <-chan bool {
	quit := make(chan bool)
        go func() {
                for s := range out {
                        fmt.Println(s)
                }
                close(quit)
        }()
        return quit
}

func main() {
        in, out := agent()
        _, qc := producer(in), consumer(out)
        <- qc
}

fizzbuzz3.go

package main

import (
        "fmt"
)

func fizzbuzz(n int) string {
	switch f, b := n % 5 == 0, n % 3 == 0; {
	case f && b: return "FizzBuzz"
	case f: return "Fizz"
	case b: return "Buzz"
	default: return fmt.Sprintf("%v", n)
	}
}


func iterFizzBuzz() <-chan string {
        r := make(chan string)
        go func() {
                for i := 1; i <= 100; i++ {
                        r <- fizzbuzz(i)
                }
                close(r)
        }()
        return r
}

func main() {
        for s := range iterFizzBuzz() {
                fmt.Println(s)
        }
}

fizzbuzz4.go

package main

import (
        "fmt"
)

func fizzbuzz(n int) string {
        switch f, b := n % 5 == 0, n % 3 == 0; {
        case f && b: return "FizzBuzz"
        case f: return "Fizz"
        case b: return "Buzz"
        default: return fmt.Sprintf("%v", n)
        }
}



func agent() (chan<- int, <-chan string) {
        in, out := make(chan int), make(chan string)
        go func() {
                for n := range in {
                        out <- fizzbuzz(n)
                }
                close(out)
        }()
        return in, out
}
func producer() (<-chan int, <-chan bool) {
        in, quit := make(chan int), make(chan bool)
        go func() {
                for i := 1; i <= 100; i++ {
                        in <- i
                }
                close(in)
                close(quit)
        }()
        return in, quit
}
func consumer() (chan<- string, <-chan bool) {
        out, quit := make(chan string), make(chan bool)
        go func() {
                for s := range out {
                        fmt.Println(s)
                }
                close(quit)
        }()
        return out, quit
}


type OChanInt  <-chan int
type IChanInt  chan<- int
func (from OChanInt) pipe(to IChanInt) {
        go func() {
                for e := range from {
                        to <- e
                }
                close(to)
        }()
}
type OChanString  <-chan string
type IChanString  chan<- string
func (from OChanString) pipe(to IChanString) {
        go func() {
                for e := range from {
                        to <- e
                }
                close(to)
        }()
}


func main() {
        ain, aout := agent()
        pout, _ := producer()
        cin, cq := consumer()
        OChanInt(pout).pipe(ain)
        OChanString(aout).pipe(cin)
        <- cq
}

• fizzbuzz.go: based on go-lang basics with channels
  • func decl
  • switch and pattern
  • channel and chan types
  • go func
  • for and range
• fizzbuzz2.go: composed actors circuit
  • chan as connector of actor(go func)s
• fizzbuzz3.go: channel as iterator
  • return chan for using on for range
• fizzbuzz4.go: circuit with piping
  • type alias for defining methods
  • type cast