1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29

@JvmInline
value class Code(val value: Short) {

    companion object {

        fun from(value: Number): CurrencyCode {
            checkValid(value)
            return CurrencyCode(value.toShort())
        }

        private fun checkValid(value: Number) {
            val targetValue = value.toDouble()
            val isValueInvalid = floor(targetValue) != targetValue
                    || targetValue < 0
                    || targetValue > Short.MAX_VALUE
            if (isValueInvalid) {
                throw DomainRuleViolationException(
                    "Code must be of 'short' type, greater than 0 and lower than ${Short.MAX_VALUE}. Provided: [$value]"
                )
            }
        }

    }

    init {
        checkValid(value)
    }

}

1. 1

val cityEq: (City) -> (Customer) -> Boolean = { city -> { it.city == city } }

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97
98. 98
99. 99
100. 100

package com.example

import kotlinx.coroutines.*
import io.ktor.network.selector.*
import io.ktor.network.sockets.*
import io.ktor.utils.io.*
import kotlinx.coroutines.channels.BroadcastChannel
import kotlinx.coroutines.channels.ClosedReceiveChannelException
import kotlinx.coroutines.channels.ConflatedBroadcastChannel
import kotlinx.coroutines.channels.ReceiveChannel
import java.io.IOException
import java.lang.StringBuilder
import java.nio.ByteBuffer

suspend fun ByteReadChannel.readString(): String {
    val result = StringBuilder()
    val decoder = Charsets.US_ASCII.newDecoder()
    val buffer = ByteBuffer.allocate(1)
    while (!isClosedForRead) {
        val byte = readByte()
        if (byte > 127 || byte < 0) {
            continue
        }
        val c = decoder.decode(buffer.also {
            it.put(byte)
            it.rewind()
        })[0]
        result.append(c)
        if (c == '\n') {
            return result.toString().trim('\r', '\n')
        }
        buffer.rewind()
        decoder.reset()
    }
    return ""
}

suspend fun ByteWriteChannel.println(text: String) {
    writeStringUtf8(text)
    writeStringUtf8("\r\n")
}

class Client(private val clientSocket: Socket, private val room: BroadcastChannel<String>) {
    private val output = clientSocket.openWriteChannel(autoFlush = true)
    private val input = clientSocket.openReadChannel()
    var nick: String? = null
        private set

    suspend fun start() = coroutineScope {
        input.discard(input.availableForRead.toLong())

        output.writeStringUtf8("Welcome! And your name: ")
        val nick = input.readString()
        room.send("$nick is here")
        output.println("Welcome $nick")
        <a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="f5819d9c86b5b6999c909b81db9b9c969e">[email protected]</a> = nick
        val roomSubscription = room.openSubscription()
        launch {
            for (message in roomSubscription) {
                output.println(message)
            }
        }
        launch {
            processUserInput(nick)
        }.join()
        roomSubscription.cancel()
    }

    private suspend fun processUserInput(nick: String) {
        while (!clientSocket.isClosed) {
            val text = input.readString()
            room.send("$nick: $text")
            if (text == "bye") {
                room.send("$nick left")
                return
            }
        }
    }
}


suspend fun stdoutRoomProcessor(input: ReceiveChannel<String>) {
    for (message in input) {
        println(message)
    }
}

suspend fun server(port: Int) = coroutineScope {
    val serverSocket = aSocket(ActorSelectorManager(coroutineContext)).tcp().bind(port = port)
    val room = ConflatedBroadcastChannel<String>()
    launch {
        stdoutRoomProcessor(room.openSubscription())
    }
    while (coroutineContext.isActive) {
        val clientSocket = serverSocket.accept()
        room.send("Client connected ${clientSocket.remoteAddress}")
        launch {
            val client = Client(clientSocket, room)
            try {
                client.start()

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11

* Returns the largest value among all values produced by [selector] function
 * applied to each element in the collection.
 * 
 * @throws NoSuchElementException if the collection is empty.
 */
@SinceKotlin("1.4")
@OptIn(kotlin.experimental.ExperimentalTypeInference::class)
@OverloadResolutionByLambdaReturnType
@kotlin.internal.InlineOnly
public inline fun <T, R : Comparable<R>> Iterable<T>.maxOf(selector: (T) -> R): R {
    val iterator = iterator()

1. 1
2. 2

val users = listOf("foo", "bar")
println(users.joinToString{","})

1. 1

https://plugins.jetbrains.com/plugin/12673-csense--kotlin-checked-exceptions

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9

private fun findFirstChecked(calendarModel: CalendarModel) =
        LocalDate.parse(
            "${calendarModel.year}-${
                calendarModel.months.indexOfFirst {
                    it.state is
                            CalendarMonthState.EnableType
                }.plus(1).toString().padStart(2, '0')
            }-01"
        )

1. 1
2. 2

Currently it's hard or even impossible to use hexadecimal literal constants that result in overflow of the corresponding signed types. 
https://github.com/Kotlin/KEEP/blob/master/proposals/unsigned-types.md

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9

object Cорок {
    infix fun тысяч(b: String) = this
    infix fun в(a: String) = this
    infix fun сунули(a: String) = this
}

fun main() {
    Cорок тысяч "обезъян" в "жопу" сунули "банан"
}

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14

enum class Measures {
    B, KB, MB, GB;

    private val size = BigDecimal.valueOf(1024L).pow(ordinal)

    companion object {
        fun toHumanSize(value: Long): String {
            val decValue = value.toBigDecimal()
            val measure = values().reversed().find { it.size < decValue } ?: B
            return "${decValue.divide(measure.size, 3, RoundingMode.UP)} $measure"

        }
    }
}