1package shapes
  2
  3import (
  4    "fmt"
  5    "math"
  6)
  7
  8// Shape interface defines common shape operations
  9type Shape interface {
 10    Area() float64
 11    Perimeter() float64
 12}
 13
 14// Drawable extends Shape with visual representation
 15type Drawable interface {
 16    Shape
 17    Draw() string
 18}
 19
 20// Comparable allows shapes to be compared
 21type Comparable interface {
 22    IsLargerThan(other Shape) bool
 23}
 24
 25// Circle implements Shape
 26type Circle struct {
 27    Radius float64
 28}
 29
 30func Area() float64 {
 31    return math.Pi * c.Radius * c.Radius
 32}
 33
 34func Perimeter() float64 {
 35    return 2 * math.Pi * c.Radius
 36}
 37
 38func String() string {
 39    return fmt.Sprintf("Circle(radius=%.2f)", c.Radius)
 40}
 41
 42func Draw() string {
 43    return "  ○  "
 44}
 45
 46func IsLargerThan(other Shape) bool {
 47    return c.Area() > other.Area()
 48}
 49
 50// Rectangle implements Shape
 51type Rectangle struct {
 52    Width  float64
 53    Height float64
 54}
 55
 56func Area() float64 {
 57    return r.Width * r.Height
 58}
 59
 60func Perimeter() float64 {
 61    return 2 *
 62}
 63
 64func String() string {
 65    return fmt.Sprintf("Rectangle(width=%.2f, height=%.2f)", r.Width, r.Height)
 66}
 67
 68func Draw() string {
 69    return " ▭ "
 70}
 71
 72func IsLargerThan(other Shape) bool {
 73    return r.Area() > other.Area()
 74}
 75
 76// Triangle implements Shape
 77type Triangle struct {
 78    A, B, C float64 // sides
 79}
 80
 81func Area() float64 {
 82    // Heron's formula
 83    s := / 2
 84    return math.Sqrt(s * * *)
 85}
 86
 87func Perimeter() float64 {
 88    return t.A + t.B + t.C
 89}
 90
 91func String() string {
 92    return fmt.Sprintf("Triangle(sides=%.2f, %.2f, %.2f)", t.A, t.B, t.C)
 93}
 94
 95func Draw() string {
 96    return " △ "
 97}
 98
 99func IsLargerThan(other Shape) bool {
100    return t.Area() > other.Area()
101}
102
103// TotalArea calculates total area of multiple shapes
104func TotalArea(shapes ...Shape) float64 {
105    total := 0.0
106    for _, shape := range shapes {
107        total += shape.Area()
108    }
109    return total
110}
111
112// PrintShapes prints information about shapes
113func PrintShapes(shapes []Shape) {
114    for i, shape := range shapes {
115        fmt.Printf("%d. %s - Area: %.2f, Perimeter: %.2f\n",
116            i+1, shape, shape.Area(), shape.Perimeter())
117    }
118}
119
120// GetLargest returns the shape with largest area
121func GetLargest(shapes []Shape) Shape {
122    if len(shapes) == 0 {
123        return nil
124    }
125
126    largest := shapes[0]
127    for _, shape := range shapes[1:] {
128        if shape.Area() > largest.Area() {
129            largest = shape
130        }
131    }
132
133    return largest
134}
135
136// GetCircles filters only circles from shapes
137func GetCircles(shapes []Shape) []*Circle {
138    var circles []*Circle
139
140    for _, shape := range shapes {
141        // Type assertion with comma-ok idiom
142        if circle, ok := shape.(*Circle); ok {
143            circles = append(circles, circle)
144        }
145    }
146
147    return circles
148}
149
150// Describe returns detailed description of any value
151func Describe(value any) string {
152    // Type switch on empty interface
153    switch v := value.(type) {
154    case int:
155        return fmt.Sprintf("Integer: %d", v)
156    case string:
157        return fmt.Sprintf("String: %q", v)
158    case float64:
159        return fmt.Sprintf("Float: %.2f", v)
160    case bool:
161        return fmt.Sprintf("Boolean: %t", v)
162    case Shape:
163        return fmt.Sprintf("Shape: %s", v, v.Area())
164    case nil:
165        return "Nil value"
166    default:
167        return fmt.Sprintf("Unknown type: %T", v)
168    }
169}
170
171// IsDrawable checks if a shape implements Drawable interface
172func IsDrawable(shape Shape) bool {
173    _, ok := shape.(Drawable)
174    return ok
175}
176
177// DrawAllDrawable draws all shapes that implement Drawable
178func DrawAllDrawable(shapes []Shape) string {
179    var result string
180
181    for _, shape := range shapes {
182        if drawable, ok := shape.(Drawable); ok {
183            result += drawable.Draw()
184        }
185    }
186
187    return result
188}

Explanation

Shape Interface:

• Defines common contract for all shapes
• Area() and Perimeter() methods
• Implemented by Circle, Rectangle, Triangle

Concrete Types:

• Each type stores necessary data
• Implements all Shape methods
• Also implements String() for pretty printing

Drawable Interface:

• Embeds Shape interface
• Adds Draw() method
• Types can implement multiple interfaces

TotalArea:

• Accepts variadic Shape parameters
• Demonstrates polymorphism - works with any Shape
• Uses interface methods without knowing concrete type

PrintShapes:

• Takes slice of Shape interface
• Uses String() method if available
• Calls Area() and Perimeter() polymorphically

GetCircles:

• Uses type assertion to filter specific type
• Comma-ok idiom prevents panic
• Returns slice of concrete Circle pointers

Describe:

• Works with empty interface
• Uses type switch to handle different types
• Demonstrates type checking at runtime

Interface Patterns

1. Small Interfaces:

1// Good: focused interface
2type Reader interface {
3    Read(p []byte)
4}
5
6// Avoid: kitchen sink interfaces

2. Interface Composition:

 1type ReadWriter interface {
 2    Reader
 3    Writer
 4}
 5
 6type ReadWriteCloser interface {
 7    Reader
 8    Writer
 9    Closer
10}

3. Accept Interfaces, Return Structs:

1// Good
2func Process(r io.Reader) {
3    // Implementation
4}
5
6// Avoid returning interfaces
7func Bad() io.Reader { // Less flexible
8    return &MyReader{}
9}

4. Type Assertions:

1// Safe: comma-ok idiom
2if concrete, ok := iface.(ConcreteType); ok {
3    // Use concrete
4}
5
6// Unsafe: will panic if wrong type
7concrete := iface.(ConcreteType)

5. Type Switch:

1switch v := iface.(type) {
2case string:
3    fmt.Println("String:", v)
4case int:
5    fmt.Println("Int:", v)
6default:
7    fmt.Println("Unknown")
8}

Common Standard Interfaces

fmt.Stringer:

1type Stringer interface {
2    String() string
3}
4
5func String() string {
6    return fmt.Sprintf("Circle(r=%.2f)", c.Radius)
7}

error:

 1type error interface {
 2    Error() string
 3}
 4
 5type MyError struct {
 6    Message string
 7}
 8
 9func Error() string {
10    return e.Message
11}

io.Reader:

1type Reader interface {
2    Read(p []byte)
3}

sort.Interface:

1type Interface interface {
2    Len() int
3    Less(i, j int) bool
4    Swap(i, j int)
5}