Strategy Pattern — Find the Bug¶

func NewX(...) SomeInterface {
    var p *ConcreteT
    if condition { p = &ConcreteT{...} }
    return p
}

func NewStripeGateway(apiKey string) Gateway {
    if apiKey == "" {
        return nil // typeless nil — comparable to nil literal
    }
    return &StripeGateway{apiKey: apiKey}
}

func NewStripeGateway(apiKey string) (*StripeGateway, error) {
    if apiKey == "" {
        return nil, errors.New("NewStripeGateway: apiKey empty")
    }
    return &StripeGateway{apiKey: apiKey}, nil
}

type LoggingCharger struct {
    log    *log.Logger
    chargeCount int
}

func (l LoggingCharger) Charge(ctx context.Context, amount int) (string, error) {
    l.chargeCount++  // mutates the local copy; lost on return
    l.log.Printf("Charge #%d: amount=%d", l.chargeCount, amount)
    return "logged", nil
}

func (l *LoggingCharger) Charge(ctx context.Context, amount int) (string, error) {
    l.chargeCount++
    l.log.Printf("Charge #%d: amount=%d", l.chargeCount, amount)
    return "logged", nil
}

var chargers = []Charger{
    &LoggingCharger{log: log.Default()},
    &CountingCharger{},
}

type LoggingCharger struct{ log *log.Logger }   // immutable

func (l LoggingCharger) Charge(...) (string, error) {
    l.log.Printf("Charge: amount=%d", amount)
    return "logged", nil
}

for _, name := range names {
    name := name   // shadow with a per-iteration local
    chargers = append(chargers, func(amount int) string {
        return fmt.Sprintf("%s charged %d", name, amount)
    })
}

for _, name := range names {
    chargers = append(chargers, makeCharger(name))
}

func makeCharger(name string) ChargeFunc {
    return func(amount int) string {
        return fmt.Sprintf("%s charged %d", name, amount)
    }
}

var (
    mu       sync.RWMutex
    registry = map[string]Codec{}
)

func Register(name string, c Codec) {
    mu.Lock()
    defer mu.Unlock()
    registry[name] = c
}

func Get(name string) (Codec, bool) {
    mu.RLock()
    defer mu.RUnlock()
    c, ok := registry[name]
    return c, ok
}

var registry sync.Map

func Register(name string, c Codec) {
    registry.Store(name, c)
}

func Get(name string) (Codec, bool) {
    v, ok := registry.Load(name)
    if !ok { return nil, false }
    return v.(Codec), true
}

// Register may only be called during init.
// Calling after the server has started races with Get.
func Register(name string, c Codec) {
    if started.Load() { panic("codec: Register after start") }
    registry[name] = c
}

package metrics_datadog

func newDatadogClient(host string) (*DatadogClient, error) {
    conn, err := net.Dial("udp", host+":8125")
    if err != nil {
        return nil, fmt.Errorf("datadog: %w", err)
    }
    return &DatadogClient{conn: conn}, nil
}

func init() {
    metrics.RegisterFactory("datadog", func() (metrics.Sink, error) {
        host := os.Getenv("DD_AGENT_HOST")
        if host == "" {
            return nil, errors.New("datadog: DD_AGENT_HOST not set")
        }
        return newDatadogClient(host)
    })
}

type DatadogClient struct {
    once sync.Once
    conn net.Conn
    err  error
}

func (d *DatadogClient) ensure() error {
    d.once.Do(func() {
        d.conn, d.err = net.Dial("udp", os.Getenv("DD_AGENT_HOST")+":8125")
    })
    return d.err
}

func (d *DatadogClient) Submit(metric string, value float64) {
    if err := d.ensure(); err != nil { return }
    fmt.Fprintf(d.conn, "%s:%f|g\n", metric, value)
}

type Charger interface {
    Charge(ctx context.Context, amount int) (string, error)
}

type Refunder interface {
    Refund(ctx context.Context, chargeID string) error
}

type Authorizer interface {
    Authorize(ctx context.Context, amount int) (string, error)
    Capture(ctx context.Context, authID string, amount int) error
}

type StripeProvider struct { /* ... */ }

func (s *StripeProvider) Charge(...) (string, error)    { /* ... */ }
func (s *StripeProvider) Refund(...) error              { /* ... */ }
func (s *StripeProvider) Authorize(...) (string, error) { /* ... */ }
func (s *StripeProvider) Capture(...) error             { /* ... */ }

// Cash App only implements Charger:
type CashAppProvider struct{}
func (c *CashAppProvider) Charge(...) (string, error) { /* ... */ }

func processRefund(r Refunder, chargeID string) error {
    return r.Refund(context.Background(), chargeID)
}

type Charger interface { Charge(ctx context.Context, amount int) (string, error) }

func canRefund(c Charger) (Refunder, bool) {
    r, ok := c.(Refunder)
    return r, ok
}

// in the service:
r, ok := canRefund(provider)
if !ok {
    return errors.New("provider does not support refunds")
}
return r.Refund(ctx, chargeID)

func isSame(a, b Strategy) bool {
    return reflect.TypeOf(a) == reflect.TypeOf(b)
}

type Strategy interface { Apply([]int) []int }

var (
    standardFilter = &FilterStrategy{ /* ... */ }
    strictFilter   = &FilterStrategy{ /* ... */ }
)

func isSame(a, b Strategy) bool {
    return a == b // both wrap pointers; pointer comparison is safe
}

type Equatable interface {
    Equals(Strategy) bool
}

func (f FilterStrategy) Equals(other Strategy) bool {
    o, ok := other.(FilterStrategy)
    if !ok { return false }
    if len(f.Allowed) != len(o.Allowed) { return false }
    for k, v := range f.Allowed {
        if o.Allowed[k] != v { return false }
    }
    return slices.Equal(f.Tags, o.Tags)
}

func isSame(a, b Strategy) bool {
    if e, ok := a.(Equatable); ok {
        return e.Equals(b)
    }
    return false
}

func (p *Processor) ProcessAll(items []int) []int {
    p.mu.RLock()
    f := p.filter
    p.mu.RUnlock()

    out := make([]int, 0, len(items))
    for _, it := range items {
        if f.Keep(it) {
            out = append(out, it)
        }
    }
    return out
}

func (p *Processor) SetFilter(f Filter) {
    p.mu.Lock()
    defer p.mu.Unlock()
    p.filter = f
}

type Processor struct {
    filter atomic.Pointer[Filter]  // Go 1.19+
}

func (p *Processor) SetFilter(f Filter) {
    p.filter.Store(&f)
}

func (p *Processor) ProcessAll(items []int) []int {
    f := *p.filter.Load()
    out := make([]int, 0, len(items))
    for _, it := range items {
        if f.Keep(it) {
            out = append(out, it)
        }
    }
    return out
}

func (p *Processor) ProcessAll(items []int, f Filter) []int {
    out := make([]int, 0, len(items))
    for _, it := range items {
        if f.Keep(it) {
            out = append(out, it)
        }
    }
    return out
}

func (f ChargeFunc) Charge(ctx context.Context, amount int) error {
    return f(ctx, amount) // call the function value directly
}

type ChargeFunc func(ctx context.Context, amount int) error

func (f ChargeFunc) Charge(ctx context.Context, amount int) error {
    return f(ctx, amount)
}

func (l *LoggingCharger) Charge(ctx context.Context, amount int) (string, error) {
    l.Log.Printf("Charge: amount=%d", amount)
    id, err := l.Inner.Charge(ctx, amount)
    if err != nil {
        l.Log.Printf("Charge failed: %v", err)
    }
    return id, err
}

type LoggingCharger struct {
    Charger              // promoted; calls without prefix go to the embedded interface
    Log *log.Logger
}

func (l *LoggingCharger) Charge(ctx context.Context, amount int) (string, error) {
    l.Log.Printf("Charge: amount=%d", amount)
    id, err := l.Charger.Charge(ctx, amount) // disambiguated
    if err != nil { l.Log.Printf("Charge failed: %v", err) }
    return id, err
}

type Factory func() Codec

var registry = map[string]Factory{}

func Register(name string, f Factory) {
    registry[name] = f
}

func Get(name string) (Codec, error) {
    f, ok := registry[name]
    if !ok { return nil, errors.New("unknown") }
    return f(), nil
}

// gzip side:
func init() {
    Register("gzip", func() Codec {
        return &GzipCodec{level: gzip.DefaultCompression}
    })
}

type GzipCodec struct{ level int }

func (g GzipCodec) Encode(in []byte) []byte {
    var buf bytes.Buffer  // local; one per call
    w, _ := gzip.NewWriterLevel(&buf, g.level)
    w.Write(in)
    w.Close()
    return buf.Bytes()
}

var bufPool = sync.Pool{
    New: func() any { return new(bytes.Buffer) },
}

func (g GzipCodec) Encode(in []byte) []byte {
    buf := bufPool.Get().(*bytes.Buffer)
    buf.Reset()
    defer bufPool.Put(buf)
    w, _ := gzip.NewWriterLevel(buf, g.level)
    w.Write(in)
    w.Close()
    out := append([]byte(nil), buf.Bytes()...) // copy out — the buf returns to the pool
    return out
}

caps := filterByCapability(strategies)  // type-asserts each
// ... later use caps ...

for _, name := range names {
    for _, r := range resolvers {
        value, err := r.Resolve(name)
        if err != nil { continue }
        if c, ok := r.(Cacher); ok {
            c.Cache(name, value)
        }
    }
}

func processBatch(resolvers []Resolver, names []string) {
    snapshot := make([]Resolver, len(resolvers))
    copy(snapshot, resolvers)

    var cacheable []Cacher
    for _, r := range snapshot {
        if c, ok := r.(Cacher); ok {
            cacheable = append(cacheable, c)
        }
    }
    // ... loop uses snapshot and cacheable consistently ...
}

func (c ClosingReadWriter) Close() error {
    if err := c.ReadCloser.Close(); err != nil { return err }
    return c.WriteCloser.Close()
}

type ClosingReadWriter struct {
    conn *myConn  // single field; methods promoted once
}

type ClosingReadWriter struct {
    r ReadCloser
    w WriteCloser
}

func (c ClosingReadWriter) Read(p []byte) (int, error)  { return c.r.Read(p) }
func (c ClosingReadWriter) Write(p []byte) (int, error) { return c.w.Write(p) }
func (c ClosingReadWriter) Close() error {
    // explicit choice: close both
    rErr := c.r.Close()
    wErr := c.w.Close()
    if rErr != nil { return rErr }
    return wErr
}