 /// Dictionary of Mappable objects <String, T: Mappable> with a transform
 public func <- <Transform: TransformType where Transform.Object: Mappable>(inout left: Dictionary<String, Transform.Object>, right: (Map, Transform)) {
 	let (map, transform) = right
-	if let object = map.currentValue as? [String : AnyObject] where map.mappingType == MappingType.FromJSON {
+	if let object = map.currentValue as? [String : AnyObject] where map.mappingType == .FromJSON {
 		let value = fromJSONDictionaryWithTransform(object, transform: transform) ?? left
 		FromJSON.basicType(&left, object: value)
-	} else if map.mappingType == MappingType.ToJSON {
+	} else if map.mappingType == .ToJSON {
 		let value = toJSONDictionaryWithTransform(left, transform: transform)
 		ToJSON.basicType(value, map: map)
 	}

/// Implicitly unwrapped Optional Dictionary of Mappable object <String, T: Mappable> with a transform
public func <- <Transform: TransformType where Transform.Object: Mappable>(inout left: Dictionary<String, Transform.Object>!, right: (Map, Transform)) {
	let (map, transform) = right
	if let dictionary = map.currentValue as? [String : AnyObject] where map.mappingType == MappingType.FromJSON {
		let transformedDictionary = fromJSONDictionaryWithTransform(dictionary, transform: transform) ?? left
		FromJSON.optionalBasicType(&left, object: transformedDictionary)
	} else if map.mappingType == MappingType.ToJSON {
		let value = toJSONDictionaryWithTransform(left, transform: transform)
		ToJSON.optionalBasicType(value, map: map)
	}


/// Object of Basic type
public func <- <T>(inout left: T, right: Map) {
	switch right.mappingType {
	case .FromJSON:
		FromJSON.basicType(&left, object: right.value())
	case .ToJSON:
		ToJSON.basicType(left, map: right)
    }
}

/// Optional object of basic type
public func <- <T>(inout left: T?, right: Map) {
	switch right.mappingType {
	case .FromJSON:
        FromJSON.optionalBasicType(&left, object: right.value())
	case .ToJSON:
        ToJSON.optionalBasicType(left, map: right)
    }
}

/// Implicitly unwrapped optional object of basic type
public func <- <T>(inout left: T!, right: Map) {
	switch right.mappingType {
	case .FromJSON:
		FromJSON.optionalBasicType(&left, object: right.value())
	case .ToJSON:
		ToJSON.optionalBasicType(left, map: right)
	}
}
