Hey folks, I’ve got a method that takes, as one of its arguments,

func: Function<Foo, Bar>

. Elsewhere in the code, when calling it, I’m trying to pass in

{ it.baz }

where it is type Foo, and baz is type Bar. But it’s giving me

unresolved reference: it

and saying that the type of the lambda is

() -> [ERROR:]

. If I prefix it with the word Function,

Function { it.baz}

it works.

My first guess was to define a

fun Map<Any, Any>.cast(value: RubyHash) = value.toMap()

. But this doesn't work.

Hey everyone! 👋 is there a specific channel for like recruiting or something?

I have the feeling that channels/coroutines is too low level

@Hamza That’s pretty misleading. They’ve said multiple times (including at KotlinConf) that experimental just means they haven’t finalized the API and that it’s fine because it’s backward-compatible back to 1.1

Does Kotlin/Common provide a "Timesamp" class (getNow(), to'String(), compare) that works for both Kotlin/Js and Kotlin/JVM ?

Does anyone know if I can apply

when

on a

pair

type? Finding it a bit difficult to make it work. Something like:

val pair: Pair<StatusAType, StatusBType> = ...
when(pair) {
            is (StatusA, StatusB) -> {

            }

        }

It is showing an error

Type Expected

in IDE

@Wahib I don't think you can use pattern matching quite like that in Kotlin. It doesn't do destructuring that way. so you can pattern match on the Pair constructor but not the values inside it that way.

Can anyone reason about this weird bug?

enum class A {
  A, B
}

enum class B {
  A, B
}

fun main(args: Array<String>) {
  val a = A.A

  when (a) {
    A.A -> println("A.A")
    A.B -> println("A.B")
    B.A -> println("B.A") // hit this branch
    B.B -> println("B.B")
  }
}

class Async_load<WaitT, ErrorT, DoneT> (
        val w: WaitT,
        f: Async_load<WaitT, ErrorT, DoneT>.(WaitT) -> Unit) {

    var state = Async_load_state.Wait<WaitT, ErrorT, DoneT>(w)
    init { f(w) }

    fun is_done(): Boolean {
        return when(state) {
            is Async_load_state.Error<*, *, *> -> true
            is Async_load_state.Done<*, *, *> -> true
            else -> false
        }
    }
}

Is there a way to simplify this? I do not want to repeat <WaitT, ErrorT, DoneT> all the time

The full code is:

sealed class Async_load_state<WaitT, ErrorT, DoneT> () {
    class Wait<WaitT, ErrorT, DoneT>(val wait: WaitT): Async_load_state<WaitT, ErrorT, DoneT>() {}
    class Error<WaitT, ErrorT, DoneT>(val error: ErrorT): Async_load_state<WaitT, ErrorT, DoneT>() {}
    class Done<WaitT, ErrorT, DoneT>(val done: DoneT): Async_load_state<WaitT, ErrorT, DoneT>() {}

}

class Async_load<WaitT, ErrorT, DoneT> (
        val w: WaitT,
        f: Async_load<WaitT, ErrorT, DoneT>.(WaitT) -> Unit) {

    var state = Async_load_state.Wait<WaitT, ErrorT, DoneT>(w)
    init { f(w) }

    fun is_done(): Boolean {
        return when(state) {
            is Async_load_state.Error<*, *, *> -> true
            is Async_load_state.Done<*, *, *> -> true
            else -> false
        }
    }
}

Basic Kotlin question. Am I right that this:

var matches = liveMatches.value
if(matches == null) {
    matches = ArrayList()
}

Can be shortened to this:

var matches = liveMatches.value ?: ArrayList()

Even shorter

var matches = liveMatches.value ?: mutableListOf()

Another one: I have defined a field

val liveChallenge = MutableLiveData<Challenge>()

. I want to expose it as a

LiveData<Challenge>

. Should I just make the field private and write a getter,

fun getLiveChallenge(): LiveData<Challenge> = liveChallenge

(like I would do in Java) or is there a smarter way?

What is JPS? There are tickets about adding JPS compilation in 1.2.60: https://github.com/JetBrains/kotlin/releases/tag/v1.2.60-eap-7

So, I have the following:

val type: Class<T> = ...
val clazz: Class<Any> = ...
val superClazz = clazz.superclass  // is Class<in Any!>!
// works fine
if (type == clazz) ...
// won't compile: Operator '==' cannot be applied
if (type == superClazz) ...

Why doesn't that work? Doesn't

Class<in Any!>! : Any

still hold true?

This message was deleted.

fun <T> Single<T>.sub(onNext: (T) -> Unit = { }): Disposable

This would be a method that by default has an empty onNext.

is there an away to avoid the assertion operator to make the value type not null on the following case?

if (key in map) {
        val value = map[key]!!
    }

If I remove the assertion operator, the type of the

value

will be

?

This issue has been fixed for a while, but is still open: https://youtrack.jetbrains.com/issue/KT-17657 What is the proper way of bringing these up to the [JB] overlords to get it remedied?

Does Kotlin/JS have a builtin json parser? If not, what library is suggested? (I'm already using Klaxson for Kotlin/JVM)

is it desired behavior for reflection to be able to bypass kotlin null safety?

So that way, both from java and kotlin i would use same package and same class name (consistency problem)

I have added a new issue on Youtrack https://youtrack.jetbrains.com/issue/KT-25180 Here I want to add a toMap() function to Kotlin Any class which will return a hashmap of the variables of the class mapped to their instance value.

I have a list of

Player

objects. Each

Player

has a

score: Int

. I want to calculate the total score for all players. Can I do something like

list.reduce { ... }

directly, or do I have to use map as well, e.g.

list.map { it.score }.reduce { sum, score -> sum + score }

There's no way to inherit constructor parameters from a parent class, right? I'm looking for something like this:

open class Parent(val a: Int, val b: Int)
class Child(val c: Int) : Parent(@inherit)
Child(a = 1, b = 2; c = 3)

inline fun foo ( ... ) // <-- this will inline all lambdas passed to foo, AND it will also inline all calls of foo ?

Hi everyone.. I have a

ktor

question

Is there any ETA on pattern matching or destructuring in Kotlin any time soon?