Typealias: co to je, syntaxe a použití

Co je Typealias?

Typealias — je deklarace ve Swift, která zavádí alternativní název pro existující typ. Po deklarování typealias lze nové jméno použít všude, kde je očekáván původní typ — kompilátor je považuje za identické. Typealias nepřidává sémantickou izolaci: hodnotu typu UserID (typealias pro String) lze předat funkci očekávající String bez chyby.

Hlavní účely typealias — zkracování dlouhých názvů, dokumentování účelu typu a abstrahování konkrétní implementace. Například typealias JSON = [String: Any] výslovně uvádí, že slovník je používán jako JSON struktura, a typealias Completion = (Result<Data, Error>) -> Void přeměňuje složitou signaturu closure na čitelný typ.

Podle Swift.org (2025) je typealias široce používán ve standardní knihovně. Například String — je typealias pro String (specializované Array<Character>), i když v moderních verzích Swift je tato implementace skrytá. Void — typealias pro prázdnou n-tici (), což činí signatury funkcí čitelnějšími.

Používejte typealias k dokumentování sémantiky typu, ale pamatujte: to nechrání před mícháním různých konceptů stejného základního typu. Pro typově bezpečné oddělení používejte obaly (struct wrapper).

Syntaxe a oblasti viditelnosti

Typealias se deklaruje klíčovým slovem typealias, za kterým následuje nové jméno, rovnítko a existující typ. Základní tvar:

typealias Name = ExistingType
typealias UserID = Int
typealias JSONDictionary = [String: Any]

Oblast viditelnosti typealias je určena místem deklarace:

Typealias uvnitř typu (například User.ID) — běžný vzor pro seskupování souvisejících aliasů. To zlepšuje jmenný prostor: Order.ID a User.ID — obojí Int, ale jsou čteny jako různé koncepty. Přístup k vnořenému typealias je přes User.ID nebo přes tečku, pokud je typ znám.

Typealias pro closure typy

Jedno z nejčastějších použití typealias — zjednodušování signatur closure. Typy closure ve Swift mohou být těžkopádné, zejména s Optional a generickými parametry. Typealias přeměňuje (Data?, Error?) -> Void na čitelný FetchResultHandler:

typealias FetchResultHandler = (Data?, Error?) -> Void

func fetchUser(id: Int, completion: FetchResultHandler) {
    // síťový požadavek
    completion(data, nil)
}

Podle Ray Wenderlich Style Guide, typealias pro closure zvyšuje čitelnost signatur metod, zejména v delegovacích prototypech a callback vzorech. Vyhněte se však nadměrnému počtu aliasů — pokud je closure použit na jednom místě, lze jej deklarovat inline.

Standardní knihovna Swift aktivně používá tuto techniku. Například DispatchQueue.WorkItem — je typealias pro DispatchWorkItem, i když zvenčí vypadá jako samostatný typ. Typealias pro closure je nástroj čitelnosti, nezneužívejte jej: 3–5 closure aliasů na modul — rozumný limit.

Typealias a generické parametry

Typealias může zahrnovat generické parametry, vytvářející specializované verze zobecněných typů. To je zvláště užitečné při práci s Result, Publisher a dalšími generickými typy ze standardní knihovny a Combine:

typealias FetchResult = Result<Data, Error>
typealias AnyPublisherOfData = AnyPublisher<Data, Error>

func loadData() -> FetchResult {
    // načítání dat
}

Lze také vytvářet typealias s vlastními generickými parametry, které jsou přesměrovány do původního typu:

typealias NetworkResult<T> = Result<T, NetworkError>

func fetchUser() -> NetworkResult<User> {
    // ...
}

Důležité pravidlo: typealias nemůže přidávat nová generická omezení (where clauses) — pouze přesměrovává parametry do původního typu. Pokud jsou potřebná další omezení, vytvořte generickou strukturu nebo třídu. Podle Swift by Sundell (2024), typealias s generic — ideální způsob, jak zkrátit opakující se signatury v projektech aktivně používajících Combine, Result a async/await.

Associatedtype v protokolech

Associatedtype — je typealias deklarovaný uvnitř protokolu, který definuje přidružený typ. Na rozdíl od běžného typealias, associatedtype není vázán na konkrétní typ ve fázi deklarace — je konkretizován každým typem potvrzujícím protokol:

protocol Container {
    associatedtype Item
    var count: Int { get }
    mutating func append(_ item: Item)
}

struct IntBox: Container {
    typealias Item = Int
    // implementace
}

struct StringBox: Container {
    typealias Item = String
    // implementace
}

Associatedtype dává protokolům flexibilitu generických typů bez specifikace konkrétního typu v místě deklarace. To je základem mnoha Swift vzorů: Collection (Element), IteratorProtocol (Element), Identifiable (ID). Kompilátor může odvodit associatedtype automaticky z implementace, proto je explicitní typealias Item = Int často vynecháváno — Swift odvodí Item jako Int z parametru metody append.

Podle Swift Evolution SE-0195 (2022) byly zavedeny opaque result types (some Container) pro práci s protokoly obsahujícími associatedtype — to vyřešilo problém PAT (protocol with associated types), které nebylo možné použít jako typ proměnné.

Typealias vs obal typu

Klíčový rozdíl: typealias — je jen jiné jméno pro existující typ, zatímco obal (wrapper) — nový typ, sémanticky izolovaný od originálu. Pokud deklarujete typealias UserID = Int, pak UserID a Int jsou zaměnitelné — funkce očekávající Int přijme UserID bez chyby.

Obal se vytváří přes struct a poskytuje skutečnou typovou bezpečnost:

struct UserID: RawRepresentable {
    let rawValue: Int
}

struct OrderID: RawRepresentable {
    let rawValue: Int
}

// Chyba kompilace: nelze předat OrderID tam, kde je očekáváno UserID

Podle Point-Free (2025) jsou obaly preferovány, když jsou různé koncepty reprezentovány jedním základním typem (UserID vs OrderID). Typealias je ospravedlněn, když cílem je čitelnost bez izolace: zkrácení dlouhého názvu, dokumentování sémantiky, abstrahování implementace přes associatedtype. Vyberte typealias pro pohodlí čtení, obal — pro typovou bezpečnost.