Main entry point and @main attribute in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define the main entry point of a Swift program using the @main attribute.

Swift

@[1]
struct MyApp {
    static func main() {
        print("Hello, Swift!")
    }
}

Drag options to blanks, or click blank then click option'

Astart

Bmain

Centry

Dlaunch

Attempts:

3 left

💡 Hint

Common Mistakes

Using @start or @entry instead of @main.

Forgetting the @ symbol before main.

The @main attribute tells Swift where the program starts. You must use @main to mark the main entry point.

2fill in blank

medium

Complete the code to define the main function inside a struct marked with @main.

Swift

@main
struct App {
    static func [1]() {
        print("App started")
    }
}

Drag options to blanks, or click blank then click option'

Astart

Blaunch

Crun

Dmain

Attempts:

3 left

💡 Hint

Common Mistakes

Naming the function 'start' or 'run' instead of 'main'.

Making the function non-static.

The main function must be named 'main' to be recognized as the program's entry point.

3fill in blank

hard

Fix the error in the code by completing the missing attribute to mark the main entry point.

Swift

[1]
struct Program {
    static func main() {
        print("Running program")
    }
}

Drag options to blanks, or click blank then click option'

A@main

B@launch

C@entry

D@start

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect attributes like @start or @entry.

Not marking the struct at all.

You must mark the struct with @main to tell Swift this is the program's entry point.

4fill in blank

hard

Fill both blanks to create a Swift program with a main entry point that prints a message.

Swift

@[1]
struct [2] {
    static func main() {
        print("Welcome!")
    }
}

Drag options to blanks, or click blank then click option'

Amain

Bstart

CMyApp

DProgram

Attempts:

3 left

💡 Hint

Common Mistakes

Using @start instead of @main.

Using invalid struct names.

Use @main to mark the struct, and the struct name can be any valid identifier like MyApp.

5fill in blank

hard

Fill all three blanks to define a Swift program with a main entry point that prints a custom message.

Swift

@[1]
struct [2] {
    static func [3]() {
        print("Hello from Swift!")
    }
}

Drag options to blanks, or click blank then click option'

Amain

Bstart

DApp

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong attribute names.

Naming the function something other than 'main'.

Using invalid struct names.

The attribute is '@main', the struct name can be 'App', and the function must be named 'main'.

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