Swift Fundamentals
Swift Fundamentals teaches core Swift concepts—types, optionals, control flow, functions, closures, structs, classes, protocols, and extensions—enabling developers to write clean, type‑safe code without framework dependencies.
Who Should Take This
It is ideal for software engineers, mobile developers, or computer‑science graduates who have basic programming experience and want to master Swift’s language fundamentals before tackling iOS frameworks or advanced topics. The curriculum builds on that foundation, guiding learners through practical exercises that reinforce type safety, abstraction, and code reuse, preparing them for real‑world Swift development.
What's Included in AccelaStudy® AI
Adaptive Knowledge Graph
Practice Questions
Lesson Modules
Console Simulator Labs
Exam Tips & Strategy
20 Activity Formats
Course Outline
61 learning goals
1
Types & Optionals
3 topics
Value types and reference types
- Identify Swift value types (Int, Double, Float, String, Bool, Character, Array, Dictionary, Set, structs, enums, tuples) and reference types (classes, closures) and describe their copy-on-assignment behavior.
- Explain type safety, type inference with let and var, and explicit type annotations, and describe when type annotations are required versus when inference is sufficient.
- Implement type aliases with typealias and describe how tuples group multiple values into a single compound value with labeled or positional access.
Optionals
- Describe Optional
as an enum with .some(T) and .none cases and explain why Swift uses optionals instead of null references. - Implement optional binding with if let, guard let, and while let to safely unwrap optionals and access their contained values.
- Implement nil coalescing (??), optional chaining (?.), and forced unwrapping (!) and explain the safety trade-offs of each approach.
- Analyze optional usage patterns to determine when guard let provides clearer early-exit semantics versus if let nesting and when forced unwrapping is justified.
Strings and characters
- Describe String as a value type with Unicode support, string interpolation (\()), multi-line string literals, and the Character type for individual Unicode grapheme clusters.
- Implement string operations including concatenation, substring extraction with String.Index, prefix/suffix checking, and iteration over characters.
- Explain why Swift strings do not support integer subscripting and how String.Index-based access preserves Unicode correctness for multi-byte characters.
2
Control Flow & Functions
2 topics
Conditional and loop statements
- Implement if/else, guard, and switch statements with pattern matching including value binding, where clauses, tuple matching, and interval matching.
- Implement for-in loops with ranges (closed and half-open), stride, while, and repeat-while loops for iteration patterns.
- Describe the guard statement's early exit pattern and explain how it differs from if let in terms of scope and readability for precondition checking.
- Compare switch exhaustiveness checking in Swift versus other languages and analyze how enum-based switches ensure all cases are handled at compile time.
Function declarations
- Describe function syntax with argument labels, parameter names, return types, and the distinction between external and internal parameter names.
- Implement functions with default parameter values, variadic parameters (...), inout parameters, and the omitted argument label (_).
- Implement function types as parameter types and return types to create higher-order functions that accept or return other functions.
- Implement nested functions and explain how they capture values from their enclosing function's scope.
3
Closures
2 topics
Closure syntax and shortcuts
- Describe closure expression syntax ({ (params) -> ReturnType in body }) and explain how closures are unnamed function values that capture their surrounding context.
- Implement closures using shorthand argument names ($0, $1), implicit returns, trailing closure syntax, and operator methods as closures.
- Implement multiple trailing closures in API calls that accept more than one closure parameter.
Capturing and escaping
- Explain how closures capture variables by reference from their enclosing scope and how capture lists ([weak self], [unowned self]) prevent retain cycles.
- Implement @escaping closures for asynchronous callbacks and completion handlers and explain why escaping closures require explicit self references.
- Describe @autoclosure for wrapping expressions in closures automatically and explain its use in short-circuit evaluation patterns like assert.
- Analyze closure capture semantics to identify potential retain cycles in class-based code and determine when to use weak versus unowned capture.
4
Structs & Classes
4 topics
Structs versus classes
- Describe structs as value types and classes as reference types and explain how assignment and passing creates copies for structs versus shared references for classes.
- Implement memberwise initializers for structs and designated initializers for classes including initializer delegation with self.init and super.init.
- Implement convenience initializers and failable initializers (init?) that return nil when initialization cannot complete with valid state.
- Describe Automatic Reference Counting (ARC) for classes, strong reference cycles, and how weak and unowned references break cycles between class instances.
- Analyze scenarios to determine when to use a struct versus a class based on value semantics, identity, inheritance needs, and ARC overhead.
Enumerations
- Describe Swift enumerations as first-class types with raw values, associated values, computed properties, and methods.
- Implement enums with associated values to model variants that carry different data and use switch pattern matching to extract associated values.
- Implement recursive enumerations with the indirect keyword to model tree-like data structures such as arithmetic expressions.
Properties
- Describe stored properties, computed properties (get/set), lazy stored properties, and the difference between instance and type (static/class) properties.
- Implement property observers (willSet and didSet) to respond to property value changes and explain when they fire versus when they do not.
- Implement lazy properties for expensive computations and explain the thread safety implications and the requirement for var declaration.
Inheritance and access control
- Describe class inheritance, method overriding with the override keyword, preventing overrides with final, and the class hierarchy from a base class.
- Implement class hierarchies with overridden methods and properties, calling super methods, and type casting with as, as?, and as!.
- Describe access control levels (open, public, internal, fileprivate, private) and explain how they restrict visibility across modules and source files.
- Evaluate when to use class inheritance versus protocol conformance and composition for code reuse and polymorphism in Swift.
5
Protocols & Extensions
3 topics
Protocol definitions and conformance
- Describe protocols as blueprints for methods, properties, and other requirements that conforming types must implement.
- Implement protocols with required methods, property requirements (get/get set), and mutating method requirements for value types.
- Implement protocol inheritance to build protocol hierarchies and adopt multiple protocols on a single type using protocol composition (Protocol1 & Protocol2).
- Describe the Equatable, Hashable, Comparable, and Codable protocols and explain how compiler-synthesized conformance works for simple types.
Protocol extensions and default implementations
- Implement protocol extensions that provide default method implementations so conforming types inherit behavior without explicit implementation.
- Implement constrained protocol extensions with where clauses to add methods only when the conforming type meets additional requirements.
- Analyze the dispatch behavior of protocol extension methods versus protocol requirement methods to predict whether a default or overridden implementation executes.
Extensions
- Describe extensions as a mechanism to add computed properties, methods, initializers, subscripts, and protocol conformance to existing types without subclassing.
- Implement extensions on standard library types (String, Int, Array) to add convenience methods and computed properties for domain-specific operations.
- Implement retroactive protocol conformance by adding protocol conformance to existing types through extensions.
- Evaluate extension design to determine when to use extensions for organizing code (protocol conformance per extension) versus when extensions fragment a type's implementation unnecessarily.
6
Collections & Generics
2 topics
Collection types
- Describe Array, Dictionary, and Set as generic collection types and explain their value-type semantics with copy-on-write optimization.
- Implement Array operations including append, insert, remove, filter, map, reduce, compactMap, flatMap, sorted, and first(where:).
- Implement Dictionary operations including subscript access, updateValue, removeValue, merging, and iteration over keys, values, and key-value pairs.
- Implement Set operations including union, intersection, subtraction, symmetric difference, and set membership testing for efficient collection comparisons.
- Compare Array, Dictionary, and Set to select the appropriate collection based on ordering, uniqueness, key-based access, and performance requirements.
Generics
- Describe generic functions and generic types with type parameters (
) and explain how they enable writing flexible, reusable code that works with any type. - Implement generic type constraints with protocol conformance requirements (T: Comparable) and where clauses for complex multi-parameter constraints.
- Implement associated types in protocols to create generic protocols and explain how the associatedtype keyword differs from generic type parameters.
- Describe opaque return types (some Protocol) and explain how they hide concrete types while preserving type identity across function calls.
- Analyze generic design to determine the minimal type constraints needed and evaluate when to use generic parameters, associated types, or opaque return types.
Hands-On Labs
15 labs
~375 min total
Console Simulator
Practice in a simulated cloud console or Python code sandbox — no account needed. Each lab runs entirely in your browser.
Scope
Included Topics
-
Swift 5.10+ language fundamentals: value types (Int, Double, String, Bool, Character), reference types, optionals (Optional
, ?, !), optional chaining, nil coalescing, and forced unwrapping. - Control flow: if/else, guard statements, switch with pattern matching and value binding, for-in loops, while/repeat-while, labeled statements, and early exit patterns.
- Functions: parameter labels, default values, inout parameters, variadic parameters, function types, and nested functions.
- Closures: closure syntax, trailing closures, capturing values, escaping closures (@escaping), autoclosures (@autoclosure), and closure as completion handlers.
- Structs and classes: value semantics versus reference semantics, properties (stored, computed, lazy, property observers), initializers (designated, convenience, failable), deinit, and ARC basics.
- Protocols: protocol definition, protocol conformance, protocol inheritance, protocol extensions with default implementations, associated types, and the Codable/Hashable/Equatable protocols.
- Extensions: adding computed properties, methods, initializers, and protocol conformance to existing types.
- Collections: Array, Dictionary, Set, and generics including generic functions, generic types, type constraints, and where clauses.
Not Covered
- SwiftUI, UIKit, AppKit, and any UI framework APIs.
- Combine framework, reactive programming, and async/await concurrency beyond basic awareness.
- Xcode project configuration, Interface Builder, storyboards, and iOS/macOS SDK specifics.
- Core Data, CloudKit, and persistence frameworks.
- Swift Package Manager advanced configuration and plugin system.
- Property wrappers implementation (basic @Published/@State awareness excluded, implementation details excluded).
Ready to master Swift Fundamentals?
Adaptive learning that maps your knowledge and closes your gaps.
Subscribe to Access