Síla static dispatch ve Swiftu

Článek vysvětluje, co je ve Swiftu static a dynamic dispatch, měří dopad na výkon a ukazuje výhody i nevýhody obou přístupů.

Lukáš Valenta · 1. července 2022 · 13 min čtení

Read in English →Auf Deutsch lesen →

Apple má o rychlosti programovacího jazyka Swift smělá tvrzení a uvádí například, že je až 2,6× rychlejší než Objective-C.

Podrobnosti testů, o které se tato tvrzení opírají, nebyly nikdy zveřejněny. Ti, kdo si je ověřovali sami, došli ke zcela opačným výsledkům: neoptimalizovaný kód ve Swiftu může být oproti Objective-C až řádově pomalejší. S optimalizacemi je obvykle stále pomalejší, ale rozdíl už není tak velký.

Softwarový inženýr a výzkumník Marcel Weiher ve své knize iOS and macOS Performance Tuning zjistil, že Swift lze výrazně zrychlit. Znamenalo by to ale přejít na čisté C nebo na funkce postavené na C a přijít o veškeré pohodlí, které Swift přináší.

V Cleeviu se snažíme psát co nejrychlejší kód a zároveň zachovat pohodlí, bezpečnost a čitelnost. Swift je proto pro většinu našich případů skvělý (i když jsme pro jeden projekt napsali na výpočetně náročnou úlohu knihovnu v C), protože naše potřeby pokrývá a nemusíme kvůli tomu přecházet na čisté C.

Některé problémy v kódu se ale dají řešit mnoha způsoby, z nichž některé jsou výkonnější a jiné méně. Tento článek se zaměřuje na rozdíl mezi static a dynamic dispatch. Podíváme se na něj v kódu a probereme, jaký má jeho použití dopad na výkon. Dostaneme se i k omezením v situacích, kdy je psaní optimálního kódu mnohem méně pohodlné.

Static dispatch

Static dispatch označuje situaci, kdy už při kompilaci víme, které tělo funkce se spustí. Obvykle ho představuje konkrétní typ nebo generika.

Ukázat se to dá na následujícím příkladu:

struct DinnerServer {
    func isFoodReady() -> Bool { 
        true
    }
}

let server = DinnerServer()
server.isFoodReady()

Tady si můžeme být jistí, že funkci vykoná DinnerServer a že dostaneme hodnotu true. Totéž platí pro třídy označené klíčovým slovem final: nelze z nich dědit, takže už při kompilaci víme, co se vykoná.

Podobný výsledek dostaneme, když použijeme generika, která protokoly ve Swiftu využívají naplno. Generika jsou nezbytnou součástí vývoje aplikací ve Swiftu, protože jazyk sám byl popsán jako protokolově orientovaný. Nejdřív si definujme protokol:

protocol Server {
    func isFoodReady() -> Bool
}

Teď zajistíme, aby DinnerServer tomuto protokolu vyhovoval. Je to jednoduché, protože DinnerServer už tu funkci implementuje.

extension DinnerServer: Server { }

Řekněme, že máme funkci, která bere jako argument Server a vrací informaci, jestli je jídlo hotové. Definovat by se dala takto:

func isFoodReady(server: Server) -> Bool {
    server.isFoodReady()
}

V současné implementaci ale říkáme, že to může být jakýkoli Server. Výsledek dostaneme, ale nevíme, který typ funkci vykoná. A protože do funkce může přijít jakýkoli Server, nevíme ani, jestli dostaneme true. Naštěstí lze kompilátoru pomocí generik říct, který typ bude za vykonání funkce zodpovědný.

func isFoodReady<T: Server>(server: T) {
    server.isFoodReady()
}

Tady funkci předáváme T: Server. Tato syntaxe ve špičatých závorkách znamená, že nečekáme jakýkoli Server, ale jeden konkrétní. Kompilátor pak vytvoří samostatnou verzi pro každý typ, který do funkce v našem kódu předáme. Velikost zkompilované aplikace tím nepatrně naroste, ale můžeme si být jistí, že kód poběží rychle, protože kompilátor za nás vytvoří funkci, která vypadá takto:

func isFoodReady(server: DinnerServer) {
    server.isFoodReady()
}

Takovou funkci v našem kódu neuvidíme. Ukazuji ji proto, abyste si uměli představit, jak kompilátor na pozadí z generik těží.

Totéž bychom samozřejmě zvládli sami: stačilo by deklarovat funkci isFoodReady(server:) pro každý typ, který protokolu Server vyhovuje. Bylo by to ale nesmyslné plýtvání časem. Ruční psaní by navíc bylo náchylnější k chybám, protože na některou funkci by se dalo snadno zapomenout.

U jedné funkce to navíc ještě vypadá zvládnutelně. Co ale u složitějšího kódu? Například když požadavky protokolu Server rozšíříme o funkce prepareIngredients a finalizePreparation

protocol Server {
    func isFoodReady() -> Bool
    func preparedIngredients(size: Int) -> ()
    func finalizePreparation() -> ()
}

a pak rozšíříme náš DinnerServer, aby protokolu Server dál vyhovoval:

extension DinnerServer: Server {
    func server.prepareIngredients(size: Int) {
        var preparedIngredients = 0
        
        while preparedIngredients < size {
            preparedIngredients += 1
        }
    }

    func finalizePreparation() { } 
}

Pak můžeme vytvořit speciální funkci pro přípravu jídla, která se postará o zavolání obou funkcí:

func prepareFood<T: Server>(server: T, size: Int) {
    server.prepareIngredients(size: size)
    server.finalizePreparation()
}

Jak jste viděli v implementaci, finalizePreparation je u DinnerServer prázdná, protože náš server nepotřebuje dělat nic víc než připravit ingredience. Jiný Server ji ale potřebovat může.

Teď to můžeme použít v další funkci (orderFood), která má spadnout, pokud jídlo není hotové ve chvíli, kdy už má být připravené:

func orderFood<T: Server>(server: T, size: Int) {
    prepareFood(server: server, size: size)
    if !isFoodReady(server: server) {
        fatalError("Food is not ready for some reason")
    }
}

Jak vidíte, kdybychom měli vytvářet funkce pro konkrétní typy, množství kódu, který bychom museli napsat, by rostlo exponenciálně

spolu s tím, jak by přibývalo funkcí nebo typů, které je používají.

Generika pomáhají i testovatelnosti kódu: můžeme si vytvořit mockovací typy jen pro testy a nemusíme pro ně psát zvláštní funkce.

Dynamic dispatch

Dynamic dispatch je přesně opačná situace: při kompilaci nevíme, které tělo funkce se vykoná. Nemůžeme tedy kompilátoru pomoci k takovým optimalizacím, jaké umí udělat u generik.

Jak by funkce s dynamic dispatch vypadala v našem příkladu, jsem už ukázal. Je to funkce, která bere jakýkoli typ vyhovující protokolu Server:

func isFoodReady(server: Server) -> Bool {
    server.isFoodReady()
}

Výsledkem je, že vykonání této dynamické isFoodReady vyžaduje za běhu víc práce. Dobře to ukazuje assembler, který kompilátor vygeneruje. Generická a negenerická funkce se především liší už v implementaci.

 output.isFoodReady<A where A: output.Server>(server: A) -> Swift.Bool: //generic function
        push    rbp
        mov     rbp, rsp
        push    r13
        sub     rsp, 40
        mov     qword ptr [rbp - 40], rdx
        mov     rax, rsi
        mov     rsi, qword ptr [rbp - 40]
        mov     qword ptr [rbp - 32], rax
        mov     r13, rdi
        mov     rdi, qword ptr [rbp - 32]
        mov     qword ptr [rbp - 24], 0
        mov     qword ptr [rbp - 16], rdi
        mov     qword ptr [rbp - 24], r13
        mov     rax, qword ptr [rsi + 8]
        call    rax
        add     rsp, 40
        pop     r13
        pop     rbp
        ret

output.isFoodReady(server: output.Server) -> Swift.Bool: //non-generic function
        push    rbp
        mov     rbp, rsp
        push    r13
        sub     rsp, 24
        mov     qword ptr [rbp - 16], 0
        mov     qword ptr [rbp - 16], rdi
        mov     rsi, qword ptr [rdi + 24]
        mov     qword ptr [rbp - 32], rsi
        mov     rax, qword ptr [rdi + 32]
        mov     qword ptr [rbp - 24], rax
        call    __swift_project_boxed_opaque_existential_1
        mov     rdi, qword ptr [rbp - 32]
        mov     rsi, qword ptr [rbp - 24]
        mov     r13, rax
        mov     rax, qword ptr [rsi + 8]
        call    rax
        add     rsp, 24
        pop     r13
        pop     rbp
        ret

Jak vidíme, negenerická funkce obsahuje zvláštní volání __swift_project_boxed_opaque_existential_1, protože právě s tím tu musíme pracovat: s existenciály. Rozdíly jsou vidět i v místě, kde se tyto funkce volají.

Volání naší generické funkce je docela přímočarý kód:

        lea     rsi, [rip + (full type metadata for output.DinnerServer)]
        add     rsi, 8
        lea     rdx, [rip + (protocol witness table for output.DinnerServer : output.Server in output)]
        call    (output.isFoodReady<A where A: output.Server>(server: A) -> Swift.Bool)

Když ale zkusíme zavolat naši generickou funkci, začne to vypadat nepřehledněji:

        lea     rax, [rip + (full type metadata for output.DinnerServer)]
        add     rax, 8
        mov     qword ptr [rbp - 16], rax
        lea     rax, [rip + (protocol witness table for output.DinnerServer : output.Server in output)]
        mov     qword ptr [rbp - 8], rax
        lea     rdi, [rbp - 40]
        call    (output.isFoodReady(server: output.Server) -> Swift.Bool)
        lea     rdi, [rbp - 40]
        call    __swift_destroy_boxed_opaque_existential_1
        xor     eax, eax
        add     rsp, 48
        pop     rbp
        ret

Nejvýraznější rozdíl je v tom, že přibylo volání funkce __swift_destroy_boxed_opaque_existential_1. Právě tato režie navíc způsobuje, že kód běží pomaleji. O kolik? K tomu se dostaneme v další části.

Na pojem existenciál narazíme také v souvislosti se Swiftem 5.6, který zavedl existential any. Swift se nás tak snaží přimět, abychom před každý typ protokolu, který chceme (například) ve funkci použít, napsali any. Díky tomu si máme lépe uvědomovat, že používáme dynamic dispatch. Dá se čekat, že v budoucích verzích Swiftu dostaneme varování nebo chybu, pokud slovo any v kódu nepoužijeme. Výše uvedený kód by vypadal takto:

func isFoodReady(server: any Server) -> Bool {
    server.isFoodReady()
}

Tak jednoduché to je. Stačí přidat slovo any.

Dalším příkladem dynamic dispatch je třída, která není definovaná jako final. Kompilátor si nemůže být jistý, jaká třída do funkce přijde: je to ta, která je ve funkci uvedená, nebo některá, která z ní dědí? Když je třída deklarovaná jako final, dědit z ní už nejde a kompilátor může provést další optimalizace. Totéž platí pro jednotlivé funkce nebo proměnné. Pokud jsou deklarované jako final, nelze je přepsat a kompilátor nemusí použít dynamic dispatch.

Proč by tedy někdo dynamic dispatch používal? Na to se podíváme v části Omezení, kde ukážu příklady situací, ve kterých je použití static dispatch přinejmenším nepohodlné.

Výsledky

Obecně se dá čekat, že dynamic dispatch bude pomalejší než stejné funkce se static dispatch. A tak to opravdu vyšlo. Otázkou je: za jakou cenu? Odpověď se liší podle toho, jestli mluvíme o generikách, nebo o final třídách.

Měření

Ukážu výsledky srovnání static a dynamic dispatch. Pro měření jsem vytvořil knihovnu, která přijímá funkce definované v typu MeasureFunc (obsahuje funkci a její název) a počet opakování.

func measure(functions: [MeasureFunc], repeats: Int)

Funguje velmi jednoduše: opakovaně spouští všechny funkce a výsledek přidává do slovníku, který se pak seřadí a výsledky se dál zpracují. Knihovna je umí vypsat nebo třeba uložit jako CSV. Průměrný čas každé funkce se pak počítá jako průměr jednotlivých běhů. Používá se CAMediaCurrentTime, jehož vytvoření je mnohem rychlejší než u Date, a měl by proto být přesnější.

func oneRunOf(_ function: () -> ()) -> Double {
    let timeBefore = CACurrentMediaTime()
    function()
    return CACurrentMediaTime() - timeBefore
}

Výsledky ukážu ve vztahu k nejrychlejší funkci. Kdyby tedy jedna funkce trvala 1 minutu a druhá 2 minuty, první by měla index 100 % a druhá 200 %, protože její vykonání trvá dvakrát déle.

Kód byl zkompilován s release optimalizacemi, bez nich by se dalo čekat, že bude mnohem pomalejší.

Ve všech testech, které vám ukážu, používám funkci TestingClass, která je deklarovaná takto:

final class TestingClass: Testable {    
    let variable1 = UUID()
    let variable2 = UUID()
    let variable3 = UUID()
    let variable4 = UUID()
    let variable5 = UUID()
}

Vyhovuje protokolu Testable, který má jediný požadavek: podporovat init bez parametrů. UUID jsem použil proto, že jejich generování chvíli trvá, i když jde o hodnotové typy.

Přidávání třídy do pole

Znovupoužití kódu je jednou ze skvělých myšlenek moderního programování. Nechceme se opakovat a chceme, pokud možno, měnit jen jeden řádek na jednom místě místo jednoho řádku na několika místech.

V prvním příkladu jsem staticky a dynamicky dispatchovaný kód testoval na přidávání naší TestingClass do Array. Ano, do ContiguousArray by to bylo rychlejší, ale ruku na srdce, to nikdo nepoužívá (a i já jen občas).

Kód pro přidávání do pole je u generického typu velmi jednoduchý: vezme jednu položku a přidá ji 100 000krát.

func getAppendingToArray<T: Testable>(_ item: T) {
    var array: Array<T> = []
                
    for _ in 0..<100000 {
        array.append(item)
    }
}

S dynamicky dispatchovanou funkcí se kód změní jen v tom, že místo T použijeme přímo Testable. Ve Swiftu 5.6 bychom použili any Testable.

func getAppendingToArrayDynamicDispatch(_ item: Testable) {
    var array: Array<Testable> = []
                
    for _ in 0..<100000 {
        array.append(item)
    }
}

Výsledky nepřekvapí: s generickou funkcí je to mnohem rychlejší. O kolik? Asi o 62 %.

Přidávání třídy do pole s inicializací

Někdy nepotřebujeme do pole opakovaně přidávat jen jednu konkrétní položku, ale také ji z nějakých dat vytvořit a udělat z ní model. Samotná inicializace tedy nějakou dobu trvá. A i když je přidávání mnohem rychlejší (jak už jsme řekli, o 62 %), rozdíl v celkovém čase funkce by měl být mnohem menší, protože čas initu by měl být stejný.

Funkce se velmi podobají prostému přidávání do Array, jen s tím rozdílem, že položku při přidání zároveň inicializujeme. Generická funkce vypadá takto:

func getAppendingAndCreatingArray<T: Testable>(ofType usedType: T.Type) {
    var array: Array<T> = []
                
    for _ in 0..<100000 {
        array.append(usedType.init())
    }
}

A dynamicky dispatchovaná takto:

func getAppendingAndCreatingArrayDynamicDispatch(ofType usedType: Testable.Type) {
    var array: Array<Testable> = []
                
    for _ in 0..<100000 {
        array.append(usedType.init())
    }
}

Výsledky potvrzují, co jsme čekali: dynamic dispatch je o 7 % pomalejší než generika, protože významnou část času zabere vytvoření třídy. Kdyby to nebyla třída nebo kdyby neměla 5 proměnných, byl by dynamic dispatch relativně pomalejší (ale nikdy o víc než 62 %, které jsme viděli v předchozím testu).

Rekurze tříd

Nebudeme se bavit o rekurzivních algoritmech (ty obvykle ani nebývají nejvýkonnějším způsobem, jak úlohu vyřešit). Ukážu vám velmi jednoduchý kód třídy, která přijme parametr a pak ho předá dál. Využití může být třeba při dependency injection, například v koordinátorech nebo při práci s ViewModely ve SwiftUI.

Rekurze se static dispatch vypadá následovně. Jak vidíte, začínáme s položkou, která vyhovuje protokolu Testable, a pak rekurzi provedeme 5krát (počínaje nulou).

final class RecursionStaticDispatch<T: Testable> {
    let storage: T
    let height: Int


    init(item: T, height: Int) {
        self.storage = item
        self.height = height
        recurseIfRecursionLessThanFive()
    }
    
    func recurseIfRecursionLessThanFive() {
        if height < 5 {
            let _ = RecursionStaticDispatch(item: storage, height: height + 1)
        }
    }
}

Dynamic dispatch vypadá velmi podobně, jediný rozdíl je v tom, že storage deklarujeme jako Testable místo generického T.

final class RecursionDynamicDispatch {
    let storage: Testable
    let height: Int


    init(item: Testable, height: Int) {
        self.storage = item
        self.height = height
        recurseIfRecursionLessThanFive()
    }
    
    func recurseIfRecursionLessThanFive() {
        if height < 5 {
            let _ = RecursionDynamicDispatch(item: storage, height: height + 1)
        }
    }
}

Static dispatch je opět mnohem rychlejší, v tomto případě o 67 %.

Final třídy

Když jsem třídy deklaroval jako final, našel jsem jen nepatrný rozdíl. Rozhodně to ale patří mezi optimalizační tipy Applu, které najdete na jeho Githubu. Na benchmarky final tříd jsem se v testech pro tento článek příliš nezaměřil, ale je vidět, že s final třídami můžeme něco málo získat, a to nejen za běhu, ale i v době kompilace.

Doporučuji tento skvělý benchmark ze Swift fór od uživatele Jon_Shier, který ukazuje, že deklarace tříd jako final může kompilaci zrychlit asi o 1 %. To není špatné, že? A protože s generiky to trvá o něco déle, můžeme tím získat zpět, co jsme ztratili. Aspoň částečně.

Omezení

Naše iOS architektura je postavená na MVVM-C. Nejdřív předáme závislosti objektu Coordinator, který pak odpovídá za vytvoření ViewModel a ViewController a následně za připojení ViewModel k ViewController (nebo k View, podle toho, jestli jde o novější aplikaci se SwiftUI, nebo o starší, postavenou čistě na UIKitu).

Začít static dispatch využívat v koordinátorech bylo poměrně snadné. Místo tohoto:

final class ExampleCoordinator {
    typealias Dependencies = AllDependencies
    
    (...)
}

Teď používáme generika deklarovaná takto:

final class ExampleCoordinator<Dependencies: AllDependencies> {    
    (...)
}

Tento kód je dokonce kratší, protože není potřeba vytvářet typealias pro Dependencies, který by se pak používal ve funkcích koordinátoru. Kdykoli tedy potřebujeme závislosti změnit, změníme je jen na jednom místě.

Jedna drobnost: když se rozhodnete pro tuto změnu a místo any existenciálu začnete brát generika, musíte to změnit všude. Nebo aspoň začít u kořenového koordinátoru a pak pokračovat dál po směru flow. Pro ukázku si deklarujme protokol Developer:

protocol Developer { }

a typ, který mu vyhovuje:

struct CleevioDeveloper: Developer { }

Tento kód se zkompiluje:

func invoiceForCustomer(developer: any Developer) { }

let developer = CleevioDeveloper()

invoiceForCustomer(developer: developer)

Následující už ale ne. Generika totiž čekají konkrétní typ a kompilátor z existenciálu konkrétní typ udělat neumí.

func invoiceForCustomer<T: Developer>(developer: T) { }

let developer: any Developer = CleevioDeveloper()

invoiceForCustomer(developer: developer)

U ViewModelů a ViewControllerů to ale tak snadné není. Kdyby byl ViewModel generický, museli bychom ho pomocí generik výslovně deklarovat ve ViewControlleru stejně jako v samotném ViewModelu (v následujícím příkladu to vidíte ve špičatých závorkách, kde musíme kód duplikovat). Ve ViewControlleru bychom pak museli deklarovat, kterým protokolům ViewModel vyhovuje, a případný refaktoring by byl o něco těžší.

protocol CanFly { }

final class ViewModel<T: CanFly> { (…) }

final class ViewController<T: CanFly>: UIViewController {
    let viewModel: ViewModel<T>

	(…)
}

Třídu, která používá generika, také nelze rozšířit tak, aby byla delegátem pro Objective-C API. Je to vidět v následujícím příkladu, kde dostáváme chybu „Conformance of generic class ViewController<T> to @objc protocol UITableViewDelegate cannot be in an extension“. Ano, dalo by se to vyřešit dalším objektem, který by jako delegát sloužil, ale vyžadovalo by to výrazné změny.

extension ViewController: UITableViewDelegate { } //does not work

Generika se také umí hodně zkomplikovat, když chceme mít pro generické závislosti výchozí argumenty. Dobře je to vidět ve SwiftUI, ale platí to všude, kde se generika používají. Pro ukázku si vytvořme velmi jednoduchý ContainerView se dvěma atributy: content a jeho overlay.

struct ContainerView<Content: View, Overlay: View>: View {
    var content: Content
    var overlay: Overlay
    
    init(@ViewBuilder content: () -> Content,
           @ViewBuilder overlay: () -> Overlay) {
        self.content = content()
        self.overlay = overlay()
    }
    
    var body: some View {
        content
            .overlay(overlay)
    }
}

Co když pro něj chceme vytvořit výchozí argumenty? Museli bychom o ně ContainerView rozšířit. Řekněme, že chceme, aby výchozím argumentem pro content byl Text a pro overlay EmptyView.

Pro Content by to vypadalo takto. Všimněte si Content == Text, kde deklarujeme, že jde o extension, která platí jen tehdy, když je Content typu Text. A v initu je také Text s lokalizovaným řetězcem „Placeholder“. Kdykoli tedy použijete init ContainerView(overlay:), zobrazí se Text s řetězcem Placeholder.

extension ContainerView where Content == Text {
    init(@ViewBuilder content: () -> Content = { Text("Placeholder") },
           @ViewBuilder overlay: () -> Overlay) {
        self.content = content()
        self.overlay = overlay()
    }
}

A aby byl Overlay ve výchozím stavu EmptyView, takto. Výsledkem je, že teď můžeme parametr overlay vynechat:

extension ContainerView where Overlay == EmptyView {
    init(@ViewBuilder content: () -> Content,
           @ViewBuilder overlay: () -> Overlay = EmptyView.init) {
        self.content = content()
        self.overlay = overlay()
    }
}

Co kdybychom ale chtěli init se dvěma výchozími argumenty, Text a EmptyView? Museli bychom deklarovat další extension, třeba takto. Díky tomu můžeme obě předchozí extension zkombinovat a ContainerView deklarovat jen jako ContainerView(), aniž bychom museli uvádět jakýkoli argument:

extension ContainerView where Content == Text, Overlay == EmptyView {
    init(@ViewBuilder content: () -> Content = { Text("Placeholder") },
           @ViewBuilder overlay: () -> Overlay = EmptyView.init) {
        self.content = content()
        self.overlay = overlay()
    }
}

A co kdybychom měli další argumenty, kterým bychom chtěli dát výchozí hodnotu? Jak vidíte, složitost tu roste exponenciálně. Pro dva výchozí argumenty potřebujeme 3 extension. Pro 3 bychom potřebovali 7 argumentů. Tady je na místě mluvit i o údržbě: jestli je čistě generický přístup vhodný hned od začátku, když API nebo architektura aplikace ještě není hotová a může se v budoucnu výrazně změnit.

Stojí za to dodat, že pokud se pro generika rozhodneme, na některých místech se tomu prostě nevyhneme. Apple dělá u svých prvků SwiftUI přesně totéž. Skutečnou implementaci sice nevidíme, ale v dokumentaci vidíme hlavičky a názvy funkcí.

SwiftUI.Label má dva argumenty: Title a Icon. A protože Apple chce, aby uživatelé mohli používat convenience inity, má navíc dvě další extension (výchozí parametry tu Apple žádné nemá), které obsahují convenience inicializátory. Například v první extension, kde je Title typu Text, jsou convenience inity, které berou String, LocalizedStringKey a také String pro obrázek nebo SF Image. Jak vidíte, Label nejde inicializovat pomocí some View a zároveň pomocí String s obrázkem. Na to by museli vytvořit další extension. Totéž platí pro případ, kdy by Title byl String, ale Icon some View. Navrhovat API je prostě těžké: buď poskytnete všechny convenience inity, nebo si usnadníte život.

public struct Label<Title, Icon> : View where Title : View, Icon : View

extension Label where Title == Text, Icon == Image

extension Label where Title == LabelStyleConfiguration.Title, Icon == LabelStyleConfiguration.Icon

Tato omezení rozhodně nejsou konečná. Podle kontextu se dají někdy obejít. Pokud máte dobré příklady omezení nebo způsobů, jak je vyřešit, dejte mi prosím vědět!

Swift 5.7

Apple přinesl do Swiftu 5.7 spoustu skvělých novinek. Výrazně zlepšil práci s generiky a odstranil některá omezení, která jsem zmínil výše.

V první kapitole tohoto článku jsme například definovali tuto funkci:

func isFoodReady<T: Server>(server: T) {

Ve Swiftu 5.7 ji stačí napsat takto:

func isFoodReady(server: some Server) {

Zápis se špičatými závorkami, který mohl potenciální uživatele generik odrazovat, je pryč. Nahrazuje ho stejné klíčové slovo some, které známe ze SwiftUI, a nově ho lze použít i u parametru funkce.

Ukázal jsem také, jak těžké je ve SwiftUI definovat výchozí argumenty parametrů. To už neplatí. V našem případě jsme potřebovali 4 inity. Ve Swiftu 5.7 stačí jediný.

 init(@ViewBuilder content: () -> Content = { Text("Placeholder") },
         @ViewBuilder overlay: () -> Overlay = EmptyView.init) {
        self.content = content()
        self.overlay = overlay()
    }

A to nejzajímavější: nově lze využít něco, čemu lidé z Applu říkají existential unboxing. Co to znamená? Existenciál teď můžeme použít v generické funkci. Myslím, že to dobře ukazuje následující příklad:

func takeAn(existential: Dependency) {
    takeA(generic: existential)
}

func takeA(generic: some Dependency) {
    takeAn(existential: generic)
}

Jak vidíte, existenciální typ any může zavolat generickou funkci, která pak (jak to šlo vždycky) znovu zavolá existenciální funkci. Právě proto (a kvůli dalším novinkám) se moje prezentace pro tým o generikách ve Swiftu 5.7 a o tom, jak s chystanými novinkami zlepšit náš kód, jmenovala Big Year For Generics.

Od Swiftu 5.7 můžeme generika do kódu zavádět postupně, protože už není nutné upravit celou hierarchii koordinátorů, když s nimi chceme začít. Stačí začít jedním a pokračovat průběžně.

Swift 5.7 tedy výrazně vylepšuje to, co jsme už měli, a dřívější kód se přitom stále zkompiluje. Jen pozor na příliš brzký přechod na Xcode 14: v době psaní článku rozhodně není stabilní a má vážné problémy.

Závěrem

Co si tedy z článku odnést? Využívejte sílu static dispatch, kdykoli to jde. Swift je pro programátora skvělý jazyk, i když dává hodně zabrat kompilátoru. A kompilátor potřebuje naši pomoc: tu mu poskytneme generiky, final třídami nebo třeba deklaracemi private a dalšími.

Pozor ale na přehnanou optimalizaci. Jak jsem ukázal v části Omezení, v některých situacích by vyžadovala rozsáhlý refaktoring stávajícího kódu a mohla by ztížit jeho budoucí refaktoring. Vždy myslete i na to, jestli se to vyplatí, protože optimalizací kódu můžete spálit spoustu svého času, nebo času klienta. A i když je dopad na výkon výrazný, naše telefony, počítače a tablety jsou dnes tak výkonné, že si ho uživatel nemusí vůbec všimnout. Optimalizovat, kdykoli to jde, je skvělé, může to dokonce ušetřit baterii, ale nepřehánějte to.

Na závěr pár praktických rad. Myslím si, že za kód, který používá existenciály bez any, vám kompilátor Swiftu v budoucnu dá varování. Až se to stane, zvažte, jestli ho místo doplnění any neudělat generický. U tříd můžete použít například následující pravidlo pro SwiftLint, které vás upozorní, pokud kód obsahuje třídu, která není deklarovaná jako final (u tříd, ze kterých se má dědit, lze pravidlo vždy vypnout). Samozřejmě si ho můžete upravit podle sebe, my ho používáme jen pro Managery, Services a Coordinatory.

final_class:
    included: ".*\\.swift"
    name: "Class not declared as final"
    regex: '^(\s*)((public|private|internal)\s|)(class)\s'
    message: "Classes should be declared as final if they are not to be subclassed"
    severity: warning
Lukáš ValentaiOS Developer
Další články

Další články z blogu.

Ocenění a uznání

Stavíme věci, které vyniknou.

V souladu s GDPRData neuchováváme
Clutch Global Fall 2023Clutch Global Spring 2024Clutch Global Fall 2024Clutch Top Web3 Development – Czech Republic 2024
Deloitte Technology Fast 50 – 2023 Central EuropeDeloitte Technology Fast 50 – Czech RepublicDeloitte Technology Fast 500 – 2023 EMEA
Druhý názor

Zeptejte se někoho
jiného než nás.

Kontext jsme už připravili.
Zeptejte se, v čem jsme dobří – a v čem ne.

Otevře nový chat s předvyplněným kontextem.

Obchod a AI poradenství

Začněte s Jakubem.

Přijďte s byznysovým problémem, procesem nebo nápadem. Pomůžeme vám najít správný další krok.

Krátký úvodní hovor je často nejrychlejší cesta, jak zjistit, co stojí za to řešit.

Jakub DurecOd tvůrců pro tvůrce
Jakub DurecAI Advisory Lead

Používáme cookies

Zásady ochrany osobních údajů