Preconditions (require, check, error) in Kotlin - Step-by-Step Execution

Concept Flow - Preconditions (require, check, error)

Start Function

↓

Check require(condition)

↓

Throw IllegalArgumentException

↓

Check check(condition)

↓

Throw IllegalStateException

↓

Call error(message)

↓

Throw IllegalStateException

↓

Continue Execution

The function starts by checking conditions with require and check. If conditions fail, exceptions are thrown. error always throws an exception immediately.

Execution Sample

Kotlin

fun validateAge(age: Int) {
    require(age >= 0) { "Age must be non-negative" }
    check(age < 150) { "Age must be realistic" }
    if (age == 100) error("Age cannot be 100")
}

This function checks if age is valid using require, check, and error to stop execution with messages if conditions fail.

Execution Table

Step	Condition Checked	Condition Result	Action Taken	Exception Thrown
1	require(age >= 0)	True	Continue	None
2	check(age < 150)	True	Continue	None
3	if (age == 100)	True	error called	IllegalStateException
4	Function ends	-	Execution completes	None

💡 Execution stops normally because all conditions passed and error was not called.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
age	Input value	Input value	Input value	Input value	Input value

Key Moments - 3 Insights

Why does require throw IllegalArgumentException but check throws IllegalStateException?

require is for checking arguments passed to a function and throws IllegalArgumentException if false (see Step 1). check is for checking internal state and throws IllegalStateException if false (see Step 2).

What happens when error() is called?

error() immediately throws an IllegalStateException with the given message and stops execution (would happen at Step 3 if condition true).

If require condition fails, does the rest of the function run?

No, if require fails (condition false), it throws an exception immediately and stops further execution (see Step 1 false branch).

Visual Quiz - 3 Questions

Look at the execution table, what exception is thrown if require condition fails?

A NullPointerException

B IllegalStateException

C IllegalArgumentException

D No exception

💡 Hint

Check Step 1 in the execution_table where require is evaluated.

At which step does check condition get evaluated?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Condition Checked' column in the execution_table.

If age is 100, what happens at Step 3?

A error() is called and throws IllegalStateException

B No action, continue execution

C require fails and throws IllegalArgumentException

D check fails and throws IllegalStateException

💡 Hint

See the condition and action at Step 3 in the execution_table.

Concept Snapshot

Preconditions in Kotlin:
- require(condition) checks arguments, throws IllegalArgumentException if false
- check(condition) checks internal state, throws IllegalStateException if false
- error(message) always throws IllegalStateException immediately
Use these to stop execution early with clear error messages.

Full Transcript

This visual execution shows how Kotlin preconditions work. The function starts and first uses require to check if the argument meets a condition. If require fails, it throws IllegalArgumentException and stops. If require passes, check tests internal state and throws IllegalStateException if it fails. The error function always throws an exception immediately when called. The execution table traces these steps with conditions and actions. Variable tracking shows the input value remains unchanged. Key moments clarify the difference between require and check exceptions and what error does. The quiz tests understanding of which exceptions are thrown and when. This helps beginners see how preconditions protect code by stopping execution early with helpful messages.

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