Swift Conditional Type Cast

let result = expression as? TargetType

if let unwrappedResult = expression as? TargetType {
    // unwrappedResult is of type TargetType (non-optional)
    // This block only executes if the runtime cast succeeds.
}

​

Technical Mechanics

• Type Signature: If expression is of type A and the target type is B, the resulting type of the as? operation is strictly B? (or Optional<B>).
• Runtime Evaluation: While the Swift compiler performs static checks to ensure the cast is structurally possible, the actual type resolution, memory layout verification, and protocol conformance checks occur dynamically at runtime.
• Memory and Semantics: The behavior of as? depends on the memory semantics of the types involved:
  • Reference Types: When casting between class instances, as? does not mutate the underlying instance or allocate new memory for the object. It returns a new reference, typed as the target Optional, pointing to the existing memory address.
  • Value Types and Type Erasure: When casting from a type-erased container (such as Any or AnyObject) or an existential protocol to a value type (such as a struct, enum, Int, or String), as? extracts and copies the underlying value. This process does not return a reference and can involve allocating new memory for the copied value.
  • Bridged Types: When casting between bridged Objective-C and Swift types (e.g., NSString to String or NSArray to [Int]), as? performs a bridging conversion. This extracts the underlying value and often allocates new memory to construct the native Swift value type.

​

Syntax Visualization

class Base {}
class Derived: Base {}
struct CustomValue {}

let classInstance: Base = Derived()
let erasedValue: Any = CustomValue()
let erasedPrimitive: Any = 42

// Reference type downcast:
// Type is Derived?, value is Optional.some(Derived)
// Points to the existing memory address.
let castClass = classInstance as? Derived 

// Value type extraction from Any:
// Type is CustomValue?, value is Optional.some(CustomValue)
// Extracts and copies the underlying struct.
let castStruct = erasedValue as? CustomValue

// Primitive extraction from Any:
// Type is Int?, value is Optional.some(42)
let castInt = erasedPrimitive as? Int

// Failing cast:
// Type is String?, value is Optional.none (nil)
let castFail = erasedPrimitive as? String

// Protocol casting (Swift 6 requires 'any' for existential types):
// Type is (any CustomStringConvertible)?, evaluates dynamically
let protocolCast = classInstance as? any CustomStringConvertible

​

Contrast with Other Cast Operators and Contexts

• as (Upcast / Coercion): Performed at compile-time. Used when casting to a superclass, an existential type, or performing a guaranteed compiler-checked conversion. Returns a non-optional.
• as! (Forced Downcast): Performed at runtime. Assumes the cast will definitively succeed. It returns a non-optional target type (T) but will trigger a fatal runtime trap if the underlying instance does not match the target type. The as? operator is the safe, optional-returning alternative to as!.
• Pattern Matching (switch / catch): A common point of confusion is how type casting works within pattern matching. While as? is required for conditional casting in standard expressions, switch statements and catch blocks use the as keyword for conditional pattern matching. In these contexts, the compiler implicitly handles the conditional check and unwrapping, meaning as? is not used:

switch erasedPrimitive {
case let value as String:
    // Matches if erasedPrimitive can be cast to String.
    // 'value' is bound as a non-optional String.
case let value as Int:
    // Matches if erasedPrimitive can be cast to Int.
    // 'value' is bound as a non-optional Int.
default:
    break
}