fun <T, E> ApiREsult<T, E>.myExtension() { }

JavaClass::new

var result = intArrayOf(1, 2, 3, 4)

val list = result.toMutableList()
list.add(5)

result = list.toIntArray

class SomeClass<out T>(private val type: Class<T>, val getDefaultValue: () -> T) {
    constructor(type: Class<T>, default: T): this(type, {default})
}

Kotlin: Overload resolution ambiguity: 
public constructor SomeClass<out T>(type: Class<TypeVariable(T)>, getDefaultValue: () -> TypeVariable(T)) defined in SomeClass
public constructor SomeClass<out T>(type: Class<TypeVariable(T)>, default: TypeVariable(T)) defined in SomeClass

when (request.path) {
    "/api/one/two" ->
        return "blah"
    "/api/three/four?arg=myArg" ->
        return "boop"

api/three/four*

object

class Mapper<T : Account> : RecordMapper<Record, T> {
    override fun map(record: Record?): T? {
        TODO("Not yet implemented")
    }
}

Record

T: Account

for (i in 0 until halfIndex) {
                for (j in s.length downTo halfIndex) {
                    println("i: ${s[i]} j: ${s[j]}")
                }
            }

head

val leftOne = arrayOne.drop(0).filter { it < arrayOne.first() }.toIntArray()

assert()

assert(1 == 1, { "Equal" })

fun main(args: Array<String>): Unit = io.ktor.server.netty.EngineMain.main(args)

fun Application.module() {
    install(FreeMarker) {
        templateLoader = ClassTemplateLoader(this::class.java.classLoader, "templates")
        outputFormat = HTMLOutputFormat.INSTANCE
    }
    routing {
        static("/static") {
            resources("files")
        }
        get("/") {
            call.respond(FreeMarkerContent("index.ftl", mapOf("entries" to blogEntries), ""))
        }

Could not find method implementation() for arguments [org.jetbrains.kotlin:kotlin-test-junit:1.5.21] on object of type org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler.

/*
 * This file was generated by the Gradle 'init' task.
 */

repositories {
    mavenCentral()
    maven {
        url = uri("<https://papermc.io/repo/repository/maven-public/>")
    }

    maven {
        url = uri("<https://oss.sonatype.org/content/groups/public/>")
    }

    maven {
        url = uri("<https://repo.maven.apache.org/maven2/>")
    }
}

dependencies {
    implementation("org.jetbrains.kotlin:kotlin-test-junit:1.5.21")
    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.5.21")
    implementation("io.github.monun:kommand-api:2.2.0")
    compileOnly("io.papermc.paper:paper-api:1.17.1-R0.1-SNAPSHOT")
}

java.sourceCompatibility = JavaVersion.VERSION_1_8

publishing {
    publications.create<MavenPublication>("maven") {
        from(components["java"])
    }
}

tasks.withType<JavaCompile> {
    options.encoding = "UTF-8"
}

console.count("something")

1 class Person(val pets: MutableList<Pet> = mutableListOf())
2
3 class Pet {
4     constructor(owner: Person) {
5         owner.pets.add(this) // adds this pet to the list of its owner's pets
6     }
7 }

var drivingStyle = when (getWeatherConditions()) {
   "Sunny" -> "Speedy"
   "Foggy", "Rainy" -> "Safely"
   "Blizzard" -> "Don't drive!"
   else -> "Undefined"
}

sealed class Weather
object Rainy : Weather()
object Sunny : Weather()
object Foggy : Weather()
object Blizzard : Weather()

var drivingStyle = when (getWeatherConditions()) {
   Sunny -> "Speedy"
   Foggy, Rainy  -> "Safely"
}

const

else

fun getSomething(): Something {}

val something: ReturnType<typeof getSomething> = getSomething()

fun executeSomething(cb: Something.(arg: String) -> Unit) {
    val something = Something()
    something.cb("the arg")
}

// here the type could be different
// val cb: Parameters<executeSomething>[0] = {
val cb: SecretUser.(arg: String) -> Unit = {
    println(propertyOfSomething)
}

executeSomething(cb)

for (i in 1 until array.size)

for num in array[1:]

mutableListOf<Pair?>

fun foo(value: List<Pair?>): Boolean {
        return list.contains(value)
    }

Type inference failed. The value of the type parameter T should be mentioned in input types (argument types, receiver type or expected type). Try to specify it explicitly.

return list.contains<Any?>(value)

Use of enum entry names as types is not allowed, use enum type instead

class A {
  generateInstance(): this:class {
     return this::class()
  }
}
class B: A() 
val b: B = B().generateInstance()

typealias IDK<T> = (value: T) -> T