Wat is een Opaque Type in Swift?

Een Opaque Type in Swift, ook wel bekend als een Opaque Return Type, is een concept geïntroduceerd in Swift 5.1. Het vereenvoudigt het gebruik van Protocollen en Generics, met name bij Protocollen met Associated Types. Dit artikel legt uit wat een Opaque Type is en hoe je het gebruikt.

Problemen met Protocollen en Generics

Wanneer een functie een Protocol met een Associated Type retourneert, is het lastig om het specifieke datatype van de retourwaarde te bepalen. Voorbeeld:

protocol P {
    associatedtype Value
    var value: Value { get } 
    init(value: Value) 
}

struct S1 : P { 
    var value: Int 
} 
struct S2: P { 
    var value: String 
}

// Fout: Retourtype kan niet worden afgeleid
// func foo() -> P { return S1() } 

Het gebruik van Generics heeft ook beperkingen, omdat je het datatype voor de parameter of retourwaarde van de functie moet specificeren:

func foo<T: P>(value: T.Value) -> T { return T(value: value) }
let s1: S1 = foo(value: 10) 
let s2: S2 = foo(value: "ahihi")

De Oplossing: Opaque Types

Een Opaque Type, gedeclareerd met het keyword some, staat een functie toe om een “verborgen” datatype te retourneren dat alleen aan het Protocol hoeft te voldoen, zonder specificatie.

func foo() -> some P { return S1(value: 11) }

In dit voorbeeld staat some P voor een specifiek datatype dat voldoet aan Protocol P. De compiler leidt dit automatisch af.

Een Opaque Type kan echter maar één datatype retourneren binnen dezelfde functie:

// Fout: Kan niet meerdere datatypes retourneren
// func bar(_ x: Int) -> some P {
//     if x > 10 { return S1(value: 12) } 
//     else { return S2(value: "ahihi") } 
// }

Opaque Types en PATs (Protocollen met Associated Types)

Opaque Types zijn bijzonder nuttig bij het werken met PATs. Ze maken het mogelijk om PATs als retourtype te gebruiken zonder het specifieke datatype te kennen, wat de code flexibeler maakt en minder afhankelijk van bibliotheekversies.

func giveMeACollection() -> some Collection { return [1, 2, 3] }
let collection = giveMeACollection()
print(collection.count) // 3

Opaque Types en Concrete Types

Wanneer een functie met een Opaque Type een concreet type retourneert, garandeert de compiler dat aanroepen van die functie altijd hetzelfde type retourneren.

func fooo() -> some Equatable { return 5 }
let f1 = fooo() 
let f2 = fooo()
print(f1 == f2) // true

Dit geldt echter niet voor PATs. Elke functie met een Opaque Type en PATs retourneert een apart datatype, zelfs als ze aan hetzelfde Protocol voldoen.

Opaque Types en Generic Placeholders

Het combineren van Opaque Types met Generic Placeholders maakt het mogelijk om functies te creëren die zowel veelzijdig zijn met meerdere datatypes, alsook geen concreet type hoeven te retourneren.

Waarom Opaque Types Gebruiken?

Opaque Types bieden flexibiliteit bij het werken met Protocollen, met name PATs. Ze voorkomen de noodzaak om concrete datatypes te specificeren, verminderen de afhankelijkheid van bibliotheekversies en verhogen de herbruikbaarheid van code.

Opaque Types in SwiftUI

Opaque Types worden veel gebruikt in SwiftUI. De body property van het View Protocol heeft het type some View, waardoor elk datatype dat voldoet aan het View Protocol kan worden geretourneerd. Dit vereenvoudigt het bouwen van gebruikersinterfaces. Het gebruik van some View voorkomt complexe datatypes wanneer een View meerdere geneste niveaus heeft.