Merge branch 'patch-1' of https://github.com/TheDmitry/Design-Patterns-In-Swift into TheDmitry-patch-1

# By TheDmitry
# Via TheDmitry
* 'patch-1' of https://github.com/TheDmitry/Design-Patterns-In-Swift:
  generation
  Add Interpreter pattern

# Conflicts:
#	Design-Patterns.playground.zip

Author: Oktawian Chojnacki

Design-Patterns.playground.zip

@@ -16,16 +16,14 @@ A short cheat-sheet with Xcode 6.3beta Playground ([Design-Patterns.playground.z
 * [Creational](#creational)
 * [Structural](#structural)
 
-*/
-/*:
+*//*:
 Behavioral
 ==========
 
 >In software engineering, behavioral design patterns are design patterns that identify common communication patterns between objects and realize these patterns. By doing so, these patterns increase flexibility in carrying out this communication.
 >
 >**Source:** [wikipedia.org](http://en.wikipedia.org/wiki/Behavioral_pattern)
-*/
-/*:
+*//*:
 🐝 Chain Of Responsibility
 --------------------------
 
@@ -174,6 +172,96 @@ let doorModule = HAL9000DoorsOperations(doors:podBayDoors)
 doorModule.open()
 doorModule.close()
 /*:
+🎶 Interpreter
+--------------
+
+The interpreter pattern is used to evaluate sentences in a language.
+
+### Example
+*/
+
+protocol IntegerExp {
+    func evaluate(context: IntegerContext) -> Int
+    func replace(character: Character, integerExp: IntegerExp) -> IntegerExp
+    func copy() -> IntegerExp
+}
+
+class IntegerContext {
+    private var data: [Character:Int] = [:]
+    
+    func lookup(name: Character) -> Int {
+        return self.data[name]!
+    }
+    
+    func assign(integerVarExp: IntegerVarExp, value: Int) {
+        self.data[integerVarExp.name] = value
+    }
+}
+
+class IntegerVarExp: IntegerExp {
+    let name: Character
+    
+    init(name: Character) {
+        self.name = name
+    }
+    
+    func evaluate(context: IntegerContext) -> Int {
+        return context.lookup(self.name)
+    }
+    
+    func replace(name: Character, integerExp: IntegerExp) -> IntegerExp {
+        if name == self.name {
+            return integerExp.copy()
+        } else {
+            return IntegerVarExp(name: self.name)
+        }
+    }
+    
+    func copy() -> IntegerExp {
+        return IntegerVarExp(name: self.name)
+    }
+}
+
+class AddExp: IntegerExp {
+    private var operand1: IntegerExp
+    private var operand2: IntegerExp
+    
+    init(op1: IntegerExp, op2: IntegerExp) {
+        self.operand1 = op1
+        self.operand2 = op2
+    }
+    
+    func evaluate(context: IntegerContext) -> Int {
+        return self.operand1.evaluate(context) + self.operand2.evaluate(context)
+    }
+    
+    func replace(character: Character, integerExp: IntegerExp) -> IntegerExp {
+        return AddExp(op1: operand1.replace(character, integerExp: integerExp),
+            op2: operand2.replace(character, integerExp: integerExp))
+    }
+    
+    func copy() -> IntegerExp {
+        return AddExp(op1: self.operand1, op2: self.operand2)
+    }
+}
+/*:
+### Usage
+*/
+var expression: IntegerExp?
+var intContext = IntegerContext()
+
+var a = IntegerVarExp(name: "A")
+var b = IntegerVarExp(name: "B")
+var c = IntegerVarExp(name: "C")
+
+expression = AddExp(op1: a, op2: AddExp(op1: b, op2: c)) // a + (b + c)
+
+intContext.assign(a, value: 2)
+intContext.assign(b, value: 1)
+intContext.assign(c, value: 3)
+
+var result = expression?.evaluate(intContext)
+/*:
 🍫 Iterator
 -----------
 
@@ -537,8 +625,7 @@ Creational
 > In software engineering, creational design patterns are design patterns that deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The basic form of object creation could result in design problems or added complexity to the design. Creational design patterns solve this problem by somehow controlling this object creation.
 >
 >**Source:** [wikipedia.org](http://en.wikipedia.org/wiki/Creational_pattern)
-*/
-/*:
+*//*:
 🌰 Abstract Factory
 -------------------
 
@@ -784,8 +871,7 @@ Structural
 >In software engineering, structural design patterns are design patterns that ease the design by identifying a simple way to realize relationships between entities.
 >
 >**Source:** [wikipedia.org](http://en.wikipedia.org/wiki/Structural_pattern)
-*/
-/*:
+*//*:
 🔌 Adapter
 ----------
 
@@ -898,8 +984,7 @@ protocol Shape {
 }
 /*: 
 Leafs
-*/
- 
+*/ 
 class Square : Shape {
     func draw(fillColor: String) {
         print("Drawing a Square with color \(fillColor)")
@@ -1129,4 +1214,4 @@ Info
 
 🚀 How to generate playground (+zip) from source: [GENERATE.md](https://github.com/ochococo/Design-Patterns-In-Swift/blob/master/GENERATE.md)
 
-*/
+*/

Design-Patterns.playground/contents.swift

@@ -182,6 +182,100 @@ doorModule.open()
 doorModule.close()
 ```
 
+🎶 Interpreter
+--------------
+
+The interpreter pattern is used to evaluate sentences in a language.
+
+### Example
+
+```swift
+
+protocol IntegerExp {
+    func evaluate(context: IntegerContext) -> Int
+    func replace(character: Character, integerExp: IntegerExp) -> IntegerExp
+    func copy() -> IntegerExp
+}
+
+class IntegerContext {
+    private var data: [Character:Int] = [:]
+    
+    func lookup(name: Character) -> Int {
+        return self.data[name]!
+    }
+    
+    func assign(integerVarExp: IntegerVarExp, value: Int) {
+        self.data[integerVarExp.name] = value
+    }
+}
+
+class IntegerVarExp: IntegerExp {
+    let name: Character
+    
+    init(name: Character) {
+        self.name = name
+    }
+    
+    func evaluate(context: IntegerContext) -> Int {
+        return context.lookup(self.name)
+    }
+    
+    func replace(name: Character, integerExp: IntegerExp) -> IntegerExp {
+        if name == self.name {
+            return integerExp.copy()
+        } else {
+            return IntegerVarExp(name: self.name)
+        }
+    }
+    
+    func copy() -> IntegerExp {
+        return IntegerVarExp(name: self.name)
+    }
+}
+
+class AddExp: IntegerExp {
+    private var operand1: IntegerExp
+    private var operand2: IntegerExp
+    
+    init(op1: IntegerExp, op2: IntegerExp) {
+        self.operand1 = op1
+        self.operand2 = op2
+    }
+    
+    func evaluate(context: IntegerContext) -> Int {
+        return self.operand1.evaluate(context) + self.operand2.evaluate(context)
+    }
+    
+    func replace(character: Character, integerExp: IntegerExp) -> IntegerExp {
+        return AddExp(op1: operand1.replace(character, integerExp: integerExp),
+            op2: operand2.replace(character, integerExp: integerExp))
+    }
+    
+    func copy() -> IntegerExp {
+        return AddExp(op1: self.operand1, op2: self.operand2)
+    }
+}
+```
+
+### Usage
+
+```swift
+var expression: IntegerExp?
+var intContext = IntegerContext()
+
+var a = IntegerVarExp(name: "A")
+var b = IntegerVarExp(name: "B")
+var c = IntegerVarExp(name: "C")
+
+expression = AddExp(op1: a, op2: AddExp(op1: b, op2: c)) // a + (b + c)
+
+intContext.assign(a, value: 2)
+intContext.assign(b, value: 1)
+intContext.assign(c, value: 3)
+
+var result = expression?.evaluate(intContext)
+```
+
 🍫 Iterator
 -----------
 

README.md

@@ -0,0 +1,90 @@
+/*:
+🎶 Interpreter
+--------------
+
+The interpreter pattern is used to evaluate sentences in a language.
+
+### Example
+*/
+
+protocol IntegerExp {
+    func evaluate(context: IntegerContext) -> Int
+    func replace(character: Character, integerExp: IntegerExp) -> IntegerExp
+    func copy() -> IntegerExp
+}
+
+class IntegerContext {
+    private var data: [Character:Int] = [:]
+    
+    func lookup(name: Character) -> Int {
+        return self.data[name]!
+    }
+    
+    func assign(integerVarExp: IntegerVarExp, value: Int) {
+        self.data[integerVarExp.name] = value
+    }
+}
+
+class IntegerVarExp: IntegerExp {
+    let name: Character
+    
+    init(name: Character) {
+        self.name = name
+    }
+    
+    func evaluate(context: IntegerContext) -> Int {
+        return context.lookup(self.name)
+    }
+    
+    func replace(name: Character, integerExp: IntegerExp) -> IntegerExp {
+        if name == self.name {
+            return integerExp.copy()
+        } else {
+            return IntegerVarExp(name: self.name)
+        }
+    }
+    
+    func copy() -> IntegerExp {
+        return IntegerVarExp(name: self.name)
+    }
+}
+
+class AddExp: IntegerExp {
+    private var operand1: IntegerExp
+    private var operand2: IntegerExp
+    
+    init(op1: IntegerExp, op2: IntegerExp) {
+        self.operand1 = op1
+        self.operand2 = op2
+    }
+    
+    func evaluate(context: IntegerContext) -> Int {
+        return self.operand1.evaluate(context) + self.operand2.evaluate(context)
+    }
+    
+    func replace(character: Character, integerExp: IntegerExp) -> IntegerExp {
+        return AddExp(op1: operand1.replace(character, integerExp: integerExp),
+            op2: operand2.replace(character, integerExp: integerExp))
+    }
+    
+    func copy() -> IntegerExp {
+        return AddExp(op1: self.operand1, op2: self.operand2)
+    }
+}
+/*:
+### Usage
+*/
+var expression: IntegerExp?
+var intContext = IntegerContext()
+
+var a = IntegerVarExp(name: "A")
+var b = IntegerVarExp(name: "B")
+var c = IntegerVarExp(name: "C")
+
+expression = AddExp(op1: a, op2: AddExp(op1: b, op2: c)) // a + (b + c)
+
+intContext.assign(a, value: 2)
+intContext.assign(b, value: 1)
+intContext.assign(c, value: 3)
+
+var result = expression?.evaluate(intContext)