You transfer your knowledge to the compiler

With Kotlin Contracts, you can “sign an agreement” between you and the compiler — if something goes wrong, the compiler will “sue” you (by crashing the application).

However, Contracts are deterministic and describe the natural effect of your code, hence it is highly unlikely for a contract to cause a crash if carefully declared.

The effect of the contract helps the compiler in the static analysis process. 
For example, if you create a function that returns true if the argument is not null, then the compiler can use this information to smart cast the argument to a non-nullable type outside the function.

How do Contracts work?

Functions produce effects

A contract adds an effect to a function.
If a function f has an effect e, we say that the invocation of f produces the effect e.

The compiler tracks all the effects produced and uses them to enhance the static analysis step.

You can declare a contract only at the beginning of a function using the Contract DSL.

Contracts syntax

Contract Effects

You can use the following functions to declare a contract:

• returns(value)
• returnsNotNull()
• implies(booleanExpression)
• callsInPlace(lambda, kind)

‘Returns’ Effect

The returns(value) function describes a situation when a function returns normally with the specified value.

The returnsNotNull() functions describe a situation when a functionreturns a non-null value.

Both these functions can be composed together with the implies function to form an effect.

The implies(booleanExpression) specifies that this effect, when observed, guarantees booleanExpression to be true.

Returns effect example

In the code snippet from above, if the function isNotNull returns true, the expression this@isNotNull != null (line 13) is guaranteed to be true.

Hence, if our function returns true, then the compiler understands that the receiver String is not null and smart casts it to a non-nullable String, outside the extension function.

‘CallsInPlace’ Effect

Let’s take the following example:

Error (line 3): “Captured member values initialization is forbidden due to possible reassignment”

This code snippet does not compile because the compiler is not able to determine that the lambda from lines 2–4 gets executed only once.

From the compiler’s perspective, this lambda could be executed many times, initiating the a variable more than once.

For the code from above to run successfully, the compiler should somehow know that the block gets executed only once.

Let’s take the same example, this time using a mutable variable (var):

Error (line 5): “Variable ‘a’ must be initialized”