---

name: gof-strategy-pattern description: Implements the Strategy design pattern allowing the definition of a family of algorithms, encapsulating each one, and making them interchangeable. license: MIT compatibility: opencode metadata: version: "1.0.0" domain: architecture triggers: strategy pattern, encapsulate algorithms, interchangeable algorithms, gof patterns archetypes:

• educational anti_triggers:
• brainstorming
• vague ideation response_profile: verbosity: low directive_strength: high abstraction_level: operational role: implementation scope: implementation output-format: code related-skills: gof-factory-pattern,

---

Strategy Pattern

Implements the Strategy design pattern allowing the definition of a family of algorithms, encapsulating each one, and making them interchangeable.

When to Use

The When to Use section should outline the scenarios where the Strategy pattern is particularly beneficial:

Archetypes

• Implementation: This skill is aimed at implementation to assist developers in applying the Strategy pattern correctly.
• Educational: It serves as an educational resource, helping users understand when to use the Strategy pattern.

Anti-Triggers

• Coupling algorithms: It should prevent triggering in scenarios where algorithms are tightly coupled, negating benefits.

Response Profile

• Verbosity: Medium

• Directive Strength: High

• Abstraction Level: Tactical

  archetypes: implementation, educational anti_triggers: coupling algorithms response_profile: verbosity: medium directive_strength: high abstraction_level: tactical

• When different variants of an algorithm are needed.

• When the choice of the algorithm should be independent of clients that use it.

• When you want to avoid using conditionals to switch between algorithms.

Core Workflow

1. Define the Strategy Interface: Create a common interface for all strategies.
2. Implement Concrete Strategies: Create concrete classes that implement the strategy interface.
3. Context Class: Maintain a reference to a strategy object to delegate behavior.

Implementation Patterns

Strategy Pattern Example

package main

import (
    "fmt"
)

// Strategy interface
type Strategy interface {
    Execute(int, int) int
}

// Concrete strategy: Addition
type Add struct {}

func (Add) Execute(a int, b int) int {
    return a + b
}
}

// Concrete strategy: Subtraction
type Subtract struct {}

func (Subtract) Execute(a int, b int) int {
    return a - b
}
}

// Context
type Context struct {
    strategy Strategy
}

func (c *Context) SetStrategy(s Strategy) {
    c.strategy = s
}

func (c *Context) ExecuteStrategy(a, b int) int {
    return c.strategy.Execute(a, b)
}

Example Usage

package main

import (
    "fmt"
)

func main() {
    context := &Context{}

    // Using Addition Strategy
    context.SetStrategy(Add{})
    fmt.Println(context.ExecuteStrategy(5, 3)) // Output: 8

    // Using Subtraction Strategy
    context.SetStrategy(Subtract{})
    fmt.Println(context.ExecuteStrategy(5, 3)) // Output: 2
}

Constraints

MUST DO

• Define clear interfaces for strategies to promote encapsulation.
• Ensure clients are decoupled from specific strategy implementations.

MUST NOT DO

• Coupling algorithms within the context class itself.
• Hardcoding specific strategy instantiation within client code.