Swift MCQ

Explanation

Apple introduced Swift at WWDC 2014 as a replacement for Objective-C for iOS, macOS, and other Apple platform development.

Explanation

let declares an immutable constant; var declares a mutable variable. Prefer let unless mutation is needed.

Explanation

Optional<T> (shorthand T?) represents a value that may or may not exist. Must be unwrapped to access the value.

Explanation

if let name = optName { use name } safely unwraps optName, executing the block only if it is non-nil.

Explanation

Structs are value types in Swift — assignment and function passing copies the entire struct. Most standard library types (Array, String, Int) are structs.

Explanation

Classes are reference types (heap, shared identity). Structs are value types (copied). Classes support inheritance; structs don't.

Explanation

Protocols define contracts like Java interfaces. Classes, structs, and enums can all conform to protocols.

Explanation

guard let x = optX else { return } unwraps optX and makes x available in the rest of the function. It reduces nesting vs if-let chains.

Explanation

let name = optName ?? "Anonymous" returns optName's value if not nil, otherwise "Anonymous".

Explanation

Swift enums are first-class types that can have associated values, raw values, computed properties, and methods.

Explanation

enum Result { case success(Int); case failure(Error) } stores specific data per case. Switch over it with case .success(let n): to extract the value.

Explanation

"Hello, \(name)!" embeds the value of name into the string literal.

Explanation

Structs are value types, so by default methods cannot modify self. mutating func allows property changes inside the method.

Explanation

Closures in Swift are similar to lambdas. { (x: Int) -> Int in return x * 2 } can be shortened to { x in x * 2 } or even { $0 * 2 }.

Explanation

Without @escaping, a closure must be used synchronously. @escaping allows the closure to be stored or called asynchronously after the function returns.

Explanation

defer { cleanup() } ensures cleanup() runs when the function exits — even via return, throw, or error. Useful for resource cleanup.

Explanation

var area: Double { get { return width * height } } computes area dynamically each time it's accessed.

Explanation

lazy var expensiveResource = HeavyObject() defers initialization until first use. Must be var; let cannot be lazy.

Explanation

Result<T, E: Error> is a Swift standard type for functions that can succeed or fail without throwing.

Explanation

If A holds a strong reference to B and B holds a strong reference to A, neither is deallocated. Break cycles with weak or unowned references.

Explanation

weak var delegate: MyDelegate? doesn't increase the retain count. When the object deallocates, the weak reference becomes nil.

Explanation

unowned let customer: Customer assumes customer outlives the dependent object. Use when the referenced object always has a longer lifetime. Accessing a deallocated unowned reference crashes.

Explanation

ARC automatically deallocates class instances when their reference count drops to zero. Structs and enums are value types and do not use ARC.

Explanation

Declarations in Swift default to internal access — accessible within the same module but not outside. open is the most permissive (subclassable from other modules).

Explanation

func parse() throws must be called with try: let result = try parse(). Errors propagate or are caught with do { try } catch { }.

Explanation

let val = try? parse() returns Optional<T>. If parsing succeeds, val wraps the result; if it throws, val is nil.

Explanation

func swap<T>(_ a: inout T, _ b: inout T) works for any type T. Generics provide type safety without code duplication.

Explanation

where clauses add extra type constraints. extension Array where Element: Equatable adds methods only when Element conforms to Equatable.

Explanation

For performance-critical code with class or protocol types, ContiguousArray avoids NSArray bridging overhead by guaranteeing contiguous storage.

Explanation

var score: Int = 0 { willSet { print("About to set \(newValue)") } didSet { print("Set from \(oldValue)") } }

Explanation

typealias Completion = (Result<Data, Error>) -> Void creates a readable alias for a complex closure type.

Explanation

func increment(_ n: inout Int) { n += 1 }; increment(&count) modifies count in place.

Explanation

@discardableResult on a function prevents the "result of call is unused" warning when callers choose not to use the return value.

Explanation

Swift switch must be exhaustive. When switching over an enum, each case must be handled. No implicit fall-through (use fallthrough explicitly if needed).

Explanation

let point = (x: 3, y: 4) groups values. Access with point.x or let (x, y) = point. Good for simple return values without defining a full struct.

Explanation

array.sort() { $0 < $1 } or array.sort { $0 < $1 } are trailing closure forms of sort(by:). Improves readability for long closures.

Explanation

var body: some View in SwiftUI returns a specific concrete type that conforms to View, without revealing the exact type to callers.

Explanation

Swift 5.7 requires any to signal existential types (var shape: any Shape), distinguishing them from concrete types and opaque types (some Shape).

Explanation

[1, 2, 3].map { $0 * 2 } returns [2, 4, 6]. map, filter, reduce, and flatMap are core Swift collection functions.

Explanation

@propertyWrapper struct Clamped<T> { ... } allows @Clamped(0...100) var progress: Int. SwiftUI uses @State, @Binding, @Published as property wrappers.

Explanation

async/await (Swift 5.5) replaces nested completion handlers with sequential-looking code that suspends at await points without blocking the thread.

Explanation

actor BankAccount { var balance: Int } serializes access to balance. External code must await to access actor-isolated state.

Explanation

@MainActor class ViewModel { } or @MainActor func updateUI() guarantees execution on the main actor, crucial for UI updates.

Explanation

withTaskGroup(of: Int.self) { group in group.addTask { await fetchValue() } } manages concurrent tasks with structured lifetimes.

Explanation

POP (Apple's WWDC 2015 talk) favors protocol extensions for shared behavior over class inheritance, enabling composition and working with value types.

Explanation

extension Collection where Element: Equatable { func unique() -> [Element] { ... } } provides default methods to all conforming Collection types.

Explanation

protocol Container { associatedtype Element; func append(_ item: Element) } — conforming types define what Element is.

Explanation

With value types (struct/enum), each copy is independent. With reference types (class), all variables pointing to the same object see the mutation.

Explanation

func assert(_ cond: @autoclosure () -> Bool) { if !cond() { ... } } allows calling assert(x > 0) without the caller explicitly wrapping in {}.

Explanation

Sendable types can be safely transferred across actor boundaries. Value types with Sendable properties are implicitly Sendable. The compiler enforces this.

Explanation

var b = a; b.append(1) — only when b is actually mutated does Swift create a new storage copy. This makes large-array assignment cheap.

Explanation

Types conforming to Hashable (which implies Equatable) can be stored in Set and used as Dictionary keys. Structs synthesize conformance if all stored properties are Hashable.

Explanation

struct User: Codable { var name: String; var age: Int } can be encoded to JSON with JSONEncoder and decoded with JSONDecoder automatically.

Explanation

Static dispatch enables inlining and is faster. Mark classes final for static dispatch. Protocol methods use witness tables (dynamic). Classes use vtables.

Explanation

@objc func handleTap(_ sender: UIButton) makes the method callable as a selector. Required for target-action, KVO, and Objective-C delegation.

Explanation

@dynamicMemberLookup enables point.x syntax for types that implement subscript(dynamicMember key: String). Used by Swift for Python/JSON DSLs.

Explanation

do-try-catch works well for synchronous code. Result<T, E> is useful when the outcome needs to be stored, passed in closures, or the caller controls when to handle it.

Explanation

@Published var name = "" in an ObservableObject class sends a Combine publisher event on each change. SwiftUI subscribes and re-renders views.

Explanation

\User.name creates a KeyPath<User, String>. Use with users.map(\User.name) or keyPath syntax in Combine/SwiftUI binding.

Explanation

@State var count = 0 stores state owned by the view. When count changes, SwiftUI re-renders the view. Pass to children with @Binding.

Explanation

@Binding var isOn: Bool in a child view connects to $isOn from the parent's @State. Changes in the child propagate back to the parent.

Explanation

@ObservedObject var viewModel: MyViewModel causes re-renders when viewModel's @Published properties change. The view does not own the object.

Explanation

Use @StateObject when a view creates its own view model. Use @ObservedObject when a parent passes the view model in. @StateObject survives parent re-renders.

Explanation

Combine provides Just, Future, PassthroughSubject, and operators like map, filter, flatMap, debounce for reactive pipelines.

Explanation

PassthroughSubject<Int, Never> lets you call send(5) to emit values imperatively. Used to bridge non-Combine code into Combine pipelines.

Explanation

let data = try await withCheckedThrowingContinuation { cont in oldAPI { result in cont.resume(returning: result) } } converts callbacks to async.

Explanation

protocol Sequence { associatedtype Element } — if conforming type doesn't specify Element, the default applies. Reduces conformance boilerplate for common cases.

Explanation

var drawable: any Drawable stores up to 3 words inline; larger values heap-allocate. Plus 1 word for type metadata and 1 for the witness table. This overhead justifies preferring generics.

Explanation

@discardableResult on functions returning Self (for chaining) lets callers chain without needing the return value, avoiding warnings.

Explanation

extension Optional: Equatable where Wrapped: Equatable means Optional<Int> is Equatable but Optional<UIView> is not. Powerful for composable conformances.

Explanation

@dynamicCallable struct PythonObject { func dynamicallyCall(withKeywordArguments: [String: Any]) -> PythonObject } enables obj(x: 1, y: 2) call syntax.

Explanation

withUnsafeMutablePointer(to: &value) { ptr in ptr.pointee = 42 } — the pointer is only valid within the closure and must not escape.

Explanation

var str: AttributedString = "Hello"; str.font = .bold enables type-safe attribute access. Unlike NSAttributedString, attributes are accessed as typed properties.

Explanation

let stream = AsyncStream<Int> { cont in timer.onTick { value in cont.yield(value) } } bridges timer callbacks into for await loops.

Explanation

The compiler flags non-isolated async calls to @MainActor properties, requiring await actor.property. This prevents data races at compile time.

Explanation

Swift package plugins (SPM 5.6+) run during build (CommandPlugin, BuildToolPlugin). Used for source code generation, protobuf compilation, and other pre-build tasks.

Explanation

nonisolated func computeHash() on an actor can be called synchronously from any context, since it only accesses non-isolated (Sendable) data.

Explanation

@TaskLocal static var requestId: String = ""; TaskLocal.$requestId.withValue("req-1") { await handler() } propagates requestId through all child tasks.

Explanation

func retry<C: Clock>(clock: C) { await clock.sleep(for: .seconds(1)) } accepts a TestClock in tests to advance time without actual waits.

Explanation

let value = await withCheckedContinuation { continuation in nonThrowingCallback { result in continuation.resume(returning: result) } }

Explanation

Swift structured concurrency (async let, TaskGroup) guarantees all child tasks complete before the parent exits, making cancellation, error propagation, and cleanup deterministic.

Explanation

var shapes: [any Shape] requires Swift 5.7. Pre-5.7, PATs (protocols with associated types) required type erasure wrappers like AnyCollection.

Explanation

When the concrete type is known at compile time, Swift may emit a specialized copy of a generic function with inlined type information, avoiding the overhead of existential boxing.

Explanation

Swift metadata includes type descriptors and protocol witness tables. Generic code uses metadata to perform operations on unknown types (copy, destroy, cast).

Explanation

@resultBuilder struct ViewBuilder transforms multiple child view expressions into a single TupleView. Used for HTML, SQL, and any embedded DSL.

Explanation

Swift's actor runtime uses a cooperative thread pool (default: number of CPUs). Tasks yield at await points rather than blocking threads, maximizing throughput.

Explanation

struct FileHandle: ~Copyable disables copying. The value must be moved or consumed. Enables RAII patterns and unique-ownership types at the language level.

Explanation

some View has static type identity — the compiler knows the exact type. any View boxes any conforming type at runtime with dynamic dispatch overhead.

Explanation

Swift 5.9 macros (declaration, expression, accessor) use SwiftSyntax to generate boilerplate at compile time. #Preview and @Observable use this mechanism.

Explanation

@Observable (Swift 5.9 / iOS 17) uses macros to instrument property access. SwiftUI views automatically track which properties they access and re-render on changes.

Explanation

Protocol witness tables (PWTs) enable dynamic dispatch for existential types (any P). Generic code with where constraints avoids PWTs via static dispatch.

Explanation

WMO (-whole-module-optimization) compiles all Swift files as one unit. The compiler can inline across file boundaries and remove unused generics, improving performance significantly.

Explanation

MemoryLayout<Int>.size = 8 on 64-bit. MemoryLayout<(Int, Bool)>.stride = 16 (padding). Needed for C struct interop and performance analysis.

Explanation

Task { @Sendable in nonSendableCapture } fails. The compiler requires that values crossing actor/task boundaries are Sendable to prevent data races.

Explanation

_modify is part of Swift's coroutine-based accessor model. It yields an inout reference, enabling operations like array[0] += 1 to work in-place without copying.

Explanation

Unmanaged<CFString>.passRetained(str).toOpaque() passes a retained CF object. takeRetainedValue() / takeUnretainedValue() control whether ARC gets ownership.

Explanation

Generic functions receive implicit metadata parameters for each type parameter. The runtime uses metadata for copy, destroy, and protocol conformance operations on unknown types.

Explanation

func getNumbers() -> some Collection<Int> says "returns a specific Collection with Int elements" without revealing the concrete type (Array, Set, etc.).

Explanation

let balance = account.balance; await transfer(); // balance may be stale here! Between the await, another Task may have changed balance. Re-read state after every suspension.

Explanation

withTaskGroup(of: T.self) { group in group.addTask { work1() }; group.addTask { work2() }; for try await result in group { collect(result) } } manages dynamic concurrency.