fun main() {
    println("Hello, World!")
}

Hello, World!

fun main() {
    // Integer variable
    val age: Int = 25

    // Double variable
    val height: Double = 5.9

    // String variable
    val name: String = "John Doe"

    // Boolean variable
    val isStudent: Boolean = true

    println("Name: $name, Age: $age, Height: $height, Is Student: $isStudent")
}

Name: John Doe, Age: 25, Height: 5.9, Is Student: true

fun main() {
    val num = 7

    // If-else statement
    if (num % 2 == 0) {
        println("$num is even.")
    } else {
        println("$num is odd.")
    }

    // For loop
    for (i in 1..5) {
        println("Iteration $i")
    }

    // While loop
    var counter = 0
    while (counter < 3) {
        println("Counter: $counter")
        counter++
    }
}

7 is odd.
Iteration 1
Iteration 2
Iteration 3
Iteration 4
Iteration 5
Counter: 0
Counter: 1
Counter: 2

fun main() {
    val sum = add(5, 10)
    println("Sum: $sum")

    val result = calculate(3, 4, 2)
    println("Result: $result")
}

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

fun calculate(x: Int, y: Int, z: Int): Int {
    return (x * y) + z
}

Sum: 15
Result: 14

fun main() {
    // Creating a list of numbers
    val numbers = listOf(1, 2, 3, 4, 5)

    // Printing the elements of the list
    println("List of numbers: $numbers")

    // Summing all elements in the list
    val sum = numbers.sum()
    println("Sum of the numbers: $sum")

    // Finding the maximum value in the list
    val maxNum = numbers.maxOrNull()
    println("Maximum number: $maxNum")

    // Checking if a number exists in the list
    val searchNumber = 3
    val containsNumber = numbers.contains(searchNumber)
    println("List contains $searchNumber: $containsNumber")

    // Using map to create a new list with squared values
    val squaredNumbers = numbers.map { it * it }
    println("Squared numbers: $squaredNumbers")
}

List of numbers: [1, 2, 3, 4, 5]
Sum of the numbers: 15
Maximum number: 5
List contains 3: true
Squared numbers: [1, 4, 9, 16, 25]

fun main() {
    var nullableName: String? = "John Doe"
    nullableName = null

    // Safe call with the ?. operator
    val nameLength = nullableName?.length
    println("Name Length: $nameLength")

    // Elvis operator ?: to provide a default value
    val finalName = nullableName ?: "Unknown"
    println("Final Name: $finalName")
}

Name Length: null
Final Name: Unknown

class Person(val name: String, val age: Int) {
    fun introduce() {
        println("Hello, my name is $name and I am $age years old.")
    }
}

fun main() {
    val person = Person("Alice", 30)
    person.introduce()
}

Hello, my name is Alice and I am 30 years old.

// Extension function to capitalize the first letter of a string
fun String.capitalizeFirstLetter(): String {
    return if (isNotEmpty()) {
        this.substring(0, 1).toUpperCase() + this.substring(1)
    } else {
        this
    }
}

fun main() {
    val text = "hello, world!"
    val capitalizedText = text.capitalizeFirstLetter()
    println("Original text: $text")
    println("Capitalized text: $capitalizedText")
}

Original text: hello, world!
Capitalized text: Hello, world!

data class Book(val title: String, val author: String, val year: Int)

fun main() {
    val book = Book("The Alchemist", "Paulo Coelho", 1988)
    println("Book Details: $book")
}

Book Details: Book(title=The Alchemist, author=Paulo Coelho, year=1988)

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)

    // Filtering even numbers using a lambda
    val evenNumbers = numbers.filter { it % 2 == 0 }
    println("Even numbers: $evenNumbers")

    // Using a higher-order function to perform custom filtering
    val filteredNumbers = filterNumbers(numbers) { num -> num > 3 }
    println("Filtered numbers: $filteredNumbers")
}

// Higher-order function to filter numbers based on a condition
fun filterNumbers(numbers: List, condition: (Int) -> Boolean): List {
    return numbers.filter { condition(it) }
}

Even numbers: [2, 4, 6]
Filtered numbers: [4, 5, 6]

fun main() {
    try {
        val result = divideNumbers(10, 0)
        println("Result: $result")
    } catch (e: ArithmeticException) {
        println("Error: Cannot divide by zero.")
    }
}

fun divideNumbers(a: Int, b: Int): Int {
    if (b == 0) {
        throw ArithmeticException("Division by zero is not allowed.")
    }
    return a / b
}

Error: Cannot divide by zero.

// Base class
open class Shape {
    open fun draw() {
        println("Drawing a shape.")
    }
}

// Derived class
class Circle : Shape() {
    override fun draw() {
        println("Drawing a circle.")
    }
}

// Function to draw any shape
fun drawShape(shape: Shape) {
    shape.draw()
}

fun main() {
    val shape: Shape = Circle()
    drawShape(shape)
}

Drawing a circle.

class Logger {
    companion object {
        fun logMessage(message: String) {
            println("LOG: $message")
        }
    }
}

fun main() {
    Logger.logMessage("This is a log message.")
}

LOG: This is a log message.

sealed class Result
data class Success(val data: String) : Result()
data class Error(val message: String) : Result()

fun processResult(result: Result) {
    when (result) {
        is Success -> println("Success: ${result.data}")
        is Error -> println("Error: ${result.message}")
    }
}

fun main() {
    val result1 = Success("Data successfully processed.")
    val result2 = Error("Something went wrong!")

    processResult(result1)
    processResult(result2)
}

Success: Data successfully processed.
Error: Something went wrong!

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        delay(1000)
        println("Coroutines are awesome!")
    }

    println("Waiting for coroutine to finish...")
    job.join()
}

Waiting for coroutine to finish...
Coroutines are awesome!

fun String.afterLast(char: Char): String? {
    val lastIndex = lastIndexOf(char)
    return if (lastIndex != -1 && lastIndex < length - 1) {
        substring(lastIndex + 1)
    } else {
        null
    }
}

fun main() {
    val text = "example.com/test"
    val afterLastSlash = text.afterLast('/')
    println("Substring after last slash: $afterLastSlash")
}

Substring after last slash: test

fun main() {
    // Creating a MutableMap of names and ages
    val ages = mutableMapOf(
        "John" to 30,
        "Alice" to 25,
        "Bob" to 28
    )

    // Adding a new entry to the map
    ages["Michael"] = 35

    // Updating the age of an existing entry
    ages["Alice"] = 26

    // Removing an entry from the map
    ages.remove("Bob")

    // Iterating through the map
    for ((name, age) in ages) {
        println("$name is $age years old.")
    }
}

John is 30 years old.
Alice is 26 years old.
Michael is 35 years old.

fun isValidEmail(email: String): Boolean {
    val emailPattern = Regex("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}")
    return email.matches(emailPattern)
}

fun main() {
    val email = "john.doe@example.com"
    val isValid = isValidEmail(email)
    if (isValid) {
        println("Valid email address.")
    } else {
        println("Invalid email address.")
    }
}

Valid email address.

import java.io.File

fun main() {
    // Writing to a file
    val content = "Hello, this is the content to be written to the file."
    val outputFile = File("output.txt")
    outputFile.writeText(content)

    // Reading from a file
    val inputFile = File("output.txt")
    val readContent = inputFile.readText()
    println("File Content: $readContent")
}

File Content: Hello, this is the content to be written to the file.

data class Person(var name: String, var age: Int)

fun main() {
    val person = Person("Alice", 30)

    // 'apply' sets properties and returns the receiver object
    val updatedPerson = person.apply {
        name = "Bob"
        age = 28
    }

    println("Original Person: $person")
    println("Updated Person: $updatedPerson")

    // 'let' performs an operation and returns a result
    val fullName = person.let { "${it.name} Doe" }
    println("Full Name: $fullName")
}

Original Person: Person(name=Alice, age=30)
Updated Person: Person(name=Bob, age=28)
Full Name: Alice Doe

class Example {
    val lazyValue: String by lazy {
        println("Initializing lazyValue")
        "Hello Lazy"
    }
}

fun main() {
    val example = Example()
    println("Before accessing lazyValue")
    println(example.lazyValue)
    println("After accessing lazyValue")
}

Before accessing lazyValue
Initializing lazyValue
Hello Lazy
After accessing lazyValue

interface Shape {
    fun draw()
}

fun main() {
    val customShape = object : Shape {
        override fun draw() {
            println("Drawing a custom shape.")
        }
    }

    customShape.draw()
}

Drawing a custom shape.

data class Point(val x: Int, val y: Int)

fun main() {
    val point = Point(10, 20)

    // Destructuring declaration
    val (x, y) = point

    println("x: $x, y: $y")
}

enum class Direction {
    NORTH,
    SOUTH,
    EAST,
    WEST
}

fun main() {
    val currentDirection = Direction.NORTH
    println("Current Direction: $currentDirection")
}

Current Direction: NORTH

tailrec fun factorial(n: Int, result: Int = 1): Int {
    return if (n == 0) {
        result
    } else {
        factorial(n - 1, result * n)
    }
}

fun main() {
    val n = 5
    val factorialResult = factorial(n)
    println("Factorial of $n is $factorialResult")
}

Factorial of 5 is 120

class Rectangle(var width: Int, var height: Int)

val Rectangle.area: Int
    get() = width * height

fun main() {
    val rectangle = Rectangle(5, 10)
    println("Rectangle Area: ${rectangle.area}")
}

Rectangle Area: 50

fun main() {
    fun greet(name: String) {
        fun formatName(name: String): String {
            return name.trim().capitalize()
        }

        val formattedName = formatName(name)
        println("Hello, $formattedName!")
    }

    greet("  Alice  ")
}

Hello, Alice!

class Circle(var radius: Double) {
    var diameter: Double
        get() = radius * 2
        set(value) {
            radius = value / 2
        }
}

fun main() {
    val circle = Circle(5.0)
    println("Diameter: ${circle.diameter}")

    circle.diameter = 10.0
    println("New Radius: ${circle.radius}")
}

Diameter: 10.0
New Radius: 5.0

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

fun main() {
    val addition = calculate(5, 3) { a, b -> a + b }
    println("Addition: $addition")

    val multiplication = calculate(5, 3) { a, b -> a * b }
    println("Multiplication: $multiplication")
}

Addition: 8
Multiplication: 15

inline fun measureTime(block: () -> Unit) {
    val startTime = System.currentTimeMillis()
    block()
    val endTime = System.currentTimeMillis()
    println("Time taken: ${endTime - startTime} ms")
}

fun main() {
    measureTime {
        for (i in 1..1000000) {
            // Some time-consuming operation
        }
    }
}

Time taken: [Time in milliseconds]

typealias EmployeeId = Int
typealias EmployeeMap = Map

fun main() {
    val employees: EmployeeMap = mapOf(
        1 to "Alice",
        2 to "Bob",
        3 to "Charlie"
    )

    println("Employee Map: $employees")
}

Employee Map: {1=Alice, 2=Bob, 3=Charlie}

sealed interface Vehicle {
    fun start()
}

class Car : Vehicle {
    override fun start() {
        println("Car started")
    }
}

class Motorcycle : Vehicle {
    override fun start() {
        println("Motorcycle started")
    }
}

fun main() {
    val car: Vehicle = Car()
    val motorcycle: Vehicle = Motorcycle()

    car.start()
    motorcycle.start()
}

Car started
Motorcycle started

inline fun  getTypeName() = T::class.simpleName

fun main() {
    val typeName = getTypeName()
    println("Type Name: $typeName")
}

Type Name: Int

object Logger {
    fun log(message: String) {
        println("LOG: $message")
    }
}

fun main() {
    Logger.log("This is a log message.")
}

LOG: This is a log message.

fun printLength(obj: Any) {
    if (obj is String) {
        // 'obj' is automatically cast to String inside this block
        println("Length of the string: ${obj.length}")
    } else {
        println("Not a string")
    }
}

fun main() {
    printLength("Hello, Kotlin")
    printLength(42)
}

Length of the string: 12
Not a string

fun printLength(str: String?) {
    // Using the non-null assertion operator
    val length = str!!.length
    println("Length of the string: $length")
}

fun main() {
    printLength("Hello, Kotlin")
    printLength(null) // This will throw a NullPointerException
}

Length of the string: 12
Exception in thread "main" kotlin.KotlinNullPointerException

val pi: Double by lazy {
    println("Calculating PI...")
    3.14159
}

fun main() {
    println("Before accessing PI")
    println("PI: $pi")
    println("After accessing PI")
}

Before accessing PI
Calculating PI...
PI: 3.14159
After accessing PI

fun greet(name: String = "Guest", age: Int = 0) {
    println("Hello, $name! You are $age years old.")
}

fun main() {
    greet("Alice", 30)
    greet("Bob")
    greet(age = 25)
}

Hello, Alice! You are 30 years old.
Hello, Bob! You are 0 years old.
Hello, Guest! You are 25 years old.

fun describeDay(day: String) {
    when (day) {
        "Monday", "Tuesday", "Wednesday", "Thursday", "Friday" -> println("Weekday")
        "Saturday", "Sunday" -> println("Weekend")
        else -> println("Invalid day")
    }
}

fun main() {
    describeDay("Monday")
    describeDay("Saturday")
    describeDay("Sunday")
    describeDay("Wednesday")
    describeDay("Friday")
    describeDay("Holiday")
}

Weekday
Weekend
Weekend
Weekday
Weekday
Invalid day

fun main() {
    val num = 5
    if (num in 1..10) {
        println("$num is between 1 and 10")
    }

    val names = listOf("Alice", "Bob", "Charlie")
    if ("Alice" in names) {
        println("Alice is in the list")
    }
}

5 is between 1 and 10
Alice is in the list

class MyClass {
    companion object {
        fun hello() {
            println("Hello from the companion object!")
        }
    }
}

fun MyClass.Companion.greet() {
    println("Greetings from the extended companion object!")
}

fun main() {
    MyClass.hello()
    MyClass.greet()
}

Hello from the companion object!
Greetings from the extended companion object!

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)

    // Using 'map' to square each number
    val squaredNumbers = numbers.map { it * it }
    println("Squared numbers: $squaredNumbers")

    // Using 'filter' to get even numbers
    val evenNumbers = numbers.filter { it % 2 == 0 }
    println("Even numbers: $evenNumbers")

    // Using 'reduce' to calculate the sum of numbers
    val sum = numbers.reduce { acc, number -> acc + number }
    println("Sum of numbers: $sum")
}

Squared numbers: [1, 4, 9, 16, 25]
Even numbers: [2, 4]
Sum of numbers: 15

fun main() {
    val name: String? = null
    val length = name?.length ?: 0
    println("Length of name: $length")
}

Length of name: 0

import kotlinx.coroutines.*

suspend fun fetchUserData(userId: Int): String {
    // Simulate an API call with a delay
    delay(1000)
    return "User data for ID $userId"
}

fun main() = runBlocking {
    val userIds = listOf(1, 2, 3)

    // Launch coroutines to fetch user data concurrently
    val deferredResults = userIds.map { userId ->
        async { fetchUserData(userId) }
    }

    // Await all the results and print them
    deferredResults.awaitAll().forEach {
        println(it)
    }
}

User data for ID 1
User data for ID 2
User data for ID 3

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

fun main() {
    val people = listOf(
        Person("Alice", 30),
        Person("Bob", 25),
        Person("Charlie", 30)
    )

    // Creating a map with name as key and person as value
    val nameToPersonMap = people.associateBy { it.name }
    println("Name to Person Map: $nameToPersonMap")

    // Grouping people by age
    val peopleByAge = people.groupingBy { it.age }.eachCount()
    println("People grouped by age: $peopleByAge")
}

Name to Person Map: {Alice=Person(name=Alice, age=30), Bob=Person(name=Bob, age=25), Charlie=Person(name=Charlie, age=30)}
People grouped by age: {30=2, 25=1}

fun String?.isNullOrBlankOrEmpty(): Boolean {
    return this == null || this.isBlank()
}

fun main() {
    val str1: String? = null
    val str2: String? = ""
    val str3: String? = "Hello, Kotlin!"

    println("str1 is blank or empty: ${str1.isNullOrBlankOrEmpty()}")
    println("str2 is blank or empty: ${str2.isNullOrBlankOrEmpty()}")
    println("str3 is blank or empty: ${str3.isNullOrBlankOrEmpty()}")
}

str1 is blank or empty: true
str2 is blank or empty: true
str3 is blank or empty: false

inline class ZipCode(val value: String)

fun main() {
    val zipCode = ZipCode("12345")
    println("Zip Code: ${zipCode.value}")
}

Zip Code: 12345

fun printType(obj: Any) {
    if (obj is String) {
        println("$obj is a String")
    } else if (obj is Int) {
        println("$obj is an Int")
    } else {
        println("Unknown type")
    }
}

fun main() {
    printType("Hello")
    printType(42)
    printType(3.14)
}

Hello is a String
42 is an Int
Unknown type

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class MyAnnotation

@MyAnnotation
class MyClass

fun main() {
    val annotation = MyClass::class.annotations.find { it.annotationClass == MyAnnotation::class }
    if (annotation != null) {
        println("MyAnnotation found on MyClass")
    } else {
        println("MyAnnotation not found on MyClass")
    }
}

MyAnnotation found on MyClass

import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json

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

fun main() {
    val person = Person("Alice", 30)

    // Serialize the object to JSON
    val json = Json.encodeToString(Person.serializer(), person)
    println("Serialized JSON: $json")

    // Deserialize JSON to an object
    val deserializedPerson = Json.decodeFromString(Person.serializer(), json)
    println("Deserialized Person: $deserializedPerson")
}

Serialized JSON: {"name":"Alice","age":30}
Deserialized Person: Person(name=Alice, age=30)

interface Source {
    fun get(): T
}

fun getSource(): Source {
    return object : Source {
        override fun get(): String = "Hello, Kotlin!"
    }
}

fun main() {
    val source: Source = getSource()
    val value: Any = source.get()
    println("Value: $value")
}

Value: Hello, Kotlin!

typealias Operation = (Int, Int) -> Int

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

fun main() {
    val operation: Operation = ::add
    println("Result of add operation: ${operation(5, 3)}")

    val anotherOperation: Operation = ::subtract
    println("Result of subtract operation: ${anotherOperation(5, 3)}")
}

Result of add operation: 8
Result of subtract operation: 2

class Person {
    var name: String = ""
    var age: Int = 0
}

fun person(block: Person.() -> Unit): Person {
    val person = Person()
    person.block()
    return person
}

fun main() {
    val person = person {
        name = "Alice"
        age = 30
    }

    println("Person: ${person.name}, ${person.age} years old.")
}

Person: Alice, 30 years old.

import com.squareup.kotlinpoet.FileSpec
import com.squareup.kotlinpoet.FunSpec

fun main() {
    val mainFun = FunSpec.builder("main")
        .addStatement("println(\"Hello, KotlinPoet!\")")
        .build()

    val file = FileSpec.builder("com.example", "HelloWorld")
        .addFunction(mainFun)
        .build()

    file.writeTo(System.out)
}

package com.example

fun main() {
    println("Hello, KotlinPoet!")
}

sealed interface Shape

data class Circle(val radius: Double) : Shape()
data class Square(val sideLength: Double) : Shape()

fun calculateArea(shape: Shape): Double {
    return when (shape) {
        is Circle -> Math.PI * shape.radius * shape.radius
        is Square -> shape.sideLength * shape.sideLength
    }
}

fun main() {
    val circle = Circle(5.0)
    val square = Square(4.0)

    println("Circle area: ${calculateArea(circle)}")
    println("Square area: ${calculateArea(square)}")
}

Circle area: 78.53981633974483
Square area: 16.0

class Tag(val name: String) {
    private val children = mutableListOf()

    fun tag(name: String, block: Tag.() -> Unit) {
        val child = Tag(name)
        child.block()
        children.add(child)
    }

    override fun toString(): String {
        return "<$name>${children.joinToString("")}"
    }
}

fun html(block: Tag.() -> Unit): Tag {
    val root = Tag("html")
    root.block()
    return root
}

fun main() {
    val result = html {
        tag("head") {
            tag("title") {
                "Page Title"
            }
        }
        tag("body") {
            tag("h1") {
                "Hello, DSL!"
            }
            tag("p") {
                "This is a custom DSL example."
            }
        }
    }

    println(result)
}

class MyClass {
    companion object {
        fun greet() {
            println("Hello from the companion object!")
        }
    }
}

fun MyClass.Companion.sayHello() {
    println("Hello from the extended companion object!")
}

fun main() {
    MyClass.greet()
    MyClass.sayHello()
}

Hello from the companion object!
Hello from the extended companion object!

interface Producer {
    fun produce(): T
}

interface Consumer {
    fun consume(item: T)
}

fun main() {
    val stringProducer: Producer = object : Producer {
        override fun produce(): String = "Hello, Kotlin!"
    }

    val anyConsumer: Consumer = object : Consumer {
        override fun consume(item: Any) {
            println("Consuming: $item")
        }
    }

    val item: Any = stringProducer.produce()
    anyConsumer.consume(item)
}

Consuming: Hello, Kotlin!

inline fun  printType() {
    println("Type: ${T::class.simpleName}")
}

fun main() {
    printType()
    printType()
    printType()
}

Type: String
Type: Int
Type: Double

inline fun  printType(list: List) {
    println("List of ${T::class.simpleName}: $list")
}

fun main() {
    val listInt = listOf(1, 2, 3)
    val listString = listOf("a", "b", "c")

    printType(listInt)
    printType(listString)
}

List of Int: [1, 2, 3]
List of String: [a, b, c]

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

fun main() {
    val people = listOf(Person("Alice", 30), Person("Bob", 25), Person("Charlie", 40))

    for ((name, age) in people) {
        println("$name is $age years old.")
    }
}

Alice is 30 years old.
Bob is 25 years old.
Charlie is 40 years old.

fun main() {
    val message = """
        |Hello, Kotlin!
        |This is a multiline string.
        |${2 + 3} equals 5.
    """.trimMargin()

    println(message)
}

Hello, Kotlin!
This is a multiline string.
5 equals 5.

import kotlinx.coroutines.*

suspend fun doSomething() {
    delay(100)
    throw RuntimeException("Oops, something went wrong!")
}

fun main() = runBlocking {
    try {
        doSomething()
    } catch (e: Exception) {
        println("Caught exception: ${e.message}")
    }
}

Caught exception: Oops, something went wrong!

data class Person(var name: String, var age: Int)

fun main() {
    val person = Person("Alice", 30)

    val letResult = person.let {
        it.name = "Bob"
        it.age + 5
    }
    println("letResult: $letResult, person: $person")

    val runResult = person.run {
        name = "Charlie"
        age + 10
    }
    println("runResult: $runResult, person: $person")

    val withResult = with(person) {
        name = "David"
        age + 15
    }
    println("withResult: $withResult, person: $person")

    val applyResult = person.apply {
        name = "Eva"
        age + 20
    }
    println("applyResult: $applyResult, person: $person")

    val alsoResult = person.also {
        it.name = "Fiona"
        it.age + 25
    }
    println("alsoResult: $alsoResult, person: $person")
}

letResult: 35, person: Person(name=Bob, age=30)
runResult: 40, person: Person(name=Charlie, age=40)
withResult: 45, person: Person(name=David, age=45)
applyResult: Person(name=Eva, age=45), person: Person(name=Eva, age=45)
alsoResult: Person(name=Fiona, age=45), person: Person(name=Fiona, age=45)

sealed class Result
data class Success(val data: String) : Result()
data class Error(val message: String) : Result()

fun processResult(result: Result) {
    when (result) {
        is Success -> println("Data: ${result.data}")
        is Error -> println("Error: ${result.message}")
    }
}

fun main() {
    val successResult = Success("Kotlin is awesome!")
    val errorResult = Error("Something went wrong!")

    processResult(successResult)
    processResult(errorResult)
}

Data: Kotlin is awesome!
Error: Something went wrong!

class MyCalculator {
    @JvmOverloads
    fun add(a: Int, b: Int, c: Int = 0): Int {
        return a + b + c
    }
}

fun main() {
    val calculator = MyCalculator()
    println(calculator.add(2, 3))
    println(calculator.add(2, 3, 5))
}

5
10

infix fun Int.multiplyBy(x: Int): Int {
    return this * x
}

fun main() {
    val result = 5 multiplyBy 3
    println("Result: $result")
}

Result: 15

import kotlin.properties.Delegates

class Example {
    val lazyValue: String by lazy {
        println("Initializing lazyValue")
        "Lazy value"
    }

    var observableValue: String by Delegates.observable("Initial value") { _, oldValue, newValue ->
        println("Old value: $oldValue, New value: $newValue")
    }

    var vetoableValue: Int by Delegates.vetoable(0) { _, oldValue, newValue ->
        newValue >= oldValue
    }
}

fun main() {
    val example = Example()

    println(example.lazyValue)
    println(example.lazyValue)

    example.observableValue = "Updated value"
    example.observableValue = "Another update"

    println("vetoableValue: ${example.vetoableValue}")
    example.vetoableValue = 10
    println("vetoableValue: ${example.vetoableValue}")
    example.vetoableValue = 5
}

Initializing lazyValue
Lazy value
Lazy value
Old value: Initial value, New value: Updated value
Old value: Updated value, New value: Another update
vetoableValue: 0
vetoableValue: 10

typealias DoubleList = List
typealias StringMap = Map

fun main() {
    val doubleList: DoubleList = listOf(1.0, 2.0, 3.0)
    val stringMap: StringMap = mapOf("one" to 1, "two" to 2, "three" to 3)

    println("Double List: $doubleList")
    println("String Map: $stringMap")
}

Double List: [1.0, 2.0, 3.0]
String Map: {one=1, two=2, three=3}

class Person {
    var name: String = ""
        get() {
            println("Getting name: $field")
            return field
        }
        set(value) {
            println("Setting name to $value")
            field = value
        }
}

fun main() {
    val person = Person()
    person.name = "Alice"
    println("Name: ${person.name}")
}

Setting name to Alice
Getting name: Alice
Name: Alice

fun main() {
    fun printMessage(message: String) {
        println("Message: $message")
    }

    printMessage("Hello, Kotlin!")
}

Message: Hello, Kotlin!

tailrec fun factorial(n: Int, acc: Int = 1): Int {
    return if (n == 0) acc else factorial(n - 1, acc * n)
}

fun main() {
    val result = factorial(5)
    println("Factorial of 5: $result")
}

Factorial of 5: 120

enum class Color(val hexCode: String) {
    RED("#FF0000"),
    GREEN("#00FF00"),
    BLUE("#0000FF")
}

fun main() {
    println("Red Hex Code: ${Color.RED.hexCode}")
    println("Green Hex Code: ${Color.GREEN.hexCode}")
    println("Blue Hex Code: ${Color.BLUE.hexCode}")
}

Red Hex Code: #FF0000
Green Hex Code: #00FF00
Blue Hex Code: #0000FF

class Rectangle(val width: Double, val height: Double)

val Rectangle.area: Double
    get() = width * height

fun main() {
    val rectangle = Rectangle(5.0, 3.0)
    println("Rectangle area: ${rectangle.area}")
}

Rectangle area: 15.0

class Example {
    lateinit var name: String

    fun init() {
        name = "Kotlin"
    }
}

fun main() {
    val example = Example()
    example.init()

    println("Name: ${example.name}")
}

Name: Kotlin

interface FactorialCalculator {
    tailrec fun factorial(n: Int, acc: Int = 1): Int {
        return if (n == 0) acc else factorial(n - 1, acc * n)
    }
}

class FactorialImpl : FactorialCalculator

fun main() {
    val factorialImpl = FactorialImpl()
    val result = factorialImpl.factorial(5)
    println("Factorial of 5: $result")
}

Factorial of 5: 120

class Person(val name: String) {
    var age: Int = 0

    constructor(name: String, age: Int) : this(name) {
        this.age = age
    }
}

fun main() {
    val person1 = Person("Alice")
    val person2 = Person("Bob", 25)

    println("Person 1: ${person1.name}, ${person1.age} years old.")
    println("Person 2: ${person2.name}, ${person2.age} years old.")
}

Person 1: Alice, 0 years old.
Person 2: Bob, 25 years old.

data class Point(val x: Int, val y: Int) {
    companion object {
        operator fun Point.plus(other: Point): Point {
            return Point(x + other.x, y + other.y)
        }
    }
}

fun main() {
    val p1 = Point(2, 3)
    val p2 = Point(4, 5)
    val sum = p1 + p2
    println("Sum: (${sum.x}, ${sum.y})")
}

Sum: (6, 8)

fun main() {
    // Closed range [1, 10]
    val range = 1..10

    // Half-open range [1, 10)
    val halfOpenRange = 1 until 10

    // Range with step 2 [1, 3, 5, 7, 9]
    val steppedRange = 1..10 step 2

    // Reverse range [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    val reversedRange = 10 downTo 1

    // Print the ranges
    println("Range: $range")
    println("Half-Open Range: $halfOpenRange")
    println("Stepped Range: $steppedRange")
    println("Reversed Range: $reversedRange")

    // Iterate through the range
    for (i in 1..5) {
        print("$i ")
    }
}

Range: 1..10
Half-Open Range: 1 until 10
Stepped Range: 1..9 step 2
Reversed Range: 10 downTo 1
1 2 3 4 5

fun greetPerson(name: String, age: Int) {
    println("Hello, $name! You are $age years old.")
}

fun main() {
    greetPerson(name = "Alice", age = 30)
    greetPerson(age = 25, name = "Bob")
}

Hello, Alice! You are 30 years old.
Hello, Bob! You are 25 years old.

fun String?.printLength() {
    if (this != null) {
        println("Length of the string: ${this.length}")
    } else {
        println("String is null")
    }
}

fun main() {
    val str1: String? = null
    val str2: String? = "Hello, Kotlin!"

    str1.printLength()
    str2.printLength()
}

String is null
Length of the string: 13

val greet: String.(String) -> String = { name -> "Hello, $name! I'm $this" }

fun main() {
    val greeting1 = "Alice".greet("Bob")
    val greeting2 = "Kotlin".greet("Developer")

    println(greeting1)
    println(greeting2)
}

Hello, Bob! I'm Alice
Hello, Developer! I'm Kotlin

class Tag(val name: String) {
    private val children = mutableListOf()

    fun tag(name: String, block: Tag.() -> Unit) {
        val child = Tag(name)
        child.block()
        children.add(child)
    }

    override fun toString(): String {
        return buildString {
            append("<$name>")
            children.forEach {
                append(it)
            }
            append("")
        }
    }
}

fun html(block: Tag.() -> Unit): Tag {
    val root = Tag("html")
    root.block()
    return root
}

fun main() {
    val result = html {
        tag("head") {
            tag("title") {
                +"Page Title"
            }
        }
        tag("body") {
            tag("h1") {
                +"Hello, DSL!"
            }
            tag("p") {
                +"This is a custom HTML DSL example."
            }
        }
    }

    println(result)
}

Page TitleHello, DSL!This is a custom HTML DSL example.

fun processNumbers(numbers: List, operation: (Int) -> Int): List {
    return numbers.map { operation(it) }
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)

    val squaredNumbers = processNumbers(numbers) { it * it }
    val doubledNumbers = processNumbers(numbers) { it * 2 }

    println("Squared Numbers: $squaredNumbers")
    println("Doubled Numbers: $doubledNumbers")
}

Squared Numbers: [1, 4, 9, 16, 25]
Doubled Numbers: [2, 4, 6, 8, 10]

val addOne: (Int) -> Int = { it + 1 }
val double: (Int) -> Int = { it * 2 }

val addOneAndThenDouble = addOne andThen double
val doubleAndThenAddOne = double compose addOne

fun main() {
    val result1 = addOneAndThenDouble(5)
    val result2 = doubleAndThenAddOne(5)

    println("Result1: $result1")
    println("Result2: $result2")
}

Result1: 12
Result2: 11

inline class Username(val value: String)

fun printUsername(username: Username) {
    println("Username: ${username.value}")
}

fun main() {
    val username = Username("kotlin_user")
    printUsername(username)
}

Username: kotlin_user

fun String.removeWhitespace(): String {
    return this.replace("\\s+".toRegex(), "")
}

fun List.sumAll(): Int {
    return this.reduce { acc, i -> acc + i }
}

fun main() {
    val text = "  Hello  Kotlin  "
    val numbers = listOf(1, 2, 3, 4, 5)

    val cleanedText = text.removeWhitespace()
    val totalSum = numbers.sumAll()

    println("Cleaned Text: '$cleanedText'")
    println("Total Sum: $totalSum")
}

Cleaned Text: 'HelloKotlin'
Total Sum: 15

inline fun execute(action: () -> Unit) {
    println("Start execution")
    action()
    println("End execution")
}

fun main() {
    execute {
        println("Inside inline function")
    }
}

Start execution
Inside inline function
End execution

inline fun  printType() {
    println("Type: ${T::class.simpleName}")
}

fun main() {
    printType()
    printType()
    printType()
}

Type: String
Type: Int
Type: Double

fun describeValue(value: Any) {
    when (value) {
        in 1..10 -> println("Value is in the range of 1 to 10")
        is String -> println("Value is a String with length ${value.length}")
        is Boolean -> println("Value is a Boolean with value $value")
        else -> println("Value is something else")
    }
}

fun main() {
    describeValue(5)
    describeValue("Kotlin")
    describeValue(true)
    describeValue(3.14)
}

Value is in the range of 1 to 10
Value is a String with length 6
Value is a Boolean with value true
Value is something else

class Person {
    lateinit var name: String

    fun initPerson() {
        name = "Alice"
    }

    fun printName() {
        println("Name: $name")
    }
}

fun main() {
    val person = Person()
    person.initPerson()
    person.printName()
}

Name: Alice

fun main() {
    val personInfo = mapOf("name" to "Alice", "age" to 30, "city" to "Wonderland")

    val (name, age, city) = personInfo

    println("Name: $name, Age: $age, City: $city")
}

Name: Alice, Age: 30, City: Wonderland

interface Greeter {
    fun greet(name: String)
}

fun main() {
    val englishGreeter = object : Greeter {
        override fun greet(name: String) {
            println("Hello, $name!")
        }
    }

    val frenchGreeter = object : Greeter {
        override fun greet(name: String) {
            println("Bonjour, $name!")
        }
    }

    englishGreeter.greet("Alice")
    frenchGreeter.greet("Bob")
}

Hello, Alice!
Bonjour, Bob!

data class Point(val x: Int, val y: Int) {
    operator fun unaryMinus() = Point(-x, -y)
}

fun main() {
    val point = Point(3, 4)
    val negativePoint = -point

    println("Original Point: (${point.x}, ${point.y})")
    println("Negative Point: (${negativePoint.x}, ${negativePoint.y})")
}

Original Point: (3, 4)
Negative Point: (-3, -4)

data class Fruit(val name: String)

class FruitBasket(private val fruits: List) {
    operator fun contains(fruit: Fruit) = fruit in fruits
}

fun main() {
    val apple = Fruit("Apple")
    val orange = Fruit("Orange")

    val basket = FruitBasket(listOf(apple, orange))

    println("Is Apple in the basket? ${apple in basket}")
    println("Is Banana in the basket? ${Fruit("Banana") in basket}")
}

Is Apple in the basket? true
Is Banana in the basket? false

fun printLength(obj: Any) {
    if (obj is String) {
        println("String length: ${obj.length}")
    } else {
        println("Not a String")
    }
}

fun main() {
    printLength("Kotlin")
    printLength(10)
}

String length: 6
Not a String

object Singleton {
    fun greet() {
        println("Hello, I'm a Singleton!")
    }
}

fun main() {
    Singleton.greet()
}

Hello, I'm a Singleton!

fun doOperation(operation: (Int, Int) -> Int) {
    val result = operation(5, 3)
    println("Result: $result")
}

fun main() {
    val add: (Int, Int) -> Int = { a, b -> a + b }
    val subtract: (Int, Int) -> Int = { a, b -> a - b }

    doOperation(add)
    doOperation(subtract)
}

Result: 8
Result: 2

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

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

fun main() {
    val numbers = listOf(2, 3, 4)

    // Using function references
    val sum = numbers.fold(0, ::add)
    val product = numbers.fold(1, ::multiply)

    println("Sum: $sum")
    println("Product: $product")
}

Sum: 9
Product: 24

fun main() {
    val day = "Monday"

    when {
        day == "Monday" -> println("Start of the week")
        day == "Friday" -> println("End of the week")
        day == "Wednesday" || day == "Thursday" -> println("Midweek")
        else -> println("Normal day")
    }
}

Start of the week