implemented composite pattern

README.md

@@ -1,8 +1,44 @@
-# golang-design-patterns
-Implementation of design patterns in Golang
+# Design patterns in golang
+>A beginner guide... happy coding!
 
+## Table of Contents
 
-### Table of contents
-**[Creational Patterns](#creational-patterns)**<br>
-**[Structural Patterns](#structural-patterns)**<br>
-**[Behavioral Patterns](#behavioral-patterns)**<br>
+- [Creational patterns](#creational-patterns)
+    - [Singleton](#singleton)
+    - [Builder](#builder)
+- [Structural patterns](#structural-patterns)
+    - [Composition](#composition)
+- [Behavioral patterns](#behavioral-patterns)
+- [Concurrency patterns](#concurrency-patterns)
+
+---
+
+## Creational patterns
+Creational design patterns abstract the instantiation process. They help make a system independent of how its objects are created, composed, and represented.
+
+### Singleton
+Ensure a class only has one instance, and provide a global point of access to it.
+
+### Builder
+Separate the construction of a complex object from its representation so that the
+same construction process can create different representations.
+
+## Structural patterns
+Structural patterns are concerned with how classes and objects are composed to form
+larger structures. Structural class patterns use inheritance to compose interfaces or implementations.
+As a simple example, consider how multiple inheritance mixes two or
+more classes into one.
+
+### Composition
+Compose objects into tree structures to represent part-whole hierarchies. Composite
+lets clients treat individual objects and compositions of objects uniformly.
+
+## Behavioral patterns
+Behavioral patterns are concerned with algorithms and the assignment of responsibilities
+between objects. Behavio ral patterns describe not just patterns of objects or classes
+but also the patterns of communication between them. These patterns characterize
+complex control flow that's difficult to follow at run-time. They shift your focus away
+from flow of control to let you concent ratejust on the way objects are interconnected.
+
+## Concurrency patterns
+Pattenrs for concurrent work and parallel execution in Go.

structural/composition/byembeding.go

@@ -0,0 +1,35 @@
+package composition
+
+import (
+	"fmt"
+)
+
+type Car struct {
+	WheelCount uint8
+	Speed int
+	DoorCount uint8
+	Brand string
+}
+
+func (c *Car) Drive() {
+	fmt.Println("Goes with speed: %d", c.Speed)
+}
+
+type FlyingCar struct {
+	Car
+	WingLength float32
+	FlySpeed int
+} 
+
+func (c *FlyingCar) Fly()  {
+	fmt.Println("Flies with speed: %d", c.FlySpeed)
+}
+
+type SwimmingCar struct {
+	Car
+	SwimSpeed int
+}
+
+func (c *SwimmingCar) Swimm()  {
+	fmt.Println("Swimm with speed: %d", c.SwimSpeed)
+}

structural/composition/byinterface.go

@@ -0,0 +1,56 @@
+package composition
+
+import (
+	"fmt"
+)
+
+type Driver interface {
+	Drive()
+}
+
+type Cleaner interface{
+	Clean()
+} 
+
+type Killer interface {
+	Kill()
+}
+
+type Barker interface {
+	Bark()
+}
+
+type Dog struct {}
+func (d *Dog) Bark()  {
+	fmt.Println("Wow!")
+}
+
+type RobotDog struct {}
+func (r *RobotDog) Drive()  {
+	fmt.Println("Driving...")
+}
+func (r *RobotDog) Bark()  {
+	fmt.Println("Wow!")
+}
+
+type CleanerRobotDog struct {}
+func (r *CleanerRobotDog) Drive()  {
+	fmt.Println("Driving...")
+}
+func (r *CleanerRobotDog) Bark()  {
+	fmt.Println("Wow!")
+}
+func (r *CleanerRobotDog) Clean()  {
+	fmt.Println("Cleaning...")
+}
+
+type KillerRobotDog struct {}
+func (r *KillerRobotDog) Drive()  {
+	fmt.Println("Driving...")
+}
+func (r *KillerRobotDog) Bark()  {
+	fmt.Println("Wow!")
+}
+func (r *KillerRobotDog) Kill()  {
+	fmt.Println("You gonna die!")
+}