Refactor strategy pattern

Author: tmrts

README.md

@@ -45,7 +45,7 @@ __Behavioral Patterns__:
 | [Observer](observer.go) | Provide a callback for notification of events/changes to data |
 | [Registry](registry.go) | Keep track of all subclasses of a given class |
 | [State](state.go) | Encapsulates varying behavior for the same object based on its internal state |
-| [Strategy](strategy/strategy.go) | Enables an algorithm's behavior to be selected at runtime |
+| [Strategy](behavioral/strategy.md) | Enables an algorithm's behavior to be selected at runtime |
 | [Template](template.go) | Defines a skeleton class which defers some methods to subclasses |
 | [Visitor](visitor.go) | Separates an algorithm from an object on which it operates |
 

behavioral/strategy.md

@@ -0,0 +1,55 @@
+#Strategy Pattern
+Strategy behavioral design pattern enables an algorithm's behavior to be selected at runtime.
+
+It defines algorithms, encapsulates them, and uses them interchangeably.
+
+## Implementation
+Implementation of an interchangeable operator object that operates on integers.
+
+```go
+type Operator interface {
+	Apply(int, int) int
+}
+
+type Operation struct {
+	Operator Operator
+}
+
+func (o *Operation) Operate(leftValue, rightValue int) int {
+	return o.Operator.Apply(leftValue, rightValue)
+}
+```
+
+## Usage
+### Addition Operator
+```go
+type Addition struct{}
+
+func (Addition) Apply(lval, rval int) int {
+	return lval + rval
+}
+```
+
+```go
+add := Operation{Addition{}}
+add.Operate(3, 5) // 8
+```
+
+### Multiplication Operator
+```go
+type Multiplication struct{}
+
+func (Multiplication) Apply(lval, rval int) int {
+	return lval * rval
+}
+```
+
+```go
+mult := Operation{Multiplication{}}
+
+mult.Operate(3, 5) // 15
+```
+
+## Rules of Thumb
+- Strategy pattern is similar to Template pattern except in its granularity.
+- Strategy pattern lets you change the guts of an object. Decorator pattern lets you change the skin.