Kotlin Essentials

1. Encapsulation
   is a concept of controlling access to the internal state of an object, protecting it from unauthorized access and ensuring data integrity.
2. Inheritance
   enables class to have the same behavior as another class by inheriting its properties and methods.
3. Polymorphism
   allows us to define one interface or method that can have multiple implementations. It means that the same method or property could exhibit different behavior in different instances of object implementing given interface.
4. Abstraction
   is a mechanism to represent the object features without exposing the actual implementation details. In other words, user of such object only needs to know what it does, not how it does it.

We will come back to these principles later in the course.

• All Kotlin files should have .kt extension, for example MyProgram.kt.
• In Kotlin, the main program entry point is defined as a top-level function, which means that it is not part of a class.

  								
  									fun main() {
  										println("Hello world!")
  									}
  								
  							

• The main function may accept an array of strings as an argument, which can be used to pass command-line arguments to the program.

  								
  									fun main(args: Array<String>) {
  										println("Number of arguments: " + args.size)
  										for (arg in args) {
  											println("Argument: $arg")
  										}
  									}
  								
  							

• Function may have zero or more parameters, and it may return a value, in which case the return type is specified.

  								
  									fun myFunction(arg1: Int, arg2: Int): Int {
  										return arg1 + arg2
  									}
  								
  							

• If a function does not return a value, the return type is Unit, but the return type can be omitted.

  								
  									fun myFunction(arg1: Int, arg2: Int) {
  										println(arg1 + arg2)
  									}
  								
  							

• Variables declared with var are mutable = their value can be changed during the program execution.
• Variables declared with val are immutable = their value cannot be changed once it is assigned = they are read-only.
• You can omit type in case variable is declared and initialized at the same time, it will be inferred by the compiler.

  								
  									val myNumber = 42
  
  									val myText = "Hello, world!"
  								
  							

• If mutable variable is not initialized at the time of declaration, you must specify it's type.

  								
  									var myNumber: Int
  
  									var myText: String
  								
  							

• Classes can have properties, functions, and multiple constructors.
• Classes are also usually part of a package, which is a way to organize classes into namespaces.
• Example:

  								
  									package com.package.domain
  
  									class MyClass {
  										var myVariable: Int = 42
  										val foo: Foo = Foo()
  
  										/*
  										Block comment
  										*/
  										fun myFunction(number: Long): String {
  											// important comment
  											return foo.bar()
  										}
  									}
  								
  							

						
							fun main() {
								print("Hello, ")  // prints on one line
								println("world!") // prints on with a new line at the end
							}
						
					

						
							// single-line comment

							/*
							Multi-line comment
							*/
						
					

• Package name is always written in all-lowercase.
• Class or interface name should be nouns in mixed case with the first letter of each internal word capitalized. Should be sufficiently descriptive.
• Method name should be verb, in mixed case with the first letter lowercase, with the first letter of each internal word capitalized.
• Variable name should be in mixed case with a lowercase first letter. Internal words start with capital letters. Should be meaningful and descriptive
• Constants name should be noun with each letter of internal word capitalized. Should be sufficiently descriptive.

Knowing what JVM primitive type they compile to is important for understanding how they are stored in memory.

Understanding memory management, garbage collection, and type systems is crucial for writing efficient code, avoiding memory leaks, and preventing issues like data loss from type mismatches.

Integer types

Unsigned Integer types

Floating-point types

Integer types

						
							val index: Byte = 127
							val smallNumber: Short = 32767
							val number: Int = 2147483647
							val bigNumber: Long = 9223372036854775807L // notice L at the end
						
					

Unsigned integer types

						
							val uIndex: UByte = 255u // u indicates unsigned type
							val uSmallNumber: UShort = 65535u
							val uNumber: UInt = 4294967295u
							val uBigNumber: ULong = 18446744073709551615u
						
					

Floating-point types

						
							val decimalNumber: Float = 123.12346f // f indicates float type
							val preciseNumber: Double = 123.12345886230469
						
					

						
							val isTrue: Boolean = true
							val character: Char = 'A'
							val text: String = "Hello, world!"

							val arrayOfStrings = arrayOf("hello", "world", "kotlin", "is", "fun")

							println(arrayOfStrings[2]) // will print "kotlin"
						
					

Anytime we don't know the type of variable, parameter or return type, we can use Any to accept any type. However, this is not recommended and should be used with caution.

Any type is equivalent to Java's Object type.

						
							val someValue: Any = "This is a string"

							if (someValue is String) {
								println("The value is a string")
							} else {
								println("The value is not a string")
							}
						
					

Some key point to keep in mind when working with nulls in Java/Kotlin code ...

• Since Kotlin and Java are interoperable, you may need to explicitly handle null values when calling Java methods from Kotlin.
• In Java
  • you can assign null to any reference variable (non-primitive types: objects, array, interface, etc)
  • for object reference types, the default value is null when they are defined as class members and not explicitly initialized
  • If you try to invoke a method or access a property on a reference variable with a null value, you will get a NullPointerException. This is a runtime exception in Java.
• In Kotlin, object references that may hold null values must be explicitly declared as nullable types.
• You can use null in comparison operations. For example, to check if an object is null, you can use if (object == null).
• Assigning null to a variable makes it eligible for garbage collection if there are no other references to the object.
• Null can be passed as an argument to a method and can also be returned from a method.

For example, this is how you can declare a variable with type inference:

							
								val number = 42             // type inferred as Int
								val text = "Hello, world!"  // type inferred as String
							
						

You can check the type of variable using the is operator.

						
							fun getSomething(): Any {
								return 1234567890
							}
						
					

						
							val something = getSomething()

							println(something is Int)			 // true
							println(something is Long)			 // false
							println(something::class.simpleName) // Int
						
					

Type Casting

						
							fun getSomething(): Any {
								return 1234567890
							}
						
					

						
							val something = getSomething()

							// Explicit type casting, only works if the value is of the same type
							val number = something as Int
						
					

Type Conversion

						
							val number = 1234567890
							val bigNumber = number.toLong() // Type conversion, no data loss
							val smallNumber = number.toShort() // Type conversion with DATA LOSS!
						
					

Assigning smaller data type to larger data type - generally doesn't result in data loss.

Assigning larger data type to smaller data type - may result in data loss.

						
							val number = 3
							val text = "Hello"
							val date = LocalDate()
						
					

								
									var name: String = "John"
									name = "Jane"
									println(name)
								
							

								
									val name: String = "John"
									name = "John"
									println(name)
								
							

						
							var number = 0

							number += 3 // equivalent: number = number + 3

							number -= 3 // equivalent: number = number - 3

							number *= 3 // equivalent: number = number * 3

							number /= 3 // equivalent: number = number / 3

							number %= 3 // equivalent: number = number % 3
						
					

						
							if (a <= b) {
								// execute if condition is met
							}
						
					

					
						if (a <= b) {
							// execute if condition is met
						} else {
							// execute if condition is NOT met
						}
					
				

					
						if (a < b) {
							// execute if first condition is met
						} else if (a == b) {
							// execute if second condition is met
						} else if (a == null) {
							// execute if third condition is met
						} else {
							// execute if no condition is NOT met
						}
					
				

						
							var result: String? = null

							if (a < b) {
								result = "a is less than b"
							} else if (a == b) {
								result = "a is equal to b"
							} else {
								result = "a is greater than b"
							}
						
					

						
							val result = if (a < b) {
								"a is less than b"
							} else if (a == b) {
								"a is equal to b"
							} else {
								"a is greater than b"
							}
						
					

						
							val result = if (a < b) "a is less than b" else "a is greater than or equal to b"
						
					

						
							val randomInt = arrayOf(0, 1, 2, 3, 4, 5).random()
						
					

						
							val result = when (randomInt) {
								0 -> "Zero"
								1 -> "One"
								2 -> "Two"
								3 -> "Three"
								4 -> "Four"
								5 -> "Five"
								else -> "Too much"
							}
						
					

						
							val result = when {
								randomInt < 0 -> "Less than 0"
								randomInt == 0 -> "Zero"
								else -> "Greater than 0"
							}
						
					

						
							val result = when (randomInt) {
								0 -> "Zero"
								in 1..3 -> "Between 1 and 3"
								in 3..5 -> "Between 3 and 5"
								else -> "Too much"
							}
						
					

The while evaluates condition at the beginning of the loop block, before any code is executed.

						
							while (condition) {
							  // code block to be executed
							}
						
					

The do while first executes code block once, and evaluates condition the condition.

						
							do {
							  // code block to be executed
							} while (condition)
						
					

						
							/*
							 Printing to console
							 */
							println("Printing to console with new line at the end")
							print("Printing to console without new line at the end")
							println() // just new line

							/*
							 String concatenation using the + operator
							 */
							val name = "Moni"
							val hello = "Hello"

							val greeting = hello + " " + name + "!"
							println(greeting)

							/*
							 String interpolation
							 */
							val fullGreeting = "$hello $name"
							println(fullGreeting)

							/*
							 String concatenation using the += operator
							 */
							var greeting2 = "Hola"
							greeting2 += " $name!" // Assignment addition String concatenation
							println(greeting2)

							/*
							 String formatting
							 */
							val formattedGreeting = String.format("%s %s!", hello, name) // String formatting
							println(formattedGreeting)
						
					

						
							val text = "Banana, Apple, Orange, Kiwi, Mango, Pineapple, Watermelon, Strawberry"

							/*
							 Find the length of the text
							 */
							println("Length: " + text.length)

							/*
							 Split the text into an array of fruits
							 */
							val fruits = text.split(",".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
							for (fruit in fruits) {
								println(fruit.trim { it <= ' ' }) // trim to remove leading or trailing space
							}

							/*
							 Check if the text contains "Apple"
							 */
							println("Has apple: " + text.contains("Apple"))
							println(text.uppercase())
							println(text.lowercase())
							println(text.substring(10, 20))

							/*
							 Replace all occurrences of "Apple" with "Peach"
							 */
							val newText = text.replace("Apple", "Peach")
							println(newText)
						
					

								
									fun add(a: Int, b: Int): Int {
										return a + b
									}

									val sum = add(2, 3)
								
							

								
									fun greet(name: String) {
										println("Hello, $name!")
									}

									greet("Alice")
								
							

								
									fun add(a: Int, b: Int) = a + b
								
							

								
									fun operation(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
										return operation(a, b)
									}

									val sum = operation(2, 3) { a, b -> a + b }
								
							

Functions can be defined at the top level of a file, meaning they do not need to be part of a class.

						
							// outer function
							fun factorial(n: Int): Int {

								// local function
								fun fact(x: Int, acc: Int): Int {
									return if (x <= 1) acc else fact(x - 1, x * acc) // tail recursion
								}

								// calls the local function
								return fact(n, 1)
							}
						
					

						
							// main entry point with a call to the outer function
							fun main() {
								println(factorial(5)) // prints 120
							}
						
					

This is useful when you have a function with many arguments, and you want to make the code more readable, for example when you have a function with many arguments.

It also allows you to specify arguments in any order, as long as you specify the name. This ofthe comes in handy when refactoring the code, adding or changing order of arguments.

								
									fun round(
										value: Double,
										decimals: Int = 2
									): Double {
										val factor = 10.0.pow(decimals.toDouble())
										return (value * factor).roundToInt() / factor
									}
								
							

								
									val result = round(value = 3.14159)
								
							

								
									val result = round(
										decimals = 4, // notice the changed order of arguments
										value = 3.14159
									)
								
							

You can define a function that takes a variable number of arguments by using the vararg keyword.

						
							fun sayHello(vararg names: String): Int {
								println("Hello, ${names.joinToString(", ")}!")
							}
						
					

						
							fun main() {
								sayHello("Alice", "Bob", "Charlie") // prints "Hello, Alice, Bob, Charlie!"
							}
						
					

If you need more than one argument, the vararg argument must be the last one.

						
							fun sayHello(greeting: String, vararg numbers: Int): Int {
								println("Hello, ${names.joinToString(", ")}!")
							}
						
					

						
							fun main() {
								sayHello(greeting = "Hi", "Alice", "Bob", "Charlie") // prints "Hi, Alice, Bob, Charlie!"
							}
						
					

• Arrays can be declared using the arrayOf<Type>() function.
  _{Type declaration can be omitted if the type of the array can be inferred from the elements passed to the arrayOf() function.}
• Arrays in Kotlin are type-safe - they can only hold elements of the specified type.
  _{If array contains elements of different types, the type of the array is inferred to be the least common supertype of the elements,
  or Any in case of no common supertype.}
• Arrays are fixed-size, meaning their size cannot be changed once created.

						
							// Declaring an array of integers
							val numbers = arrayOf(1, 2, 3, 4, 5)

							// Declaring an array of strings
							val cities = arrayOf("Bangkok", "Beijing", "Tokyo", "London", "Paris")

							// Declaring an array of mixed types
							val mixed = arrayOf(1, "Bangkok", 3.14, 'A', true)

							val empty = emptyArray<String>() // size 0

							val arrayOfNulls = arrayOfNulls<String>(5) // size 5, all elements are null
						
					

• Elements can be accessed or modified using their index and [] operator. Arrays are zero-based.
  _{For example array[0] will access first element.}
• Modifying an element using an index that is out of bounds will throw an ArrayIndexOutOfBoundsException.

						
							val array = arrayOf(1, 2, 3, 4, 5)

							// updating an element on index 4 (5th element)
							array[4] = 42

							// accessing an element on index 4 (5th element)
							println(array[4])

							// accessing an element on index 5 (6th element) - will throw ArrayIndexOutOfBoundsException
							try {
								println(array[5])
							} catch (e: ArrayIndexOutOfBoundsException) {
								println(e.message)
							}
						
					

						
							println(array.size) // prints 5
						
					

The main difference between arrays and collections is that collections can grow or shrink in size. They generally provide more functionality and are easier to work with than arrays, but also are less efficient in terms of memory and performance.

There are several types of collections in Kotlin, such as List, Set, Map, etc.

Unlike and array, which is basic data structure, collections are interfaces that define a set of operations that can be performed on a group of objects.

Lists

Lists are ordered collections of elements that can contain duplicates and individual elements can be accessed by their index.

Sets

Sets are unordered collections of unique elements, meaning order is not guaranteed, and they don't allow duplicate elements.

You can work with a set just like you would with a list, but there are some differences:

• You cannot access elements by index, because sets are unordered.
• Adding an element that already exists in the set will not add a duplicate.
• Removing an element that does not exist in the set will not throw an exception.

Maps

Maps are collections of key-value pairs, where keys are unique and are used to access values. Values can be duplicates.

Kotlin provides standard library functions for working with collections, which we will explore in more detail.

Collections are constructed using functions listOf<Type>(), setOf<Type>() or mapOf<KeyType, ValueType>() for read-only collections.

						
							val list = listOf<String>()

							val set = setOf<Int>()

							val map = mapOf<String, Int>()
						
					

Or by variable type declaration.

						
							val list: List<String> = listOf()
						
					

If type can be inferred from the elements, you can omit the type declaration.

						
							val list = listOf("Java", "Kotlin", "JavaScript", "TypeScript", "Python")

							val set = setOf(2020, 2021, 2022, 2023, 2024, 2025)

							val map = mapOf(
								"Java" to 1995,
								"Kotlin" to 2011,
								"JavaScript" to 1995,
								"TypeScript" to 2012,
								"Python" to 1991
							)
						
					

Mutable collections can be created using mutableListOf<Type>(), mutableSetOf<Type>() and mutableMapOf<KeyType, ValueType>().

To construct an empty collection, you can use the emptyList<Type>(), emptySet<Type>() or emptyMap<KeyType, ValueType>() functions.

						
							val emptyList = emptyList<String>()

							val emptySet = emptySet<Int>()

							val emptyMap = emptyMap<String, Int>()
						
					

Similarly, empty collections can be created emptyMutableList<Type>(), emptyMutableSet<Type>() and emptyMutableMap<KeyType, ValueType>() functions.

Collection operations are declared in the standard library in two ways:

1. Member functions of collection interfaces defining operations that are essential for the collection type.
2. Extension functions providing additional functionality.

This is important to know in case you want to implement you own collection type as you will need to implement all functions in the given interface(s).

Some of the common operations on collections include:

• Transformations
• Filtering
• plus and minus operators
• Grouping
• Retrieving collection parts
• Retrieving single elements
• Ordering
• Aggregate operations

For immutable collections, you can use the plus() function to create a new collection with the added element.

						
							val list = mutableListOf("Java", "Kotlin", "JavaScript", "TypeScript")

							list.plus("Python")
						
					

For mutable collections, you can use the add(), addFirst(), addLast() and addAll()functions to add an elements to the collection.

						
							val mutableList = mutableListOf("Java", "Kotlin")

							mutableList.add("C#")
							mutableList.addLast("Rust")
							mutableList.addAll(listOf("JavaScript", "TypeScript"))
						
					

For both mutable and immutable collections, you can use the + operator to create a new collection with the added element.

						
							val newList = list + "Python"
						
					

You can also add elements to mutable collections using the += operator.

						
							mutableList += "Python"
						
					

And finally, you can use the addAll(), addFirst(), and addLast() functions to add multiple elements to a mutable collection.

Removing elements is similar.

Immutable collections provide the minus() function and the - operator to create a new collection with the removed element.

						
							val list = mutableListOf("Java", "Kotlin", "JavaScript", "TypeScript", "Python")

							val newList = list - "JavaScript"
						
					

Mutable collections provide the remove(), removeFirst(), removeLast() removeAt(), removeAll() and also removeIf() functions to remove an element from the collection.

						
							val mutableList = mutableListOf("Java", "Kotlin", "JavaScript", "TypeScript", "Python")

							// removes element "JavaScript"
							mutableList.remove("JavaScript")

							// removes element at index 2
							mutableList.removeAt(2)

							// removes elements "Java" and "Kotlin"
							mutableList.removeAll(listOf("Java", "Kotlin"))

							// removes elements with length > 5
							mutableList.removeIf { it.length > 5 }
						
					

You can also use the -= operator to remove an element from a mutable collection.

						
							mutableList -= "JavaScript"
						
					

Retrieving elements from a collection is straightforward and similar to arrays.

Here are few examples:

						
							val list = listOf("Java", "Kotlin", "JavaScript", "TypeScript", "Python")

							// get element at index 2
							val element = list[2]

							// get first element
							val first = list.first()

							// get last element
							val last = list.last()

							// get element at index 2 or return "C++" if index is out of bounds
							val elementAtOrElse = list.getOrElse(2) { "C++" }

							// get element at index 10 or return null if index is out of bounds
							val elementAtOrNull = list.getOrNull(10)

							// you can also use the random() function to get a random element from the collection
							val randomElement = list.random()
						
					

Iterators are not the most idiomatic way to iterate over collections, so Kotlin provides other ways to iterate over collections which implement the Iterable interface.

One of such ways is to use a for loop.

						
							val list = listOf("Java", "Kotlin", "JavaScript", "TypeScript", "Python")

							for (element in list) {
								println(element)
							}
						
					

Both are higher-order function that takes a lambda as an argument. The basic syntax is ...

						
							val list = listOf("Java", "Kotlin", "JavaScript", "TypeScript", "Python")

							list.forEach {
								println(it)
							}
						
					

By default, the lambda passed to the forEach function takes a single argument, which can be referenced using the it keyword.

You can also specify the argument name explicitly (in this case, element).

						
							list.forEach { element ->
								println(element)
							}
						
					

There is also a shorthand syntax for the lambda if it takes a single argument: list.forEach(::println).

The forEachIndexed also provides the index of the element as the first argument to the lambda. This may be useful in some situations.

						
							list.forEachIndexed { index, element ->
								println("Element at index $index is $element")
							}
						
					

Some common transformation operations performed on collections include:

• map using functions like map, flatMap, mapNotNull, mapIndexed, mapIndexedNotNull.
• filter using functions like filter, filterNot, filterIndexed, filterNotNull, distinct, distinctBy.
• sort using functions like sorted, sortedBy, sortedWith, sortedDescending, sortedByDescending, reversed, shuffled.
• group using functions like groupBy, partition, associate, associateBy, associateWith.
• plus, minus to add or remove elements from a collection.
• other transformation functions like reduce, zip, zipWithNext, unzip, flatten, fold.

All of these transformations return a new collection with the transformation applied, they do not modify the original collection.

The returned collection can be of any type, not necessarily the same as the original collection.

There are several map functions available in the Kotlin standard library:

• map - applies a function to each element and returns a list of the results.
• mapNotNull - applies a function to each element and returns a list of non-null results.
• mapIndexed - applies a function to each element and its index and returns a list of the results.
• mapIndexedNotNull - applies a function to each element and its index and returns a list of non-null results.
• flatMap - applies a function to each element and returns a list of the results, which are then flattened into a single list.
• mapTo, mapIndexedTo, mapNotNullTo, etc ... - applies a function to each element and adds the results to the given destination.

Generally, the returned collection is the same type as the original collection.

Some of the filter functions available in the Kotlin standard library include:

• filter - filters elements based on a predicate and returns a list of elements that satisfy the predicate.
• filterNot - filters elements based on a predicate and returns a list of elements that do not satisfy the predicate.
• filterNotNull - filters out null elements and returns a list of non-null elements.
• filterIndex - filters elements based on a predicate with index and returns a list of elements that satisfy the predicate.

The result of grouping operations is a map where the key is the result of the selector function and the value is a list of elements.

Some of the grouping functions available in the Kotlin SDK include:

• groupBy - groups elements by the result of the given selector function.
• partition - splits the collection into a pair of lists based on a predicate.
• associate - creates a map from the elements of the collection.
• associateBy - creates a map from the elements of the collection using the provided key selector function.
• associateWith - creates a map from the elements of the collection using the provided value selector function.

								
									val priceList = listOf(
										"Mango" to 20,
										"Apple" to 25,
										"Banana" to 10,
										"Coconut" to 15,
										"Pineapple" to 30,
										"Orange" to 5,
										"Grapes" to 40
									)

									val priceCategory = priceList.groupBy { (_, price) ->
										when (price) {
											in 0..10 -> "Cheap"
											in 11..20 -> "Affordable"
											in 21..30 -> "Expensive"
											else -> "Very Expensive"
										}
									}
								
							

								
									Affordable=[(Mango, 20), (Coconut, 15)]
									Expensive=[(Apple, 25), (Pineapple, 30)]
									Cheap=[(Banana, 10), (Orange, 5)]
									Very Expensive=[(Grapes, 40)]
								
							

• sorted - sorts elements in natural order.
• sortedBy - sorts elements by the result of the given selector function.
• sortedWith - sorts elements using the given comparator.
• sortedDescending - sorts elements in reverse natural order.
• sortedByDescending - sorts elements by the result of the given selector function in reverse order.
• reversed - reverses the order of elements in the collection.
• shuffled - shuffles the elements in the collection.

Examples:

						
								val priceList = listOf(
									"Mango" to 20,
									"Apple" to 25,
									"Banana" to 10,
									"Coconut" to 15,
									"Pineapple" to 30,
									"Orange" to 5,
									"Grapes" to 40
								)

								priceList.sortedBy { (_, price) -> price }

								priceList.sortedByDescending { (_, price) -> price }

								priceList.sortedWith(
									compareBy(
										{ it.first },
										{ it.second }
									)
								)
						
					

There are even more useful transformation functions available in the Kotlin SKD. Some worth mentioning are:

• reduce - combines elements of a collection into a single value.
• zip - combines two collections into a single collection of pairs.
• zipWithNext - combines each element with the next element in the collection.
• unzip - splits a collection of pairs into two collections.
• flatten - flattens a collection of collections into a single collection.
• fold - combines elements of a collection into a single value starting with an initial value.

Unlike collections, sequences don't contain elements, they produce them while iterating. This is useful when you need to perform multi-step operations on a collection.

Operations on collections are executed eagerly, meaning they perform all operations on all elements immediately.
Operations sequences are executed lazily, meaning they perform operations on elements only when needed.

This can be beneficial for large collections or when you need to perform complex operations on elements.
On the other hand, sequences may be less efficient for small collections or simple operations.

Sequences offer the similar functions as collections, such as forEach, map, filter, etc.

The main difference is that when working with sequences, we distinguish between intermediate and terminal operations, where intermediate operations return a new sequence and terminal operations return a result.

What that means is that when you call a terminal operation, all intermediate operations are executed and the collection is so called "consumed".

!!!    Keep this in mind because if you call a terminal operation prematurely, you may either end up with unexpected results, or at least with a performance hit.    !!!

						
							val sequence = sequenceOf(1, 2, 3, 4, 5)
						
					

						
							val sequence = listOf(1, 2, 3, 4, 5).asSequence()
						
					

						
							val sequence = generateSequence(1) { it + 1 }
						
					

						
							val sequence = sequence {
								for (i in 1..5) {
									yield(i)
								}
							}
						
					

• The package declaration is usually the first line in a Kotlin file. It specifies the package to which the file belongs.
• Package names are typically written in all lowercase and follow the reverse domain name convention.
• To use classes and functions from other packages, you need to import them using the import keyword.
• If no package is specified, the file belongs to the default package.

						
							package com.motycka.edu.model // <- package name

							import java.time.LocalDate // <- import of class LocalDate from java.time package

							class User(
								val name: String,
								val birthDate: LocalDate
							)
						
					

They can be broadly categorized into two types:

Access Modifiers

These define the visibility or accessibility of functions, classes, methods, and variables.

Non-Access Modifiers

These define other characteristics such as behavior, state, or implementation details.

Lambda Expression

Lambda expressions are typically used for short, concise functions that are passed as arguments to higher-order functions. They are commonly used in collection operations like , filter, and forEach.

						
							val lambdaName: (Type) -> ReturnType = { argument: Type -> body }
						
					

If lambda expression has a single parameter, you can use the default name it.

Anonymous Function

Anonymous functions are used when you need more control over the function's return type or when you need to use the return statement to exit the function itself rather than the enclosing function.

						
							val lambdaName = fun(name: Type): Type {
								return value
							}
						
					

Opposite of anonymous function is called a named function.

Function with one parameter and no return value:

						
							val greet: (String) -> Unit = { name -> println("Hello, $name!") }

							greet("World")
						
					

If lambda expression has a single parameter, you can use the default name it:

						
							val greet: (String) -> Unit = { println("Hello, $it!") }

							greet("World")
						
					

Function with two parameters and a return value:

						
							val multiply: (Int, Int) -> Int = { a, b -> a * b }

							val result = multiply(10, 20)
						
					

Common examples of lambda function is the forEach:

						
							val cities = listOf("Bangkok", "Barcelona", "Tokyo", "London", "New York")

							cities.forEach { city ->
								println(city)
							}
						
					

							
								val greet = fun(name: String) {
									println("Hello, $name!")
								}

								greet("World")
							
						

							
								val multiply = fun(a: Int, b: Int): Int {
									return a * b
								}

								val result = multiply(10, 20)
							
						

In summary, lambda expressions are more concise and are typically used for simpler functions, while anonymous functions provide more flexibility with explicit return types and return behavior.

There are few use cases for lambda expressions and anonymous functions:

• Passing functions as arguments to higher-order functions
• Returning functions from other functions
• Defining local functions that are not needed outside the scope of the enclosing function

In this example, the operation function takes two integers and a lambda function as arguments.

						
							fun operation(x: Int, y: Int, func: (Int, Int) -> Int): Int {
								return func(x, y)
							}
						
					

The most common use way pass the function argument is:

						
							val result = operation(10, 20) { x, y -> x + y }
						
					

Another possibility is to pass a function reference (it can be a named function or a member function):

						
							val multiply: (Int, Int) -> Int = { a, b -> a * b }

							val result = operation(10, 20, multiply)
						
					

You can also return functions from other functions.

						
							fun getCalculator(): (Int, Long, Double) -> Double {
								return { a, b, c -> a + b + c }
							}
						
					

						
							val calculator = getCalculator()

							val result = calculator(1, 2, 3.0)
						
					

For example, you can add a new method to the String class to capitalize the first letter of each word in a sentence.

						
							fun String.capitalizeWords(): String {
								return this.split(" ").joinToString(" ") { it.capitalize() }
							}
						
					

You can then use this extension function on any String object.

						
							fun main() {
								val sentence = "hello world from kotlin"
								println(sentence.capitalizeWords()) // Output: "Hello World From Kotlin"
							}
						
					

You can use extension functions to create a more fluent API by adding methods to existing classes that allow you to chain method calls together.

						
							data class Person(
								val name: String,
								val age: Int,
								val country: String
							)
						
					

						
							fun List<Person>.filterByCountry(country: String): List<Person> {
								return this.filter { it.country.lowercase() == country.lowercase()) }
							}

							fun List<Person>.sortByName(): List<Person> {
								return this.sortedBy { person -> person.name }
							}
						
					

You can then use these extension functions to create a more readable and expressive code.

						
							val people = listOf(
								// list of people
							)

							val filteredPeople = people
								.filterByCountry("Thailand")
								.sortByName()
						
					

						
							data class Person(
								val name: String,
								val age: Int,
								val country: String
							)
						
					

						
							fun Person.canDrinkBeer(): Boolean {
								val legalAge = when (country) {
									"USA" -> 21
									else -> 18
								}
								return age >= legalAge
							}
						
					

						
							fun main() {
								val person = Person("John", 21, "USA")
								println("${person.name} can drink beer: ${person.canDrinkBeer()}")
							}
						
					

						
							data class Person(
								val name: String,
								val age: Int,
								val country: String
							)
						
					

						
							data class Student(
								val name: String,
								val country: String,
								val dateEnrolled: LocalDate
							)
						
					

						
							fun Person.toStudent() = Student(
								name = name,
								country = country,
								dateEnrolled = LocalDate.now()
							)
						
					

						
							val person = Person("John", 21, "USA")
    						val student = person.toStudent()
						
					

When you use a scope function, you can access the object's properties and functions without having to use the object's name.

The scope functions in Kotlin are let, run, with, apply, and also.

Each scope function has a different context object and return value, which makes them useful for different use cases.

The context object of the let function is referred to as it and the return value is the result of the lambda expression.

The let function is particularly useful when used with a nullable types, because it allows us to chain multiple operations on a nullable object.

						
							data class Message(
								val text: String?,
								var acknowledged: Boolean = false
							) {
								fun send(): Message {
									TODO("Response message")
								}
							}
						
					

						
							val message = Message(text = "Hello")

							val response = message.send()

							val text = response.text?.let {
								println("Received message: $it")
							}

							// process text
						
					

The context object of the run function is referred to as this and the return value is the result of the lambda expression.

						
							data class Message(
								val text: String?,
								var acknowledged: Boolean = false
							) {
								fun send(): Message {
									TODO("Response message")
								}
							}
						
					

						
							val message = Message(text = "Hello").run {
								if (send().acknowledged) {
									println("Message acknowledged")
								} else {
									println("Message not acknowledged")
								}
								this
							}
						
					

						
							data class Message(
								val text: String?,
								var acknowledged: Boolean = false
							) {
								fun send(): Message {
									TODO("Response message")
								}
							}
						
					

						
							val message =  Message(text = "Hello")

							with(message) {
								if (send().acknowledged) {
									println("Message acknowledged")
								} else {
									println("Message not acknowledged")
								}
							}
						
					

						
							data class Message(
								val text: String?,
								var acknowledged: Boolean = false
							) {
								fun send(): Message {
									TODO("Response message")
								}
							}
						
					

						
							   val message =  Message(text = "Hello").apply {
									acknowledged = true
								}
						
					

						
							data class Message(
								val text: String?,
								var acknowledged: Boolean = false
							) {
								fun send(): Message {
									TODO("Response message")
								}
							}
						
					

						
							val message = Message(text = "Hello")
								.also { println(it)  }

							val response = message.send()
								.also { println(it)  }