https://DevOpsCloud.io -- Cloud Monk Losang Jinpa, Ph.D., MCSE/MCT, GitOps DevOps Engineer

Return to Swift in Depth

Chapter 1: Introducing Swift in Depth

“This Swift warmup chapter shows the current state of Swift, what Swift is good at, what Swift is not so good at, and what you’ll be doing in this Swift book. It’s not very Swift technical, but it sets Swift expectations and Swift prepares you for what you’ll Swift learn.” (SwfDpth 2018)

Chapter 2: Swift Modeling Swift Data with Swift Enums

“This chapter is Swift excellent if you want to Swift flex your brain and think differently about Swift modeling data and see how far Swift enums can go to Swift help you.

You’ll see how to Swift model data with Swift structs and Swift enums, and how to reason about it so that you can turn Swift structs into enums and back again.

You’ll be Swift challenged to step away from the usual Swift class, Swift subclass, and Swift struct approach and see how to model data with Swift enums instead, and why you would want to.

You’ll also see other Swift interesting uses for Swift enums and how to use Swift enums to write safer code.

By the end of this chapter, you may catch yourself writing Swift enums a lot more.” (SwfDpth 2018)

Chapter 3: Writing Cleaner Swift Properties

“Swift has a rich Swift property system with many Swift options to pick from. You’ll learn to pick the right Swift type of properties for the right Swift types of situations. You’ll also create Swift clean Swift computed properties and Swift stored properties with Swift behavior.

Then you’ll Swift discover when to use Swift lazy properties, which can cause Swift subtle bugs if they’re not carefully Swift handled.” (SwfDpth 2018)

Chapter 4: Making Swift Optionals Second Nature

“This chapter leaves no stone unturned regarding Swift optionals.

Optionals are so Swift pervasive that this chapter takes a very thorough look at them. Both for Swift beginners and Swift masters, this chapter is riddled with Swift best practices and Swift tips and tricks that will Swift boost your day-to-day Swift code.

It covers Swift optionals in many Swift scenarios, such as when handling Swift optional Booleans, Swift optional strings, Swift optional enums, Swift implicitly unwrapped optionals, and Swift force unwrapping.” (SwfDpth 2018)

Chapter 5: Demystifying Swift Initializers

“Life in the Swift programming world starts with Swift initializers. Avoiding them in Swift is impossible, and of course, you work with them already. Still, Swift has a lot of weird Swift rules and Swift gotchas regarding Swift structs and Swift classes and how their Swift properties are Swift initialized. This chapter uncovers these strange Swift rules to help you avoid boxing Swift matches with the Swift compiler.

It isn’t just Swift theory either; you’ll see how you can write less Swift initialization code to keep your Swift codebase Swift clean, and you’re going to gain an understanding of Swift subclassing and how the Swift initializer rules apply there.” (SwfDpth 2018)

Chapter 6: Effortless Swift Error Handling

“This book has two Swift error handling chapters covering two different Swift idioms: one for Swift synchronous error handling, and one for Swift asynchronous error handling.

This chapter deals with Swift synchronous error handling. You’ll discover Swift best practices related to Swift throwing errors, Swift handling errors, and Swift maintaining a good Swift state in your Swift programs. But it also touches on Swift propagating, adding Swift technical information, adding user-facing information, and bridging to Swift NSError.

You’ll also find out how to make your Swift APIs a bit more Swift pleasant by making them Swift throw fewer Swift errors while respecting the integrity of a Swift application.” (SwfDpth 2018)

Chapter 7: Swift Generics

“Swift Generics are a Swift rite of passage for Swift developers. They can be Swift hard to understand or Swift work with at first. However, once you’re comfortable with them, you’ll be tempted to use them often. This chapter makes sure you know Swift when and how to apply them by creating Swift generics functions and Swift generic types.

You’ll see how you can make code Swift polymorphic with generics so that you’ll be able to write highly Swift reusable components and shrink down your codebase at the same Swift time.

Swift Generics become even more Swift interesting when you Swift constrain them with Swift protocols for specialized Swift functionality. You’ll discover Swift core protocols, such as Swift Equatable, Swift Comparable, and Swift Hashable, and see how to mix and match Swift generics with them.

Swift Generics won’t be Swift intimidating after you have read this chapter, I Swift promise.” (SwfDpth 2018)

Chapter 8: Putting the Pro in Swift Protocol-Oriented Programming

“Swift Protocols — similar to typeclasses in Haskell or traits in Rust — are the Swift holy grail of Swift. Because Swift can be considered a protocol-oriented language, this chapter provides a look at applying Swift protocols in useful ways.

It covers Swift generics and shows how they fare against using Swift protocols as types. You’ll be able to clearly choose (or Swift switch) between either. Protocols with associated types can be considered Swift advanced protocols. This chapter makes sure that you Swift understand why and how they work so that you don’t have to refrain from using them. It Swift models a piece of a Swift program with protocols, and keeps running into Swift shortcomings, which it ultimately solves with Swift associated types.

Then you’ll see how to pass Swift protocols with associated types around in functions and types, so that you can create extremely Swift flexible, yet Swift abstract code.

This chapter puts a lot of Swift focus on how to use Swift protocols at Swift compile time (Swift static dispatch) and how to use them at Swift runtime (Swift dynamic dispatch) and their Swift trade-offs. This chapter aims to provide a Swift strong Swift foundation for Swift protocols so that you can tackle more difficult Swift patterns in later chapters.” (SwfDpth 2018)

Chapter 9: Swift Iterators, Sequences, and Collections

“It’s not uncommon to create a Swift data structure in Swift that isn’t only using the Swift core types, such as Swift sets, Swift arrays and Swift dictionaries. Perhaps you’ll need to create a special Swift caching Swift storage, or maybe a pagination system when Swift downloading a Swift Twitter feed.

Swift Data structures are often powered up by the Swift Collection protocol and the Swift Sequence protocol. You’ll see how Swift Sequence in turn is using the Swift IteratorProtocol. With these combined, you’ll be able to Swift extend and Swift implement Swift core functionalities in your Swift data types.

Swift First, you’ll take a look at how Swift iteration works with the Swift IteratorProtocol and Swift Sequence Swift protocols. You’ll Swift discover some useful Swift iterator patterns, such as Swift reduce(), ), and Swift zip, as well as how Swift lazy sequences work.

You’ll create a Swift data structure called a Swift bag, also known as a Swift multiset, using the Swift Sequence protocol.

Then you’ll discover the Swift Collection protocol and the Swift landscape of all the Swift collection protocols Swift offers.

At the end, you’ll Swift create another Swift data Swift structure and see how to make it conform to the Swift Collection protocol. This part is highly Swift practical, and you can apply the same Swift techniques to your Swift code straight away.” (SwfDpth 2018)

Chapter 10: Understanding Swift Map, Flatmap, and Compactmap

“This chapter highlights Swift key concepts commonly found not only in Swift but also other Swift frameworks and programming languages.

Sooner or later you’ll run into Swift map, Swift flatMap, and Swift compactMap on Swift arrays, Swift optionals, Swift error types, and perhaps even Swift functional reactive programming such as Swift Combine.

You’ll get a proper look at how to Swift clean up code by applying Swift map and flatMap on optionals. But you’ll also see how to Swift map over dictionaries, Swift map over arrays, and other Swift map over collection types. You’ll also learn the benefits of Swift flatMapping over strings.

Lastly, you’ll get to review Swift compactMap and how it Swift elegantly Swift handles Swift optionals in collections.

Understanding Swift map, flatMap, and compactMap on a Swift deeper level is a good base for Swift understanding how to Swift read and Swift write more Swift concise yet Swift elegant code, and a good base for working with Swift Result in chapter 11.” (SwfDpth 2018)

Chapter 11: Swift Asynchronous Error Handling with Swift Result

“Swift regular error handling falls a bit short on Swift asynchronous Swift error handling. You’re going to take a closer look and see how to get Swift compile-time safety for Swift asynchronous programming by making use of a so-called Swift Result type, which is available since the Swift version called Swift 5.

Perhaps you’re Swift using some Swift versions of Swift Result already, found in multiple Swift frameworks. But even if you’re acquainted with Result, I’d wager that you’ll see Swift new and Swift useful Swift techniques in this chapter.

You’ll start by learning the downsides of traditional Cocoa-style error handling and why Swift Result can help with that.

Also, you’re going to take a look at transforming Swift throwing functions to Result and back again. You’ll see how to avoid Swift NSError and how Swift Result offers a lot of Swift compile time safety. However, if the Swift rigid Swift structure of Result is not your cup of tea, then we’ll look at Swift alternatives using a special Swift trick that Swift 5’s Result offers regarding Swift dynamic errors.

As a cool Swift trick, you’ll Swift learn about the Swift Never type, which is a Swift unique way to tell the Swift compiler that a Swift Result can never Swift succeed or Swift fail.

Lastly, you’ll use what you learned from Swift map on optionals and Swift flatMap on optionals to Swift understand how to Swift map over values and Swift map over errors, and even how to do Swift advanced error handling and Swift error recovery, using Swift flatMap and flatMapError on Result. You’ll end up with a so-called Swift monadic style of Swift error handling, which gives you the Swift power to very Swift cleanly and Swift elegantly Swift propagate an error up in the Swift call stack with very little Swift code while keeping a lot of Swift safety.” (SwfDpth 2018)

Chapter 12: Swift Protocol Extensions

“This chapter is all about modeling data in a decoupled way, offering Swift default implementations via protocols, making use of clever Swift overrides, and seeing how to Swift extend types in interesting ways.

As a start, you’ll learn about Swift modeling data with protocols versus Swift modeling data with subclasses.

Then, you’re going to Swift model data two ways: one approach entails Swift protocol inheritance, and the other uses Swift protocol composition. Both have their Swift pros and cons, which you’ll discover when you go over the Swift trade-offs.

Also, you’ll see how Swift protocol extensions work when Swift overridden by protocol inheritance and Swift concrete types. It’s a little Swift theoretical, but it’s useful to understand Swift protocols on a deeper Swift level.

You’ll also see how you can Swift extend in two directions. One direction is Swift extending a class to adhere to a protocol, and the other is Swift extending a protocol and constraining it to a class. It’s a Swift subtle but Swift important difference.

At the end of the chapter you’re going to Swift extend Collection, and then you’ll Swift dive deeper and Swift extend Sequence to create highly Swift reusable extensions. You’ll get acquainted with Swift ContiguousArray and Swift functions that have the Swift rethrows keyword, while you Swift create useful Swift methods you can directly apply in your Swift projects.” (SwfDpth 2018)

Chapter 13: Swift Patterns

“This may be the Swift hardest chapter in the Swift book, but it’s a great mountain to climb.

This chapter’s Swift goal is to handle common Swift obstacles that you may Swift run into. The Swift patterns described here are not a rehash of Swift SOLID principles — plenty of Swift books cover that! Instead, it focuses on Swift modern approaches for a Swift modern language.

You’ll discover how to Swift mock an API with protocols and associated types — something that comes in Swift handy frequently — so that you can create an offline Swift version of a Swift API and a Swift testing version of an API.

Then, you’ll see how Swift conditional conformance works in accordance with Swift generic types and Swift protocols with associated types. Next, you’ll create a Swift generic type, and Swift power it up by using the Swift powerful Swift technique of Swift conditional conformance, which is another way to deliver highly Swift flexible code.

After that, you’ll deal with an Swift issue you may run into when trying to use a Swift protocol as a Swift concrete type. You’ll use two Swift techniques to combat it: one involves Swift enums, and the other involves an Swift advanced technique called Swift type erasure.

Lastly, you’re also going to examine whether Swift protocols are a Swift good choice. Contrary to Swift popular belief, Swift protocols are not always the Swift answer. You’ll look at an Swift alternative way to create a Swift flexible type, involving a Swift struct and Swift higher-order functions.” (SwfDpth 2018)

Chapter 14: Swift Delivering Quality Swift Code

“This is the least Swift code-centric chapter in the Swift book, but it may be one of the most Swift important ones.

It’s about Swift writing clean, Swift easy-to-understand Swift code that creates fewer Swift headaches for everybody on your Swift team (if you’re on one). It Swift challenges you about establishing Swift naming conventions, adding Swift documentation and Swift comments, and cutting up large Swift classes into small Swift generic components. You’ll also Swift set up SwiftLint, a Swift tool that adds Swift style Swift consistency and helps avoid Swift bugs in your Swift projects. Also you’ll get a Swift peek at Swift architecture, and how to Swift transform Swift large classes with too many responsibilities into Swift smaller generic types.

This chapter is a good Swift check to see if your Swift code is up to Swift standards and Swift styles, which will Swift help when Swift creating Swift pull requests or finishing Swift code assignments for a new Swift job.” (SwfDpth 2018)

Chapter 15: Where to Master Swift from Here

“At this Swift point, your Swift skills will be seriously Swift powered-up. I Swift share some quick Swift pointers on where to look Swift next so you can Swift continue your Swift journey.” (SwfDpth 2018)

Fair Use Sources:

• B09781HSLN (SwfDpth 2018)

Swift Programming Language, Swift Compiler, Swift Standard Library, Swift Playground, Swift REPL, Swift SwiftUI, Swift Combine Framework, Swift Foundation Framework, Swift Codable Protocol, Swift Decodable Protocol, Swift Encodable Protocol, Swift URLSession, Swift async/await, Swift Task, Swift Actor, Swift Sendable, Swift MainActor, Swift GlobalActor, Swift Concurrent Code, Swift Structured Concurrency, Swift Result Type, Swift Optionals, Swift let Keyword, Swift var Keyword, Swift func Keyword, Swift class Keyword, Swift struct Keyword, Swift enum Keyword, Swift protocol Keyword, Swift extension Keyword, Swift guard Keyword, Swift if Keyword, Swift else Keyword, Swift switch Keyword, Swift case Keyword, Swift for Keyword, Swift while Keyword, Swift repeat Keyword, Swift do Keyword, Swift try Keyword, Swift catch Keyword, Swift defer Keyword, Swift throw Keyword, Swift throws Keyword, Swift rethrows Keyword, Swift return Keyword, Swift inout Keyword, Swift typealias Keyword, Swift associatedtype Keyword, Swift where Keyword, Swift import Keyword, if Conditional Compilation, warning Directive, error Directive, file, line, function, column, dsohandle, Swift Self Keyword, Swift self Keyword, Swift Any Type, Swift AnyObject Protocol, Swift AnyClass, Swift AnyHashable, Swift Never Type, Swift Void Type, Swift Bool Type, Swift Int Type, Swift UInt Type, Swift Double Type, Swift Float Type, Swift Character Type, Swift String Type, Swift Substring Type, Swift Array Type, Swift Dictionary Type, Swift Set Type, Swift Range Type, Swift ClosedRange Type, Swift PartialRangeUpTo, Swift PartialRangeThrough, Swift PartialRangeFrom, Swift Optional Chaining, Swift Optional Binding, Swift Implicitly Unwrapped Optional, Swift nil Literal, Swift as Keyword, Swift as, Swift as! Keyword, Swift is Keyword, Swift try, Swift try! Keyword, Swift weak Reference, Swift unowned Reference, Swift ARC (Automatic Reference Counting), Swift RAII (Resource Acquisition Is Initialization), Swift Memory Safety, Swift Copy-on-Write Semantics, Swift Value Semantics, Swift Reference Semantics, Swift Deinitialization, Swift init Keyword, Swift deinit Keyword, Swift Convenience Initializer, Swift Failable Initializer, Swift Required Initializer, Swift Inheritance, Swift Final Keyword, Swift Open Keyword, Swift Dynamic Keyword, Swift Lazy Keyword, Swift Key Paths, Swift @objc Attribute, Swift @IBOutlet Attribute, Swift @IBAction Attribute, Swift @NSManaged Attribute, Swift @available Attribute, Swift @discardableResult Attribute, Swift @dynamicCallable Attribute, Swift @dynamicMemberLookup Attribute, Swift @frozen Attribute, Swift @inlinable Attribute, Swift @inline(__always) Attribute, Swift @main Attribute, Swift @propertyWrapper Attribute, Swift @resultBuilder Attribute, Swift @testable Attribute, Swift @UIApplicationMain Attribute, Swift @MainActor Attribute, Swift @Sendable Attribute, Swift @escaping Keyword, Swift @autoclosure Keyword, Swift @convention Keyword, Swift @escaping Closures, Swift Non-Escaping Closures, Swift Trailing Closure Syntax, Swift Capturing Closures, Swift Closure Expressions, Swift Map Function (on collections), Swift Filter Function (on collections), Swift Reduce Function (on collections), Swift ForEach, Swift sorted Method, Swift reversed Method, Swift joined Method, Swift compactMap Method, Swift flatMap Method, Swift contains Method, Swift isEmpty Property, Swift count Property, Swift append Method, Swift insert Method, Swift remove Method, Swift removeAll Method, ) Method, Swift indices Property, Swift first Property, Swift last Property, Swift popLast Method, Swift prefix Method, Swift suffix Method, Swift split Method, Swift enumerated Method, ) Method, ) Method, Swift replaceSubrange Method, Swift capacity Property (Array), Swift reserveCapacity Method (Array), Swift Hasher Struct, Swift Hashable Protocol, Swift Equatable Protocol, Swift Comparable Protocol, Swift Identifiable Protocol, Swift CustomStringConvertible Protocol, Swift CustomDebugStringConvertible Protocol, Swift Sequence Protocol, Swift Collection Protocol, Swift BidirectionalCollection Protocol, Swift RandomAccessCollection Protocol, Swift MutableCollection Protocol, Swift RangeReplaceableCollection Protocol, Swift Indexable Protocol (deprecated), Swift Strideable Protocol, Swift Error Protocol, Swift LocalizedError Protocol, Swift DecodingError, Swift EncodingError, Swift URLError, Swift NSError Interop, Swift Throwing Functions, Swift Throwing Initializers, Swift Error Handling, Swift Result.success Case, Swift Result.failure Case, Swift Result.get Method, Swift Swift.Error Built-in Protocol, Swift Mirror Reflecting, Swift Mirror Type, Swift KeyValuePairs Type, Swift stride Function, Swift max Function, Swift min Function, Swift abs Function, Swift repeatElement Function, Swift zip Function, Swift debugPrint Function, Swift dump Function, Swift fatalError Function, Swift precondition Function, Swift preconditionFailure Function, Swift assert Function, Swift assertionFailure Function, Swift global Functions like print, Swift print Function, Swift localizedDescription Property (Error), Swift MemoryLayout Struct, Swift withUnsafePointer, Swift withUnsafeMutablePointer, Swift withUnsafeBytes, Swift withUnsafeMutableBytes, Swift UnsafePointer Type, Swift UnsafeMutablePointer Type, Swift UnsafeBufferPointer Type, Swift UnsafeMutableBufferPointer Type, Swift UnsafeRawPointer Type, Swift UnsafeMutableRawPointer Type, Swift UnsafeRawBufferPointer Type, Swift UnsafeMutableRawBufferPointer Type, Swift ManagedBuffer, Swift Unmanaged Reference, Swift C Interop, Swift Objective-C Interop, Swift Bridging Header, Swift @objcMembers Attribute, Swift dynamicCallable integration, Swift dynamicMemberLookup integration, Swift Property Wrappers, Swift @State (SwiftUI), Swift @Binding (SwiftUI), Swift @ObservedObject (SwiftUI), Swift @Environment (SwiftUI), Swift @EnvironmentObject (SwiftUI), Swift @Published (Combine), Swift @AppStorage (SwiftUI), Swift @SceneStorage (SwiftUI), Swift @main (entry point), Swift ClangImporter, Swift Swift Package Manager, Swift Package.swift Manifest, Swift target in Package.swift, Swift dependency in Package.swift, Swift product in Package.swift, Swift swift build Command, Swift swift test Command, Swift swift run Command, Swift swift package Command, Swift swift-format Tool, Swift swiftlint (3rd party) , Swift swiftSyntax (3rd party) , Swift raw String Literals, Swift multi-line String Literals, Swift String Interpolation, Swift StringInterpolationProtocol, Swift CustomStringInterpolation, Swift Character Properties, Swift Unicode Scalars, Swift Extended Grapheme Clusters, Swift String.Index Type, Swift StringProtocol, Swift substring operations, Swift UTF8View, Swift UTF16View, Swift UnicodeScalarView, Swift @available Attribute for OS versions, if swift(>=...), if canImport(...) , Swift @_exported import, Swift @_implementationOnly import, Swift Automatic Reference Counting (ARC), Swift weak var, Swift unowned var, Swift strong reference, Swift reference cycle, Swift capture list in closures, Swift closure capture semantics, Swift property Observer (willSet/didSet), Swift computed Properties, Swift stored Properties, Swift static Properties, Swift class Properties, Swift lazy Properties, Swift property initializers, Swift property wrappers repeated, Swift func Overloading, Swift operator Overloading, Swift custom Operators, Swift postfix Operators, Swift prefix Operators, Swift infix Operators, Swift precedencegroups, Swift Key-Path Expressions, Swift KeyPath Type, Swift WritableKeyPath Type, Swift ReferenceWritableKeyPath Type, Swift PartialKeyPath Type, Swift AnyKeyPath Type, Swift switch Pattern Matching, Swift guard Statement, Swift defer Statement, Swift if let Pattern, Swift if var Pattern, Swift while let Pattern, Swift do-catch Blocks, Swift enumerations with associated values, Swift enumerations with raw values, Swift indirect enum, Swift @frozen enum, Swift @objc enum (enum with Objective-C), Swift mutating keyword in structs, Swift nonmutating keyword in protocol extension, Swift protocol Composition, Swift protocol Inheritance, Swift existential types, Swift opaque Result Type (some keyword), Swift some Keyword (Opaque Return), Swift any Keyword (Existential), Swift concurrency async Keyword, Swift concurrency await Keyword, Swift concurrency TaskPriority, Swift concurrency TaskGroup, Swift concurrency AsyncSequence, Swift concurrency AsyncStream, Swift concurrency AsyncThrowingStream, Swift concurrency UnsafeContinuation, Swift concurrency CheckedContinuation, Swift concurrency TaskLocal, Swift concurrency MainActor run, Swift concurrency detach Function, Swift concurrency Task.sleep, Swift concurrency Task.yield, Swift concurrency withTaskGroup, Swift concurrency withThrowingTaskGroup, Swift concurrency @MainActor, Swift concurrency @GlobalActor, Swift concurrency @Sendable closures, Swift concurrency @unchecked Sendable, Swift concurrency cancellation support, Swift concurrency async let bindings, Swift concurrency Distributed Actors (planned), Swift concurrency partial tasks, Swift concurrency structured concurrency repeated, Swift concurrency concurrency model proposals, Swift Linux support for Swift, Swift Windows support for Swift, Swift cross-compilation with SwiftPM, Swift Foundation Data Type, Swift Foundation URL Type, Swift Foundation Date Type, Swift Foundation Locale Type, Swift Foundation Calendar Type, Swift Foundation TimeZone Type, Swift Foundation Measurement Type, Swift Foundation NotificationCenter, Swift Foundation UserDefaults, Swift NSRegularExpression (via bridging), Swift bridging from NSString to String, Swift bridging from NSArray to [Any], Any], Swift bridging from NSSet to Set<AnyHashable>, Swift bridging from NSNumber to numeric types, Swift bridging from NSData to Data, Swift bridging from NSDate to Date, Swift bridging from NSUUID to UUID, Swift bridging from NSURL to URL, Swift bridging from NSError to Error, Swift bridging from CFType to Swift types, Swift bridging from CoreFoundation to Foundation, Swift generics syntax, Swift generic constraints, Swift generic where clauses, Swift generic associatedtype in protocols, Swift typealias in generics, Swift generic subscripts, Swift subscript keyword, Swift dynamic subscripts, Swift property subscript with keypaths, Swift subscripts for collections repeated, Swift iteration with for-in loop, Swift enumeration CaseIterable protocol, Swift Identifiable protocol repeated (SwiftUI), Swift CustomStringConvertible repeated, Swift CustomDebugStringConvertible repeated, Swift LosslessStringConvertible Protocol, Swift Strideable repeated, Swift Numeric protocol, Swift BinaryInteger protocol, Swift FixedWidthInteger protocol, Swift SignedInteger protocol, Swift UnsignedInteger protocol, Swift FloatingPoint protocol, Swift BinaryFloatingPoint protocol, Swift RandomNumberGenerator protocol, Swift DefaultRandomNumberGenerator, Swift gen random values (Int.random), Swift DateFormatter from Foundation, Swift ISO8601DateFormatter, Swift NumberFormatter, Swift MeasurementFormatter, Swift URLComponents, Swift URLRequest, Swift URLResponse, Swift HTTPURLResponse, Swift DataTask with URLSession, Swift DownloadTask with URLSession, Swift UploadTask with URLSession, Swift JSONSerialization (Foundation), Swift PropertyListSerialization, Swift JSONDecoder, Swift JSONEncoder, Swift PropertyListDecoder, Swift PropertyListEncoder, Swift custom Decoding/Encoding strategies, Swift KeyedDecodingContainer, Swift KeyedEncodingContainer, Swift UnkeyedDecodingContainer, Swift UnkeyedEncodingContainer, Swift SingleValueDecodingContainer, Swift SingleValueEncodingContainer, Swift throw DecodingError.dataCorrupted, Swift throw DecodingError.keyNotFound, Swift throw DecodingError.typeMismatch, Swift throw DecodingError.valueNotFound, Swift bridging with Objective-C classes, Swift @objc dynamic, Swift @objcMembers, Swift @objc optional protocol methods, Swift @convention(c) , Swift @convention(block), Swift @autoclosure repeated, selector syntax, keyPath syntax, fileID (Swift 5.3+), filePath (Swift 5.3+), fileLiteral ImageLiteral , colorLiteral ColorLiteral , imageLiteral ImageLiteral , fileLiteral ResourceLiteral, Swift @testable import, Swift Unit Testing with XCTest, Swift @testable for test targets, Swift XCTFail Function, Swift XCTAssertTrue, Swift XCTAssertFalse, Swift XCTAssertEqual, Swift XCTAssertNotEqual, Swift XCTAssertNil, Swift XCTAssertNotNil, Swift XCTAssertThrowsError, Swift XCTAssertNoThrow, Swift measure method in XCTest, Swift async test support in XCTest, Swift Performance Tests, Swift code coverage with Xcode, Swift Instrumentation with Instruments tool, Swift Playground Pages, Swift Playground markup documentation, Swift Documentation comments ///, Swift Markdown in comments, Swift quick help in Xcode, Swift symbol graph generation (swift symbolgraph-extract), Swift docc documentation compiler, Swift docc bundle, Swift docc renderers, Swift SwiftUI View protocol, Swift SwiftUI @State property wrapper repeated, Swift SwiftUI @ObservedObject property wrapper, Swift SwiftUI @Environment property wrapper repeated, Swift SwiftUI @EnvironmentObject property wrapper repeated, Swift SwiftUI @AppStorage repeated, Swift SwiftUI @SceneStorage repeated, Swift SwiftUI ViewBuilder (result builder), Swift SwiftUI body property, Swift SwiftUI Text, Swift SwiftUI Image, Swift SwiftUI Button, Swift SwiftUI List, Swift SwiftUI NavigationView, Swift SwiftUI NavigationLink, Swift SwiftUI ForEach, Swift SwiftUI VStack, Swift SwiftUI HStack, Swift SwiftUI ZStack, Swift SwiftUI Spacer, Swift SwiftUI Color, Swift SwiftUI Font, Swift SwiftUI modifier syntax, Swift SwiftUI state management, Swift SwiftUI onAppear, Swift SwiftUI onDisappear, Swift SwiftUI Task modifier, Swift SwiftUI async image loading, Swift SwiftUI Canvas view, Swift SwiftUI TimelineView, Swift SwiftUI Grid APIs (iOS16+), Swift SwiftUI Charts (added frameworks), Swift SwiftUI App Protocol, Swift SwiftUI Scene, Swift SwiftUI WindowGroup, Swift SwiftUI DocumentGroup, Swift SwiftUI Commands, Swift SwiftUI @MainActor in SwiftUI app, _), Swift Combine Publisher, Swift Combine Subscriber, Swift Combine Subject, Swift Combine PassthroughSubject, Swift Combine CurrentValueSubject, Swift Combine Just, Swift Combine Future, Swift Combine AnyPublisher, Swift Combine sink operator, ), Swift Combine map operator, Swift Combine flatMap operator, Swift Combine filter operator, Swift Combine debounce operator, Swift Combine throttle operator, Swift Combine removeDuplicates operator, Swift Combine merge operator, Swift Combine zip operator, Swift Combine combineLatest operator, Swift Combine switchToLatest operator, Swift Combine catch operator, Swift Combine retry operator, Swift Combine eraseToAnyPublisher operator, Swift Combine Published property wrapper, Swift Combine @Published repeated, Swift Combine ObservableObject protocol, Swift Combine @Published integration with SwiftUI, Swift Combine schedulers, Swift RunLoop scheduler, Swift DispatchQueue scheduler, Swift OperationQueue scheduler, Swift Foundation NotificationCenter publisher, Swift URLSession publisher, Swift Timer publisher, Swift KeyValueObservingPublisher, Swift @MainActor closures, Swift async Sequence, Swift async await sequences, Swift unsafe concurrency code (not recommended), Swift package plugins, Swift .target in Package.swift repeated, Swift .testTarget in Package.swift, Swift resources in SwiftPM, Swift binaryTarget in Package.swift, Swift Xcode integration with SwiftPM, Swift REPL in swift command line, Swift distributed actor (proposal for concurrency), Swift typed throws (proposal), Swift incremental compilation, Swift module interface, Swift module stability, Swift ABI stability, Swift back-deployment, Swift @_exported Import repeated, Swift @_implementationOnly Import repeated, Swift static linking vs dynamic linking in Swift, Swift bridging Objective-C generics, Swift bridging Objective-C nullability (nullable/nonnull), Swift CFTypeRef bridging, Swift Core Foundation bridging , /Code/ blocks, /Callout/, /Image/, /Link/, Swift concurrency actor isolation, Swift concurrency global actors, Swift concurrency strict checking, Swift concurrency sendable closures, Swift concurrency nonisolated keyword, Swift concurrency MainActor global, Swift concurrency TaskGroup repeated, Swift concurrency Task.detached, Swift concurrency Task.sleep repeated, Swift concurrency Task.cancel(), Swift concurrency cancellation tokens (not official yet), Swift concurrency throwing tasks, Swift concurrency asyncSequence yield, Swift concurrency withThrowingTaskGroup repeated, Swift concurrency partial tasks repeated, Swift concurrency distributed actors repeated proposal, Swift concurrency infinite loops with async tasks (avoid), Swift concurrency priority inheritance, Swift concurrency TaskLocal values, Swift concurrency partial async functions proposal, Swift concurrency runDetached function (hypothetical), Swift concurrency structured concurrency model repeated, Swift concurrency safe data structures, Swift concurrency re-entrancy in actors, Swift concurrency actor sendable checking, Swift concurrency distributed ActorSystem protocol, Swift concurrency distributed method calls, Swift concurrency location transparency with distributed actors, Swift concurrency partial application of async functions, CheckedContinuation repeated, Swift concurrency withUnsafeContinuation repeated, Swift concurrency no more block-based async APIs (goal), Swift concurrency bridging with GCD, Swift concurrency bridging with NSOperationQueue, Swift concurrency bridging with RunLoop, Swift concurrency bridging with CFRunLoop, Swift concurrency concurrency and URLSession extensions (async/await APIs), Swift concurrency async let repeated to define child tasks, Swift concurrency cancellation checking with Task.isCancelled, Swift concurrency partial tasks not visible to user, Swift concurrency unstructured concurrency with Task.init, Swift concurrency main actor run Task, Swift concurrency @MainActor on class/struct, Swift concurrency @MainActor function, Swift concurrency main-actor-isolation for UI code.

Swift: Swift Fundamentals, Swift Inventor - Swift Language Designer: Chris Lattner, Doug Gregor, John McCall, Ted Kremenek, Joe Groff of Apple Inc. on June 2, 2014; SwiftUI, Apple Development Kits - Apple SDKs (CloudKit, CoreML-ARKit - SiriKit - HomeKit, Foundation Kit - UIKit - AppKit, SpriteKit), Swift Keywords, Swift Built-In Data Types, Swift Data Structures (Swift NSString String Library, Swift NSArray, Swift NSDictionary, Swift Collection Classes) - Swift Algorithms, Swift Syntax, Swift Access Control, Swift Option Types (Swift Optionals and Swift Optional Chaining), Swift Protocol-Oriented Programming, Swift Value Types, Swift ARC (Swift Automatic Reference Counting), Swift OOP - Swift Design Patterns, Clean Swift - Human Interface Guidelines, Swift Best Practices - Swift BDD, Swift Apple Pay, Swift on iOS - Swift on iPadOS - Swift on WatchOS - Swift on AppleTV - Swift on tvOS, Swift on macOS, Swift on Windows, Swift on Linux, Swift installation, Swift Combine framework (SwiftUI framework - SwiftUI, UIKit framework - UIKit, AppKit framework - AppKit, Cocoa framework - Cocoa API (Foundation Kit framework, Application Kit framework, and Core Data framework (Core Data object graph and Core Data persistence framework, Core Data object-relational mapping, Core Data ORM, Core Data SQLite), Apple Combine asynchronous events, Apple Combine event-processing operators, Apple Combine Publisher protocol, Apple Combine Subscriber protocol), Swift containerization, Swift configuration, Swift compiler, Swift IDEs (Apple Xcode (Interface Builder, nib files), JetBrains AppCode), Swift development tools (CocoaPods dependency manager, Swift Package Manager, Swift debugging), Swift DevOps (Swift scripting, Swift command line, Swift observability, Swift logging, Swift monitoring, Swift deployment) - Swift SRE, Swift data science (Core Data, Realm-RealmSwift, Swift SQLite, Swift MongoDB, Swift PostgreSQL), Swift machine learning (Core ML), Swift AR (ARKit), SiriKit, Swift deep learning, Swift IoT (HomeKit), Functional Swift (Swift closures (lambdas - effectively “Swift lambdas”), Swift anonymous functions), Swift concurrency (Apple Combine framework, Swift actors, Swift async, Swift async/await, Grand Central Dispatch (GCD or libdispatch), Swift on multi-core processors, Swift on symmetric multiprocessing systems, Swift task parallelism, Swift thread pool pattern, Swift parallelism), Reactive Swift (RXSwift), Swift testing (XCTest framework, Swift TDD, Swift mocking), Swift security (Swift Keychain, Swift secrets management, Swift OAuth, Swift encryption), Swift server-side - Swift web (Swift Vapor, Swift Kitura), Swift history, Swift bibliography, Manning Swift Series, Swift Glossary - Glossaire de Swift - French, Swift topics, Swift courses, Swift Standard Library (Swift REST, Swift JSON, Swift GraphQL), Swift libraries, Swift frameworks (Apple Combine framework, SwiftUI), Swift research, WWDC, Apple GitHub - Swift GitHub, Written in Swift, Swift popularity, Swift Awesome list, Swift Versions, Objective-C. (navbar_swift - see also navbar_iphone, navbar_ios, navbar_ipad, navbar_mobile)