Where is the decoder in init(from decoder: Decoder) from?

[ApolloZhu]

How does SwiftUI know the default value for Decoder when we never provided a default value for it?

Original question: https://twitter.com/dev_seungjun/status/1512509304238387202

[ApolloZhu]

init vs init(from:)

Before defining init(), the only way to construct an instance of User2 is using the init(from decoder: Decoder) (I'll refer to it as init(from:) for short), and you must pass an argument that conforms to the Decoder protocol when trying to construct a User2, like:

let ddFromDecoder = User2(from: /* some decoder */)

With the addition of init(), there are now 2 ways to construct an instance of User2, by either calling init() or init(from:) with an argument:

let dd = User2() 
let ddFromDecoder = User2(from: /* some decoder */)

Note that the reason "we don't need to pass parameter for 'from'" is because User2() doesn't call init(from:); it calls the new init() that you just defined. You can observe this more directly by adding a print statement to each initializer:

class User2: Codable ... {
    required init(from decoder: Decoder) { print("from decoder"); ... }
    init() { print("default") }
}

let dd = User2() // prints "default" only

Who used init(from:)?

You've never called init(from:) directly in your code, but you were able to obtain an instance of type Response (day 49) and Order (day 51). How did that happen?

// from day 49, decodedResponse is an instance of type Response
if let decodedResponse = try? JSONDecoder().decode(Response.self, from: data) {
    results = decodedResponse.results
}

// from day 51, decodedOrder is an instance of type Order
let decodedOrder = try JSONDecoder().decode(Order.self, from: data)
confirmationMessage = "Your order for \(decodedOrder.quantity)x \(Order.types[decodedOrder.type].lowercased()) cupcakes is on its way!"
...

Looks like JSONDecoder has an instance method decode(_:from:) that we called to convert data to a Codable type. So ...

How does JSONDecoder work?

Luckily, Swift open-sourced its Foundation library for us to see how JSONDecoder is implemented. The decode(_:from:) method is defined between lines 196 and 206:

open func decode<T: Decodable>(_ type: T.Type, from data: Data) throws -> T {
    do {
        var parser = JSONParser(bytes: Array(data))
        let json = try parser.parse()
        return try JSONDecoderImpl(userInfo: self.userInfo, from: json, codingPath: [], options: self.options).unwrap(as: T.self)
    } catch ...
}

The return statement initialized a JSONDecoderImpl and calls the unwrap method on it to convert json to the desired type (referred to as T here, which can be User2, Order, Response, or any other Codable type). unwrap between lines 270 and 288 is defined as:

func unwrap<T: Decodable>(as type: T.Type) throws -> T {
    ...
    return try T(from: self)
}

..., where it calls the init(from:) initializer on desired type T passing self as the decoder. Indeed, JSONDecoderImpl conformed to the Decoder protocol on line 226:

extension JSONDecoderImpl: Decoder {

Now we have the answer: when we call decode(some type T, from: some data) on JSONDecoder, it constructs an instance of type JSONDecoderImpl and passes that as the decoder to init(from:), creating an instance of type T.

Is there a default value?

Codable is designed to be flexible. Let's say you have stored a User2 in a .plist file instead, then you can use something like:

let decodedUserFromPLIST = try PropertyListDecoder().decode(User2.self, from: /* data from plist file */)

... to get an instance of User2. Similarly, you can check out the Foundation framework's source code to see how exactly PropertyListDecoder works, but I think we can agree that it will need to use a different decoder that understands plist data instead of JSON data.

Therefore, there is no default value for the Decoder. It depends on what kind of decoder you use, allowing your Codable types to work with many kinds of decoders/formats.

[seungjun-green]

Thank you so much for the detailed explanation! It helped me a lot :)