1# Interface Design and Composition
2 
3## Small, Focused Interfaces
4 
5```go
6// Single-method interfaces (idiomatic Go)
7type Reader interface {
8    Read(p []byte) (n int, err error)
9}
10 
11type Writer interface {
12    Write(p []byte) (n int, err error)
13}
14 
15type Closer interface {
16    Close() error
17}
18 
19// Interface composition
20type ReadCloser interface {
21    Reader
22    Closer
23}
24 
25type WriteCloser interface {
26    Writer
27    Closer
28}
29 
30type ReadWriteCloser interface {
31    Reader
32    Writer
33    Closer
34}
35```
36 
37## Accept Interfaces, Return Structs
38 
39```go
40package storage
41 
42import "io"
43 
44// Storage is the concrete type (struct)
45type Storage struct {
46    baseDir string
47}
48 
49// NewStorage returns a concrete type
50func NewStorage(baseDir string) *Storage {
51    return &Storage{baseDir: baseDir}
52}
53 
54// SaveFile accepts an interface for flexibility
55func (s *Storage) SaveFile(filename string, data io.Reader) error {
56    // Implementation can work with any Reader
57    // (file, network, buffer, etc.)
58    return nil
59}
60 
61// Usage allows dependency injection
62type Uploader interface {
63    SaveFile(filename string, data io.Reader) error
64}
65 
66type Service struct {
67    uploader Uploader // Accept interface
68}
69 
70// NewService accepts interface for testing flexibility
71func NewService(uploader Uploader) *Service {
72    return &Service{uploader: uploader}
73}
74```
75 
76## io.Reader and io.Writer Patterns
77 
78```go
79import (
80    "io"
81    "strings"
82)
83 
84// Chain readers with io.MultiReader
85func combineReaders() io.Reader {
86    r1 := strings.NewReader("Hello ")
87    r2 := strings.NewReader("World")
88    return io.MultiReader(r1, r2)
89}
90 
91// Tee reader for duplicating reads
92func duplicateRead(r io.Reader, w io.Writer) io.Reader {
93    return io.TeeReader(r, w) // Writes to w while reading from r
94}
95 
96// Limit reader to prevent reading too much
97func limitedRead(r io.Reader, n int64) io.Reader {
98    return io.LimitReader(r, n)
99}
100 
101// Custom Reader implementation
102type UppercaseReader struct {
103    src io.Reader
104}
105 
106func (u *UppercaseReader) Read(p []byte) (n int, err error) {
107    n, err = u.src.Read(p)
108    for i := 0; i < n; i++ {
109        if p[i] >= 'a' && p[i] <= 'z' {
110            p[i] = p[i] - 32
111        }
112    }
113    return n, err
114}
115 
116// Custom Writer implementation
117type CountingWriter struct {
118    w     io.Writer
119    count int64
120}
121 
122func (cw *CountingWriter) Write(p []byte) (n int, err error) {
123    n, err = cw.w.Write(p)
124    cw.count += int64(n)
125    return n, err
126}
127 
128func (cw *CountingWriter) BytesWritten() int64 {
129    return cw.count
130}
131```
132 
133## Embedding for Composition
134 
135```go
136import "sync"
137 
138// Embed to extend behavior
139type SafeCounter struct {
140    mu sync.Mutex
141    m  map[string]int
142}
143 
144func (sc *SafeCounter) Inc(key string) {
145    sc.mu.Lock()
146    defer sc.mu.Unlock()
147    sc.m[key]++
148}
149 
150// Embed interface to add default behavior
151type Logger interface {
152    Log(msg string)
153}
154 
155type NoOpLogger struct{}
156 
157func (NoOpLogger) Log(msg string) {}
158 
159type Service struct {
160    Logger // Embedded interface (default implementation can be provided)
161}
162 
163func NewService(logger Logger) *Service {
164    if logger == nil {
165        logger = NoOpLogger{} // Provide default
166    }
167    return &Service{Logger: logger}
168}
169 
170// Now Service.Log() is available
171```
172 
173## Interface Satisfaction Verification
174 
175```go
176import "io"
177 
178// Compile-time interface verification
179var _ io.Reader = (*MyReader)(nil)
180var _ io.Writer = (*MyWriter)(nil)
181var _ io.Closer = (*MyCloser)(nil)
182 
183type MyReader struct{}
184 
185func (m *MyReader) Read(p []byte) (n int, err error) {
186    return 0, nil
187}
188 
189type MyWriter struct{}
190 
191func (m *MyWriter) Write(p []byte) (n int, err error) {
192    return len(p), nil
193}
194 
195type MyCloser struct{}
196 
197func (m *MyCloser) Close() error {
198    return nil
199}
200```
201 
202## Functional Options Pattern
203 
204```go
205package server
206 
207import "time"
208 
209type Server struct {
210    host         string
211    port         int
212    timeout      time.Duration
213    maxConns     int
214    enableLogger bool
215}
216 
217// Option is a functional option for configuring Server
218type Option func(*Server)
219 
220func WithHost(host string) Option {
221    return func(s *Server) {
222        s.host = host
223    }
224}
225 
226func WithPort(port int) Option {
227    return func(s *Server) {
228        s.port = port
229    }
230}
231 
232func WithTimeout(timeout time.Duration) Option {
233    return func(s *Server) {
234        s.timeout = timeout
235    }
236}
237 
238func WithMaxConnections(max int) Option {
239    return func(s *Server) {
240        s.maxConns = max
241    }
242}
243 
244func WithLogger(enabled bool) Option {
245    return func(s *Server) {
246        s.enableLogger = enabled
247    }
248}
249 
250// NewServer creates a server with functional options
251func NewServer(opts ...Option) *Server {
252    // Defaults
253    s := &Server{
254        host:     "localhost",
255        port:     8080,
256        timeout:  30 * time.Second,
257        maxConns: 100,
258    }
259 
260    // Apply options
261    for _, opt := range opts {
262        opt(s)
263    }
264 
265    return s
266}
267 
268// Usage:
269// server := NewServer(
270//     WithHost("0.0.0.0"),
271//     WithPort(9000),
272//     WithTimeout(60 * time.Second),
273//     WithLogger(true),
274// )
275```
276 
277## Interface Segregation
278 
279```go
280// Bad: Fat interface
281type BadRepository interface {
282    Create(item Item) error
283    Read(id string) (Item, error)
284    Update(item Item) error
285    Delete(id string) error
286    List() ([]Item, error)
287    Search(query string) ([]Item, error)
288    Count() (int, error)
289}
290 
291// Good: Segregated interfaces
292type Creator interface {
293    Create(item Item) error
294}
295 
296type Reader interface {
297    Read(id string) (Item, error)
298}
299 
300type Updater interface {
301    Update(item Item) error
302}
303 
304type Deleter interface {
305    Delete(id string) error
306}
307 
308type Lister interface {
309    List() ([]Item, error)
310}
311 
312// Compose only what you need
313type ReadWriter interface {
314    Reader
315    Creator
316}
317 
318type FullRepository interface {
319    Creator
320    Reader
321    Updater
322    Deleter
323    Lister
324}
325```
326 
327## Type Assertions and Type Switches
328 
329```go
330import "fmt"
331 
332// Safe type assertion
333func processValue(v interface{}) {
334    // Two-value assertion (safe)
335    if str, ok := v.(string); ok {
336        fmt.Println("String:", str)
337        return
338    }
339 
340    // Type switch
341    switch val := v.(type) {
342    case int:
343        fmt.Println("Int:", val)
344    case string:
345        fmt.Println("String:", val)
346    case bool:
347        fmt.Println("Bool:", val)
348    default:
349        fmt.Println("Unknown type")
350    }
351}
352 
353// Check for optional interface methods
354type Flusher interface {
355    Flush() error
356}
357 
358func writeAndFlush(w io.Writer, data []byte) error {
359    if _, err := w.Write(data); err != nil {
360        return err
361    }
362 
363    // Check if Writer also implements Flusher
364    if flusher, ok := w.(Flusher); ok {
365        return flusher.Flush()
366    }
367 
368    return nil
369}
370```
371 
372## Dependency Injection via Interfaces
373 
374```go
375package app
376 
377import "context"
378 
379// Define interfaces for dependencies
380type UserRepository interface {
381    GetUser(ctx context.Context, id string) (*User, error)
382    SaveUser(ctx context.Context, user *User) error
383}
384 
385type EmailSender interface {
386    SendEmail(ctx context.Context, to, subject, body string) error
387}
388 
389// Service depends on interfaces
390type UserService struct {
391    repo   UserRepository
392    mailer EmailSender
393}
394 
395func NewUserService(repo UserRepository, mailer EmailSender) *UserService {
396    return &UserService{
397        repo:   repo,
398        mailer: mailer,
399    }
400}
401 
402func (s *UserService) RegisterUser(ctx context.Context, email string) error {
403    user := &User{Email: email}
404    if err := s.repo.SaveUser(ctx, user); err != nil {
405        return err
406    }
407    return s.mailer.SendEmail(ctx, email, "Welcome", "Thanks for registering!")
408}
409 
410// Easy to mock in tests
411type MockUserRepository struct{}
412 
413func (m *MockUserRepository) GetUser(ctx context.Context, id string) (*User, error) {
414    return &User{ID: id}, nil
415}
416 
417func (m *MockUserRepository) SaveUser(ctx context.Context, user *User) error {
418    return nil
419}
420```
421 
422## Quick Reference
423 
424| Pattern | Use Case | Key Principle |
425|---------|----------|---------------|
426| Small interfaces | Flexibility | Single-method interfaces |
427| Accept interfaces | Testability | Depend on abstractions |
428| Return structs | Clarity | Concrete return types |
429| io.Reader/Writer | I/O operations | Standard library integration |
430| Embedding | Composition | Extend behavior without inheritance |
431| Functional options | Configuration | Flexible constructors |
432| Type assertions | Runtime checks | Safe downcasting |
433