Is there any idiomatic way to avoid a huge when? Like when(string){ "blabla" -> {generateA} "bleble" -> {generateB} "blibli" -> {generateC} "bloblo" -> {generateE} "blublu" -> {generateD} .... } Is there any pattern that could help me out with this? For instance Command or Factory? This when is going to grow when I add more items, note each item have different behavior The example would be from my ViewModel I send this "type" to my useCase and my useCase decide what to do, because create N UseCase perhaps is a mess...

general question: do I have to always write a coroutine variant of functions accepting lambdas? for example: fun doit(callback: () -> Unit) = … suspend fun doitAsync(suspend callback: () -> Unit) = … or can I somehow declare a function that accepts both suspending and non-suspending? I can imagine that ‘suspend’ adds overhead in the non-suspending case due a compiler generated state machine for supporting async. or: is it a reasonable approach to use runBlocking inside a non-suspending lambda or are there drawbacks?

Hey all, as far as I know we do not have any way of asserting that a generic class is a data class right? Is there a plan to introduce something like this? I think this is somthing that would be really useful. In my case I have an interface, and I want to define an extension method for the classes that implement that interface, and only for the ones that are data classes. In my head this could be totally written down like this:

fun <data T: MyInterface> T.doSomethig() = copy(...)

And I could get access to beautiful concepts like copy which comes with the

data

modifier on a class. Until this is functionality is implemented, do you know of a good way to do assert that the copy method exists in this scope?

is this the most elegant / proper way to use e.g. repeat() with a suspending function?

suspend fun bla(): Unit = TODO()

repeat(10) {
  runBlocking {
    bla()
  }
}

or do I need a suspendable version of repeat ("repeatAsync") ?

In a hot loop more than 50% of my time is spent in a call to

launch

. How can I launch coroutines from a non-suspend function in a fire-and-forget way faster?

The scoping functions (

let

,

apply

,

also

etc.) use

contract

which is marked as

@Experimental

. @Vsevolod Tolstopyatov [JB] suggested to not use shared flow in this from the past event as

SharedFlow

was still experimental. He specifically pointed out to wait for a stable version if you work for a bank. Well, I currently work for a bank and I am told not to use anything marked as

@Experimental

. Since everything in

standard.kt

uses

contract

, does this mean these functions aren’t stable either?

How can I detach from a sharedflow

I'm not sure is this is a right channel for this but, did anyone tried from

Mindorks

-

Android Online Course for Professionals

? Or maybe has other Courses to recommend?

Is there anyone from India who successfully registered on the Medium partner program?

Looking to make a delegate that returns the class name. Something like this:

private val logger by OurLogger()

I have a delegate working perfectly for class properties.

class OurLogger {
    operator fun provideDelegate(thisRef: Any, prop: KProperty<*>) = LoggingDelegate(thisRef.javaClass.name)
}
class LoggingDelegate(klassName: String) : ReadOnlyProperty<Any?, Logger> {
    private val capturedLogger = LogManager.getLogger(klassName)
    override fun getValue(thisRef: Any?, property: KProperty<*>): Logger = capturedLogger
}

I can't get it to work though for top level properties. It seems to be looking for a

provideDelegate(thisRef: Nothing?, prop: KProperty<*>

which makes sense because it doesn't have a this. In my case, using the generated class that houses the static variable(aka, the fileNameKT) would be fine, but I can't figure out how to get the

provideDelegate(thisRef: Any, prop: KProperty<*>)

vs

provideDelegate(thisRef: Nothing?, prop: KProperty<*>)

to work. The second I make the thisRef Nothing, I can't do anything w/ it. I looked at the implementation of

Lazy

it seems to get away with it on the top level via an extension function

kotlin.Lazy<T>.getValue(thisRef: kotlin.Any?, property: kotlin.reflect.KProperty<*>)

Any advice on the top-level stuff?

https://twitter.com/kotlin/status/1319310316648488961 📢 Join the Kotlin team on October 26-27 for an AMA session on Reddit. We will cover unanswered questions from the 1.4 Online Event and also any new ones you ask! Click “Join” at https://t.co/AEDizVPcrp to get notifications about the session. https://t.co/fsE4laFnW3 Twitter

I have a C library that I’d like to use and am wondering if I can get around having to write jni bindings

Hi all, I have the following code, and I was wondering how to unwrap my collection of optionals into the actual type. Is there a better way to do this in Kotlin?

data class Alert(val message: String)
val alerts : List<Optional<Alert>> = getAlerts()

// filter 
val messages = alerts
    .filter { it.isPresent }
    .map {it.get().message }

Anyone have a suggestion for how to do things like .map and .filter on a StateFlow without converting it to regular Flow object? Or does that just not make much logical sense? I can see how composition like that can throw a wrench into the current value management, but it seems like it’s kind of a miss.

any thoughts on this pattern to attempt to log the specific reason a chained boolean expression failed without having to have separate branches. (example is a bit contrived, just curious about thoughts on the pattern, or if there’s a better approach)

fun Boolean.err(errorMessage: String): Boolean {
    if (!this) {
        <http://logger.info|logger.info> { errorMessage }
    }
    return this
}
...
if ((queryParams.size != 2).err("Expect exactly two query params but got ${queryParams.size}")
    || (queryParams["o"] == null).err("Query param o must be populated")
    || (queryParams["p"] == null).err("Query param p must be populated")
) {
    return badRequest().buildAndAwait()
}

wanted to share a usher parody/cover my friend wrote 😂

Kotlin
Aw man

We at compile time
IntelliJ on fullscreen from side to side
Side-side to side
This task, an easy one
Compiling to bytecode tonight, night, night
bytecode tonight

Heads up
You see a method with more than one expression
Total shock fills your body
Oh, no, it's you again
I can never forget those line lines lines
Lines-lines-lines

'Cause, baby, tonight
We're gonna be writing Kotlin again
'Cause, baby, tonight
You grab your map, filter, and run again (run again-gain)
And run, run until it's done, done
Until the sun comes up in the morn'
'Cause, baby, tonight
We're gonna be writing Kotlin again (Kotlin again-gain)

Hi, I've met somebody who's having trouble getting an invite link to this server. According to him/her, nobody emailed him after a day (registered here https://surveys.jetbrains.com/s3/kotlin-slack-sign-up). Can anybody help with this? Also that page says I can invite people, but I don't find an option in the top-left dropdown?

I’m writing a Kotlin Native app. programs will be run on many different architectures including mac/darwin x86_64, to linux x86_64, and even raspberry pi armv6/7. Are there any good libraries out there for file access yet? Basically I’m looking for something that takes the place of the java based stuff that we have in regular kotlin.

Hello, I have a question about

Dispatchers

. I created an endless loop to create threads and see how the program will behave.

class MainActivity : AppCompatActivity() {

    private val dispatcher: CoroutineContext = <http://Dispatchers.IO|Dispatchers.IO>

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val cores = Runtime.getRuntime().availableProcessors()
        println("Cores: $cores")
        println("===============================")

        endlessLoop()
    }

    fun endlessLoop() = runBlocking {
        withContext(dispatcher) {
            println(Thread.currentThread().name)
            while(true) {
                launch {
                    println(Thread.currentThread().name)
                    while(true) {
                        // endless loop
                    }
                }
            }
        }
    }
}

I got a phone with 4 cores and each core can handle 4 threads. If I would run this

Dispatchers.Default

. Then output will be:

DefaultDispatcher-worker-1
DefaultDispatcher-worker-2
DefaultDispatcher-worker-3
DefaultDispatcher-worker-4

I get this, because all cores got occupied and working at 100% to get it done and no more tasks are allowed to be added. However if I run it with

<http://Dispatchers.IO|Dispatchers.IO>

which has 64 threads in the pool, it will run all 64 threads. I though it was 4 cores * 4 threads = 16 threads max. Can someone explain me why the program doesn't stop at

DefaultDispatcher-worker-16?

Would be nice, if someone could help:

what would you say is a good example usage of

.let {}

on a non-nullable instance?

Hello, new to Kotlin. Does anyone know of a general purpose programming language (possibly dynamicall/gradually typed) implemented using Kotlin? Or an interesting external DSLs from a design/implementation point of view?

otherwise I guess I'll have to convert my flow to RxJava..?

My "hello world" fat jar is 1.6Mb... Is there any way of shrinking this down? I'm hoping to build an app for a Raspberry Pi, and will choose between Kotlin, C (or even assembly!) for programming it.

how about C with dietlibc? can you show your hello world in kotlin? 🙂

How comes I can't create an extension function on Map with multiple signatures? https://pl.kotl.in/i5aSCMMgj but also I can't use Any, Any, so I'm not sure what's the best way to do it?

Hey there. I'm building an app with kotlin and jpa. When starting the application I get the following error / warning

org.hibernate.HibernateException: Getter methods of lazy classes cannot be final: SomeEntity#getFoo

. The error is gone when I mark the property explicitly as open but from what I understood is that this should happen automatically with the jpa compiler plugin?

when using kotlinx immutable classes, is it best to use the

List

type for return values or

ImmutableList

? i don't want the downstream consumers to modify it (which either would provide). It kind of seems like an implementatino details that i am using

ImmutableList

In this multi-modules Android project I am enabling explicit API mode in this commit. The compiler forces me to change a few classes and methods (adding

public

), all in one module. ❓ Why are all other modules not affected although they do not declare

public

modifiers for their classes and methods?

Hi, I am a web developer. I have a project that requires to also build on mobile apps to gain more potential customers. Usually should I build for android or iOS first? Thoughts?