 	}
 
 	/// Parent Coordinator
-	open var parent: Any?
+	open var parentCoordinator: Coordinator<Any>?
 	///	A dictionary of child Coordinators, where key is Coordinator's identifier property
 	open var childCoordinators: [Identifier: Any] = [:]
 
-
-
-	///	Returns either `parent` coordinator or nil if there isn‘t one
-	override open var coordinatingResponder: UIResponder? {
-		guard let parent = self.parent as? UIResponder else { return nil }
-		return parent
-	}
 
 
 	/// Tells the coordinator to create its initial view controller and take over the user flow.




	/// Default identifier is the class name of the Coordinator
	public static var identifier: Identifier {
		return String(describing: self)
	}



/**
Must be adopted by UIViewController subclasses that are presented by Coordinators,
so that responder chain works properly.

Coordinators must set this property for their rootViewController.
*/
public protocol Coordinable: class {
	var coordinatingResponder: Coordinable?		{ get }
}


extension Coordinator: Coordinable {
	///	Returns either `parent` coordinator or nil if there isn‘t one
	open var coordinatingResponder: Coordinable? {
		return parentCoordinator
	}
}


/**
Driving engine of the message passing through the app, with no need for Delegate pattern nor Singletons.

Coordinable will piggy-back on the UIResponder.next? in order to pass the message through UIView/UIVC hierarchy of any depth and complexity.
However, it does not interfere with the regular UIResponder functionality.

At the UIViewController level (see below), it‘s intercepted to switch up to the coordinator, if the UIVC has one.
Once that happens, it stays in the Coordinator hierarchy, since coordinator can be nested only inside other coordinators.
*/
public extension UIView {
	open var coordinatingResponder: Coordinable? {
		return next as? Coordinable
	}
	/*	// sort-of implementation of the custom message/command to put into your UIResponder extension
	func messageTemplate(args: Whatever, sender: Any?) {
	coordinatingResponder?.messageTemplate(args: args, sender: sender)
	}
 */
}

//	Make sure every UIViewController adopts this protocol
public extension UIViewController: Coordinable {
	private struct AssociatedKeys {
		static var ParentCoordinator = "ParentCoordinator"
	}
	///	*Must* be set for View Controller acting as Coordinator.rootViewController
	open var parentCoordinator: Coordinator<Any>? {
		get {
			//	DANGER: this returns Any! so if you call this and 
			//	object is not really there, your app will crash
			return objc_getAssociatedObject(self, &AssociatedKeys.ParentCoordinator) as? Coordinator<Any>
		}
		set {
			objc_setAssociatedObject(self, &AssociatedKeys.ParentCoordinator, newValue, .OBJC_ASSOCIATION_RETAIN)
