Kotlin¶

// The `fun` keyword declares a function.
// `main` is the special entry point for the application.
fun main() {
    // `println` prints a line to the console.
    // Semicolons are optional in Kotlin!
    println("Hello, Kotlin!")
}

val name: String = "Kotlin" // Read only
// name = "Java" // This would be a compile time error!

var score: Int = 100 // Mutable
score = 101 // This is fine

// Type inference works, so you can omit the type if the compiler can figure it out.
val language = "Kotlin" // Inferred as String

val user = "Alice"
val points = 99

// Simple variable interpolation
val message = "User $user has $points points."

// Expression interpolation
val status = "Status: ${if (points > 90) "Excellent" else "Good"}"

println(message) // "User Alice has 99 points."
println(status)  // "Status: Excellent"

var a: String = "abc"
// a = null // Compile time error!

var b: String? = "abc"
b = null // This is OK

val length: Int? = b?.length // If b is not null, return its length. Otherwise, return null.

// If b is not null, l is b.length. Otherwise, l is -1.
val l = b?.length ?: -1

val items = listOf("apple", "banana", "kiwi")

// for loop
for (item in items) {
    println(item)
}

// while loop
var index = 0
while (index < items.size) {
    println("Item at $index is ${items[index]}")
    index++
}

// A simple function
fun double(x: Int): Int {
    return x * 2
}

// Functions can be written as a single expression
fun triple(x: Int): Int = x * 3

// Default and named arguments make functions more readable
fun greet(name: String, greeting: String = "Hello") {
    println("$greeting, $name!")
}

greet("Alice") // "Hello, Alice!"
greet("Bob", "Hi") // "Hi, Bob!"
greet(greeting = "Yo", name = "Charlie") // "Yo, Charlie!"

// Add a new `shout()` function to the String class
fun String.shout(): String {
    return this.toUpperCase() + "!!!"
}

fun main() {
    val message = "hello world"
    println(message.shout()) // "HELLO WORLD!!!"
}

// `operate` is a higher order function that takes two integers and a function.
fun operate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

fun main() {
    // Define a lambda for addition
    val sum: (Int, Int) -> Int = { x, y -> x + y }

    val result = operate(5, 10, sum)
    println(result) // 15

    // You can also pass a lambda directly
    val product = operate(5, 10, { x, y -> x * y })
    println(product) // 50

    // If the lambda is the last argument, it can be moved outside the parentheses
    val difference = operate(10, 5) { x, y -> x y }
    println(difference) // 5
}

val readOnlyList: List<String> = listOf("a", "b", "c")
// readOnlyList.add("d") // Compile time error!

val mutableList: MutableList<String> = mutableListOf("a", "b", "c")
mutableList.add("d") // This is fine

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

//forEach
numbers.forEach { println(it) } // `it` is the implicit name for a single parameter in a lambda

// map
val squared = numbers.map { it * it } // [1, 4, 9, 16, 25, 36]

// filter
val evens = numbers.filter { it % 2 == 0 } // [2, 4, 6]

// firstOrNull (safe)
val firstEven = numbers.firstOrNull { it % 2 == 0 } // 2

// Chaining them together
val result = numbers
    .filter { it > 2 }
    .map { it * 10 }
    .first()

println(result) // 30

// The `val` in the constructor declares a read only property.
class User(val id: Int, var username: String) {
    // init block for constructor logic
    init {
        println("User created with id $id and username $username")
    }
}

val user = User(1, "alice")
user.username = "alice_b"
// user.id = 2 // Error: val cannot be reassigned

data class ServerConfig(val host: String, val port: Int)

val config1 = ServerConfig("localhost", 8080)
val config2 = ServerConfig("localhost", 8080)

println(config1) // ServerConfig(host=localhost, port=8080)
println(config1 == config2) // true (structural equality)

interface Loggable {
    fun log(): String
}

open class Asset(val name: String) {
    open fun describe() {
        println("This is an asset named $name")
    }
}

class Server(name: String, val ip: String) : Asset(name), Loggable {
    override fun describe() {
        println("This is a server named $name with IP $ip")
    }

    override fun log(): String {
        return "Server accessed: $name"
    }
}

import kotlinx.coroutines.*

fun main() = runBlocking { // Starts a coroutine scope
    println("Main program starts: ${Thread.currentThread().name}")

    // launch a new coroutine in the background
    launch {
        println("Fake work starts: ${Thread.currentThread().name}")
        delay(1000) // Non blocking delay
        println("Fake work finished.")
    }

    delay(500) // The main coroutine continues its own work
    println("Main program continues...")
    delay(1000)
    println("Main program ends.")
}

// Imagine this is a Java method: public String findUser() { ... }
val user = JavaClass.findUser() // user is of type String!

// This will compile, but will throw an NPE at runtime if findUser() returns null!
println(user.length)

// Safe way
val user: String? = JavaClass.findUser()
println(user?.length) // Now you must use a safe call

// In a Ktor web server
val userInput = call.receive<User>() // This might throw an exception if the JSON is malformed

// But it does NOT validate the content. An attacker could send `{"username": "", "email": "not an email"}`
// You still need to validate the properties of the `userInput` object.
if (userInput.username.isBlank()) {
    // handle error
}

import kotlinx.serialization.*
import kotlinx.serialization.json.*

@Serializable // This annotation makes the class serializable
data class User(val name: String, val email: String)

fun main() {
    val user = User("test", "test@example.com")

    // Encoding (object to string)
    val jsonString = Json.encodeToString(user)

    // Decoding (string to object) This is safe!
    val decodedUser = Json.decodeFromString<User>(jsonString)
}

data class User(val username: String, val email: String) {
    init {
        require(username.isNotBlank()) { "Username cannot be blank." }
        require(username.length >= 3) { "Username must be at least 3 characters long." }
        require(email.contains("@")) { "Invalid email format." }
    }
}

fun main() {
    try {
        val user = User("testuser", "test@example.com")
        println("User created: $user")
        val invalidUser = User("", "") // This will throw an IllegalArgumentException
    } catch (e: IllegalArgumentException) {
        println("Error creating user: ${e.message}")
    }
}

fun String.toSafeHtml(): String {
    return this
        .replace("&", "&")
        .replace("<", "&lt;")
        .replace(">", "&gt;")
        .replace("\"", "&quot;")
        .replace("'", "&#39;")
}

fun main() {
    val userInput = "<script>alert('xss')</script>"
    val sanitized = userInput.toSafeHtml()
    println("Original: $userInput")
    println("Sanitized: $sanitized")
}

    implementation("io.ktor:ktor server core jvm:$ktor_version")
    implementation("io.ktor:ktor server netty jvm:$ktor_version")
    implementation("ch.qos.logback:logback classic:$logback_version")

import io.ktor.server.application.*
import io.ktor.server.engine.*
import io.ktor.server.netty.*
import io.ktor.server.response.*
import io.ktor.server.routing.*

fun main() {
    embeddedServer(Netty, port = 8080) {
        routing {
            get("/") {
                call.respondText("Hello, Ktor!")
            }
            get("/users/{username}") {
                val username = call.parameters["username"]
                if (username != null) {
                    call.respondText("Profile page for $username")
                } else {
                    call.respondText("Username parameter is missing!")
                }
            }
        }
    }.start(wait = true)
}

import kotlinx.coroutines.*
import java.net.URL

suspend fun fetchUrl(url: String): String {
    println("Fetching $url...")
    // In a real app, use a proper HTTP client like Ktor or OkHttp
    return URL(url).readText().substring(0, 100) // Get first 100 chars
}

fun main() = runBlocking {
    val time = System.currentTimeMillis()

    // `async` starts a coroutine that returns a `Deferred` (like a future or promise)
    val postDeferred = async { fetchUrl("https://jsonplaceholder.typicode.com/posts/1") }
    val userDeferred = async { fetchUrl("https://jsonplaceholder.typicode.com/users/1") }

    // `await()` suspends the coroutine until the result is ready
    val post = postDeferred.await()
    val user = userDeferred.await()

    println("\n---
Post ---
$post...")
    println("\n---
User ---
$user...")
    println("\nTotal time: ${System.currentTimeMillis() time} ms")
}