Is there something anomalous between `inline class`es and

companion object

? testing the function I got a

java.lang.NoSuchMethodError

whenever I call a

const

from the

companion

, replacing with its

String

everything runs flawlessly

-.kt

-.kt

Look at the version in

gradle/wrapper/gradle-wrapper.properties

Thank you, I'll give it a go!

I'm curious. I understand why kotlin made += either do a mutable operation, or immutable + reassignment

However, why not prioritize one of these, probably the first one?

It seems a bit silly that:

var x = mutableListOf<String>()
    x += "hello"

doesn't compile

I think of immutable + reassignment as a fallback; if you have a mutable container it seems like you would want to mutate in place generally speaking

I like the error. It is ambiguous and forces the developer to make a choice by adjusting the code their way.

more specifically, the ambiguity is introduced by having both the

var

reference to the collection and the collection itself be mutable. Generally your code is better off if you pick one of those or the other, and in cases where both really is appropriate, being explicit with

.add

is easier to read at a glance

In this example you would just use val

But it gets really annoying when e.g. you have a map of string to list

A very common situation

imo that's precisely the kind of place where pushing you to the explicit

.add

helps readability

Meh. Lots of languages have an operator like this or similar and it it invariably works this way

The ambiguity error is actually a really really common point of confusion

From what I've seen googling around

If you really wanted to argue in favor of readability/clarity/explicit ness, just having two operators would make more sense

+== for example, which sort of signals the idea of a change in identity (since !== checks for negated identity equality)

Curious: is it at all possible for a user to write a function/extension function, that does something similar to what += does for Map? I would guess "no" because inside a function you can't "reseat" anything passed in. But it would be nice if there was some way; the same way that x += y saves you writing x = x +y. You could imagine for immutable data classes, instead of writing x = x.copy("name"="John"), it would be nice if you could write x += copy("name" = "John") or something like that

This has probably been asked a million times: I have a small kotlin app (currently for Android) that simply shows random words and the user can click to get the next word. So very simple. Let's say I want to include something similar on a web-page using Kotlin only (no JS). Where is a good, up-to-date tutorial about this topic?

I found [this Medium post from 2017](https://medium.com/bcgdv-engineering/building-a-full-stack-web-app-in-kotlin-af8e8fe1f5dc).

Things like

n + { foo() }

do not compile it seems

Why is there the restriction on JvmName for inline classes? Could something similar be added that sets what the base function name will be before it gets mangled?

https://twitter.com/kotlin/status/1148145540627959808 Have you been suspending your learning of coroutines and channels because you didn’t know where to start? Get asynchronous clarity with our new hands-on lab: https://t.co/5agGaA2X91 https://t.co/kwH30KcM3P Twitter

why does IntProgression not implement ClosedRange and skip IntRange

whats the point of this subclass

some operator functions are words too