⭐Opaque Types

Swift ⟩ Type ⟩

Swift 5.1 feature

⭐️ 重點

If a function with an opaque return type returns from multiple places, all of the possible return values must have the same type. For a generic function, that return type can use the function’s generic type parameters, but it must still be a single type. 👉 Swift

• the function body determines its concrete return type (including the concrete type of any associated type) at compile time. (💈範例 ⭐️ 5)

• use PAT (protocol with associated types) as return types. (💈範例 ⭐️ 5)

• preserve type identity (always return the same type). (💈範例 ⭐️ 2, 5)

• the body of a SwiftUI view returns some View. (View is a PAT)

💈範例

👉 paiza.io

// protocol
protocol CanAdd {
    static func +(a: Self, b: Self) -> Self
}

// protocol conformaning types
extension Int: CanAdd {}
extension Double: CanAdd {}
extension String: CanAdd {}

// ---------------------------
//     ⭐️ generic function
// ---------------------------

//   ╭─────────────── ⭐️ 1 ─────────────╮
func add<T: CanAdd>(_ a: T, _ b: T) -> T {
    return a + b
}
// ⭐️ 1. generic function declaration
//       type parameters (i.e. T) determined by caller (call site)

// caller (call site) determines type parameters
let r1 = add(42, 99)            // T = Int
let r2 = add(3.1415, 1.618)     // T = Double
let r3 = add("Hello", "World")  // T = String

// -----------------------------
//     ⭐️ opaque return type
// -----------------------------

// protocol
protocol Describer {
    func describe() -> String
}

// conformaning types
struct Human: Describer {
    func describe() -> String { "I’m a `Human`." }
}

struct Animal: Describer {
    func describe() -> String { "I’m a `Animal`." }
}


//                      ╭─── ⭐️ 2 ────╮
func someDescriber() -> some Describer {
    Human()        // concrete return type determined in here.
}
// ⭐️ 2. opaque return type
//      concrete return type determined by function body

print(type(of: someDescriber()))        // ⭐️ (always) Human

/*
    Opaque Return Type vs. Generic Type
    -----------------------------------
    • opaque return type: 
      function BODY ("inside") determines its concrete return type.
      
    • generic type: 
      caller & type DECLARATION ("outside") determine its concrete type 
      of type parameters.
*/

// -----------------------------
//     ⭐️ protocol type
// -----------------------------

//                  ╭─ ⭐️ 3 ─╮
func describer() -> Describer {
    Double.random(in: 0..<1) > 0.5 ? Human() : Animal() 
}
// ⭐️ 3. protocol type
//       can refer to MANY (conformaning) concrete types.

print(type(of: describer()))        // ⭐️ Human | Animal

/*
    Opaque Type vs. Protocol Type
    -----------------------------
    • opaque type  : always refers to ONE specific, concrete type.
    • protocol type: can refer to MANY (conformaning) concrete types.
*/

// -----------------------------------------------
//     ⭐️ PAT (protocol with associated types)
// -----------------------------------------------

protocol HasData {
    associatedtype Data            // associated type
    var data: Data { get }
}

struct IntData: HasData {
    var data: Int
}

struct StringData: HasData {
    var data: String
}

//                ╭─⭐️ 4─╮
// func data() -> HasData {
//     StringData(data: "Yellow")
// }
// ⛔ error: 
//   protocol 'HasData' can only be used as a generic constraint 
//   because it has Self or associated type requirements
// ⭐️ 4. protocol type CANNOT determine its ASSOCIATED TYPE `Data`
//       from the function declaration ("outside").

//                 ╭── ⭐️ 5 ───╮
func someData() -> some HasData {
    StringData(data: "Yellow")      // return type is determined in here.
    // return type: StringData
    // associated type Data: String
}
// ⭐️ 5. opaque return type
//      let the BODY (implementation) of the function determine:
//      - concrete return type 
//      - including concrete type of any associated type.

print(type(of: someData()))     // StringData

📘 手冊

• Swift ⟩ Opaque Types (about "opaque")

• SE0244 ⟩ Opaque Result Types

• SwiftUI ⟩ View ⟩ .body

📗 參考

• appypie ⟩ Opaque Types and ‘some’ in Swift (💈範例)

• Paul ⟩

  • How to use opaque return types in Swift

  • Why does SwiftUI use “some View” for its view type?

• Ray ⟩ Opaque Return Types and Type Erasure

• Sundell ⟩

  • The Swift 5.1 features that power SwiftUI’s API ⟩ Opaque return types

  • Opaque return types in Swift

👥 相關

• View

• ViewBuilder

• .logType()

• Type Erasure

• Protocols with Associated Types

• Swift 5.1 features.

• Protocol '...' can only be used as a generic constraint because it has Self or associated type can be solved by using keyword some.

• compare: 🗝️ any.

Opaque Type vs. Generic Type

• opaque return type: its concrete type is determined by function body ("inside"). - 💈範例 ⭐️ 2, 5

• generic type: its placeholders (type parameters) & return type are determined by caller (call site) & type declaration ("outside"). - 💈範例 ⭐️ 1

Opaque Type vs. Protocol Type

• opaque type : always refers to ONE specific, concrete type. - 💈範例 ⭐️ 2, 5

• protocol type: can refer to MANY (conformaning) concrete types. - 💈範例 ⭐️ 3