     }
 }
 
-public func ~> <T: MappableObject>(reference: [String : T]!, map: Map) throws {
-    switch map.type {
-    case .ToJson:
-        try map.setToLastKey(reference)
-    case .FromJson:
-        break
-    }
-}
-
-public func ~> <T: MappableObject>(reference: [String : [T]]!, map: Map) throws {
-    switch map.type {
-    case .ToJson:
-        try map.setToLastKey(reference)
-    case .FromJson:
-        break
-    }
-}
-
-public func ~> <T : MappableObject>(reference: Set<T>!, map: Map) throws {
+public func ~> <T: JsonConvertibleType>(reference: [String : T]!, map: Map) throws {
+    switch map.type {
+    case .ToJson:
+        try map.setToLastKey(reference)
+    case .FromJson:
+        break
+    }
+}
+
+public func ~> <T: JsonConvertibleType>(reference: [String : [T]]!, map: Map) throws {
+    switch map.type {
+    case .ToJson:
+        try map.setToLastKey(reference)
+    case .FromJson:
+        break
+    }
+}
+
+public func ~> <T : JsonConvertibleType>(reference: Set<T>!, map: Map) throws {
     switch map.type {
     case .ToJson:
         try map.setToLastKey(reference)

    }
}

public func <~ <T: MappableObject>(inout reference: [[T]], map: Map) throws {
    switch map.type {
    case .ToJson:
        break
    case .FromJson:
        reference = try <~map
    }
}

public func <~ <T: MappableObject>(inout reference: [[T]]!, map: Map) throws {
    switch map.type {
    case .ToJson:
        break
    case .FromJson:
        reference = try <~map
    }
}

public func <~ <T: MappableObject>(inout reference: [[T]]?, map: Map) throws {
    switch map.type {
    case .ToJson:
        break
    case .FromJson:
        reference = try <~map
    }
}

public func <~ <T: MappableObject>(inout reference: [String : T], map: Map) throws {
    switch map.type {
    case .ToJson:
        break
    case .FromJson:
        reference = try <~map
    }
}

public func <~ <T: MappableObject>(inout reference: [String : T]!, map: Map) throws {
    switch map.type {
    case .ToJson:
        break
    case .FromJson:
        reference = try <~map
    }
}

public func <~ <T: MappableObject>(inout reference: [String : T]?, map: Map) throws {
    switch map.type {
    case .ToJson:
        break
    case .FromJson:
        reference = try <~map
    }
}

public func <~ <T: MappableObject>(inout reference: [String : [T]], map: Map) throws {
    switch map.type {
    case .ToJson:
        break
    case .FromJson:
        reference = try <~map
    }
}

public func <~ <T: MappableObject>(inout reference: [String : [T]]!, map: Map) throws {
    switch map.type {
    case .ToJson:
        break
    case .FromJson:
        reference = try <~map
    }
}

public func <~ <T: MappableObject>(inout reference: [String : [T]]?, map: Map) throws {
    switch map.type {
    case .ToJson:
        break
    case .FromJson:
        reference = try <~map
    }
}

public func <~ <T: MappableObject>(inout reference: Set<T>, map: Map) throws {
    switch map.type {
    case .ToJson:
        break
    case .FromJson:
        reference = try <~map
    }
}

public func <~ <T: MappableObject>(inout reference: Set<T>!, map: Map) throws {
    switch map.type {
    case .ToJson:
        break
    case .FromJson:
        reference = try <~map
    }
}

public func <~ <T: MappableObject>(inout reference: Set<T>?, map: Map) throws {
    switch map.type {
    case .ToJson:
        break

    }
}

public func <~> <T: JsonConvertibleType>(inout reference: [[T]], map: Map) throws {
    switch map.type {
    case .ToJson:
        try reference ~> map
    case .FromJson:
        try reference <~ map
    }
}

public func <~> <T: JsonConvertibleType>(inout reference: [[T]]!, map: Map) throws {
    switch map.type {
    case .ToJson:
        try reference ~> map
    case .FromJson:
        try reference <~ map
    }
}

public func <~> <T: JsonConvertibleType>(inout reference: [[T]]?, map: Map) throws {
    switch map.type {
    case .ToJson:
        try reference ~> map
    case .FromJson:
        try reference <~ map
    }
}

public func <~> <T: JsonConvertibleType>(inout reference: [String : T], map: Map) throws {
    switch map.type {
    case .ToJson:
        try reference ~> map
    case .FromJson:
        try reference <~ map
    }
}

public func <~> <T: JsonConvertibleType>(inout reference: [String : T]!, map: Map) throws {
    switch map.type {
    case .ToJson:
        try reference ~> map
    case .FromJson:
        try reference <~ map
    }
}

public func <~> <T: JsonConvertibleType>(inout reference: [String : T]?, map: Map) throws {
    switch map.type {
    case .ToJson:
        try reference ~> map
    case .FromJson:
        try reference <~ map
    }
}

public func <~> <T: JsonConvertibleType>(inout reference: [String : [T]], map: Map) throws {
    switch map.type {
    case .ToJson:
        try reference ~> map
    case .FromJson:
        try reference <~ map
    }
}

public func <~> <T: JsonConvertibleType>(inout reference: [String : [T]]!, map: Map) throws {
    switch map.type {
    case .ToJson:
        try reference ~> map
    case .FromJson:
        try reference <~ map
    }
}

public func <~> <T: JsonConvertibleType>(inout reference: [String : [T]]?, map: Map) throws {
    switch map.type {
    case .ToJson:
        try reference ~> map
    case .FromJson:
        try reference <~ map
    }
}

public func <~> <T: JsonConvertibleType>(inout reference: Set<T>, map: Map) throws {
    switch map.type {
    case .ToJson:
        try reference ~> map
    case .FromJson:
        try reference <~ map
    }
}

public func <~> <T: JsonConvertibleType>(inout reference: Set<T>!, map: Map) throws {
    switch map.type {
    case .ToJson:
        try reference ~> map
    case .FromJson:
        try reference <~ map
    }
}

public func <~> <T: JsonConvertibleType>(inout reference: Set<T>?, map: Map) throws {
    switch map.type {
    case .ToJson:
        try reference ~> map
    case .FromJson:
        try reference <~ map
    }
}
