Kotlin

Sealed Classes in Kotlin

A Sealed Class is used to represent restricted class hierarchies. It allows you to define a set of subclasses that are known at compile-time, ensuring that no other subclasses can be created outside the file where the sealed class is defined.

• Exhaustive Checks: When used in a when expression, the compiler verifies that all possible subclasses are covered, removing the need for an else branch.
• State Management: Unlike Enums, each subclass of a sealed class can have multiple instances and hold unique data (state).

Sealed Class vs. Enum

Code Example:

The object Keyword in Kotlin

In Kotlin, the object keyword is a thread-safe, first-class citizen used to define a Singleton—a class that has exactly one instance. Unlike Java, where you must manually implement the Singleton pattern using private constructors and static methods, Kotlin handles the instantiation and lifecycle automatically.

• Initialization: The object is initialized lazily the first time it is accessed.
• Thread Safety: The initialization is thread-safe by default.
• Functionality: Objects can inherit from classes and implement interfaces, just like regular classes.
• Global Access: It can be accessed directly by its name without using a constructor.

Use Cases for object

Code Example:

The companion object in Kotlin

A companion object is a specialized object declared inside a class. It is used to define members (properties and methods) that belong to the class itself rather than to specific instances of that class.

In Java, these are called static members. Kotlin does not have the static keyword; instead, it uses companion objects to group these members while maintaining a strictly object-oriented structure.

• Access: Members are called using the class name (e.g., MyClass.myFunction()).
• Interface Support: Unlike Java statics, a companion object can implement interfaces and extend classes.
• Quantity: Only one companion object is allowed per class.
• Access to Private Members: The companion object can access private members of the containing class.

Companion Object vs. Java Static

Code Example: Factory Pattern

A common use case for companion objects is the Factory Pattern, where you hide the constructor and provide a static-like method to create instances.

Higher-Order Functions in Kotlin

A Higher-Order Function is a function that does at least one of the following:

• Takes one or more functions as parameters.
• Returns a function as its result.

In Kotlin, functions are "first-class citizens," meaning they can be stored in variables and passed around just like integers or strings. This is a core pillar of functional programming in Kotlin.

Key Components

Code Examples:

1. Passing a Function as a Parameter

   This is commonly used for callbacks or defining custom behavior for a process.

2. Returning a Function

   Useful for "function factories" where the output depends on the input configuration.

Common Built-in Higher-Order Functions

Kotlin's standard library uses these extensively for collection processing:

• .filter { ... }: Takes a predicate function to filter a list.
• .map { ... }: Takes a transformation function to change list items.
• .forEach { ... }: Takes a function to execute for every element.

List vs. MutableList vs. Array

In Kotlin, these three structures are used to store collections of elements, but they differ in mutability, memory representation, and flexibility.

Key Differences Explained

• Array<T>: Use this when you know the number of elements in advance and need high-performance access. It is a low-level structure where the size is locked upon initialization.
• List<T>: This is an interface for a read-only collection. You cannot add or remove items. It provides a view of the data that ensures it won't be modified, which is essential for thread safety.
• MutableList<T>: Use this when you need to dynamically grow or shrink your collection. It includes methods like .add(), .remove(), and .clear().

Code Example:

Collection Transformations: Filter, Map, and Reduce

These are higher-order functions used to process collections in a functional style. They allow you to transform or analyze data without using manual for loops.

Detailed Breakdown

• filter : Takes a predicate (a function returning a Boolean).If the predicate is true, the element is included in the new list.
  • Example: numbers.filter { it > 10 }
• map : Applies a transformation function to every element. This is useful for extracting specific properties from a list of objects.
  • Example: users.map { it.name } (Turns a list of Users into a list of Strings).
• reduce : Starts with the first element as the "accumulator" and sequentially applies an operation. Note: It throws an exception if the collection is empty.(Use fold if you need an initial starting value).
  • Example: numbers.reduce { acc, next -> acc + next }

Combined Code Example

This example demonstrates a typical data pipeline:

Sequences vs. Iterables

In Kotlin, both IterableIterable (like List or Set) and Sequence offer functional processing (map, filter, etc.), but they differ fundamentally in evaluation strategy and performance for large datasets.

• Iterable (Eager Evaluation): Processes the entire collection at each step. If you chain three operations, Kotlin creates two intermediate lists before the final result.
• Sequence (Lazy Evaluation): Processes elements one by one through the entire chain. No intermediate collections are created. It performs "lazy" computation, meaning nothing happens until a terminal operation (like toList() or first()) is called.

Key Comparison

Behavioral Example

Consider a list of numbers where we want to find the first squared even number:

In this example, the Sequence is significantly faster because it stops as soon as the condition is met, whereas the Iterable finishes processing the entire list even though only the second element was needed.

Infix Functions in Kotlin

An Infix Function allows you to call a member function or an extension function using a more natural, English-like syntax by omitting the dot (.) and parentheses (). This is commonly used to create Domain Specific Languages (DSLs) or more readable mathematical operations.

Requirements for an Infix Function

To mark a function with the infix keyword, it must satisfy these three conditions:

• It must be a member function or an extension function.
• It must have exactly one parameter.
• The parameter must not accept a variable number of arguments (vararg) and must not have a default value.

Precedence

Infix functions have lower precedence than arithmetic operators, type casts, and the rangeTo operator. For example:

• 1..10 step 2 is parsed as (1..10) step 2.
• a + b combinedWith c is parsed as (a + b) combinedWith c.

Code Example: Creating an Infix Function

In this example, we create an extension function for the String class that allows us to "pair" two strings using the word onto.

Common Built-in Infix Functions

The when Expression in Kotlin

The when expression is Kotlin's more powerful, flexible version of the switch statement found in Java or C. It matches its argument against all branches sequentially until a condition is satisfied.

• Expression vs. Statement: Unlike a switch statement, when can be used as an expression, meaning it can return a value that you can assign to a variable.
• No break Needed: Once a branch is matched, the execution finishes for that when block. You don't need to add break keywords to prevent "fall-through."
• Exhaustiveness: When used as an expression, the compiler forces you to cover all possible cases (often requiring an else branch), making the code safer.

Flexible Branching Logic

when is not limited to constants; it can handle ranges, types, and logic.

Code Example

1. As an Expression (Assigning to a Variable)
2. Without an Argument (Replacingif-else if)

   If no argument is supplied, the branch conditions act as simple boolean expressions.