Is there a software license listed somewhere for the kotlin standard library?

Is there any way to suspend until some predicate is met, other than like a while loop?

I have

tasks.withType(JmhTask::class.java) { }

where

tasks

is a

TaskContainer

type, which extends

interface DomainObjectCollection<T>

DomainObjectCollection<T>::withType

is defined as

<S extends T> DomainObjectCollection<S> withType(Class<S> type, Action<? super S> configureAction)

I'd like to type instead

tasks<JmhTask> { }

, so I wrote:

inline operator fun <reified S> TaskContainer.invoke(configureAction: Action<in S>?) = withType(S::class.java, configureAction)

but

withType

is marked red:

None of the following functions can be called with the arguments supplied.
withType(Class<TypeVariable(S)!>, Action<in TypeVariable(S)!>)   where S = TypeVariable(S) for    fun <S : Task!> withType(type: Class<S!>, configureAction: Action<in S!>): DomainObjectCollection<S!> defined in org.gradle.api.tasks.TaskContainer

When any IntelliJ-family IDE calls out to external tools such as Gradle; Why does it not log the actual command passed to that tool, in the console (so that it appears just above the tool output)? This would be extremely useful both for learning what's going on under the hood, and for diagnosing problems. I'm currently facing an issue where a Gradle build succeeds from the command line but fails inside the IDE. It's hard to see what the underlying difference is.

Is there a standard imaging library for kotlin? Something that would allow me to build up images and save the in various formats? Perhaps do some light image processing?

message has been deleted

Hey everyone, very basic question but I can’t figure out if there’s a native kotlin function to do something like this where I want to get a list of the numbers in originalNumbers that are not in newNumbers

val originalNumbers = listOf(1,3,5,6,8,235,764)
val newNumbers = listOf(1,4,6,235,764,23)
val toRemove = originalNumbers.filter { it !in newNumbers } // [3, 5, 8]

This work perfectly fine, but just for my own peace of mind I feel like there’s a collections functions that would do exactly that?

What are folks using for XML databinding in Kotlin? JAXB, Jackson, something else?

Hi kotlin peeps, I'm getting stuck on some java kotlin interop. I have some android code (in java) that I am interacting with that simplifies to this:

public class FooService {
    public void addFoo(Foo foo) {
        // woop
    }

    public void removeFoo(Foo foo) {
        // womp
    }
}
interface Foo {
    void callback();
}

and then in the kotlin code I have:

class FooKotlin {
    fun buzz() {
        val fooService = FooService()
        fooService.addFoo {
            // do some callback stuff

            fooService.removeFoo(???)
        }
    }
}

I'm not sure what to replace the

???

with in order to remove the callback listener after it has executed once

Does anyone know an article or something similar that gives a technical comparison of Kotlin to C#?

Is anyone else seeing this when trying to upgrade to the 1.4 EAP Plugin

What is the order of function returned by val KClass<*>.memberFunctions: Collection<KFunction<*>> , is it the order of declaration?

Hi, is it possible to create a

when

statement dynamically from a map, or two arrays/lists? something like

val teamMap : Map<String, String> = mapOf("Yankees" to "baseball", "Cowboys" to "football", "Lakers" to "basketball")
val sport : String = when {
  teamMap.map { e -> mystring.contains(e.key) -> e.value }
}

also a value for

else

would need to be supplied, not sure the best way

I wrote some Skia wrappers for Kotlin, full GPU support, off screen, etc - I wonder if people would be interested.

Hi all, I'm using operator overloading and have issues with inheritance, with

open class MyInt(open var int: Int = 0) : {
    operator fun plus(increment: Int): MyInt = MyInt(int + increment)
}

I can do

MyInt(4) + 3

It works. But now, I would like to extends

MyInt

class OtherInt(override var int: Int = 0) : MyInt(int)

I can do

OtherInt(4) + 3

but the output is a

MyInt.

Is there a way for

OtherInt

to benefit from operator overloading without reimplementing it in it?

if I do a

when

over a type system, like when { foo is A -> foo is B -> } why can the compiler not figure out compile-time if the when is exhaustive without an else branch?

I was thinking about

foo.let(Bar::method)

vs

foo.let { Bar.method(it) }

in terms of compiler speed, thinking that the function reference opens up to fewer possibilities compared to a block, and it could have a slight, but measurable compilation speedup if used a lot. Generating a 1000 long file with identical

.let { .. }

and another file with

.let(func::ref)

resulted in

.let { ... }

being consistently slightly faster with 7.125 seconds vs 7.882 seconds. One hypothesis is that the function reference version is transformed to the block version during compilation, perhaps someone here knows more of the compiler internals to pitch in on that. As expected identical byte code is generated in both cases. When I then tried with Kotlin 1.4 M2, it turned out that the

.let { ... }

version had become slower, and has now consistently the exact same compilation speed as the function reference. Which is the reason to why I signed up to this slack 🙂 Was hoping for the opposite as 1.4 is touted to improve compilation speed (but it's not like it's life or death which style is preferred).

Why are data classes so slow when instantiating them in intellij? My cursor locks up while typing

How can I get a Java

Class

from a

KClass

? For example I have

KClassImpl "class kotlin.String"

and I want to get Java’s

String.class

from it I tried:

JvmClassMappingKt.getJavaClass(klass)

but it returns

class kotlin.reflect.jvm.internal.KClassImpl

😕

Is there a way with reified generics to handle

T: Any?

differently from

T: Any

without conflicting overloads? The following conflict:

inline fun <reified T: Any> foo(): Bar<T> {}
inline fun <reified T: Any, S: T?> foo(): Bar<S> {}

Which makes sense since it’s ambiguous for the call when T is non-null.

is

companion object

the kookiest kotlin-specific syntax for a typical OOP language feature? y/y?

I’m not sure if this is the best channel to post this, but here it is: I just started with kotlin (2-3 months ago), and to learn it I took on a fun project based on this programming challenge, LambdaSharp / LambdaRobots*.* I will be sharing the kotlin challenge with my team next week (mostly java and python devs) to introduce them to kotlin and AWS Lambda. I am looking for a handful of volunteers to help me test-run the challenge and get some feedback.

I am getting this error after upgrading Kotlin to 1.4 m2

e: java.lang.IllegalStateException: Backend Internal error: Exception during file facade code generation

I have some confusion over the type system, could anybody clarify what is meant by

{Comparable<{ Double & Int }> & Number}

https://stackoverflow.com/questions/62241262/understanding-kotlin-type-system-what-is-meant-by-comparable-double-int

Is there any trick for declare an extension ONLY for nullable type?

class MyClass<T>

MyClass<String?>().myExtension()  // -> OK
MyClass<String >().myExtension()  // -> Does not compile?

what does

Foo!!

mean??

why cant you have a

suspend

and an

operator

fun?

It seems like the compiler's null tracking doesn't work when the type of the variable is a function and the variable is an instance variable on a class.

fun thing(a: ((String) -> String)?) {
    if (a == null) {
        println("null")
    } else {
    	println(a("hello"))
    }
}

class Thing(private val a: ((String) -> String)?) {
    fun thing() {
        if (a == null) {
            println("null")
        } else {
            // Reference has a nullable type '((String) -> String)?', use explicit '?.invoke()' to make a function-like call instead
        	println(a("hello"))
        }
    }
}

Reproducing the issue using the playground

Is it possible to show compile time values within the code passively. consider this piece of code:

if(yourValue == SOME_VALUE)

where SOME_VALUE is a const val defined in an interface. Can I show the value of this value passively like inferred types are passively shown in the code?