Swift

Advanced Swift Features Demonstration:

// Protocol with associated types
protocol Container {
    associatedtype Item
    mutating func add(_ item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}

// Generic implementation with value semantics
struct Stack<Element>: Container {
    var items = [Element]()
    
    // Protocol conformance
    mutating func add(_ item: Element) {
        items.append(item)
    }
    
    var count: Int {
        return items.count
    }
    
    subscript(i: Int) -> Element {
        return items[i]
    }
    
    // Using higher-order functions
    func map<T>(_ transform: (Element) -> T) -> Stack<T> {
        var mappedStack = Stack<T>()
        for item in items {
            mappedStack.add(transform(item))
        }
        return mappedStack
    }
}

// Memory safety with copy-on-write semantics
var stack1 = Stack<Int>()
stack1.add(10)
var stack2 = stack1  // No copying occurs yet (optimization)
stack2.add(20)       // Now stack2 gets its own copy of the data
        

Advanced Syntax Comparison:

// Swift Protocol with Associated Type and Extensions
protocol Convertible {
    associatedtype ConvertedType
    func convert() -> ConvertedType
}

// Extension adding functionality to a type
extension String: Convertible {
    typealias ConvertedType = Int
    
    func convert() -> Int {
        return Int(self) ?? 0
    }
    
    // Computed property
    var wordCount: Int {
        return self.components(separatedBy: .whitespacesAndNewlines)
            .filter { !$0.isEmpty }.count
    }
}

// Usage with trailing closure syntax
let numbers = ["1", "2", "3"].map { $0.convert() }
        

// Objective-C Protocol with Associated Type (pre-Swift)
@protocol Convertible <NSObject>
- (id)convert;
@end

// Category adding functionality
@interface NSString (Convertible) <Convertible>
- (NSInteger)convert;
- (NSInteger)wordCount;
@end

@implementation NSString (Convertible)
- (NSInteger)convert {
    return [self integerValue];
}

- (NSInteger)wordCount {
    NSArray *words = [self componentsSeparatedByCharactersInSet:
                     [NSCharacterSet whitespaceAndNewlineCharacterSet]];
    NSPredicate *predicate = [NSPredicate predicateWithFormat:@"length > 0"];
    NSArray *nonEmptyWords = [words filteredArrayUsingPredicate:predicate];
    return [nonEmptyWords count];
}
@end

// Usage with blocks
NSArray *strings = @[@"1", @"2", @"3"];
NSMutableArray *numbers = [NSMutableArray array];
[strings enumerateObjectsUsingBlock:^(NSString *obj, NSUInteger idx, BOOL *stop) {
    [numbers addObject:@([obj convert])];
}];
        

Memory Layout and Performance Characteristics:

import Swift

// Memory sizes
print(MemoryLayout<Int>.size)           // 8 bytes on 64-bit systems
print(MemoryLayout<Double>.size)        // 8 bytes
print(MemoryLayout<Bool>.size)          // 1 byte
print(MemoryLayout<Character>.size)     // 16 bytes (stores Unicode scalar)

// Type boundaries
let minInt = Int.min                    // -9223372036854775808 on 64-bit
let maxInt = Int.max                    // 9223372036854775807 on 64-bit
let doublePrec = Double.ulpOfOne        // 2.22e-16 (unit of least precision)

// String internals - Unicode-aware
let emoji = "👨‍👩‍👧‍👦"                    // Family emoji
print(emoji.count)                      // 1 (one grapheme cluster)
print(emoji.unicodeScalars.count)       // 7 (composed of multiple Unicode scalars)
        

// Integer Types and Characteristics
let defaultInt = Int.max          // 9223372036854775807 on 64-bit systems
let specificInt: Int16 = 32767    // Maximum value for Int16
let unsignedInt: UInt = 100       // Unsigned integer

// Binary, Octal, and Hexadecimal literals
let binary = 0b1010               // 10 in binary
let octal = 0o12                  // 10 in octal
let hexadecimal = 0xA             // 10 in hexadecimal

// Integer operations and overflow handling
let a = Int.max
// let willOverflow = a + 1       // Would cause runtime error in debug
let overflowing = a &+ 1          // -9223372036854775808 (wraps around using overflow operator)

// Bit manipulation
let bitAnd = 0b1100 & 0b1010      // 0b1000 (8)
let bitOr = 0b1100 | 0b1010       // 0b1110 (14)
let bitXor = 0b1100 ^ 0b1010      // 0b0110 (6)
let bitShift = 1 << 3             // 8 (left shift by 3 bits)
        

// IEEE-754 Characteristics
let doubleEpsilon = Double.ulpOfOne    // Approximately 2.2204460492503131e-16
let floatEpsilon = Float.ulpOfOne      // Approximately 1.1920929e-07

// Special values
let infinity = Double.infinity
let notANumber = Double.nan
let pi = Double.pi                     // 3.141592653589793
let e = Darwin.M_E                     // 2.718281828459045 (requires import Darwin)

// Decimal precision
let precisionExample: Double = 0.1 + 0.2    // 0.30000000000000004 (not exactly 0.3)

// Efficient calculation with Numeric protocol
func sumOf(_ numbers: [T]) -> T {
    return numbers.reduce(0, +)
}
let doubles = [1.5, 2.5, 3.5]
print(sumOf(doubles))    // 7.5
        

// Boolean optimization and usage patterns
let condition1 = true
let condition2 = false

// Short-circuit evaluation
if condition1 || expensiveComputation() {  // expensiveComputation() never gets called
    // ...
}

// Toggle method (Swift 4.2+)
var mutableBool = true
mutableBool.toggle()    // Now false

// Conformance to ExpressibleByBooleanLiteral
struct BoolWrapper: ExpressibleByBooleanLiteral {
    let value: Bool
    
    init(booleanLiteral value: Bool) {
        self.value = value
    }
}
let wrapper: BoolWrapper = true    // Uses the ExpressibleByBooleanLiteral initializer
        

// String architecture and Unicode handling
let cafe1 = "café"                 // With composed é
let cafe2 = "cafe\u{301}"          // With combining acute accent
print(cafe1 == cafe2)              // true - Unicode equivalence
print(cafe1.count)                 // 4 grapheme clusters
print(Array(cafe2.utf8).count)     // 5 UTF-8 code units

// String views
let heart = "❤️"
print(heart.count)                        // 1 (grapheme cluster)
print(heart.unicodeScalars.count)         // 1 (Unicode scalar)
print(heart.utf16.count)                  // 2 (UTF-16 code units)
print(heart.utf8.count)                   // 4 (UTF-8 code units)

// String optimization
let staticString = "StaticString"
print(type(of: staticString))            // String
let literalString = #file                // StaticString - compiler optimization
print(type(of: literalString))           // StaticString

// Advanced string interpolation (Swift 5)
let age = 30
let formattedInfo = """
    Name: \(name.uppercased())
    Age: \(String(format: "%02d", age))
    """
        

// Array implementation and optimization
var original = [1, 2, 3]
var copy = original         // No actual copy is made (copy-on-write)
copy.append(4)              // Now a copy is made, as we modify copy

// Array slices
let numbers = [10, 20, 30, 40, 50]
let slice = numbers[1...3]  // ArraySlice containing [20, 30, 40]
let newArray = Array(slice) // Convert slice back to array

// Performance characteristics
var performanceArray = [Int]()
performanceArray.reserveCapacity(1000)  // Pre-allocate memory for better performance

// Higher-order functions
let mapped = numbers.map { $0 * 2 }                 // [20, 40, 60, 80, 100]
let filtered = numbers.filter { $0 > 30 }           // [40, 50]
let reduced = numbers.reduce(0, { $0 + $1 })        // 150
let allGreaterThan5 = numbers.allSatisfy { $0 > 5 } // true
        

// Dictionary implementation and optimization
var userRoles: [String: String] = [:]
userRoles.reserveCapacity(100)  // Pre-allocate capacity

// Hashable requirement for keys
struct User: Hashable {
    let id: Int
    let name: String
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)  // Only hash the id for efficiency
    }
    
    static func == (lhs: User, rhs: User) -> Bool {
        return lhs.id == rhs.id
    }
}

// Dictionary with custom type keys
var userScores = [User(id: 1, name: "Alice"): 95,
                  User(id: 2, name: "Bob"): 80]

// Default values
let bobScore = userScores[User(id: 2, name: "Any")] ?? 0  // 80 (name is ignored in equality)
let charlieScore = userScores[User(id: 3, name: "Charlie"), default: 0]  // 0 (not found)

// Dictionary transformations
let keysArray = Array(userScores.keys)
let valuesArray = Array(userScores.values)
let namesAndScores = userScores.mapValues { score in
    return score >= 90 ? "A" : "B"
}
        

Advanced Switch Pattern Matching:

let point = (2, 0)

switch point {
case (0, 0):
    print("Origin")
case (_, 0):
    print("On the x-axis at \(point.0)")
case (0, _):
    print("On the y-axis at \(point.1)")
case (-2...2, -2...2):
    print("Inside the box")
default:
    print("Outside of box")
}
// Prints: "On the x-axis at 2"
    

Advanced iteration with stride:

for i in stride(from: 0, to: 10, by: 2) {
    print(i)  // Prints 0, 2, 4, 6, 8
}

// Using where clause for filtering
for i in 1...10 where i % 2 == 0 {
    print(i)  // Prints 2, 4, 6, 8, 10
}
    

Guard statement for early validation:

func processUserData(name: String?, age: Int?) {
    guard let name = name, !name.isEmpty else {
        print("Invalid name")
        return
    }
    
    guard let age = age, age >= 18 else {
        print("User must be at least 18")
        return
    }
    
    // Valid user processing continues here
    print("Processing user: \(name), age \(age)")
}
    

outerLoop: for i in 1...5 {
    innerLoop: for j in 1...5 {
        if i * j > 10 {
            break outerLoop  // Exits both loops
        }
        print("\(i) * \(j) = \(i*j)")
    }
}
    

var body: some View {
    if isLoggedIn {
        WelcomeView()
    } else {
        LoginView()
    }
    // This if statement is transformed by the ViewBuilder result builder
}
    

// Basic syntax
if condition {
    // executed when condition is true
} else if anotherCondition {
    // executed when first condition is false but second is true
} else {
    // executed when both conditions are false
}

// Swift supports compound conditions without parentheses
if x > 0 && y < 10 || z == 0 {
    // executed when compound condition is true
}

// If statements with binding (optional unwrapping)
if let unwrappedValue = optionalValue {
    // executed when optionalValue is not nil
    // unwrappedValue is available in this scope
}

// Multiple optional binding
if let first = optional1, let second = optional2, first < second {
    // Both optionals must have values and first must be less than second
}
    

// Advanced switch with pattern matching
let point = (2, 3)
switch point {
case (0, 0):
    print("Origin")
case (let x, 0):
    print("X-axis at \(x)")
case (0, let y):
    print("Y-axis at \(y)")
case let (x, y) where x == y:
    print("On the line x = y")
case let (x, y) where x == -y:
    print("On the line x = -y")
case let (x, y):
    print("Point: (\(x), \(y))")
}

// Enum matching with associated values
enum NetworkResponse {
    case success(Data)
    case failure(Error)
    case redirect(URL)
}

let response = NetworkResponse.success(someData)
switch response {
case .success(let data) where data.count > 0:
    print("Got \(data.count) bytes")
case .success:
    print("Got empty data")
case .failure(let error as NSError) where error.domain == NSURLErrorDomain:
    print("Network error: \(error.localizedDescription)")
case .failure(let error):
    print("Other error: \(error)")
case .redirect(let url):
    print("Redirecting to \(url)")
}
    

// Iterating with ranges
for i in 0..<5 { /* Half-open range: 0,1,2,3,4 */ }
for i in 0...5 { /* Closed range: 0,1,2,3,4,5 */ }

// Stride iteration
for i in stride(from: 0, to: 10, by: 2) { /* 0,2,4,6,8 */ }
for i in stride(from: 10, through: 0, by: -2) { /* 10,8,6,4,2,0 */ }

// Enumerated iteration
for (index, element) in array.enumerated() {
    print("Element \(index): \(element)")
}

// Dictionary iteration
let dict = ["a": 1, "b": 2]
for (key, value) in dict {
    print("\(key): \(value)")
}

// Pattern matching in for loops
let points = [(0, 0), (1, 0), (1, 1)]
for case let (x, y) where x == y in points {
    print("Diagonal point: (\(x), \(y))")
}

// Using where clause for filtering
for number in 1...100 where number.isMultiple(of: 7) {
    print("\(number) is divisible by 7")
}
    

// While loop - condition checked before iteration
var counter = 0
while counter < 5 {
    print(counter)
    counter += 1
}

// Repeat-while loop - condition checked after iteration
// (guarantees at least one execution)
counter = 0
repeat {
    print(counter)
    counter += 1
} while counter < 5

// While loop with optional binding
var optionalValues = [Int?]([1, nil, 3, nil, 5])
while let value = optionalValues.popLast() {
    if let unwrapped = value {
        print("Got value: \(unwrapped)")
    } else {
        print("Got nil value")
    }
}
    

func processNetworkResponse(data: Data?, response: URLResponse?, error: Error?) {
    // Early validation with guard
    guard error == nil else {
        print("Error: \(error!.localizedDescription)")
        return
    }
    
    guard let httpResponse = response as? HTTPURLResponse else {
        print("Invalid response type")
        return
    }
    
    guard (200...299).contains(httpResponse.statusCode) else {
        print("HTTP error: \(httpResponse.statusCode)")
        return
    }
    
    guard let responseData = data, !responseData.isEmpty else {
        print("No data received")
        return
    }
    
    // At this point, we have validated all conditions:
    // 1. No error occurred
    // 2. Response is an HTTP response
    // 3. Status code is in the success range
    // 4. Data exists and is not empty
    // All unwrapped variables are available in this scope
    
    print("Received \(responseData.count) bytes with status \(httpResponse.statusCode)")
    // Process the data...
}
    

// Basic function declaration
func functionName(parameterName: ParameterType) -> ReturnType {
    // Function body
    return value
}

// Function invocation
let result = functionName(parameterName: argument)
        

func calculate(from startValue: Int, to endValue: Int) -> Int {
    // Here "from" and "to" are external names
    // "startValue" and "endValue" are internal names
    return endValue - startValue
}

// Called using external names
let difference = calculate(from: 10, to: 20)
        

// Variadic parameter example
func calculateSum(of numbers: Int...) -> Int {
    return numbers.reduce(0, +)
}

// In-out parameter example
func swapValues(_ a: inout Int, _ b: inout Int) {
    let temp = a
    a = b
    b = temp
}

// Default parameter example
func createUser(name: String, age: Int = 18) {
    // Implementation
}
        

// Function type: (Int, Int) -> Int
let mathOperation: (Int, Int) -> Int = addNumbers

// Higher-order function example
func performOperation(_ a: Int, _ b: Int, using operation: (Int, Int) -> Int) -> Int {
    return operation(a, b)
}

// Call with function as argument
let result = performOperation(10, 5, using: addNumbers)
        

func makeIncrementer(incrementAmount: Int) -> () -> Int {
    var total = 0
    
    func incrementer() -> Int {
        total += incrementAmount
        return total
    }
    
    return incrementer
}
        

func functionName(paramLabel internalName: ParamType, param2: ParamType2) -> ReturnType {
    // Function body
    return someValue
}
        

func findDistance(from startPoint: Point, to endPoint: Point) -> Double {
    // Use startPoint and endPoint internally
    let dx = endPoint.x - startPoint.x
    let dy = endPoint.y - startPoint.y
    return sqrt(dx*dx + dy*dy)
}

// Called with external labels
let distance = findDistance(from: pointA, to: pointB)
        

func multiply(_ a: Int, _ b: Int) -> Int {
    return a * b
}

// Called without labels
let product = multiply(4, 5)
        

func createPath(filename: String, directory: String = FileManager.default.currentDirectoryPath) -> String {
    return "\(directory)/\(filename)"
}

// Different ways to call
let path1 = createPath(filename: "data.txt")  // Uses current directory
let path2 = createPath(filename: "data.txt", directory: "/custom/path")
        

func calculateMean(_ numbers: Double...) -> Double {
    var total = 0.0
    for number in numbers {
        total += number
    }
    return numbers.isEmpty ? 0 : total / Double(numbers.count)
}

let average = calculateMean(1.5, 2.5, 3.5, 4.5)  // Accepts any number of doubles
        

// Swift implements in-out parameters by copying-in and copying-out
func swap(_ a: inout Int, _ b: inout Int) {
    let temp = a
    a = b
    b = temp
}

var x = 10, y = 20
swap(&x, &y)  // Must pass with & operator
print(x, y)   // Output: 20 10
        

func computeFactorial(_ n: Int) -> Int {
    guard n > 1 else { return 1 }
    return n * computeFactorial(n - 1)
}
        

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    guard !array.isEmpty else { return nil }
    
    var currentMin = array[0]
    var currentMax = array[0]
    
    for value in array[1.. currentMax {
            currentMax = value
        }
    }
    
    return (currentMin, currentMax)
}

if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
    print("min is \(bounds.min) and max is \(bounds.max)")
}
        

func findIndex(of value: Int, in array: [Int]) -> Int? {
    for (index, element) in array.enumerated() {
        if element == value {
            return index
        }
    }
    return nil
}
        

func square(_ number: Int) -> Int {
    number * number  // Return keyword is implied
}
        

func process(_ value: Int) -> Int {
    return value * 2
}

func process(_ value: String) -> String {
    return value.uppercased()
}

// Swift chooses the correct implementation based on the argument type
let result1 = process(42)       // Uses first implementation
let result2 = process("hello")  // Uses second implementation
        

func swapValues(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}
        

Memory Model Comparison:

// Struct: Value semantics demonstration
struct Point {
    var x, y: Double
}

var point1 = Point(x: 10, y: 20)
var point2 = point1          // Creates a complete copy
point2.x = 15                // Only modifies point2
// Memory: Two independent values exist

// Class: Reference semantics demonstration
class Rectangle {
    var width, height: Double
    
    init(width: Double, height: Double) {
        self.width = width
        self.height = height
    }
}

let rect1 = Rectangle(width: 30, height: 40)
let rect2 = rect1            // Creates a new reference to the same instance
rect2.width = 50             // Modifies the single shared instance
// Memory: Single instance with reference count of 2
        

Advanced Property Patterns:

class DataManager {
    // Lazy stored property - initialized only when accessed
    lazy var expensiveResource: [String] = {
        // Imagine complex calculation or loading from disk
        return ["Large", "Dataset", "Loaded", "Lazily"]
    }()
    
    // Type property with custom getter
    static var appVersion: String {
        return Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "Unknown"
    }
    
    // Private setter, public getter - controlled access
    private(set) var lastUpdated: Date = Date()
    
    // Property wrapper usage (Swift 5.1+)
    @UserDefaultsStored(key: "username", defaultValue: "Guest")
    var username: String
    
    // Computed property with custom setter logic
    var temperatureInCelsius: Double = 0
    var temperatureInFahrenheit: Double {
        get {
            return temperatureInCelsius * 9/5 + 32
        }
        set {
            temperatureInCelsius = (newValue - 32) * 5/9
        }
    }
}
        

Advanced Method Patterns:

protocol Drawable {
    func draw()
}

struct Point: Drawable {
    var x, y: Double
    
    // Mutating method - can modify properties
    mutating func moveBy(dx: Double, dy: Double) {
        x += dx
        y += dy
    }
    
    // Method with function parameter (higher order function)
    func transform(using transformer: (Double) -> Double) -> Point {
        return Point(x: transformer(x), y: transformer(y))
    }
    
    // Protocol implementation
    func draw() {
        print("Drawing point at (\(x), \(y))")
    }
    
    // Static method for factory pattern
    static func origin() -> Point {
        return Point(x: 0, y: 0)
    }
}

class Shape {
    // Method with default parameter
    func resize(by factor: Double = 1.0) {
        // Implementation
    }
    
    // Method with variadic parameters
    func addPoints(_ points: Point...) {
        for point in points {
            // Process each point
        }
    }
    
    // Class method that can be overridden
    class func defaultShape() -> Shape {
        return Shape()
    }
}

class Circle: Shape {
    // Overriding a class method
    override class func defaultShape() -> Shape {
        return Circle(radius: 10)
    }
}
        

Advanced Initialization Patterns:

// Struct initialization
struct Size {
    var width: Double
    var height: Double
    
    // Custom initializer
    init(dimension: Double) {
        self.width = dimension
        self.height = dimension
    }
    
    // Failable initializer
    init?(dictionary: [String: Any]) {
        guard let width = dictionary["width"] as? Double,
              let height = dictionary["height"] as? Double else {
            return nil
        }
        
        self.width = width
        self.height = height
    }
}

// Class initialization with inheritance
class Vehicle {
    let numberOfWheels: Int
    
    // Designated initializer
    init(wheels: Int) {
        self.numberOfWheels = wheels
    }
    
    // Convenience initializer
    convenience init() {
        self.init(wheels: 4)
    }
    
    // Required initializer
    required init(coder: NSCoder) {
        numberOfWheels = coder.decodeInteger(forKey: "wheels")
    }
}

class Bicycle: Vehicle {
    let hasBell: Bool
    
    // Designated initializer that calls superclass initializer
    init(hasBell: Bool) {
        self.hasBell = hasBell
        super.init(wheels: 2)
    }
    
    // Must implement required initializers
    required init(coder: NSCoder) {
        hasBell = coder.decodeBool(forKey: "bell")
        super.init(coder: coder)
    }
}

// Class with multiple designated and convenience initializers
class ViewController {
    var title: String
    var isModal: Bool
    
    // Designated initializer 1
    init(title: String, modal: Bool) {
        self.title = title
        self.isModal = modal
    }
    
    // Designated initializer 2
    init(nibName: String) {
        self.title = nibName
        self.isModal = false
    }
    
    // Convenience initializer calling designated initializer 1
    convenience init() {
        self.init(title: "Untitled", modal: false)
    }
    
    // Convenience initializer calling another convenience initializer
    convenience init(modal: Bool) {
        self.init()
        self.isModal = modal
    }
}
        

Advanced Optional Usage:

// Optional pattern matching
if case let .some(value) = optionalValue {
    // Use unwrapped value
}

// Optional map and flatMap for functional transformations
let mappedValue = optionalString.map { $0.uppercased() }
let flatMapped = optionalString.flatMap { Int($0) }

// Optional as a functor and monad in functional programming
let result = optionalValue
    .map { $0 * 2 }
    .flatMap { optionalFunction($0) }
        

if let (Scoped Unwrapping):

if let unwrapped = optional {
    // Scope-limited unwrapped value
    // Creates a new immutable binding
    // Bindings can be comma-separated for compound conditions
}

// Compound binding with where clause
if let first = optional1,
   let second = optional2,
   let third = functionReturningOptional(),
   where someCondition(first, second, third) {
    // All bindings must succeed
}
        

guard let (Early Return Pattern):

guard let unwrapped = optional else {
    // Handle absence case
    return // or throw/break/continue
}
// Unwrapped is available in the entire remaining scope
// Must exit scope if binding fails