Hello, World! Hey, an interop question: how would you return a

Future<Void>

in a Kotlin library (so it's nice for Java users)? I'd like to avoid returning

Future<Unit>

because this would expose a Kotlin specific type to my API.

Hi there, I was trying to match the types of two values simultaneously. I realized it was not doable with

when

. Is there any library dealing with this kind of problem or any idiomatic way? I tried to roll a dsl but it looked terrible:

I'm having some trouble with type inference. For example, if I write:

val myMap = mapOf("id" to 10, "hash" to 99999L)

I would expect the

id

key to contain an

Int

and the

hash

key to contain a

Long

, but that's not the case--

id

is now mapped to a long! I can fix this by writing

val myMap = mapOf("id" to 10 as Int, "hash" to 9999L)

But then IntelliJ tells me that the cast is not needed. Is there a better way?

Is there a nice way of accessing functions and/or variables (members in general) of a class without initializing it? I think it would be some kind of a singleton but I've only seen very complex approaches. Should be like an object but it's indeed a class.

quick question: is coroutine in experimental?

When I followed the IDE auto-suggestion to rename

10.seconds

to

Duration.seconds(10)

I got an error that

Duration.seconds

does not exist. Autocomplete shows the only members of

Duration.Companion

are

ZERO

and

INFINITY

. However, jumping to the definition of

Duration

shows

fun seconds

. I don't understand what could cause this

Can someone take a look at my build config and see if there's some obvious way to speed up compilation and testing? https://gitlab.com/timmc/cavern/-/blob/master/spelunk/pom.xml Right now it takes about a minute and a half to do

mvn test -Dtest="StateTest"

. I don't have the fastest computer, but I feel like this should take 30 seconds at most. Alternatively, is there some way I can do incremental compilation and/or testing? Anything to get the feedback loop down to seconds rather than minutes.

What is the official logo of Kotlin? I see both :kotlinnew: and :kotlin: in various places. The official website uses :kotlinnew:, but the Press Kit contains only :kotlin:. Are they both in active use? What is the difference?

oh, I just realised the code above is fine, the reason is that my code uses a function, not just the value

sealed class Parent() {
    data class Child(val value: String) : Parent()
}
data class Other(val value: (Parent) -> String)
val child = Child("something")
val f: (Child) -> String = { child -> child.value}
val x = Other(f as (Parent) -> String)

This message was deleted.

Hello guys 🙂 Was looking to simplify a bit of code I have Looks like this :

sealed class Sealed(open val x: Int) {
    data class A(override val x: Int) : Sealed(x)
    data class B(override val x: Int) : Sealed(x)
}

private fun copyTest(test: Sealed, y: Int): Sealed {
    // "standard" way, it works
    return when (test) {
        is Sealed.A -> test.copy(x = y)
        is Sealed.B -> test.copy(x = y)
    }
    // Sadly, this does not
    return test.copy(x = y)
}

Is the when approach the only one? Or am I missing something? Thanks!

Hi all, a high level question. I am test driving Elm and like it. However, it got me thinking of something Kotlin related. If I was to create some sort of VDOM consisting of simple data classes and compare those that would just work fine. However, when I'd include events, using some sort of 'onClick' anonymous function, the diffing will always cause to assert that the anonymous functions are different, even when they are structurally the same. As I believe Elm doesn't have this problem (because of a complete different language and compiler). Example:

data class Node(val name: String, val onClick: () -> Unit)

fun main() {
    val a = Node("Foo") { println("Foo") }
    val b = Node("Foo") { println("Foo") }
    println(a == b) // prints "false"
}

Is there a way to obtain something similar?

I'm trying to find a way to bring multiple values into scope with inheritance. Currently this is what I'm doing:

interface A {
    val prop1: ...
    val prop2: ...
    ...

    companion object : A {
        ...
    }
}

interface B : A {
    val prop3: ...
    ...

    companion object : B, A by A {
        ...
    }
}

Is there a way to do this without the weird interface / companion construct?

I continue to struggle with finding a good, go-to pattern for error types in kotlin 😕 Say you have a hardware device, and you want to present a bunch of data about that device. Its serial number, its battery state, etc. Each one of these data requires issuing a command to the device and reading a response, and that command might fail. These values all have different types --- some are counters, some are strings, some are dates, etc. But they all have exactly the same failure semantics --- the device might return an error. Say, further, that all of these data accessors are defined on top of an underlying sendCommand function, which always returns a string or error. From the caller’s perspective, the fact that these methods are defined in terms of sendCommand() is an implementation detail — they expect to be informed of how the device access failed (which is to say, the set of errors returned by the lower-level sendCommand is exactly the same as the set of errors returned by these field accessors by definition). Is the best possible pattern in this scenario to define a generic Result<T> type, and for every single field accessor, to write, e.g.,

when (sendCommand(val result = command)) {
    is Result.Success<CommandResponse> -> Result.Success(getDerivedValue(result))
    is Result.SomeFailure<CommandResponse> -> Result.SomeFailure(result.message)
    is Result.OtherFailure<CommandResponse> -> Result.OtherFailure(result.message)
}

I can’t think of a better way, but this feels incredibly boilerplatey — I’d love to be able to just return the underlying errors (since that’s what the caller will care about), but that doesn’t work since the generic type parameter is changing (even though the error subtypes don’t actually make use of the type parameter). Alternatively, I could just hide the error, and present these fields as properties that are null if the lookup failed. But then I’ve robbed the caller of the ability to respond meaningfully to the failure. TL;DR: is there any good pattern for forwarding a lower-level error up the call stack, where appropriate? Because I can certainly think of cases where that seems very appropriate.

Is there any kotlinian way to avoid an if else after a

find

or

firstOfNull

?

val foo = bar.firstOfNull {whatever}
if(foo==null) smthing()
else smthing2()

Hello Kotlinians its good to be here, i hope to learn and collaborate as much and share with the community as well. I just finished from an Interview for the role of Android Engineering... wish me luck please.

Is there a way to sum multiple fields of a data class into a new instance? E.g.

private data class Quantity(val quantity: BigDecimal, val pendingQuantity: BigDecimal)
fun main(){
    val quantities = listOf(Quantity(BigDecimal.ONE, BigDecimal.ZERO), Quantity(BigDecimal.ZERO, BigDecimal.TEN), Quantity(BigDecimal.ONE, BigDecimal.ONE))
    println(quantities.sum()) //expecting Quantity(2, 11)
}

Obviously

.sum()

doesn’t work, just an example of what i’d like it to look like

What is the easiest way to get value from

Map<String,String>

with case insensitive

String

key? More context and detailed scenario in the thread...

Is it ever ok to use runBlocking in regular code? Somehow that seems wrong

Is there any multiplatform library for strings localization? I mean something like:

object Strings : LocalizedStrings {
    val hello by string(default = "Hello") {
        val ru by value("Привет")
        val ua by value("Прівіт")
    }
}

fun main() {
    Strings.locale = "ru"  // This should be also built in library with different realizations on each platform
    println(Strings.hello)
}

Also would be nice to provide mutable state for compose, observable value for kvision, etc.

So… what are the rules for when a (non-suspending) inline function can be used to call suspending code? .let(), for instance, works in both blocking and asynchronous contexts (ie, the lambda passed to .let() can call suspend functions if .let() was called from a coroutine body). However, it seems like if any restrictions are put on the lambda’s return type at all, suddenly it becomes necessary to declare your function as a

suspend inline

function (ie,

inline fun <T> foo(() -> T) {}

works in a suspend context;

inline fun foo(() -> Int) {}

does not). Am I correct about that? And if so, out of curiosity, what’s the implementation reason?

Hey, .. Is there neater way to do this

fun foo() : Response {
             workFlowLog?.let {  Response.Sucess(BatchApprovalWorkFlowList(workFlowLog) ) } ?: run { Response.Error(Exception()) } 
}

My intention is to return different response in case workflow is null. My team mates say this kinda of ugly. Is there a better kotlin idiom to craft this statement. if( w == null) ... else ... , we are trying to avoid this.

Which do you prefer for removing all occurrences of a specific hard-coded character?

1. someString.replace(" ", "")
2. someString.filterNot { it == ' ' }
3. someString.filterNot(' '::equals)

Hey folks, I took the liberty to start a channel for jobs worldwide who offer relocation and remote options. #jobsworldwide Feel free to join! 🙂

does anyone know of an optics library for kotlin that works with jackson

JsonNode

?

are GitHub language-color and the new logo related?

why does the former work but not the latter ?

Are namespaces coming to Kotlin? Really missing that feature for organizing top level functions. As an alternative there are `object`s, but a function inside an object isn't enforced to be stateless..

is there a nicer way of writing this in kotlin:

val NullableData? = firstNullable?.let { first ->
            secondNullable?.let { second ->
                NullableData(first, second)
            }
        }

I have something like that but with many more fields so it is massively nested. I suppose I could turn nulls into exceptions and surround the whole thing in a try catch? In Haskell/Purescript/Scala we would have

do

notation for this and I think arrow had done something like this but I couldn’t find it?