Main entry point and @main attribute in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a Swift program with @main attribute

What is the output of this Swift program using the @main attribute?

Swift

import Foundation

@main
struct HelloWorld {
    static func main() {
        print("Hello, Swift!")
    }
}

A No output

B Compilation error: Missing main.swift file

C Runtime error: main function not found

D Hello, Swift!

💡 Hint

The @main attribute marks the program's entry point.

The @main attribute tells Swift where the program starts. The static main() method is called automatically, printing the message.

❓ Predict Output

intermediate

Output when multiple @main structs exist

What happens if you compile this Swift code with two structs marked @main?

Swift

import Foundation

@main
struct FirstApp {
    static func main() {
        print("First")
    }
}

@main
struct SecondApp {
    static func main() {
        print("Second")
    }
}

A Compilation error: Multiple @main types found

B Prints "First" then "Second"

C Prints "Second" only

D Runtime error: ambiguous entry point

💡 Hint

Swift requires exactly one @main entry point.

Swift does not allow more than one @main attribute in a program. This causes a compilation error.

🔧 Debug

advanced

Why does this @main struct fail to compile?

This Swift program uses @main but fails to compile. Why? import Foundation @main struct App { func main() { print("Hello") } }

Swift

import Foundation

@main
struct App {
    func main() {
        print("Hello")
    }
}

A Missing import of SwiftUI

B The struct must be a class to use @main

C main() must be static, but it is an instance method

D main() must return an Int

💡 Hint

The entry point method must be static.

The @main attribute requires a static main() method. Instance methods cannot be used as entry points.

🧠 Conceptual

advanced

Purpose of the @main attribute in Swift

What is the main purpose of the @main attribute in a Swift program?

A To enable multithreading in the program

B To mark the program's entry point where execution starts

C To import the main module automatically

D To define the main user interface layout

💡 Hint

Think about where the program begins running.

The @main attribute tells Swift which type contains the program's starting point, the main() method.

❓ Predict Output

expert

Output of a Swift program using @main with async main

What is the output of this Swift program using an async main method with @main?

Swift

import Foundation

@main
struct AsyncApp {
    static func main() async {
        try? await Task.sleep(nanoseconds: 1_000_000_000) // 1 second
        print("Async Hello")
    }
}

A Async Hello

B Compilation error: async main not supported

C Runtime error: Task.sleep not allowed in main

D No output, program exits immediately

💡 Hint

Swift 5.5+ supports async main methods with @main.

Swift allows async static main() methods with @main. The program waits 1 second then prints the message.

Practice

1. What does the @main attribute do in a Swift program?

easy

A. It marks the program's starting point where execution begins.

B. It defines a class as a data model.

C. It imports external libraries into the program.

D. It declares a variable as constant.

Solution

1. Step 1: Understand the role of @main

   The @main attribute tells Swift which type contains the program's entry point.

2. Step 2: Identify the program start

   This attribute marks where the program starts running, so it controls the first code executed.

3. Final Answer:

   It marks the program's starting point where execution begins. -> Option A

4. Quick Check:

   @main marks start point [OK]

Hint: Remember: @main means 'start here' in Swift programs [OK]

Common Mistakes:

• Confusing @main with import statements
• Thinking @main defines variables
• Assuming @main is for classes only

2. Which of the following is the correct way to declare the main entry point using @main in Swift?

easy

A. @main struct App { static func main() { print("Hello") } }

B. struct App { @main func main() { print("Hello") } }

C. @main func main() { print("Hello") }

D. func main() { @main print("Hello") }

Solution

1. Step 1: Check the placement of @main

   The @main attribute must be placed before a type (struct, class, or enum), not before a function.

2. Step 2: Verify the static main() method

   The type marked with @main must have a static main() method as the entry point.

3. Final Answer:

   @main struct App { static func main() { print("Hello") } } -> Option A

4. Quick Check:

   @main before type + static main() [OK]

Hint: Put @main before a type, not a function [OK]

Common Mistakes:

• Placing @main before a function instead of a type
• Missing static keyword on main()
• Using @main inside a function body

3. What will be the output of this Swift program?

@main struct MyApp {
    static func main() {
        print("Start")
        run()
    }
    static func run() {
        print("Running")
    }
}

medium

A. No output, program error

B. Running\nStart

C. Start

D. Start\nRunning

Solution

1. Step 1: Identify the program start

   The @main attribute marks MyApp as the entry point, so main() runs first.

2. Step 2: Trace the function calls

   main() prints "Start" then calls run(), which prints "Running".

3. Final Answer:

   Start Running -> Option D

4. Quick Check:

   main() prints Start then run() prints Running [OK]

Hint: Follow the call order inside static main() [OK]

Common Mistakes:

• Assuming run() runs before main()
• Forgetting to call run() inside main()
• Thinking @main runs run() automatically

4. Identify the error in this Swift program using @main:

@main class App {
    func main() {
        print("Hello")
    }
}

medium

A. The @main attribute cannot be used on a class.

B. The main() method must be static.

C. The print statement is invalid inside main().

D. The class must be a struct instead.

Solution

1. Step 1: Check the main() method signature

   The @main type must have a static main() method to serve as the entry point.

2. Step 2: Identify the missing static keyword

   Here, main() is an instance method, missing static, causing a compile error.

3. Final Answer:

   The main() method must be static. -> Option B

4. Quick Check:

   main() must be static in @main type [OK]

Hint: Static main() is required inside @main type [OK]

Common Mistakes:

• Omitting static keyword on main()
• Thinking @main can't be on classes
• Confusing instance and static methods

5. You want to create a Swift program that prints "Welcome!" only if a condition is true at startup. Using @main, which is the best way to implement this?

hard

A. struct App {
static func main() {
if true {
print("Welcome!")
}
}
}

B. @main struct App {
func main() {
if true {
print("Welcome!")
}
}
}

C. @main struct App {
static func main() {
if true {
print("Welcome!")
}
}
}

D. @main func main() {
if true {
print("Welcome!")
}
}

Solution

1. Step 1: Use @main on a type with static main()

   The program must have a type marked with @main and a static main() method to run at startup.

2. Step 2: Implement conditional print inside static main()

   Inside main(), use the if statement to print "Welcome!" only if the condition is true.

3. Final Answer:

   @main struct App { static func main() { if true { print("Welcome!") } } } -> Option C

4. Quick Check:

   @main type + static main() + condition inside main() [OK]

Hint: Always put @main on type with static main() method [OK]

Common Mistakes:

• Making main() an instance method
• Forgetting @main attribute on the type
• Trying to put @main on a function