Swift Introduction

1. Basic Data Types

Swift has several basic data types.

let age: Int = 25
let price: Double = 19.99
let isActive: Bool = true
let name: String = "Swift"
let letter: Character = "A"

Simple explanation:

Int       = whole number
Double    = decimal number
Bool      = true or false
String    = text
Character = single character

---

2. Constants vs Variables

Swift uses let and var.

let = constant value, cannot change
var = variable value, can change

Example:

let maxLoginAttempts = 10
var currentLoginAttempt = 0

currentLoginAttempt += 1

Best practice:

Use let by default.
Use var only when the value needs to change.

---

3. Type Inference

Swift can automatically detect the type.

let count = 42        // Int
let pi = 3.14159      // Double
let name = "Swift"    // String
let isReady = true    // Bool

You can also write the type manually.

var message: String
message = "Hello Swift"

Simple explanation:

Type inference makes code shorter.
Explicit type declaration makes code clearer when needed.

---

4. Type Annotation

Type annotation means manually writing the data type.

let username: String = "Tawheed"
let score: Int = 100
let rating: Double = 4.8
let isPremium: Bool = true

Use type annotation when:

You want clear code
Swift cannot infer type
You want to avoid wrong type guessing

---

5. Type Safety

Swift is type-safe. It does not allow mixing incompatible types directly.

let number = 3
let decimal = 0.14

let result = Double(number) + decimal

print(result)

Wrong:

// let result = number + decimal

Simple explanation:

Int and Double are different types.
Swift requires explicit conversion.

---

6. Type Conversion

Swift does not automatically convert types.

let intValue = 10
let doubleValue = Double(intValue)

print(doubleValue)

String to Int:

let numberText = "123"
let number = Int(numberText)

print(number ?? 0)

Int to String:

let age = 25
let ageText = String(age)

print(ageText)

---

7. Comments

Comments are used to explain code.

Single-line comment:

// This is a single-line comment
let name = "Swift"

Multi-line comment:

/*
 This is a multi-line comment.
 It can contain many lines.
*/
let age = 25

---

8. Print Output

print() is used to show output.

let name = "Swift"
print(name)

String interpolation:

let age = 25
print("Age is \(age)")

---

9. Operators

Operators are used to perform operations.

---

Arithmetic Operators

let a = 10
let b = 3

print(a + b) // Addition
print(a - b) // Subtraction
print(a * b) // Multiplication
print(a / b) // Division
print(a % b) // Remainder

---

Assignment Operator

var count = 10

count += 1
count -= 1
count *= 2
count /= 2

---

Comparison Operators

let a = 10
let b = 20

print(a == b)
print(a != b)
print(a > b)
print(a < b)
print(a >= b)
print(a <= b)

---

Logical Operators

let isLoggedIn = true
let isPremium = false

print(isLoggedIn && isPremium) // AND
print(isLoggedIn || isPremium) // OR
print(!isLoggedIn)             // NOT

---

Range Operators

Closed range:

for number in 1...5 {
    print(number)
}

Output:

1 2 3 4 5

Half-open range:

for number in 1..<5 {
    print(number)
}

Output:

1 2 3 4

---

10. Strings

String stores text.

let name = "Swift"
let message = "Hello, \(name)"

print(message)

---

Empty String

var text = ""

if text.isEmpty {
    print("Text is empty")
}

---

String Count

let name = "Swift"
print(name.count)

---

String Uppercase and Lowercase

let name = "Swift"

print(name.uppercased())
print(name.lowercased())

---

String Contains

let message = "I love Swift"

if message.contains("Swift") {
    print("Found Swift")
}

---

Multi-line String

let paragraph = """
Swift is powerful.
Swift is safe.
Swift is modern.
"""

print(paragraph)

---

11. Character

Character stores a single character.

let letter: Character = "A"
print(letter)

Loop through characters in a string:

let word = "Swift"

for char in word {
    print(char)
}

---

12. Collections

Swift has three main collection types:

Array      = ordered list
Set        = unique unordered values
Dictionary = key-value pairs

---

13. Array

Array stores ordered values.

let numbers = [1, 2, 3, 4, 5]
print(numbers)

Explicit type:

let names: [String] = ["John", "Sarah", "Alex"]

---

Access Array Item

let names = ["John", "Sarah", "Alex"]

print(names[0])

---

Add Item

var names = ["John", "Sarah"]

names.append("Alex")

print(names)

---

Remove Item

var names = ["John", "Sarah", "Alex"]

names.remove(at: 1)

print(names)

---

Loop Array

let names = ["John", "Sarah", "Alex"]

for name in names {
    print(name)
}

---

Array Count

let names = ["John", "Sarah", "Alex"]

print(names.count)

---

Check Empty Array

let names: [String] = []

if names.isEmpty {
    print("No names found")
}

---

14. Set

Set stores unique values.

let numbers: Set<Int> = [1, 2, 2, 3, 4]

print(numbers)

Output contains unique values only.

---

Add Item to Set

var numbers: Set<Int> = [1, 2, 3]

numbers.insert(4)

print(numbers)

---

Remove Item from Set

var numbers: Set<Int> = [1, 2, 3]

numbers.remove(2)

print(numbers)

---

Set Operations

let a: Set<Int> = [1, 2, 3]
let b: Set<Int> = [3, 4, 5]

print(a.union(b))
print(a.intersection(b))
print(a.subtracting(b))

Simple explanation:

union        = all values
intersection = common values
subtracting  = values from first set not in second

---

15. Dictionary

Dictionary stores key-value data.

let user = [
    "name": "John",
    "email": "john@example.com"
]

print(user["name"] ?? "")

---

Dictionary with Type

var user: [String: String] = [
    "name": "John",
    "email": "john@example.com"
]

---

Add or Update Value

var user = [
    "name": "John"
]

user["email"] = "john@example.com"
user["name"] = "Alex"

print(user)

---

Remove Value

var user = [
    "name": "John",
    "email": "john@example.com"
]

user.removeValue(forKey: "email")

print(user)

---

Loop Dictionary

let user = [
    "name": "John",
    "email": "john@example.com"
]

for (key, value) in user {
    print("\(key): \(value)")
}

---

16. Optionals

Optionals represent values that may or may not exist.

var possibleNumber: Int? = 123
possibleNumber = nil

Simple explanation:

Int  = must contain an Int value
Int? = may contain Int or nil

---

Optional Binding with if let

var possibleNumber: Int? = 123

if let number = possibleNumber {
    print(number)
} else {
    print("No number found")
}

---

Optional Binding with guard let

func showNumber(_ possibleNumber: Int?) {
    guard let number = possibleNumber else {
        print("No number found")
        return
    }

    print(number)
}

Use guard let when you want to exit early.

---

Default Value with ??

let name: String? = nil
let greeting = "Hello, " + (name ?? "Guest")

print(greeting)

---

Force Unwrapping

Force unwrapping uses !.

let name: String? = "Swift"

print(name!)

Warning:

If value is nil, force unwrap causes crash.
Avoid force unwrap unless you are 100% sure.

---

Optional Chaining

Optional chaining safely accesses properties or methods.

class User {
    var profile: Profile?
}

class Profile {
    var name: String = "Tawheed"
}

let user = User()

print(user.profile?.name ?? "No profile")

---

Implicitly Unwrapped Optional

var username: String! = "Swift"

print(username)

Simple explanation:

String! behaves like optional but can be used like normal value.
It can still crash if nil.
Use carefully.

---

17. Tuples

Tuple groups multiple values together.

let httpError = (404, "Not Found")

print(httpError.0)
print(httpError.1)

---

Named Tuple

let status = (code: 200, message: "OK")

print(status.code)
print(status.message)

---

Tuple Return from Function

func getUser() -> (name: String, age: Int) {
    return ("John", 25)
}

let user = getUser()

print(user.name)
print(user.age)

---

18. Control Flow

Control flow controls how code runs.

---

if else

let age = 18

if age >= 18 {
    print("Adult")
} else {
    print("Minor")
}

---

else if

let score = 85

if score >= 90 {
    print("A")
} else if score >= 80 {
    print("B")
} else {
    print("C")
}

---

switch

let day = "Friday"

switch day {
case "Friday":
    print("Weekend is near")
case "Saturday":
    print("Weekend")
default:
    print("Normal day")
}

---

switch with range

let score = 85

switch score {
case 90...100:
    print("A")
case 80..<90:
    print("B")
case 70..<80:
    print("C")
default:
    print("Failed")
}

---

for loop

for number in 1...5 {
    print(number)
}

---

while loop

var count = 0

while count < 5 {
    print(count)
    count += 1
}

---

repeat while

var count = 0

repeat {
    print(count)
    count += 1
} while count < 5

Simple explanation:

while checks condition first.
repeat while runs at least once.

---

break

for number in 1...10 {
    if number == 5 {
        break
    }

    print(number)
}

---

continue

for number in 1...5 {
    if number == 3 {
        continue
    }

    print(number)
}

---

19. Functions

Function is a reusable block of code.

func greet() {
    print("Hello Swift")
}

greet()

---

Function with Parameter

func greet(name: String) {
    print("Hello, \(name)")
}

greet(name: "Tawheed")

---

Function with Return Value

func add(a: Int, b: Int) -> Int {
    return a + b
}

let result = add(a: 10, b: 20)

print(result)

---

Function with Multiple Return Values

func getUserInfo() -> (name: String, age: Int) {
    return ("John", 25)
}

let user = getUserInfo()

print(user.name)

---

External and Internal Parameter Names

func greet(user name: String) {
    print("Hello, \(name)")
}

greet(user: "Tawheed")

Simple explanation:

user = external name used when calling
name = internal name used inside function

---

Omitting External Parameter Name

func greet(_ name: String) {
    print("Hello, \(name)")
}

greet("Tawheed")

---

Default Parameter Value

func greet(name: String = "Guest") {
    print("Hello, \(name)")
}

greet()
greet(name: "Tawheed")

---

Variadic Parameter

A variadic parameter accepts multiple values.

func sum(_ numbers: Int...) -> Int {
    var total = 0

    for number in numbers {
        total += number
    }

    return total
}

print(sum(1, 2, 3, 4))

---

In-Out Parameter

inout allows a function to modify a parameter.

func increase(_ value: inout Int) {
    value += 1
}

var count = 10
increase(&count)

print(count)

Simple explanation:

Use & when passing inout parameter.

---

20. Closures

Closure is a block of code that can be stored or passed around.

let greeting = {
    print("Hello Closure")
}

greeting()

---

Closure with Parameter

let greet: (String) -> Void = { name in
    print("Hello, \(name)")
}

greet("Tawheed")

---

Closure with Return Value

let add: (Int, Int) -> Int = { a, b in
    return a + b
}

print(add(10, 20))

---

Short Closure Syntax

let numbers = [3, 1, 4, 2]

let sortedNumbers = numbers.sorted { $0 < $1 }

print(sortedNumbers)

Simple explanation:

$0 = first parameter
$1 = second parameter

---

Trailing Closure

func performTask(action: () -> Void) {
    action()
}

performTask {
    print("Task completed")
}

---

Escaping Closure

An escaping closure runs after the function returns.

var savedCompletion: (() -> Void)?

func loadData(completion: @escaping () -> Void) {
    savedCompletion = completion
}

loadData {
    print("Data loaded")
}

savedCompletion?()

Use cases:

API callback
Delayed action
Stored closure
Async completion

---

Autoclosure

@autoclosure automatically converts an expression into a closure.

func logMessage(_ message: @autoclosure () -> String) {
    print(message())
}

logMessage("Hello Swift")

Simple explanation:

You pass normal expression.
Swift wraps it as a closure automatically.

---

21. Enumerations

Enum represents fixed possible values.

enum UserType {
    case free
    case premium
    case admin
}

let type = UserType.premium

---

Enum with Switch

enum PaymentStatus {
    case pending
    case completed
    case failed
}

let status = PaymentStatus.completed

switch status {
case .pending:
    print("Payment pending")
case .completed:
    print("Payment completed")
case .failed:
    print("Payment failed")
}

---

Enum with Raw Value

enum Direction: String {
    case north = "North"
    case south = "South"
    case east = "East"
    case west = "West"
}

print(Direction.north.rawValue)

---

Enum with Associated Value

enum ApiResult {
    case success(data: String)
    case failure(message: String)
}

let result = ApiResult.success(data: "User loaded")

switch result {
case .success(let data):
    print(data)
case .failure(let message):
    print(message)
}

Simple explanation:

Raw value = predefined fixed value
Associated value = dynamic value attached to enum case

---

22. Structures

Struct is a value type.

struct User {
    let id: Int
    var name: String
}

let user = User(id: 1, name: "Tawheed")

print(user.name)

Use struct for:

Models
DTOs
UI state
Simple data
Value-based objects

---

Struct with Method

struct User {
    var name: String

    func greet() {
        print("Hello, \(name)")
    }
}

let user = User(name: "Tawheed")
user.greet()

---

Mutating Method

Struct is value type. To modify its own property inside method, use mutating.

struct Counter {
    var count = 0

    mutating func increase() {
        count += 1
    }
}

var counter = Counter()
counter.increase()

print(counter.count)

---

23. Classes

Class is a reference type.

class UserManager {
    var username = "Guest"

    func updateName(_ name: String) {
        username = name
    }
}

let manager = UserManager()
manager.updateName("Tawheed")

print(manager.username)

Use class for:

Shared reference
Inheritance
ObservableObject
Manager objects
Service objects
Objects with lifecycle

---

24. Struct vs Class

Main difference:

Struct = Value type
Class  = Reference type

Struct example:

struct Profile {
    var name: String
}

var profile1 = Profile(name: "A")
var profile2 = profile1

profile2.name = "B"

print(profile1.name) // A
print(profile2.name) // B

Class example:

class ProfileClass {
    var name: String

    init(name: String) {
        self.name = name
    }
}

let p1 = ProfileClass(name: "A")
let p2 = p1

p2.name = "B"

print(p1.name) // B
print(p2.name) // B

Simple explanation:

Struct copies data.
Class shares the same object reference.

---

25. Properties

Properties store values inside struct, class, or enum.

---

Stored Property

struct User {
    let id: Int
    var name: String
}

---

Computed Property

Computed property calculates value.

struct Rectangle {
    var width: Double
    var height: Double

    var area: Double {
        return width * height
    }
}

let rectangle = Rectangle(width: 10, height: 5)

print(rectangle.area)

---

Property Observer

Property observers observe value changes.

var username: String = "Guest" {
    willSet {
        print("Will change to \(newValue)")
    }

    didSet {
        print("Changed from \(oldValue) to \(username)")
    }
}

username = "Tawheed"

---

Lazy Property

Lazy property is created only when first used.

class DataManager {
    lazy var data = loadData()

    func loadData() -> String {
        print("Loading data...")
        return "Loaded Data"
    }
}

let manager = DataManager()
print(manager.data)

---

Static Property

Static property belongs to the type, not object.

struct AppConfig {
    static let appName = "My App"
}

print(AppConfig.appName)

---

26. Methods

Methods are functions inside struct, class, or enum.

struct Calculator {
    func add(a: Int, b: Int) -> Int {
        return a + b
    }
}

let calculator = Calculator()
print(calculator.add(a: 10, b: 20))

---

Type Method

Type method belongs to type itself.

struct MathHelper {
    static func square(_ number: Int) -> Int {
        return number * number
    }
}

print(MathHelper.square(5))

---

27. Subscripts

Subscripts allow accessing values using square brackets.

struct NumberList {
    let numbers = [10, 20, 30]

    subscript(index: Int) -> Int {
        return numbers[index]
    }
}

let list = NumberList()

print(list[0])

---

28. Initialization

Initializer creates an instance.

struct User {
    let name: String

    init(name: String) {
        self.name = name
    }
}

let user = User(name: "Tawheed")

---

Default Initializer

struct User {
    var name = "Guest"
}

let user = User()

print(user.name)

---

Memberwise Initializer

Struct automatically gets memberwise initializer.

struct User {
    let id: Int
    let name: String
}

let user = User(id: 1, name: "Tawheed")

---

Failable Initializer

Initializer can fail and return nil.

struct User {
    let age: Int

    init?(age: Int) {
        if age < 0 {
            return nil
        }

        self.age = age
    }
}

let user = User(age: -1)

print(user as Any)

---

29. Deinitialization

deinit runs when class instance is removed from memory.

class User {
    init() {
        print("User created")
    }

    deinit {
        print("User removed")
    }
}

var user: User? = User()
user = nil

Note:

deinit is only available for classes.
Structs do not have deinit.

---

30. Inheritance

Inheritance allows one class to inherit from another class.

class Animal {
    func sound() {
        print("Animal sound")
    }
}

class Dog: Animal {
    override func sound() {
        print("Bark")
    }
}

let dog = Dog()
dog.sound()

Simple explanation:

Dog inherits Animal.
Dog overrides sound().

---

final Class

final prevents inheritance.

final class PaymentManager {
    func pay() {
        print("Payment started")
    }
}

---

31. Protocols

Protocol defines requirements.

protocol Downloadable {
    func download()
}

struct VideoDownloader: Downloadable {
    func download() {
        print("Download started")
    }
}

let downloader = VideoDownloader()
downloader.download()

---

Protocol with Property

protocol UserProtocol {
    var name: String { get }
}

struct User: UserProtocol {
    let name: String
}

---

Protocol Inheritance

protocol Readable {
    func read()
}

protocol Writable {
    func write()
}

protocol ReadWriteable: Readable, Writable {}

struct FileManager: ReadWriteable {
    func read() {
        print("Reading")
    }

    func write() {
        print("Writing")
    }
}

---

Protocol as Type

protocol PaymentService {
    func pay()
}

class StripePayment: PaymentService {
    func pay() {
        print("Paid with Stripe")
    }
}

let paymentService: PaymentService = StripePayment()
paymentService.pay()

---

32. Extensions

Extension adds functionality to an existing type.

extension String {
    func addWelcomeText() -> String {
        return "Welcome, \(self)"
    }
}

print("Tawheed".addWelcomeText())

---

Extension with Computed Property

extension Int {
    var isEven: Bool {
        return self % 2 == 0
    }
}

print(10.isEven)

---

Protocol Extension

protocol Greetable {
    var name: String { get }
}

extension Greetable {
    func greet() {
        print("Hello, \(name)")
    }
}

struct User: Greetable {
    let name: String
}

let user = User(name: "Tawheed")
user.greet()

---

33. Generics

Generics allow reusable code for different types.

func printValue<T>(_ value: T) {
    print(value)
}

printValue("Hello")
printValue(100)
printValue(true)

---

Generic Struct

struct Box<T> {
    let value: T
}

let stringBox = Box(value: "Swift")
let intBox = Box(value: 100)

print(stringBox.value)
print(intBox.value)

---

Generic Constraint

func compareValues<T: Equatable>(_ a: T, _ b: T) -> Bool {
    return a == b
}

print(compareValues(10, 10))
print(compareValues("A", "B"))

Simple explanation:

T: Equatable means T must support equality check.

---

34. Access Control

Access control controls visibility.

open       = accessible and subclassable outside module
public     = accessible outside module
internal   = accessible inside module, default
fileprivate = accessible inside same file
private    = accessible inside same scope/type

Example:

public class ApiService {
    private let token = "secret"

    public func fetchData() {
        print("Fetching data")
    }
}

Best practice:

Keep properties private when possible.
Expose only what is needed.

---

35. Type Casting

Type casting checks or converts object type.

class Animal {}
class Dog: Animal {
    func bark() {
        print("Bark")
    }
}

let animal: Animal = Dog()

if let dog = animal as? Dog {
    dog.bark()
}

---

is Operator

if animal is Dog {
    print("Animal is Dog")
}

---

as? vs as!

let dog1 = animal as? Dog // Safe optional cast
let dog2 = animal as! Dog // Force cast, can crash

Use as? more often.

---

36. Nested Types

Nested type means defining a type inside another type.

struct User {
    enum Role {
        case admin
        case customer
    }

    let name: String
    let role: Role
}

let user = User(name: "Tawheed", role: .admin)

---

37. Error Handling

Swift handles errors with throws, do, try, and catch.

enum LoginError: Error {
    case invalidEmail
    case invalidPassword
}

func login(email: String, password: String) throws {
    if !email.contains("@") {
        throw LoginError.invalidEmail
    }

    if password.count < 6 {
        throw LoginError.invalidPassword
    }

    print("Login successful")
}

do {
    try login(email: "test@example.com", password: "123456")
} catch {
    print("Login failed: \(error)")
}

---

try, try?, try!

try  = normal error handling
try? = converts result to optional
try! = force try, crashes if error happens

Example:

let result = try? login(email: "wrong", password: "123")

Avoid:

try!

unless you are completely sure no error will happen.

---

38. Result Type

Result represents success or failure.

enum NetworkError: Error {
    case invalidResponse
}

func fetchData() -> Result<String, NetworkError> {
    return .success("Data loaded")
}

let result = fetchData()

switch result {
case .success(let data):
    print(data)
case .failure(let error):
    print(error)
}

Use Result when:

A function can succeed or fail
You want to return success/failure clearly

---

39. Assertions and Preconditions

Assertions help catch problems during development.

let age = 20

assert(age >= 0, "Age cannot be negative")

Precondition checks important conditions.

precondition(age >= 0, "Invalid age")

Simple difference:

assert       = mainly for debugging
precondition = important runtime condition

---

40. Memory Management and ARC

Swift uses ARC: Automatic Reference Counting.

ARC automatically removes class instances from memory when they are no longer used.

class User {
    let name: String

    init(name: String) {
        self.name = name
        print("\(name) created")
    }

    deinit {
        print("\(name) removed")
    }
}

var user: User? = User(name: "Tawheed")
user = nil

---

Strong Reference

Strong reference keeps an object alive.

class User {}

var user1: User? = User()
var user2 = user1

The object remains alive while strong references exist.

---

Retain Cycle

Retain cycle happens when two objects strongly reference each other.

Bad example:

class User {
    var profile: Profile?
}

class Profile {
    var user: User?
}

Both objects keep each other alive.

---

weak Reference

Use weak to avoid retain cycle.

class User {
    var profile: Profile?
}

class Profile {
    weak var user: User?
}

weak must be optional because it can become nil.

---

unowned Reference

Use unowned when reference should never become nil while used.

class Customer {
    var card: CreditCard?

    deinit {
        print("Customer removed")
    }
}

class CreditCard {
    unowned let customer: Customer

    init(customer: Customer) {
        self.customer = customer
    }
}

Use carefully.

---

weak self in Closure

class DownloadManager {
    var onComplete: (() -> Void)?

    func start() {
        onComplete = { [weak self] in
            self?.showSuccess()
        }
    }

    func showSuccess() {
        print("Download completed")
    }
}

This prevents closure retain cycle.

---

41. Concurrency

Concurrency means doing multiple tasks without blocking the app.

Use cases:

API call
Image loading
File processing
Database query
Background calculation

---

async Function

func fetchUserName() async -> String {
    return "Tawheed"
}

---

await

Task {
    let name = await fetchUserName()
    print(name)
}

Simple explanation:

async marks a function as asynchronous.
await waits for async result.

---

Task

Task starts asynchronous work.

Task {
    print("Async task started")
}

---

MainActor

Use MainActor for UI-related updates.

@MainActor
class UserViewModel: ObservableObject {
    @Published var username = "Guest"

    func updateName() {
        username = "Tawheed"
    }
}

Simple explanation:

UI updates should happen on main thread.
MainActor helps ensure that.

---

Task.detached

Detached task runs independently.

Task.detached {
    let result = heavyCalculation()
    print(result)
}

func heavyCalculation() -> Int {
    return (1...1000).reduce(0, +)
}

Use carefully because detached tasks do not inherit parent context.

---

async let

async let runs async work in parallel.

func fetchName() async -> String {
    return "Tawheed"
}

func fetchAge() async -> Int {
    return 25
}

Task {
    async let name = fetchName()
    async let age = fetchAge()

    let result = await "\(name), \(age)"
    print(result)
}

---

Actor

Actor protects shared mutable state.

actor Counter {
    private var value = 0

    func increase() {
        value += 1
    }

    func getValue() -> Int {
        return value
    }
}

let counter = Counter()

Task {
    await counter.increase()
    let value = await counter.getValue()

    print(value)
}

Simple explanation:

Actor helps prevent data race.

---

42. Protocol-Oriented Programming

Swift strongly supports protocol-oriented programming.

Instead of depending on concrete classes, depend on protocols.

protocol PaymentService {
    func pay(amount: Double)
}

class StripePaymentService: PaymentService {
    func pay(amount: Double) {
        print("Paid \(amount) using Stripe")
    }
}

class CheckoutViewModel {
    private let paymentService: PaymentService

    init(paymentService: PaymentService) {
        self.paymentService = paymentService
    }

    func checkout() {
        paymentService.pay(amount: 19.99)
    }
}

Benefits:

Cleaner architecture
Easier testing
Less coupling
Flexible implementation

---

43. Opaque Types

Opaque type hides the exact return type but keeps type safety.

protocol Shape {
    func draw()
}

struct Circle: Shape {
    func draw() {
        print("Drawing circle")
    }
}

func makeShape() -> some Shape {
    return Circle()
}

Simple explanation:

some Shape means this function returns one specific type that conforms to Shape,
but caller does not need to know the exact type.

Common in SwiftUI:

var body: some View {
    Text("Hello")
}

---

44. Any Type

Any can store any type.

let values: [Any] = [1, "Swift", true, 9.99]

for value in values {
    print(value)
}

Use carefully.

Any removes type safety.
Use specific types when possible.

---

45. AnyObject

AnyObject represents any class instance.

class User {}

let object: AnyObject = User()

Simple explanation:

Any = any type
AnyObject = any class type

---

46. Property Wrappers

Property wrappers add behavior to properties.

Simple example:

@propertyWrapper
struct Capitalized {
    private var value: String = ""

    var wrappedValue: String {
        get {
            value
        }
        set {
            value = newValue.capitalized
        }
    }
}

struct User {
    @Capitalized var name: String
}

var user = User()
user.name = "Tawheed"

print(user.name)

Simple explanation:

Property wrapper wraps a property and controls how it stores or returns value.

Common SwiftUI property wrappers:

@State
@Binding
@ObservedObject
@StateObject
@Environment
@EnvironmentObject
@AppStorage

---

47. Result Builders

Result builders help build complex nested values.

SwiftUI uses result builders to build views.

Simple concept:

import SwiftUI

@ViewBuilder
func makeView(isLoggedIn: Bool) -> some View {
    if isLoggedIn {
        Text("Home")
    } else {
        Text("Login")
    }
}

Simple explanation:

@ViewBuilder allows multiple view expressions
to be combined into one result.

---

48. Pattern Matching

Pattern matching is commonly used with switch.

let value = 10

switch value {
case 0:
    print("Zero")
case 1...10:
    print("Between 1 and 10")
default:
    print("Other")
}

---

Pattern Matching with Tuple

let point = (x: 0, y: 5)

switch point {
case (0, 0):
    print("Origin")
case (0, _):
    print("On Y axis")
case (_, 0):
    print("On X axis")
default:
    print("Somewhere else")
}

---

Pattern Matching with Enum

enum ApiResult {
    case success(String)
    case failure(String)
}

let result = ApiResult.success("Loaded")

switch result {
case .success(let data):
    print(data)
case .failure(let message):
    print(message)
}

---

49. Where Clause

where adds extra condition.

let number = 10

switch number {
case let x where x % 2 == 0:
    print("Even number")
default:
    print("Odd number")
}

---

50. Higher-Order Functions

Higher-order functions take closures.

Common examples:

map
filter
reduce
sorted
compactMap
flatMap
forEach

---

map

Transforms values.

let numbers = [1, 2, 3]

let doubled = numbers.map { $0 * 2 }

print(doubled)

---

filter

Filters values.

let numbers = [1, 2, 3, 4, 5]

let evenNumbers = numbers.filter { $0 % 2 == 0 }

print(evenNumbers)

---

reduce

Combines values into one result.

let numbers = [1, 2, 3, 4]

let total = numbers.reduce(0) { result, number in
    result + number
}

print(total)

Short form:

let total = numbers.reduce(0, +)

---

compactMap

Removes nil values and unwraps optionals.

let texts = ["1", "2", "abc", "4"]

let numbers = texts.compactMap { Int($0) }

print(numbers)

Output:

[1, 2, 4]

---

sorted

let numbers = [3, 1, 4, 2]

let sortedNumbers = numbers.sorted { $0 < $1 }

print(sortedNumbers)

---

51. Codable

Codable is used for JSON encoding and decoding.

struct User: Codable {
    let id: Int
    let name: String
}

---

Decode JSON

let json = """
{
    "id": 1,
    "name": "Tawheed"
}
""".data(using: .utf8)!

let user = try JSONDecoder().decode(User.self, from: json)

print(user.name)

---

Encode JSON

let user = User(id: 1, name: "Tawheed")

let data = try JSONEncoder().encode(user)

print(String(data: data, encoding: .utf8) ?? "")

---

Custom CodingKey

struct User: Codable {
    let userId: Int
    let userName: String

    enum CodingKeys: String, CodingKey {
        case userId = "user_id"
        case userName = "user_name"
    }
}

Simple explanation:

Use CodingKeys when JSON key and Swift property name are different.

---

52. Date Handling

import Foundation

let now = Date()

print(now)

---

DateFormatter

import Foundation

let formatter = DateFormatter()
formatter.dateFormat = "yyyy-MM-dd"

let dateText = formatter.string(from: Date())

print(dateText)

---

Convert String to Date

let formatter = DateFormatter()
formatter.dateFormat = "yyyy-MM-dd"

let date = formatter.date(from: "2026-05-20")

print(date as Any)

---

53. Accessing Files

Use FileManager.

import Foundation

func saveText() {
    let text = "Hello Swift"

    let url = FileManager.default.urls(
        for: .documentDirectory,
        in: .userDomainMask
    )[0].appendingPathComponent("note.txt")

    try? text.write(to: url, atomically: true, encoding: .utf8)

    print(url)
}

---

Read File

func readText() {
    let url = FileManager.default.urls(
        for: .documentDirectory,
        in: .userDomainMask
    )[0].appendingPathComponent("note.txt")

    let text = try? String(contentsOf: url, encoding: .utf8)

    print(text ?? "")
}

---

54. Key Paths

Key paths reference properties.

struct User {
    let name: String
    let age: Int
}

let users = [
    User(name: "John", age: 25),
    User(name: "Sarah", age: 30)
]

let names = users.map(\.name)

print(names)

Simple explanation:

\.name means access name property from each user.

---

55. Equatable

Equatable allows checking equality.

struct User: Equatable {
    let id: Int
    let name: String
}

let user1 = User(id: 1, name: "John")
let user2 = User(id: 1, name: "John")

print(user1 == user2)

---

56. Comparable

Comparable allows sorting custom types.

struct User: Comparable {
    let age: Int

    static func < (lhs: User, rhs: User) -> Bool {
        return lhs.age < rhs.age
    }
}

let users = [
    User(age: 30),
    User(age: 20),
    User(age: 25)
]

print(users.sorted())

---

57. Hashable

Hashable allows using custom types in Set or Dictionary keys.

struct User: Hashable {
    let id: Int
    let name: String
}

let users: Set<User> = [
    User(id: 1, name: "John"),
    User(id: 1, name: "John")
]

print(users.count)

---

58. Custom Operators

Swift allows custom operators.

infix operator **

func ** (lhs: Int, rhs: Int) -> Int {
    return Int(pow(Double(lhs), Double(rhs)))
}

print(2 ** 3)

Use carefully.

Custom operators can make code confusing if overused.

---

59. Macros

Macros generate code at compile time.

Simple concept:

Macro helps reduce repeated code.
It expands during compilation.

Example of common Swift attribute-style usage:

@Observable
class UserViewModel {
    var name = "Guest"
}

Simple explanation:

Macros are advanced.
You do not need to master them first.
Understand the concept before writing custom macros.

---

60. Swift Package Manager

Swift Package Manager is used to manage Swift dependencies.

Package file:

// Package.swift

import PackageDescription

let package = Package(
    name: "MyPackage",
    products: [
        .library(
            name: "MyPackage",
            targets: ["MyPackage"]
        )
    ],
    targets: [
        .target(
            name: "MyPackage"
        ),
        .testTarget(
            name: "MyPackageTests",
            dependencies: ["MyPackage"]
        )
    ]
)

Simple explanation:

Swift Package Manager helps create reusable libraries
and add third-party packages.

---

61. Modules and Import

A module is a unit of code that can be imported.

import Foundation
import SwiftUI

Examples:

Foundation = dates, files, networking, collections utilities
SwiftUI    = UI framework
UIKit      = older iOS UI framework
Combine    = reactive framework

---

62. Availability Check

Use availability check for OS-specific code.

if #available(iOS 17.0, *) {
    print("Use iOS 17 feature")
} else {
    print("Fallback for older iOS")
}

---

63. Compiler Directives

Compiler directives help run code conditionally.

#if DEBUG
print("Debug mode")
#else
print("Release mode")
#endif

---

64. Documentation Comments

Documentation comments help explain code.

/// Adds two integer numbers.
/// - Parameters:
///   - a: First number.
///   - b: Second number.
/// - Returns: Sum of two numbers.
func add(a: Int, b: Int) -> Int {
    return a + b
}

---

65. Naming Convention

Swift naming should be clear and readable.

Good:

func calculateTotalPrice() {}
let userName = "Tawheed"
let isPremiumUser = true

Bad:

func calc() {}
let usr = "Tawheed"
let flag = true

Best practice:

Use clear names.
Boolean should start with is, has, can, should.
Function names should describe action.

---

66. Basic Swift Coding Style

Good style:

struct User {
    let id: Int
    let name: String

    func greet() {
        print("Hello, \(name)")
    }
}

Key rules:

Use let by default
Avoid force unwrap
Keep functions small
Use meaningful names
Use guard for early return
Use protocols for abstraction
Keep code readable

---

67. Mini Practice Examples

---

Reverse String

func reverseString(_ text: String) -> String {
    return String(text.reversed())
}

print(reverseString("Swift"))

---

Check Even Number

func isEven(_ number: Int) -> Bool {
    return number % 2 == 0
}

print(isEven(10))

---

Find Maximum Number

func findMax(_ numbers: [Int]) -> Int? {
    return numbers.max()
}

print(findMax([10, 4, 20, 7]) ?? 0)

---

Remove Duplicates

func removeDuplicates(_ numbers: [Int]) -> [Int] {
    return Array(Set(numbers))
}

print(removeDuplicates([1, 2, 2, 3, 4, 4]))

Keep order:

func removeDuplicatesKeepingOrder(_ numbers: [Int]) -> [Int] {
    var seen = Set<Int>()
    var result: [Int] = []

    for number in numbers {
        if !seen.contains(number) {
            seen.insert(number)
            result.append(number)
        }
    }

    return result
}

print(removeDuplicatesKeepingOrder([1, 2, 2, 3, 4, 4]))

---

Count Character Frequency

func characterCount(_ text: String) -> [Character: Int] {
    var result: [Character: Int] = [:]

    for char in text {
        result[char, default: 0] += 1
    }

    return result
}

print(characterCount("hello"))

---

68. Swift Learning Order

Follow this order:

1. Variables and constants
2. Basic data types
3. Type inference
4. Operators
5. Strings
6. Arrays
7. Sets
8. Dictionaries
9. Optionals
10. Tuples
11. Control flow
12. Functions
13. Closures
14. Enums
15. Structs
16. Classes
17. Properties
18. Methods
19. Initializers
20. Protocols
21. Extensions
22. Generics
23. Error handling
24. ARC and memory management
25. Higher-order functions
26. Codable
27. Access control
28. Type casting
29. Concurrency
30. Actors
31. Result builders
32. Property wrappers
33. Macros
34. Swift Package Manager
35. Clean coding style

---

Key Takeaways

Use let by default.
Use var only when value changes.
Swift is strongly typed and safe.
Optionals prevent null-related crashes.
Avoid force unwrapping.
Use guard let for early exits.
Use structs for models and value data.
Use classes when reference behavior is needed.
Use protocols for abstraction and testability.
Use extensions to organize code.
Use generics for reusable code.
Use Codable for JSON.
Use async/await for modern asynchronous programming.
Use actors to protect shared state.
Use weak self to avoid closure retain cycles.
Keep code clean, readable, and simple.