package main
import (
 "bytes"
 "fmt"
 "net/http"
 "sync"
 "time"
)
type Request struct {
 Method string
 Url    string
 Body   string
}
func main() {
 var wg sync.WaitGroup
 in := make(chan Request)
 out := make(chan *http.Response)
 // Start goroutine to coalesce requests
 go func() {
  coalesced := make(map[string][]Request)
  for req := range in {
   key := req.Method + ":" + req.Url
   coalesced[key] = append(coalesced[key], req)
  }
  for _, requests := range coalesced {
   wg.Add(1)
   go func(requests []Request) {
    defer wg.Done()
    // Send batched requests
    responses := sendBatch(requests)
    // Send responses back on out channel
    for _, resp := range responses {
     out <- resp
    }
   }(requests)
  }
 }()
 // Send requests to coalescer
 go func() {
  requests := []Request{
   {Method: "GET", Url: "<https://httpbin.org/get>"},
   {Method: "POST", Url: "<https://httpbin.org/post>", Body: "foo"},
   {Method: "GET", Url: "<https://httpbin.org/get>"},
   {Method: "POST", Url: "<https://httpbin.org/post>", Body: "bar"},
  }
  for _, req := range requests {
   in <- req
  }
  close(in)
 }()
 // Receive responses
 wg.Add(1)
 go func() {
  defer wg.Done()
  for resp := range out {
   fmt.Println(resp.Status)
   resp.Body.Close()
  }
 }()
 go func() {
  <-time.After(4 * time.Second)
  close(out)
 }()
 // Wait for all responses to be received
 wg.Wait()
}
func sendBatch(requests []Request) []*http.Response {
 client := &http.Client{}
 var responses []*http.Response
 for _, req := range requests {
  body := ""
  if req.Body != "" {
   body = req.Body
  }
  payload := []byte(body)
  req, _ := http.NewRequest(req.Method, req.Url, bytes.NewReader(payload))
  resp, err := client.Do(req)
  if err != nil {
   fmt.Println(err)
   return nil
  }
  responses = append(responses, resp)
 }
 return responses
}