Anthony Levings presented on using enums with associated values to safely parse JSON in Swift and achieve type safety. This approach wraps JSON values as they are parsed to restrict changes of type. It enables compile-time type checking and reduces testing needs compared to approaches that return loose types. Potential challenges include increased build times for large models, but alternative approaches that wrap values on demand may address this.

1. {"JSON, Swift and Type
Safety" : "It's a wrap"}
@gylphi @sketchytech
[Anthony Levings,
@sketchyTech]
Presented at SwiftSummit.com, 21 March 2015

2. NSDataNSDataif letNSData?NSData?

3. AnyObject?AnyObject?NSJSONSerializationNSDataNSData

4. NSArrayNSArray
AnyObject?AnyObject?
NSDictionaryNSDictionary

5. AnyObjectAnyObject AnyObjectAnyObject AnyObjectAnyObject
NSArrayNSArray

6. NSArrayNSArray
NSDictionaryNSDictionary
NSStringNSString
AnyObjectAnyObjectNSNumberNSNumber NSNullNSNull

7. Safety Last
“Smash and Grab”

8. var error:NSError?
if let jsonObject = NSJSONSerialization.JSONObjectWithData(data, options: nil, error: &error)
as? [String: AnyObject] {
let count = jsonObject["resultCount"] as? Int
// casting value to Int
}

9. var error:NSError?
if let jsonObject = NSJSONSerialization.JSONObjectWithData(data, options: nil, error: &error) as?
[String: AnyObject] {
var jDict = jsonObject
jDict["resultCount"] = "string"
// change of type can happen easily
let jsonData = NSJSONSerialization.dataWithJSONObject(jDict, options: nil, error: nil)
}

10. Simple Safety
“Dream Data”

11. if the JSON you are receiving looks like this
{"key1":"value1","key2":"value2","key3":"value3"
}
or this
[1,2,3,4,5,6,6,7,8,9,10]

12. then you can simply write
if let dict = jsonObject as? Dictionary<String,String>
{ }
or this
if let dict = jsonObject as? [Int]
{ }
to achieve type safety, but this will rarely the case in
the real world and so rather than keep dreaming, we
have…

13. Safely Wrapped
enum with associated values

14. enum Value {
// enum cases
case StringType(String)
case NumberType(NSNumber)
case NullType(NSNull)
// collection types
case DictionaryType(Dictionary<String,Value>)
case ArrayType([Value])
}

15. And we then wrap each value of a received
[AnyObject] or [String: AnyObject] as the
initializer to our enum*
* working code available, ask me after if you’re interested

16. if let num = dictionary["key"]?.number { }
RATHER THAN THIS:
if let dict = jsonObj as? [String: AnyObject],
str = dict[“key”] as? NSNumber { }
We can then combine associated values with
computed variables to achieve this kind of syntax:

17. Argo (thoughtbot)
Swiftz (typelift)
json-swift (David Owens II)
Three GitHub Swift–JSON libraries that already use associated
value enums in their code:

18. Type Safety =
Empowerment
• restrict changes of type (e.g. through subscripting)
• prevent the return of AnyObject
• enable the compiler to better detect errors and assist the
programmer
• reduction in the amount of code to test types and return
values
• IT MAKES US THINK ABOUT TREATMENT OF JSON!

19. Potential Problems

20. The larger your model object, the longer the build takes [using
Argo]. This is an issue with the Swift compiler having trouble
working out all the nested type inference. While Argo works, it
can be impracticle for large objects. There is work being done on
a separate branch to reduce this time. (Tony DiPasquale,
thoughtbot)
https://robots.thoughtbot.com/parsing-embedded-json-and-arrays-in-swift
Argo

21. Wrapped on Demand
A possible solution

22. enum Value {
// enum cases
case StringType(String)
case NumberType(NSNumber)
case NullType(NSNull)
// collection types
case DictionaryType(JSONDictionary)
case ArrayType(JSONArray)
}

23. If we use a struct and an enum together we can leverage
stored values:
(1) the getter can wrap individual values on demand (not
in advance).
(2) changes and additions to stored values become
simplified

24. if let p = parsedJSON["results"]?.jsonArr,
d = p[0]?.jsonDict {
d["trackName"]?.str
}
parsedJSON["results"]?[0]?["trackName"] = "Something"
And setting:
Getting:

25. Using the struct approach we also have easier access to information like
which keys have String values, which have Number values, etc.
—- Dictionary —-
json.keysWithNumberValues
json.keysWithStringValues
—- Array ——-
json.isNumberArray
json.isStringArray
json.isMixedArray
json.removeAllNumbers()
json.removeAllStrings()
and other benefits of stored properties, which enums don’t enjoy.

26. Bespoke Handling of
Data

27. if let url = NSURL(string:"http://itunes.apple.com/search?term=b12&limit=40"),
data = NSData(contentsOfURL: url),
parsedJSON = JSONParser.parseDictionary(data),
iTD = iTunesData(dict: parsedJSON)
{
let tracks = map(iTD.results, {x in Track(dict:x.jsonDict)})
}
Bespoke Handling of Data

28. public struct iTunesData {
public var resultCount:Int {
return results.count
}
public var results:JSONArray
public init?(dict:JSONDictionary) { ... }
public subscript (index:Int) -> JSONDictionary? { ... }
public mutating func updateTrackDetails(track:Track) { ... }
public func outputJSON() -> NSData? { ... }
}

29. public struct Track {
public var trackName:String, collectionName:String, trackId:Int
public init?(dict:JSONDictionary?) {
if let tN = dict?["trackName"]?.str,
cN = dict?["collectionName"]?.str,
tI = dict?["trackId"]?.num {
trackName = tN
collectionName = cN
trackId = tI.integerValue
}
else {
return nil
}
}
}

30. Round-tripping bespoke
data

31. Track info
iTunesData
JSONParser
JSON in
JSON out

32. JSON (JavaScript Object Notation) is a lightweight
data-interchange format. It is easy for humans to read
and write. It is easy for machines to parse and
generate. It is based on a subset of the JavaScript
Programming Language, Standard ECMA-262 3rd
Edition - December 1999. JSON is a text format that is
completely language independent but uses conventions
that are familiar to programmers of the C-family of
languages, including C, C++, C#, Java, JavaScript,
Perl, Python, and many others. These properties make
JSON an ideal data-interchange language.