     var myInt: Int
     var myString: String
     var myStruct: MyStruct
-    
-    init(myInt: Int, myString: String, myStruct: MyStruct) {
+
+    init(myInt: Int, myString: String,
+         myStruct: MyStruct, myColor: UIColor) {
         self.myInt = myInt
         self.myString = myString
         self.myStruct = myStruct

extension UInt16 : PseudoEquatableType {}
extension UInt32 : PseudoEquatableType {}
extension UInt64 : PseudoEquatableType {}

extension Double : PseudoEquatableType {}
extension Float : PseudoEquatableType {}
extension Float80 : PseudoEquatableType {}

extension String : PseudoEquatableType {}
// ...
/*  EquatableConstruct conformance to Equatable  */
func ==<T: EquatableConstruct>(lhs: T, rhs: T) -> Bool {
    
    let mirrorLhs = Mirror(reflecting: lhs)
    let mirrorRhs = Mirror(reflecting: rhs)
    
    guard let displayStyle = mirrorLhs.displayStyle,
        (displayStyle == .struct || displayStyle == .class) else {
            
            print("Invalid use: type is not a construct.")
            return false
    }
    
    let childrenLhs = mirrorLhs.children.filter { $0.label != nil }
    let childrenRhs = mirrorRhs.children.filter { $0.label != nil }
    
    if childrenLhs.count == childrenRhs.count {
        
        for i in 0..<childrenLhs.count {
            
            guard let valLhs = childrenLhs[i].value as? PseudoEquatableType,
                  let valRhs = childrenRhs[i].value as? PseudoEquatableType else {
                    print("Invalid use: Properties 'lhs.\(childrenLhs[i].label!)'",
                        "and/or 'rhs.\(childrenRhs[i].label!)' are/is not of",
                        "PseudoEquatableType type.")
                    return false
            }
            
            if !valLhs.isEqualTo(valRhs) {
                return false
            }
        }
    }
        
    else {
        return false
    }
    
    return true
}

//===----------------------------------------------------------------------===//

///
protocol EquatableConstruct : Equatable { }

/*  Heterogeneous protocol acts as castable meta-type used for
    property-by-property equalitu testing in EquatableConstruct   */
protocol PseudoEquatableType {
    func isEqual(to other: PseudoEquatableType) -> Bool
}

extension PseudoEquatableType where Self : Equatable {
    func isEqual(to other: PseudoEquatableType) -> Bool {
        if let o = other as? Self { return self == o }
        return false
    }
