anybody know if

kotlin.Result

becomes usable as a return value in 1.5?

In kotlinx.coroutines, there are functions like

atomic<T>()

but Intellij cannot resolve it. What are those and where are they defined?

Anyone who knows any opensource pure kotlin repos. Please no kotlin android

Hello, How can I compare generic class with list class? I have a generic class named BaseResponse now I want to extract the actual type "O" from the base-response. I have used the inline function with reified type parameter as defined in kotlin documentation but it is not working. This is my function in which I am passing the base response model and comparing the java class and getting the actual object. But If there is a List type like BaseResponseModel<List> it is always going in the else branch, not in the first comparison of the when statement.

inline fun <reified O> getAPIResult(apiResponse: BaseResponseModel<O>): O? {
    val actualResult: O? = try {
        when (O::class.java) {
            List::class.java -> {
                apiResponse.getResponseModel(object : TypeToken<List<O>>() {}.type)
            }
            ArrayList::class.java -> {
                apiResponse.getResponseModel(object : TypeToken<ArrayList<O>>() {}.type)
            }
            else -> {
                apiResponse.getResponseModel(O::class.java)
            }
        }
    } catch (e: Exception) {
        null
    }
    return actualResult
}

How can I use Kotlin Function type as a Data type within Java? For example: I have a typealias 

typealias _Validator_<_ValidatableT_, _FailureT_> = _suspend_ (_ValidatableT_) -> _Either_<_FailureT_, Any?>

Within Kotlin, I use it like this as a data type to assign to a lamda 

val validateParent3X: _Validator_<_Egg_, _ValidationFailure_> = {...}

But I cannot use typealias from Java. What is the idiomatic way to use this Function type as data type on Java? I see two unknows I have for java interoperability. 1. How can I idimotically refer a Function type 2. Function type being 

suspend

Is it possible to add annotations to extension functions? I am currently writing an extension function that returns a string based on the value of an Int:

fun Int.toFriendlyName(): String{
    return when(this) {
        PredefinedValue1 -> "PredefinedValue1"
        PredefinedValue2 -> "PredefinedValue2"
        PredefinedValue3 -> "PredefinedValue3"
        else -> willNeverHappen("This value is not supported")
    }
}

However this is problematic as this extension function can now be used on all integers in the scope of the extension functions. I know that the `Int`s that I will be calling this on will be annotated with @Barcode.BarcodeFormat - so is there a way for me to mark that on my extension function so that I can only use it on integers with that specific annotation?

I haven't fully understood how SAM works. But would it be possible to mix it with enum classes? so instead of having something like this:

fun interface Ordering {
    fun String.getOrdering(): List<String>
}

enum class CustomValueCriteriaOrder : Ordering {
    ALPHABETICALLY {
        override fun String.getOrdering(): List<String> {
            return emptyList()
        }
    }
}

I could have

fun interface Ordering {
    fun String.getOrdering(): List<String>
}

enum class CustomValueCriteriaOrder : Ordering {
    ALPHABETICALLY { emptyList() }
}

Is there a workaround for this issue? https://youtrack.jetbrains.com/issue/KT-34051

I am using the

kotlin.time.Duration

concept in my code and see that I can convert to

String

pretty easily. I am not seeing a way to go the other way around, which makes it quite hard to use it as a field in a form or to save/retrieve in preferences... Am I missing something?

I am trying to investigate value classes, but in intellij, when I try to add @JvmInline, it is unable to find it

👋🏽 I’m trying to understand if there is a difference between the following blocks of code. Personally, I find that B is easier to read and understand in a sense that I don’t need to know what exactly

apply {}

does in order to understand the code. I am more curious to understand if there is some sort of tradeoff I’m missing here if one chooses A over B or vice versa. Thanks!

// A
val setOfInts = HashSet<Int>().apply{
    for (i in 0..20) {
        this += i
    }
}

// B
val setOfInts = mutableSetOf<Int>()
for (i in 0..20) {
    setOfInts.add(i)
}

Quick question because I can't find this anywhere online. So most Apache 2.0 licensed work uses the long-form, boilerplate notice at the top of each file, and in that case if you're making a derivative of it you just add another "Copyright YYYY Firstname Lastname" line underneath the already existing one, but the Kotlin compiler code uses this shorthand form:

/*
 * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
 * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
 */

so in this case should I change it to " Copyright 2010-2019 JetBrains s.r.o., Kotlin Programming Language contributors, and Firstname Lastname", or what should I do?

This message was deleted.

Is there a more concise way of doing the following:

fun charToNumber(input: Char): Int {
    val numbersToLetters = listOf('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
    'T', 'U', 'V', 'W', 'X', 'Y', 'Z')

    return numbersToLetters.indexOf(input.toUpperCase()) + 1
}

would this work:

for (number in input.toString().split("")) {
    
}

Anything I can do to exclude a particular field from data class

.toString()

except overriding it? I have a LAZY collection in a data class, so it throws an exception on

.toString()

What is the lowest common ancestor of

Array<Int>

and

Array<in Int>

? In my opinion it should be

Array<in Int>

. But kotlin compiler thinks it's

Array<out Int?>

. I agree that

Array<out Int?>

is supertype of both

Array<Int>

and

Array<in Int>

, but it's not the lowest. What do you think?

I was never good at probability at school

something something shakespeare with monkeys on a typewriter

Seems as though I reached the limit of Int... Should've used 'double' for numbering. Anyways, passed almost 3 hours; hasn't found 'TOMJONEYWASHERE'. I will try again tomorrow:

@therealbluepandabear please stop spamming, use threads

Is there an out of the box way to take from an Iterable until a predicate is satisfied, including the element that first satisfies the predicate? Something like:

val xs = listOf("a", "e", "c", "b", "d")
xs.takeUntil { it == "c" } == listOf("a", "e", "c")

why doesn't this compile :

val one = """text \$text"""

it won't escape the $. Works fine in a normal string. how do I turn of templating in raw strings?

In a compute program, how would I calculate in Kotlin where the values of a list are all equal to each to each other? Thank you.

I have a weird question... Given a while(True) loop, how can I make it run faster? Are there any ways or does this just depend on the amount of code taht's executed each time?

I have got a question on Kotlin serialization. I want to use sealed classes to deserialize. Is there a way to change the type key from "type" to something else on the sealed class.

Help! I have lost the release key which I used to sign apk builds in Android Studio. Can I get/extract that release Key info from apk? I have already tried to make a new key with almost the same info but the time/validity info is unable to match. And now I am unable to install the update on the apk already installed version on mobile.

Just found I’ve made a completely invalid assumption about

singleOrNull

- I assumed it would throw an exception if size > 1, but it returns null.

Hi 👋, maybe a silly question related to Java/Kotlin interop, I face something that worries me 😱 In Java, a legacy class exposes

public void setFoo(@NonNull Bar bar)
{
  // ...
}

In Kotlin side

myObject.foo = null // OK
myObject.setFoo(null) // KO

The property access compiles 😱 The function call doesn't compile 👍 Is it expected? Can I avoid exposing

setFoo

as a Kotlin property at will? It seems fragile to allow such property access, no?

Is there a guide to understanding time, space complexity for kotlin utility functions? e.g. “str”.reversed(), arr.sortedBy{ } etc.