Why Swift is strongly typed - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift code with type safety?

Consider this Swift code snippet. What will it print?

Swift

let number: Int = 10
let text: String = "20"
// What happens if we try to add number + text?
// print(number + text) // Uncommenting this line causes an error

print(number)

A Compilation error

B 30

C 10

D 1020

💡 Hint

Swift does not allow adding an Int and a String directly.

Swift is strongly typed, so it prevents adding an Int and a String without explicit conversion. The commented line causes a compile error. The print(number) line prints 10.

🧠 Conceptual

intermediate

Why does Swift require explicit type conversion?

Why does Swift require you to convert types explicitly instead of allowing implicit conversions?

A To prevent unexpected bugs by enforcing clear type usage

B To make the code run faster by skipping conversions

C Because Swift does not support multiple data types

D To allow variables to change types automatically

💡 Hint

Think about how clear rules help avoid mistakes in your code.

Swift's strong typing forces explicit conversions to avoid bugs caused by mixing incompatible types silently.

🔧 Debug

advanced

What error does this Swift code produce?

Look at this Swift code. What error will it cause?

Swift

var value: Int = 5
value = "10"

A Runtime error: Invalid cast

B Type mismatch error: Cannot assign String to Int

C No error, value becomes 10

D Syntax error: Missing semicolon

💡 Hint

Check the variable type and the assigned value type.

Swift does not allow assigning a String to an Int variable. This causes a compile-time type mismatch error.

❓ Predict Output

advanced

What is the output of this Swift function using strong typing?

What will this Swift function print?

Swift

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

let result = multiply(3, 4)
print(result)

A 12

B 7

C 34

D Compilation error

💡 Hint

Check the multiplication of 3 and 4.

The function multiply takes two Ints and returns their product. 3 * 4 = 12.

🚀 Application

expert

How does Swift's strong typing help prevent bugs in this scenario?

Imagine you have a function that takes a user age as an Int. What problem does strong typing help avoid?

A Automatically converting age to a String when printing

B Ignoring the age parameter if it is zero

C Allowing the age to be negative without warning

D Passing a String like "twenty" instead of an Int, causing a compile error

💡 Hint

Think about what happens if you try to pass text instead of a number.

Strong typing forces the age parameter to be an Int, so passing a String like "twenty" causes a compile-time error, preventing bugs.