Why Preconditions (require, check, error) in Kotlin? - Purpose & Use Cases

The Big Idea

What if a tiny check could save your whole program from crashing unexpectedly?

The Scenario

Imagine you write a program that takes user input for age and you want to make sure the age is not negative. Without preconditions, you have to write many if statements everywhere to check if the input is valid before using it.

The Problem

Manually checking conditions everywhere makes your code long, hard to read, and easy to forget. If you miss a check, your program might crash or behave strangely later, making bugs hard to find.

The Solution

Kotlin's preconditions like require, check, and error let you quickly and clearly state what must be true before your code runs. They stop the program early with helpful messages if something is wrong, keeping your code clean and safe.

Before vs After

✗ Before

if (age < 0) {
    throw IllegalArgumentException("Age cannot be negative")
}
// continue with age

✓ After

require(age >= 0) { "Age cannot be negative" }
// continue with age

What It Enables

This lets you catch problems early and write safer, easier-to-understand code that clearly states its rules.

Real Life Example

When building a banking app, you can use require to ensure withdrawal amounts are positive before processing, preventing mistakes and protecting users.

Key Takeaways

Manual checks clutter code and risk missing errors.

Preconditions provide a simple way to enforce rules upfront.

They improve code safety and clarity by stopping errors early.

Practice

1. What is the primary purpose of the require function in Kotlin?

easy

A. To log warnings without stopping the program

B. To verify the internal state of the program

C. To stop the program immediately with an error message

D. To check if function arguments meet certain conditions

Solution

1. Step 1: Understand require usage

   require is used to check if the inputs to a function are valid before proceeding.

2. Step 2: Differentiate from other preconditions

   check is for program state, and error stops the program immediately. require is specifically for argument validation.

3. Final Answer:

   To check if function arguments meet certain conditions -> Option D

4. Quick Check:

   require = argument check [OK]

Hint: Require checks function inputs are valid before running [OK]

Common Mistakes:

• Confusing require with check for program state
• Thinking error is for argument validation
• Assuming require stops program immediately

2. Which of the following is the correct syntax to use check in Kotlin to verify a condition with a lazy message?

easy

A. check(value > 0, "Value must be positive")

B. check { value > 0, "Value must be positive" }

C. check(value > 0) { "Value must be positive" }

D. check(value > 0); "Value must be positive"

Solution

1. Step 1: Recall check function signature

   check takes a Boolean condition and a lambda returning a message string if false.

2. Step 2: Match syntax with options

   check(value > 0) { "Value must be positive" } uses check(condition) { "message" } which is correct Kotlin syntax.

3. Final Answer:

   check(value > 0) { "Value must be positive" } -> Option C

4. Quick Check:

   check syntax = condition + lambda message [OK]

Hint: Use check(condition) { "message" } syntax [OK]

Common Mistakes:

• Passing message as second argument instead of lambda
• Using comma inside lambda incorrectly
• Omitting braces for message lambda

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

fun test(x: Int) {
    require(x > 0) { "x must be positive" }
    check(x < 10) { "x must be less than 10" }
    println("x is valid: $x")
}

test(15)

medium

A. IllegalStateException: x must be less than 10

B. IllegalArgumentException: x must be positive

C. No output, program stops silently

D. x is valid: 15

Solution

1. Step 1: Evaluate require(x > 0)

   Since 15 > 0, require passes without exception.

2. Step 2: Evaluate check(x < 10)

   15 is not less than 10, so check throws IllegalStateException with message "x must be less than 10".

3. Final Answer:

   IllegalStateException: x must be less than 10 -> Option A

4. Quick Check:

   require passes, check fails with IllegalStateException [OK]

Hint: Require checks args, check checks state; exception shows which failed [OK]

Common Mistakes:

• Thinking require throws error for x=15
• Assuming println runs after failed check
• Confusing exception types thrown by require and check

4. Identify the error in this Kotlin code snippet:

fun validate(name: String) {
    require(name.isNotEmpty(), "Name cannot be empty")
    check(name.length > 3) { "Name too short" }
}

medium

A. check condition should be inside require

B. No error, code is correct

C. require should not have a message

D. Incorrect use of require with message as second argument

Solution

1. Step 1: Review require syntax

   Both require(condition, "message") (eager message) and require(condition) { "message" } (lazy message) are valid overloads.

2. Step 2: Review check syntax

   The lambda syntax for check is also valid. The code compiles and works as expected.

3. Final Answer:

   No error, code is correct -> Option B

4. Quick Check:

   Both eager and lazy messages valid [OK]

Hint: require/check support both eager message and lazy lambda [OK]

Common Mistakes:

• Thinking comma message is invalid for require
• Confusing require syntax with only lambda support
• Forgetting that multiple overloads exist

5. You want to stop your Kotlin program immediately with a custom error message if a critical condition fails.

fun criticalCheck(flag: Boolean) {
    // Your code here
}

hard

A. Use error("Critical failure") if flag is false

B. Use require(flag == false) { "Critical failure" }

C. Use check(flag == false) { "Critical failure" }

D. Use println("Critical failure") and continue

Solution

1. Step 1: Understand error function purpose

   error immediately throws an IllegalStateException with the given message and stops the program.

2. Step 2: Apply error for critical failure

   Use if (!flag) error("Critical failure") to stop execution immediately when condition fails.

3. Final Answer:

   Use error("Critical failure") if flag is false -> Option A

4. Quick Check:

   error stops program immediately with message [OK]

Hint: Use error() to stop program immediately with message [OK]

Common Mistakes:

• Using require or check which throw exceptions but may be caught
• Printing message without stopping program
• Not stopping program on critical failure