cy6erGn0m

fun <T : Comparable<T>> mergeSort(input: Array<T>) {
    mergeSort(input, naturalOrder())
}

fun <T> mergeSort(input: Array<T>, comparator: Comparator<T>) {
    if (input.size < 2) return
    val tempSpace = input.copyOf()

    for (windowSize in generateSequence(1) { it * 2 }.takeWhile { it < input.size }) {
        for (segment in 0 until input.size / windowSize step 2) {

cy6erGn0m

import kotlinx.cinterop.*
import org.ssh.*

fun main(): Unit = memScoped {
    val session = ssh_new() ?: return
    val port = alloc<IntVar>()
    port.value = 22
    val verbosity = alloc<UIntVar>()
    verbosity.value = SSH_LOG_PROTOCOL

cy6erGn0m

// Please note that you don't even need kotlin-reflect.jar

class C {
    val f: String
        get() = "ok"
}

fun usage() {
    val fn = makeFunction(C::f)
    println(fn(C()))

cy6erGn0m

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
import java.util.concurrent.locks.*
import kotlin.coroutines.*

private val MyEventLoop: CoroutineDispatcher = TODO()

/**
 * This is simplified blocking adapter example. 
 * NEVER use in production as it is just clarification, not actual implementation

cy6erGn0m

private val XFrameOptionsAttribute = AttributeKey<XFrameOptions>("X-Frame-Options")

sealed class XFrameOptions {
    object Deny : XFrameOptions() {
        override fun toString() = "deny"
    }
    object SameOrigin : XFrameOptions() {
        override fun toString() = "sameorigin"
    }
    class AllowFrom(val url: String) : XFrameOptions() {

cy6erGn0m

sealed class XFrameOptions {
    object Deny : XFrameOptions() {
        override fun toString() = "deny"
    }
    object SameOrigin : XFrameOptions() {
        override fun toString() = "sameorigin"
    }
    class AllowFrom(val url: String) : XFrameOptions() {
        override fun toString(): String = "allow-from $url"
    }

cy6erGn0m

package org.jetbrains.ktor.client

import org.eclipse.jetty.http2.client.*
import org.eclipse.jetty.http2.client.http.*
import org.eclipse.jetty.http2.server.*
import org.eclipse.jetty.server.*
import org.eclipse.jetty.servlet.*
import org.eclipse.jetty.util.thread.*
import org.junit.*
import java.util.concurrent.*

cy6erGn0m

val cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
            .with(CacheManagerPersistenceConfiguration(storagePath))
            .withCache("kweetsCache",
                    CacheConfigurationBuilder.newCacheConfigurationBuilder<Int, Kweet>()
                            .withResourcePools(ResourcePoolsBuilder.newResourcePoolsBuilder()
                                    .heap(1000, EntryUnit.ENTRIES)
                                    .offheap(10, MemoryUnit.MB)
                                    .disk(100, MemoryUnit.MB, true)
                            )
                            .buildConfig(Int::class.javaObjectType, Kweet::class.java))

cy6erGn0m

fun findFreePort() = ServerSocket(0).use { it.localPort }

cy6erGn0m

dependencies {
  testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlinVersion"
}