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.

Practice

1. Why does Swift use strong typing for variables and constants?

easy

A. To catch errors early and make code safer

B. To allow variables to change types anytime

C. To make code run faster by ignoring types

D. To let programmers skip declaring types

Solution

1. Step 1: Understand strong typing purpose

   Strong typing means every variable has a fixed type to avoid mistakes.

2. Step 2: Identify why Swift uses it

   Swift uses strong typing to catch errors early and keep code safe.

3. Final Answer:

   To catch errors early and make code safer -> Option A

4. Quick Check:

   Strong typing = safer code [OK]

Hint: Strong typing means fixed types for safety [OK]

Common Mistakes:

• Thinking variables can change types freely
• Believing types are ignored for speed
• Assuming types are optional in Swift

2. Which of the following is the correct way to declare a strongly typed integer variable in Swift?

easy

A. var age = "25"

B. var age: Int = 25

C. var age: String = 25

D. var age = 25.0

Solution

1. Step 1: Check variable declaration syntax

   In Swift, you declare a variable with var, specify type with colon, then assign value.

2. Step 2: Match type and value

   var age: Int = 25 declares age as Int and assigns 25, which is correct for strong typing.

3. Final Answer:

   var age: Int = 25 -> Option B

4. Quick Check:

   Correct type and value match = var age: Int = 25 [OK]

Hint: Match variable type and value exactly [OK]

Common Mistakes:

• Assigning string to an Int type
• Using wrong type annotation
• Mixing number types like Int and Double

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

let number: Int = 10
let text: String = "10"
print(number == Int(text)!)

medium

A. false

B. Compilation error

C. true

D. Runtime error

Solution

1. Step 1: Understand type conversion

   text is a String "10". Int(text)! converts it to Int 10 safely.

2. Step 2: Compare values

   number is Int 10, Int(text)! is also 10, so number == Int(text)! is true.

3. Final Answer:

   true -> Option C

4. Quick Check:

   10 == 10 is true [OK]

Hint: Convert string to Int before comparing [OK]

Common Mistakes:

• Assuming string and int compare directly
• Ignoring forced unwrap with !
• Expecting false because types differ

4. Identify the error in this Swift code snippet:

var score: Int = "100"
print(score)

medium

A. Variable score is not initialized

B. Missing semicolon at end of line

C. print function syntax is incorrect

D. Type mismatch: assigning String to Int variable

Solution

1. Step 1: Check variable type and assigned value

   score is declared as Int but assigned a String "100" which is invalid.

2. Step 2: Understand Swift's strong typing rules

   Swift does not allow assigning a String to an Int variable without conversion.

3. Final Answer:

   Type mismatch: assigning String to Int variable -> Option D

4. Quick Check:

   Type mismatch error = Type mismatch: assigning String to Int variable [OK]

Hint: Match variable type and assigned value exactly [OK]

Common Mistakes:

• Thinking semicolon is required
• Assuming implicit conversion from String to Int
• Believing print syntax is wrong

5. You want to create a function in Swift that accepts only integers and returns their square. Why is strong typing important here?

hard

A. It ensures only integers are passed, preventing errors

B. It allows passing any type without restrictions

C. It automatically converts strings to integers

D. It makes the function run faster by ignoring types

Solution

1. Step 1: Understand function parameter typing

   Strong typing requires the function to accept only Int type, avoiding wrong inputs.

2. Step 2: Recognize benefits of strong typing in functions

   This prevents runtime errors by catching type mistakes early.

3. Final Answer:

   It ensures only integers are passed, preventing errors -> Option A

4. Quick Check:

   Strong typing = safer function inputs [OK]

Hint: Strong typing prevents wrong input types [OK]

Common Mistakes:

• Thinking any type can be passed
• Assuming automatic type conversion
• Believing types slow down functions