What is general requirement of PC to open a large project (like Kotlin itself) in Intellij? Seems the intellij is eating so much RAM ~2.8GB but still not able to index anything (only getting purple-white highlighted).

Is there a more Kotlin-like alternative to express this piece of code?

var n = completionProviders.indexOfFirst(...) + 1

if (n == 0) {
  n = completionProviders.size
}

Not with takeUnless/takeIf

would be cool to have nullsafe operator variants.. especially for

get

.. would avoid some ugly hacks with

let

or assigning intermediary variables not sure if that would promote writing worse code and longer nullsafe call chains..

I was going through an older Kotlin tutorial, and noticed some nice upgrades to the language. However, there is one place that seems so strange. This deals with varargs, arrays, spread operator, and named parameters.

fun sayHello(greeting: String, vararg names: String) {
    names.forEach { name ->
        println("$greeting $name")
    }
}

fun main() {
    val interestingThings3 = arrayOf("Kotlin", "Programming", "Coding")
    sayHello(greeting = "Hi", *interestingThings3)
    sayHello(greeting = "Hi", names = *interestingThings3)
}

This works, but the last statement suggests to remove

Redundant spread (*) operator

. That leads to the following valid code.

fun main() {
    val interestingThings3 = arrayOf("Kotlin", "Programming", "Coding")
    sayHello(greeting = "Hi", *interestingThings3)
    sayHello(greeting = "Hi", names = interestingThings3)
}

Since the last statement doesn't need the spread operator, I thought I would remove it from both

fun main() {
    val interestingThings3 = arrayOf("Kotlin", "Programming", "Coding")
    sayHello(greeting = "Hi", interestingThings3)  // ERROR
    sayHello(greeting = "Hi", names = interestingThings3)
}

But this gives an error on the first statement. Why? Why does the first one error out, but the last one if perfectly fine.

i'm trying to write a binary tree in kotlin with

sealed class BinaryTree<T> {
    val root: BinaryTree<T> = Leaf
}

data class Node<T>(val data: T, val left: BinaryTree<T>, val right: BinaryTree<T>) : BinaryTree<T>()
object Leaf : BinaryTree<Nothing>()

can anyone help my understand why

root: BinaryTree<T> = Leaf

gives the error

Type mismatch.
Required:
BinaryTree<T>
Found:
Leaf

val searchQuery = state.getLiveData("query", "")

private val tasksFlow = combine(
        searchQuery.asFlow(),
        preferencesFlow
    ) { query: String, filterPreferences: FilterPreferences ->
        Pair(query, filterPreferences)
    }.flatMapLatest { (query, filterPreferences) ->
        taskDao.getTasks(query, filterPreferences.sortOrder, filterPreferences.hideCompleted)
    }

If I set

searchQuery.value = null

this will crash. How can I get null-safety here?

Have gone through the official docs and some tutorials online but still quite unsure where and when to use Interface Delegation. When do you use Interface Delegation in your projects? 🤔 Examples and instances would be greatly appreciated. 🙏🏾

Any plans for suspendable property getters?

Does anyone see the same issue? I can't import extension functions from the Locks file. I'm on 1.4.20-RC Obviously that also breaks file parsing, which runs forever.

message has been deleted

Is it even possible to create a method reference to such a function?

public operator fun T.minus(b: T): T = add(this, -b)

How do you name whatever can be called on a class? Like properties + methods + extensions. Basically what’s the word for “members + extensions of class X”?

Hi, having upgraded to 1.4 i get an

OutOfMemoryException

during

compileKotlinJs

. Any idea how to tackle that?

Hi, what is the convention when having a suspend and non-suspend version of the same method, which one contains the actual implementation? For example, when having a

get()

method (non-suspend) and a

getAsync()

method (suspendable), which one should own the logic/implementation? Option 1 (suspendable owns the logic/implementation):

fun get(): String {
  return runBlocking {
    getAsync()
  }
}

suspend fun getAsync(): String {
	  // actual getter logic
}

Option 2 (non-suspendable owns the logic/implementation):

fun get(): String {
  // actual getter logic
}

suspend fun getAsync(): String {
  	withContext(dispatchers.default()) {
		return get()
	}
}

IMPORTANT Folks, please remember that the purpose of this Slack is for Kotlin and anything related to Kotlin. It is not a general platform to have channels and discussions around technology in general. As such, creating channels that are off-topic (i.e. a channel on MVVM architecture for instance….just made that up, not sure if it exists), is not really acceptable. Why this policy? Because this is about Kotlin and the Kotlin community. If we start allowing a variety of off-topic channels, tomorrow we may very-well end up with many different channels that are no longer remotely related to Kotlin, and then it no longer becomes a Kotlin Community but a strange form of StackOverflow as a Slack instance. We realise it’s often hard to distinguish between a general topic and its relation to Kotlin, but, a good rule of thumb is to find the intersection between the two. If there is intersection, then it makes sense to discuss/have channels around the topic. Appreciate your understanding on this matter. Thanks.

Do Fun Interfaces work with extension functions?

fun interface PropHandler<P> {
    fun P.handle(): Unit
}

isn’t it possible anymore to invite members from slack app directly?

what's the annotation for functions with same signature but return type?

Curious what other peoples opinions are for this. My team and I are considering using Java interfaces instead of Kotlin interfaces for our public APIs while working on a library that can be heavily used by both. The main reason for using Java interfaces is to ensure that Java is a first class citizen and to make it harder for us to rely on Kotlin’s syntactic sugar that can lead to APIs that are annoying to use from Java. Yes, there are rules we can put in place to make sure our API is easy to use from Java but I would argue its harder to follow these instead of 1 rule of “all public api interfaces in Java!“. This could also make it easier to onboard new developers as the one rule is easier to follow. Interested to hear what others think.

I'm trying to upgrade a maven project to kotlin 1.4, but it depends on a lib using kotlin 1.3 and I'm getting complaints about

Runtime JAR files in the classpath should have the same version

. Is it possible to depend on a 1.3 lib in a 1.4 project? Should I be setting the kotlin-stdlib dependencies in the 1.3 project to

compile

scope or something?

This message was deleted.

What would be correct way to hash a unique string that can potentially be too long for the place it's stored, but still wanting to guarantee uniqueness to a high precision? I am currently trying to pass the unique string into a murmur3 128 bit hash, and it gives two 64 bit longs as the output. I wanted to then convert this to Base64 which the method I'm using requires a byte array, can I just do something like

encodeToString("${long1}${long2}".toByteArray())

?

Is there a way to know if the type argument passed to a

fun <reified T>

is a nullable type? I am asking in the context of https://youtrack.jetbrains.com/issue/KT-8947 I would like to be able to do something like:

fun <reified T> foo() = if(T::isNullable) "y" else "n"
foo<Int?>() // returns y
foo<Int>()  // return n

Has anyone used https://github.com/avaje/avaje-inject with kotlin and wants to share experience? :) We consider moving away from micronaut and spring, so we could need a new di framework.

what are some libraries used for code generation / parsing / compiler stuff in kotlin ?

Anybody have thoughts on the performance of the following code block? I came across this in our project and I feel like this would not perform well

inline fun <reified T> HashMap<String, T>.toAnalyticsBundle(): Bundle {
    val analyticsRegex = Regex(FirebaseAnalyticsManager.ANALYTICS_REGEX_STRING)

    return Bundle().apply {
        for (key in keys) {
            val value = this@toAnalyticsBundle[key]
            val firebaseKey = FirebaseAnalyticsManager.googleAnalyticsifyString(key, analyticsRegex)
            when (value) {
                is Int -> this@apply.putInt(firebaseKey, value)
                is Float -> this@apply.putFloat(firebaseKey, value)
                is Double -> this@apply.putDouble(firebaseKey, value)
                is Boolean -> this@apply.putBoolean(firebaseKey, value)
                is Char -> this@apply.putChar(firebaseKey, value)
                is String -> this@apply.putString(firebaseKey, value)
                is Parcelable -> this@apply.putParcelable(firebaseKey, value)
                is Serializable -> this@apply.putSerializable(firebaseKey, value)
            }

        }
    }
}
fun googleAnalyticsifyString(stringToConvert: String, regex: Regex = Regex(ANALYTICS_REGEX_STRING)): String {
    val charArray = stringToConvert.toLowerCase().replace(regex, "").toCharArray()
    for((index, char) in charArray.withIndex()) {
        if(char == ' ') {
            val nextCharIndex = index + 1
            if(nextCharIndex < stringToConvert.length) {
                charArray[nextCharIndex] = charArray[nextCharIndex].toUpperCase()
            }
        }
    }
    return charArray
        .joinToString("")
        .replace(" ", "")
}

hi, I have to paginate some web api and stop after a request returns “more”: false. I’m currently looking at sequences and takeWhile stops immediately after the predicate returns false; is there a way to say: take from this sequence until you encounter something including that thing? Only solution I can think of is using a mutable local variable and set that to false after the takeWhile

What’s up with requests to Youtrack taking multiple eternities to get a response ? Painful to use right now https://youtrack.jetbrains.com/