compare the creation of a map by using both the `to` infix function and the `Pair` constructor to create the individual pairs:

```kotlin
val nigeriaCallingCodePair = 234 to "Nigeria"
val nigeriaCallingCodePair2 = Pair(234, "Nigeria") // same as above
val nigeriaCallingCodePair3 = 234.to("Nigeria") // same as using 234 to "Nigeria"

val callingCodesMap: Map = mapOf(234 to "Nigeria", 1 to "USA", 233 to "Ghana")
val callingCodesPairMap: Map = mapOf(Pair(234, "Nigeria"), Pair(1, "USA"), Pair(233, "Ghana"))
```

### Extension Function
Kotlin provides the ability to extend a class with new functionality without having to inherit from the class or use design patterns such as Decorator. For example, you can write new functions for a class from a third-party library that you can't modify.

To declare an extension function, we need to prefix its name with a receiver type, i.e. the type being extended.

```kotlin
fun MutableList.swap(index1: Int, index2: Int) {
// the this keyword inside an extension function corresponds to the receiver object (the one that is passed before the dot).
val tmp = this[index1] // 'this' corresponds to the list
this[index1] = this[index2]
this[index2] = tmp
}
```

Extension cannot be overloaded. So, it’s impossible to use the override keyword to modify the behavior of an extension that’s already been created.

If a class has a member function, and an extension function is defined which has the same receiver type, the same name, and is applicable to given arguments, the member always wins.

> **Extensions are resolved statically**
>
> Extensions do not actually modify classes they extend. By defining an extension, you do not insert new members into a class, but merely make new functions callable with the dot-notation on variables of this type.
>
> Extension functions are dispatched statically, i.e. they are not virtual by receiver type. This means that the extension function being called is determined by the type of the expression on which the function is invoked, not by the type of the result of evaluating that expression at runtime.

### Extension Properties
```kotlin
val List.lastIndex: Int
get() = size - 1
```

Note that, since extensions do not actually insert members into classes, there's no efficient way for an extension property to have a backing field. This is why **initializers are not allowed for extension properties**. Their behavior can only be defined by explicitly providing getters/setters.

```kotlin
val House.number = 1 // error: initializers are not allowed for extension properties
```

### Declaring Extensions as Members
Inside a class, you can declare extensions for another class. Inside such an extension, there are multiple implicit receivers - objects members of which can be accessed without a qualifier. The instance of the class in which the extension is declared is called **dispatch receiver**, and the instance of the receiver type of the extension method is called **extension receiver**.

```kotlin
class Host(val hostname: String) {
fun printHostname() { print(hostname) }
}

class Connection(val host: Host, val port: Int) {
fun printPort() { print(port) }

fun Host.printConnectionString() {
printHostname() // calls Host.printHostname()
print(":")
printPort() // calls Connection.printPort()
}

fun connect() {
/*...*/
host.printConnectionString() // calls the extension function
}
}

fun main() {
Connection(Host("kotl.in"), 443).connect()
//Host("kotl.in").printConnectionString(443) // error, the extension function is unavailable outside Connection
}
```

In case of a name conflict between the members of the dispatch receiver and the extension receiver, the extension receiver takes precedence. To refer to the member of the dispatch receiver you can use the qualified `this` syntax.

```kotlin
class Connection {
fun Host.getConnectionString() {
toString() // calls Host.toString()
this@Connection.toString() // calls Connection.toString()
}
}
```

Extensions declared as members can be declared as `open` and overridden in subclasses. This means that the dispatch of such functions is virtual with regard to the dispatch receiver type, but static with regard to the extension receiver type.

```kotlin
open class Base { }

class Derived : Base() { }

open class BaseCaller {
open fun Base.printFunctionInfo() {
println("Base extension function in BaseCaller")
}

open fun Derived.printFunctionInfo() {
println("Derived extension function in BaseCaller")
}

fun call(b: Base) {
b.printFunctionInfo() // call the extension function
}
}

class DerivedCaller: BaseCaller() {
override fun Base.printFunctionInfo() {
println("Base extension function in DerivedCaller")
}

override fun Derived.printFunctionInfo() {
println("Derived extension function in DerivedCaller")
}
}

fun main() {
BaseCaller().call(Base()) // "Base extension function in BaseCaller"
DerivedCaller().call(Base()) // "Base extension function in DerivedCaller" - dispatch receiver is resolved virtually
DerivedCaller().call(Derived()) // "Base extension function in DerivedCaller" - extension receiver is resolved statically
}
```

### Extension Visibility
- An extension declared on top level of a file has access to the other private top-level declarations in the same file.
- If an extension is declared outside its receiver type, such an extension cannot access the receiver's private members.

Conditions
---
```kotlin
val state = readline()
val capital: String?

when (state) {
"CA" -> capital = "Sacramento"
"OR" -> capital = "Salem"
"NH", "VT", "MA" -> capital = "New England"
else -> capital = "Unknown"
}

println("The capital is $capital")
```
or
```kotlin
val state = readline()
val capital = when (state) {
"CA" -> "Sacramento"
"OR" -> "Salem"
"NH", "VT", "MA" -> "New England"
else -> "Unknown"
}

println("The capital is $capital")
```

```kotlin
val answer = 42
when (answer) {
in 1..49 -> println("Not yet")
in 50..75 -> println("Close enough")
else -> {
println("Definitely not!")
println("No really")
}
}
```
or
```kotlin
when {
number < 1 -> print("Number is less than 1")
number > 1 -> print("Number is greater than 1")
}
```

### Null Values
```kotlin
var nullvalue: String? = null
println("nullValue is $nullValue") // null

val length: Int? = nullValue?.length
println("length is $length") // length is null

val message = if (length != null) "length is $length" else "length is null"
println(message)

val length2: Int = length ?: -1
println("length2 is $length2") // length2 is -1

val length3: Int = length!!
try {
print("length3 is $length3") // will raise KotlinNullPointerException because length is null
} catch(e: KotlinNullPointerException) {
println("length3 is null")
}
```

### Loops
```kotlin
val colors = arrayOf("Red", "Green", "Blue")
val values = intArrayOf(1, 3, 5, 7, 9)

// for each loop
for (color in colors) {
println(color)
}

// for loop with indices
for (i in values.indices step 2) {
println(values[i])
}

for (i in 0 until colors.size) { // 0..colors.size - 1
println(colors[i])
}

// while loop
var counter = 0
while (counter < colors.size) {
println("color = ${colors[counter]}")
++counter
}

// do/while loop
counter = 0
do {
println("color = ${colors.get(counter)}")
++counter
} while (counter < colors.size)
```

Classes
---
### Object
Kotlin has language support for creating singletons with the `object` keyword.

### Companion Object
The same as with normal objects, companion objects cannot have constructors, but can extend other classes and implement interfaces.
```kotlin
class MathLib {
companion object {
fun addValues(num1: Int, num2: Int) = num1 + num2
}
}
```

### Enum Class
```kotlin
enum class Operation(val operator: String) {
ADD("+"), SUBTRACT("-"), MULTIPLY("*"), DIVIDE("/")
}
```

### Data Class
To ensure consistency and meaningful behavior of the generated code, data classes have to fulfill the following requirements:

- The primary constructor needs to have at least one parameter;
- All primary constructor parameters need to be marked as `val` or `var`;
- Data classes cannot be abstract, open, sealed or inner;
- (before 1.1) Data classes may only implement interfaces.

```kotlin
// primary constructor
data class ClothingItem(val type: String,
val size: String,
val price: Double)

fun main() {
val item = ClothingItem("Short", "L", 19.99)
println(item) // ClothingItem(type=short, size=L, price=19.99)
}
```

### Class Constructors
```kotlin
// primary constructor
data class ClothingItem constructor (var type: String?,
val size: String,
val price: Double) {
// executed when primary constructor called
init {
type = type?.toUpperCase() ?: "UNKNOWN"
}

// secondary constructor: has to daisy chain to primary constructor
constructor(size: String, price: Double): this(null, size, price) {
// type = "Unknown"
}
}

fun main() {
val item = ClothingItem("M", 14.99)
println(item) // ClothingItem(type=UNKNOWN, size=M, price=14.99)
}
```

### Class Properties
```kotlin
data class ClothingItem(private var _type: String?,
val size: String,
private var _price: Double) {
var type: String? = _type
get() = field ?: "Unknown"

var price = _price
set(value) {
field = value * .9
}
}

fun main() {
val item = ClothingItem("M", 14.99)
println("item type = ${item.type}") // item type = Unknown

item.price = 10.0
println("item price = ${item.price}") // item price = 9.0
}
```

### Inheritance
```kotlin
open class SuperClass(anInt: Int) {
protected val _anInt = anInt

override fun toString(): String {
return "${this::class.simpleName} [anInt: $_anInt]"
}

open fun multiply(factor: Int): Int {
return _anInt * factor
}
}

class SubClass(anInt: Int): SuperClass(anInt) {
override fun multiple(factor: Int): Int {
return super.multiply(factor) * factor
}
}
```

### Interface
```kotlin
interface Dog {
var fur: String
fun speak() {
println("Woof!")
}
}

interface Cat {
var fur: String
fun speak() {
println("Meow!")
}
}

class Retriever: Dog, Cat {
override var fur: String
get() = "golder"
set(value) {}

override fun speak() {
super.speak()
}
}

fun makeItTalk(dog: Dog) {
dog.speak()
}

fun reportBreed(name: String, dog: Dog) {
println("$name is a ${dog::class.simpleName}")
}

fun main() {
val buster = Retriever()
makeItTalk(buster)
reportBreed("Buster", buster)
}
```

### Callbacks
```kotlin
class ClickEvent(x: Int, y: Int)

interface ClickListener {
fun onClick(event: ClickEvents)
}

class StatefulWidget(listener: ClickListener) {
private var _listener: ClickListener? = listener

fun click(x: Int, y: Iny) {
listener?.onClick(ClickEvent(x, y))
}
}

fun main() {
// using anonymous object
val widget = StatefulWidget(object: ClickListener {
override fun onClick(event: ClickEvent) {
println("clicked at (${event.x}, ${event.y})s")
}
})

widget.click(5, 18)
}
```

### Sealed Class
```kotlin
// abstract class
sealed class ClothingItem(val type: String) {
abstract val size: String
abstract val price: Double
}

// subclasses must be in the same code file
data class Shirt(override var size: String,
override var price: Double): ClothingItem("Shirt")

data class Pants(override var size: String,
override var price: Double): ClothingItem("Pants")

fun main() {
val item1 = Shirt("XL", 19.99)
val item2 = Pants("32", 24.99)

val mostExpensive =
if (item1.price > item2.price) item1 else item2

val instructions = when(mostExpensive) {
is Shirt -> "Button it!"
is Pants -> "Buckle it!"
}

println(instructions)
}
```

More Kotlin
---

### Enums
Enums are **exhaustive** in `when` expressions (`switch` in Java). In Kotlin, we can return on expressions or assign a value to one, forcing each branch of the expression to supply a valid value to fulfill the expression return type.

> In **Java**, `enum` are static singleton objects that cannot have multiple instances.

### Sealed Class
**Sealed Classes** are a special kind of class such that the Kotlin compiler can verify all subtypes during compilation, adding some unique benefits.

To allow our `enum` to hold state, but have the compiler verify we covered all cases of an instance, we change the declaration to a `sealed class`.

```kotlin
sealed class Result {
data class Success (val data: T): Result()
data class Error(val exception: Exception): Result()
object InProgress: Result()
}

fun handleResult(result: Result) {
val action = when(result) {
is Result.Success -> {}
is Result.Error -> {}
Result.InProgress -> {}
}.exhaustive
}

val .exhaustive: T
get() = this
```

### Unit
`Unit` in Kotlin corresponds to the `void` in Java. Like void, Unit is the return type of any function that does not return any meaningful value, and it is optional to mention the Unit as the return type. But unlike void, Unit is a real class (Singleton) with only one instance.

### Nothing
`Nothing` is a type in Kotlin that represents "a value that never exists", that means just "no value at all".

### `lateinit` vs `lazy`
`lateinit`:
- Use it with mutable variable `var`
```kotlin
lateinit var name: String //Allowed
lateinit val name: String //Not Allowed
```

- Allowed with only **non-nullable** data types
```kotlin
lateinit var name: String //Allowed
lateinit var name: String? //Not Allowed
```

- It is a promise to compiler that the value will be initialized in future.

> If you try to access `lateinit` variable without initializing it then it throws `UnInitializedPropertyAccessException`.

`lazy`:
- Lazy initialization was designed to prevent unnecessary initialization of objects.
- Your variable will not be initialized unless you use it.
- It is initialized only once. Next time when you use it, you get the value from cache memory.
- It is thread safe (It is initializes in the thread where it is used for the first time. Other threads use the same value stored in the cache).
- The variable can only be `val`.
- The variable can only be **non-nullable**.

```kotlin
val aVar by lazy {
println("I am computing this value") // prints only once
"Hola" // the return value of lambda expression
}

fun main(args: Array) {
println(aVar)
println(aVar)
}

// Result:
// "I am computing this value"
// "Hola"
// "Hola"
```

### Type Checks and Casts
#### `is` and `!is` Operators
We can check whether an object conforms to a given type at runtime by using the `is` operator or its negated form `!is`:
```kotlin
if (obj is String) {
print(obj.length)
}

if (obj !is String) { // same as !(obj is String)
print("Not a String")
}
```

#### Smart Casts
In many cases, one does not need to use explicit cast operators in Kotlin, because the compiler tracks the `is`-checks and explicit casts for immutable values and inserts (safe) casts automatically when needed.

The compiler is smart enough to know a cast to be safe if a negative check leads to a return.

or in the right-hand side of `&&` and `||`.

```kotlin
fun demo(x: Any) {
if (x is String) {
print(x.length) // x is automatically cast to String
}
}

if (x !is String) return
print(x.length) // x is automatically cast to String

// x is automatically cast to string on the right-hand side of `||`
if (x !is String || x.length == 0) return

// x is automatically cast to string on the right-hand side of `&&`
if (x is String && x.length > 0) {
print(x.length) // x is automatically cast to String
}

when (x) {
is Int -> print(x + 1)
is String -> print(x.length + 1)
is IntArray -> print(x.sum())
}
```

#### "Unsafe" cast operator
Usually, the cast operator throws an exception if the cast is not possible. Thus, we call it unsafe. The unsafe cast in Kotlin is done by the infix operator `as`:
```kotlin
val x: String = y as String
```

Note that null cannot be cast to `String` as this type is not nullable, i.e. if `y` is null, the code above throws an exception. To make such code correct for null values, use the nullable type on the right hand side of the cast:
```kotlin
val x: String? = y as String?
```

#### "Safe" (nullable) cast operator
To avoid an exception being thrown, one can use a safe cast operator `as?` that returns `null` on failure:
```kotlin
val x: String? = y as? String
```
Note that despite the fact that the right-hand side of `as?` is a non-null type `String` the result of the cast is nullable.

### Coroutines
Kotlin Coroutines are like lightweight threads. They are lightweight because creating coroutines doesn’t allocate new threads. Instead, they use predefined thread pools, and smart scheduling. Scheduling is the process of determining which piece of work you will execute next.

Additionally, coroutines can be **suspended** and **resumed** mid-execution. This means you can have a long-running task, which you can execute little-by-little. You can pause it any number of times, and resume it when you’re ready again.

#### CoroutineScope
- Keep track of coroutines
- Ability to cancel ongoing work
- Notified when a failure happens

```kotlin
val scope = CoroutineScope(Job())
val job = scope.launch {
// Coroutine
}
```

> Cancelling the scope **cancels its children**.
>
> a **cancelled** child doesn't affect other siblings.

#### Job
- Provides lifecycle
- Couroutine hierarchy

#### Job Lifecycle
**States**:
- New, Active
- Completing, Completed
- Cancelling, Cancelled

**Properties**:
- isActive
- isCancelled
- isCompleted

#### CoroutineContext
Defines the behavior of coroutine and consist set of elements with default values:
- CoroutineDispatcher -> Threading (Dispatchers.Default)
- Job -> Lifecycle (No parent Job)
- CoroutineExceptionHandler (None)
- CoroutineName ("coroutine")

> a **new coroutine** inherits the parent context.
>
> Parent context = Defaults + inherited context + arguments
>
> Coroutine context = parent context + Job()

#### Cooperative Cancellation
`val isActive`:
- Do an action before finishing the coroutine.

`fun ensureActive()`:
- Instantaneously stop work.

`suspend fun yield()`:
- CPU heavy computation that may exhaust thread-pool.
- Checks if the coroutine Job was completed. If yes, throws `CancellationException`.

> **PRO TIP**: All the suspending functions in `Kotlin.coroutines` are **cancellable**.
>
> If you create your own suspend functions, make them cancellable.

### Singleton
```kotlin
object SomeSingleton
```
The above Kotlin object will be compiled to the following equivalent Java code:
```kotlin
public final class SomeSingleton {
public static final SomeSingleton INSTANCE;

private SomeSingleton() {
INSTANCE = (SomeSingleton)this;
System.out.println("init complete");
}

static {
new SomeSingleton();
}
}
```

This is the preferred way to implement singletons on a JVM because it enables thread-safe lazy initialization without having to rely on a locking algorithm like the complex double-checked locking.

### `suspending` vs. `blocking`
- A **blocking** call to a function means that a call to any other function, from the same thread, will halt the parent’s execution. Following up, this means that if you make a blocking call on the main thread’s execution, you effectively freeze the UI. Until that blocking calls finishes, the user will see a static screen, which is not a good thing.

- **Suspending** doesn’t necessarily block your parent function’s execution. If you call a suspending function in some thread, you can easily push that function to a different thread. In case it is a heavy operation, it won’t block the main thread. If the suspending function has to suspend, it will simply pause its execution. This way you free up its thread for other work. Once it’s done suspending, it will get the next free thread from the pool, to finish its work.

> Suspending functions can invoke any other regular functions, but to actually suspend the execution, it has to be another suspending function. A suspending function cannot be invoked from a regular function, therefore several so-called coroutine builders are provided, which allow calling a suspending function from a regular non-suspending scope like `launch`, `async`, `runBlocking`.

### Flow
Using the `List` result type, means we can only return all the values at once. To represent the stream of values that are being asynchronously computed, we can use a `Flow` type just like we would the `Sequence` type for synchronously computed values:

```kotlin
suspend fun foo(): List {
delay(1000) // pretend we are doing something asynchronous here
return listOf(1, 2, 3)
}

fun main() = runBlocking {
foo().forEach { value -> println(value) }
}
```

```kotlin
fun foo(): Flow = flow { // flow builder
for (i in 1..3) {
delay(100) // pretend we are doing something useful here
emit(i) // emit next value
}
}

fun main() = runBlocking {
// Launch a concurrent coroutine to check if the main thread is blocked
launch {
for (k in 1..3) {
println("I'm not blocked $k")
delay(100)
}
}
// Collect the flow
foo().collect { value -> println(value) }
}

// Result:
// I'm not blocked 1
// 1
// I'm not blocked 2
// 2
// I'm not blocked 3
// 3
```

- A builder function for `Flow` type is called `flow`.
- Code inside the `flow { ... }` builder block can suspend.
- The function `foo()` is no longer marked with `suspend` modifier.
- Values are emitted from the flow using `emit` function.
- Values are collected from the flow using `collect` function.

> We can replace `delay` with `Thread.sleep` in the body of foo's `flow { ... }` and see that the main thread is blocked in this case.

Flows are cold streams similar to sequences — the code inside a flow builder does not run until the flow is collected.

> **Hot Observables**: are ones that are pushing event when you are not subscribed to the observable. Like mouse moves, or Timer ticks or anything like that.
>
> **Cold Observables**: are ones that start pushing only when you subscribe, and they start over if you subscribe again.

### Scope Functions
functions whose sole purpose is to execute a block of code within the context of an object without its name.
There are five of them: `let`, `run`, `with`, `apply`, and `also`.

There are two main differences between each scope function:
- The way to refer to the context object
- The return value.

Each scope function uses one of two ways to access the context object: as a lambda receiver (`this`) or as a lambda argument (`it`).

`run`, `with`, and `apply` refer to the context object as a lambda receiver - by keyword `this`.

```kotlin
val adam = Person("Adam").apply {
age = 20 // same as this.age = 20 or adam.age = 20
city = "London"
}
println(adam)
```

`let` and `also` have the context object as a lambda argument. If the argument name is not specified, the object is accessed by the implicit default name `it`.

```kotlin
fun getRandomInt(): Int {
return Random.nextInt(100).also {
writeToLog("getRandomInt() generated value $it")
}
}

val i = getRandomInt()
```

The scope functions differ by the result they return:
- `apply` and `also` return the context object.
- `let`, `run`, and `with` return the lambda result.

```kotlin
val numberList = mutableListOf()
numberList.also { println("Populating the list") }
.apply {
add(2.71)
add(3.14)
add(1.0)
}
.also { println("Sorting the list") }
.sort()
```

```kotlin
val numbers = mutableListOf("one", "two", "three")
val countEndsWithE = numbers.run {
add("four")
add("five")
count { it.endsWith("e") }
}
println("There are $countEndsWithE elements that end with e.")
```

| Function | Object reference | Return value | Is extension function |
| --- | --- | --- | --- |
| let | it | Lambda result | Yes |
| run | this | Lambda result | Yes |
| run | - | Lambda result | No: called without the context object |
| with | this | Lambda result | No: takes the context object as an argument. |
| apply | this | Context object | Yes |
| also | it | Context object | Yes |

Here is a short guide for choosing scope functions depending on the intended purpose:

- Executing a lambda on non-null objects: `let`
- Introducing an expression as a variable in local scope: `let`
- Object configuration: `apply`
- Object configuration and computing the result: `run`
- Running statements where an expression is required: non-extension `run`
- Additional effects: `also`
- Grouping function calls on an object: `with`

Overriding vs Overloading
---
Overloading happens at compile-time while Overriding happens at runtime: The binding of overloaded method call to its definition happens at compile-time however binding of overridden method call to its definition happens at runtime.

> **Static binding** in Java occurs during compile time.
>
> **Dynamic binding** occurs during runtime.

Static methods can be overloaded which means a class can have more than one static method of same name. Static methods cannot be overridden, even if you declare a same static method in child class it has nothing to do with the same method of parent class as overridden static methods are chosen by the reference class and not by the class of the object.

```java
public class Animal {
public static void testClassMethod() {
System.out.println("The static method in Animal");
}

public void testInstanceMethod() {
System.out.println("The instance method in Animal");
}
}

public class Cat extends Animal {
public static void testClassMethod() {
System.out.println("The static method in Cat");
}

public void testInstanceMethod() {
System.out.println("The instance method in Cat");
}

public static void main(String[] args) {
Cat myCat = new Cat();
myCat.testClassMethod();
Animal myAnimal = myCat;
myAnimal.testClassMethod();
myAnimal.testInstanceMethod();
}
}

/*
Result:
// testClassMethod() is called from "Cat" reference
"The static method in Cat"

// testClassMethod() is called from "Animal" reference,
// ignoring actual object inside it (Cat)
"The static method in Animal"

// testInstanceMethod() is called from "Animal" reference,
// but from "Cat" object underneath
"The instance method in Cat"
*/
```

Dictionary
---

### What are Domain Specific Languages (DSLs)
A Domain Specific Language is a programming language with a higher level of abstraction optimized for a specific class of problems. A DSL uses the concepts and rules from the field or domain.

### Parameter vs Argument
**Parameter** is variable defined in function declaration.

**Argument** is the actual value of this variable that get passed to the function.

**Type parameter** is blueprint or placeholder for a type declared in generic.

**Type argument** is actual type used to parametrize generic.

### Statement vs Expression
**Expression** in a programming language is a combination of one or more explicit values, constants, variables, operators and functions that the programming language interprets and computes to produce another value.
An expression is every part of code that returns value.

**Statement** is the smallest standalone element of an imperative programming language that expresses some action to be carried out.

#### What is an expression in Java vs in Kotlin?
Note, that there are some fundamental differences between what is, and what is not an **expression** in Kotlin and in Java. All Kotlin functions calls are **expressions**, because they return at least `Unit`. Calls of Java functions that do not defined any return type are not **expressions**. Kotlin value assignment (`a = 1`) is **not an expression** in Kotlin, while it is in Java because over there it returns assigned value (in Java you can do `a = b = 2` or `a = 2 * (b = 3)`). All usages of control structures (`if, switch`) in Java are not expressions, while Kotlin allowed `if`, `when` and `try` to return values: