Composition Root

import "fmt"

//entity
type Order struct {
    ID    int
    Total int
}

func (o Order) Payable() int {
    if o.Total >= 200 {
        return o.Total - o.Total/10
    }
    return o.Total
}

//gateway
type Catalog interface {
    Price(sku string) (int, bool)
}

//repository
type Orders interface {
    Save(order Order)
    Count() int
}

//output port
type Report interface {
    Say(text string)
}

type Item struct {
    SKU   string
    Count int
}

//use case: asks for its parts, never builds them
type PlaceOrder struct {
    catalog Catalog
    orders  Orders
    report  Report
    nextID  int
}

func (u *PlaceOrder) Place(items []Item) {
    total := 0
    for _, item := range items {
        price, ok := u.catalog.Price(item.SKU)
        if !ok {
            u.report.Say("no " + item.SKU)
            return
        }
        total += price * item.Count
    }
    order := Order{u.nextID, total}
    u.nextID++
    u.orders.Save(order)
    u.report.Say(fmt.Sprintf("order %d for %d",
        order.ID, order.Payable()))
}

//adapters
type MemoryCatalog struct{}

func (MemoryCatalog) Price(sku string) (int, bool) {
    prices := map[string]int{"pen": 30, "lamp": 190}
    price, ok := prices[sku]
    return price, ok
}

type MemoryOrders struct {
    rows []Order
}

func (m *MemoryOrders) Save(order Order) {
    m.rows = append(m.rows, order)
}

func (m *MemoryOrders) Count() int {
    return len(m.rows)
}

type ConsoleReport struct{}

func (ConsoleReport) Say(text string) {
    fmt.Println(text)
}

type SilentReport struct{}

func (SilentReport) Say(text string) {
}

//composition root: the only place that sees every layer
//at once, and the only place where an adapter is built.
//go has no container for this on purpose: wiring is
//plain code, and in a real program it lives in main
type ShopApp struct {
    UseCase *PlaceOrder
    Orders  Orders
}

func newApp(report Report) *ShopApp {
    orders := &MemoryOrders{}
    return &ShopApp{
        UseCase: &PlaceOrder{MemoryCatalog{}, orders,
            report, 1001},
        Orders: orders,
    }
}

func newLoudApp() *ShopApp {
    return newApp(ConsoleReport{})
}

func newQuietApp() *ShopApp {
    return newApp(SilentReport{})
}

//client code
app := newLoudApp()
app.UseCase.Place([]Item{{"pen", 2}, {"lamp", 1}})
app.UseCase.Place([]Item{{"chair", 1}})

//a second root builds the same use case differently
night := newQuietApp()
night.UseCase.Place([]Item{{"lamp", 1}})
fmt.Println("saved", night.Orders.Count())
//printed: order 1001 for 225
//         no chair
//         saved 1