Sealed classes with when exhaustive check in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a sealed class named Shape.

Kotlin

sealed class [1]

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

AclassShape

BShape

Cshape

DsealedShape

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase or incorrect class names.

Adding extra words to the class name.

The sealed class must be named Shape exactly as intended.

2fill in blank

medium

Complete the code to define a data class Circle inheriting from Shape with a radius property.

Kotlin

data class Circle(val radius: Double) : [1]()

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

AShape

Bshape

CCircle

Dsealed

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase 'shape' instead of 'Shape'.

Trying to inherit from the same class name.

The class Circle must inherit from the sealed class Shape.

3fill in blank

hard

Fix the error in the when expression to make it exhaustive for Shape.

Kotlin

fun area(shape: Shape): Double = when(shape) {
    is Circle -> Math.PI * shape.radius * shape.radius
    is Rectangle -> shape.width * shape.height
    [1]
}

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

Ais Shape -> 0.0

Bis Square -> shape.side * shape.side

Celse -> 0.0

Dis Triangle -> 0.5 * shape.base * shape.height

Attempts:

3 left

💡 Hint

Common Mistakes

Missing the else branch causing compilation error.

Adding incorrect or incomplete subclass checks.

Adding else makes the when expression exhaustive if not all subclasses are covered.

4fill in blank

hard

Fill both blanks to create a when expression that is exhaustive without else, covering all subclasses.

Kotlin

fun describe(shape: Shape): String = when(shape) {
    is Circle -> "Circle with radius ${shape.radius}"
    [1] -> "Rectangle with width ${shape.width} and height ${shape.height}"
    [2] -> "Square with side ${shape.side}"
}

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

Ais Rectangle

Bis Square

Cis Triangle

Delse

Attempts:

3 left

💡 Hint

Common Mistakes

Using else instead of subclass names.

Missing one subclass causing non-exhaustive error.

To make the when exhaustive without else, all subclasses must be covered explicitly.

5fill in blank

hard

Fill all three blanks to create a sealed class hierarchy and an exhaustive when expression that returns area.

Kotlin

sealed class [1]
data class Circle(val radius: Double) : [1]()
data class Rectangle(val width: Double, val height: Double) : [1]()
fun area(shape: [1]): Double = when(shape) {
    is Circle -> Math.PI * shape.radius * shape.radius
    is Rectangle -> shape.width * shape.height
}

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

AShape

BCircle

CRectangle

Dsealed

Attempts:

3 left

💡 Hint

Common Mistakes

Using different class names in inheritance.

Using 'sealed' keyword instead of class name.

All classes inherit from the sealed class Shape, and the function uses it as parameter type.

Practice

1. What is the main benefit of using sealed classes in Kotlin when combined with a when expression?

easy

A. The when expression becomes exhaustive, ensuring all cases are handled.

B. It allows subclassing from any file in the project.

C. It automatically generates getter and setter methods.

D. It makes the class open for inheritance everywhere.

Solution

1. Step 1: Understand sealed classes restriction

   Sealed classes restrict subclassing to the same file, so all subclasses are known at compile time.

2. Step 2: Effect on when expression

   This allows the when expression to be exhaustive because the compiler knows all possible subclasses.

3. Final Answer:

   The when expression becomes exhaustive, ensuring all cases are handled. -> Option A

4. Quick Check:

   Sealed classes + when = exhaustive check [OK]

Hint: Sealed classes limit subclasses, making when exhaustive [OK]

Common Mistakes:

• Thinking sealed classes allow subclassing anywhere
• Confusing sealed classes with data classes
• Believing sealed classes auto-generate methods

2. Which of the following is the correct syntax to declare a sealed class in Kotlin?

easy

A. sealed class Shape {}

B. open sealed class Shape {}

C. sealed interface Shape {}

D. final sealed class Shape {}

Solution

1. Step 1: Recall sealed class declaration syntax

   In Kotlin, sealed classes are declared with the keyword sealed followed by class and the class name.

2. Step 2: Check options for correctness

   sealed class Shape {} uses correct syntax: sealed class Shape {}. open sealed class Shape {} incorrectly adds open, which is not allowed. sealed interface Shape {} uses sealed interface, which is invalid. final sealed class Shape {} uses final sealed class, which is not allowed.

3. Final Answer:

   sealed class Shape {} -> Option A

4. Quick Check:

   sealed class declaration = sealed class Shape {} [OK]

Hint: Use only 'sealed class ClassName' to declare sealed classes [OK]

Common Mistakes:

• Adding 'open' modifier to sealed class
• Trying to declare sealed interfaces (not allowed)
• Using 'final' modifier with sealed class

3. Given the sealed class hierarchy below, what will be the output of the describe function when called with Shape.Circle(5.0)?

sealed class Shape {
    data class Circle(val radius: Double) : Shape()
    data class Rectangle(val width: Double, val height: Double) : Shape()
}

fun describe(shape: Shape): String = when(shape) {
    is Shape.Circle -> "Circle with radius ${shape.radius}"
    is Shape.Rectangle -> "Rectangle with width ${shape.width} and height ${shape.height}"
}

medium

A. Rectangle with width 5.0 and height 5.0

B. Compilation error due to missing else branch

C. Shape.Circle

D. Circle with radius 5.0

Solution

1. Step 1: Identify the input and matching when branch

   The input is Shape.Circle(5.0). The when expression matches is Shape.Circle branch.

2. Step 2: Evaluate the returned string

   The branch returns the string "Circle with radius 5.0" using the radius property.

3. Final Answer:

   Circle with radius 5.0 -> Option D

4. Quick Check:

   Input Circle(5.0) returns "Circle with radius 5.0" [OK]

Hint: Match input type in when to get correct output string [OK]

Common Mistakes:

• Confusing Circle with Rectangle output
• Expecting a compilation error due to else missing
• Returning class name instead of formatted string

4. Consider the following code snippet. What is the error and how can it be fixed?

sealed class Result {
    object Success : Result()
    object Failure : Result()
}

fun handle(result: Result) = when(result) {
    is Result.Success -> "Success"
}

medium

A. Runtime error: Result.Failure is not handled and causes crash.

B. Compilation error: when expression is not exhaustive; add branch for Result.Failure.

C. No error; code runs fine and returns null for Result.Failure.

D. Syntax error: sealed classes cannot have object subclasses.

Solution

1. Step 1: Identify the sealed class subclasses

   Result has two subclasses: Success and Failure.

2. Step 2: Check when expression branches

   The when expression only handles Result.Success, missing Result.Failure branch.

3. Step 3: Understand Kotlin's exhaustiveness check

   Since Result is sealed, when must handle all subclasses or have an else branch. Missing Failure causes compilation error.

4. Final Answer:

   Compilation error: when expression is not exhaustive; add branch for Result.Failure. -> Option B

5. Quick Check:

   Sealed class when must cover all subclasses [OK]

Hint: Add all sealed subclasses in when to avoid errors [OK]

Common Mistakes:

• Assuming runtime error instead of compile error
• Ignoring missing branches in when
• Thinking sealed classes can't have object subclasses

5. You have a sealed class Operation with subclasses Add, Subtract, and Multiply. Write a Kotlin function calculate that takes an Operation and two integers, and returns the result of applying the operation. Which of the following implementations correctly uses an exhaustive when expression?

hard

A. fun calculate(op: Operation, a: Int, b: Int): Int = when(op) {
is Operation.Add -> a + b
else -> 0
}

B. fun calculate(op: Operation, a: Int, b: Int): Int = when(op) {
is Operation.Add -> a + b
is Operation.Subtract -> a - b
}

C. fun calculate(op: Operation, a: Int, b: Int): Int = when(op) {
is Operation.Add -> a + b
is Operation.Subtract -> a - b
is Operation.Multiply -> a * b
}

D. fun calculate(op: Operation, a: Int, b: Int): Int = when(op) {
is Operation.Multiply -> a * b
else -> a + b
}

Solution

1. Step 1: Check all subclasses handled in when

   Operation has Add, Subtract, Multiply. fun calculate(op: Operation, a: Int, b: Int): Int = when(op) { is Operation.Add -> a + b is Operation.Subtract -> a - b is Operation.Multiply -> a * b } handles all three explicitly.

2. Step 2: Verify exhaustiveness and correctness

   fun calculate(op: Operation, a: Int, b: Int): Int = when(op) { is Operation.Add -> a + b is Operation.Subtract -> a - b is Operation.Multiply -> a * b } covers all subclasses, so when is exhaustive. The other options miss some subclasses or rely on else, which is less clear.

3. Final Answer:

   fun calculate(op: Operation, a: Int, b: Int): Int = when(op) { is Operation.Add -> a + b is Operation.Subtract -> a - b is Operation.Multiply -> a * b } -> Option C

4. Quick Check:

   All subclasses covered in when = exhaustive [OK]

Hint: Cover all sealed subclasses explicitly for exhaustive when [OK]

Common Mistakes:

• Missing some subclasses in when branches
• Using else instead of explicit branches
• Returning wrong default values