You are always going to need the Kotlin stdlib because the compiler will generate call to stdlib just like Java compiler generates calls to java.lang for some cases.

How to convert

MutableMap<String, Dequeue<String>>

to

MutableMap<String, Array<String>>

Single expression syntax is discouraged on

Unit

functions, right?

I've never seen anything like this before so it looks very odd.

Default arguments and named parameters aside, does Kotlin follow the exact same rules regarding function overloading as Java?

is there any way to get rid of the auto-generated

INSTANCE

on objects (the one that's visible from java)?

any idea on how i can connect springboot to sqlite datasource?

How does one check to see if a property value that is declared as type Any has been initialized with a function? i.e.

class SomeClass {
    var someProp: Any? = null
}

fun main() {
   val someClass = SomeClass()
    someClass.someProp = {
        println("I do things")
    }

    // else where

    if(someClass.someProp is Function<*>){
        someClass.someProp() // invoke not found...
    }
}

I’ve started with Kotlin a couple of days ago and I’m pretty overwhelmed, because I don’t know ANY Java. I’ll be using Kotlin at my new job. Should I start with Java? If so, what’s the best resource for getting started with Java?

Trying to understand why is this

suspend fun loadTwoThings() = coroutineScope {
   val job1 = async { getDataOne() }
   val job2 = async { getDataTwo() }
   saveData(job1.await(), job2.await())
}

different from this

suspend fun loadTwoThings() = {
   val job1 = async { getDataOne() }
   val job2 = async { getDataTwo() }
   saveData(job1.await(), job2.await())
}

As I understand, if I cancel a coroutine that called

loadTwoThings

, without coroutineScope the two async will keep running. Also, if one async fails it will let the other keep running. Why is that? A failed child is supposed to cancel its parent, and a cancelled parent is supposed to cancel its children. Are the two asyncs not children of the main coroutine? What exactly does

coroutineScope

do that makes a difference?

how can i convert

listOf(Pair("a","b"), Pair("a","c"), Pair("b","d"))

to

mapOf("a" to ["b","c"], "b" to "d")

?

hi everyone! pretty noob question here, I come from a Go background and I'm looking for something like composition in Kotlin, I know there's inheritance in the way that I can define a class like

class Person(val name: String, val lastName: String)
class Employee(val name: String, val lastName: String): Person(name, lastName)

but is there a way to have that Employee class just inherit all the properties of Customer, without listing them all explicitly as properties ? my guess is no, but I may be missing something

you mean by using a

(T) -> (R?)

and then

mapNotNull

? That'd work (assuming

T : Any

) but it would create an intermediate list, which ideally I'd like to avoid.

Hi everyone! - when we are using Kotlin data class with javax.persistence entity, does it make sense to have something like

@Column(nullable = false)
    val locationId: String?,

- if the db schema defines not null, does it make sense to mark the data class field as nullable? What is the behaviour in such a case?

does

withTimeoutOrNull

not work with

readBytes

? example, this always works (and I’m pretty sure 1ms will timeout since its a remote URL)

val bytes = withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
                        withTimeoutOrNull(1) {
                            URL(urlPath).readBytes()
                        }
                    }

Hi, I have a spring boot project in which I’ve a Service (just a

class xyzService.kt

). In this service, i have several private values. Now, for the usecase I’m trying to solve in this service, I wanted to have an

abstract inner class Action

which has 1 more layer of inner classes, like

inner class Action.Cancel

,

Action.Start

etc (actual usecases are a bit more complex but I guess this translates okay). Each of these inner classes should also have access to the values in the top level service class. Then from the service class (but outside the Action class) I wish to be able to do

Action.Cancel().execute()

(execute is an overridden function from the superclass). However, I seem to run into some issues with these visibility modifiers. When attempting to interact with the values in the top level service class, I get the following:

Constructor of inner class Start can be called only with receiver of containing class

. Am I using the wrong hierarchy here? What’d be more appropriate? Does this seem like a wrong way to do things?

underscores for default parameters does currently not work? I thought I read that somewhere

In a DTO data class containing

people: List<Person>?

is it safer to do

people: List<Person?>?

instead? i.e. people field can be null and also list containing null or empty?

Does this argument really hold when the IDE already has these little parameter hints?

"On the JVM: the named argument syntax cannot be used when calling Java functions because Java bytecode does not always preserve names of function parameters." This sentence just means that I can't call Java methods from Kotlin with the named parameter syntax?

How would you import a Kotlin project into another project?

Is anybody using bazel to compile kotlin in a real world production environment. I have tried a couple of times. It seems to basically not work, except for toy demos. Am I missing something? It would be great to hear of real life projects. Do you have to maintain your own rulesets?

Hi, I'm new to kotlin but have experience with python/django. I'm embarrassed to say I'm immediately having issues just with the very beginning of the basic tutorial from kotlin's website: https://play.kotlinlang.org/hands-on/Building%20Web%20Applications%20with%20React%20and%20Kotlin%20JS/02_Setting_up. I tried running yarn start and got what's in the code snippet. Has anyone seen this before?

what is the reason that default parameter values don't support type inference?

This message was deleted.

I can't overload a

vararg

function with an

Array

of the same type because the vararg is internally represented as an array on the JVM? (I know I can use the spread operator)

The kotlin in action book has a section where it recommends to make data classes immutable using val. It states that kotlin creates the toString, equals and hashCode methods that we used to implement on our own in Java and gives this as a reason why immutable data classes are recommended. I'm having a hard time understanding why it is recommended this way. What are your thoughts on this?

should top level vals be ALL_CAPS_CASE?

In Java it is said that varargs are just syntactic sugar for arrays. Is this also true for Kotlin or can it do anything arays can't?