I wonder if anyone can help me to add a cocoapod to a kotlin native module, not having much luck so far! The library is Google's NearbyMessages API. https://developers.google.com/nearby/messages/ios/get-started So far I have: 1. Cloned the KMM with cocoapods sample app. https://github.com/Kotlin/kotlin-with-cocoapods-sample 2. Gradle sync and build the project. Everything succeeds. 3. Add the NearbyMessages pod in build.gradle.kts just above the AFNetworking line...

pod("NearbyMessages")

4. Now when I gradle sync I get the following error.

> Task :kotlin-library:cinteropNearbyMessagesIosArm64 FAILED

Exception in thread "main" java.lang.Error: /var/folders/t7/gwvnk41x66g5kmr7s7y8thdw0000gn/T/6648793494349780018.m:1:9: fatal error: module 'NearbyMessages' not found

at org.jetbrains.kotlin.native.interop.indexer.UtilsKt.ensureNoCompileErrors(Utils.kt:152)

at org.jetbrains.kotlin.native.interop.indexer.ModuleSupportKt.getModulesASTFiles(ModuleSupport.kt:68)

at org.jetbrains.kotlin.native.interop.indexer.ModuleSupportKt.getModulesInfo(ModuleSupport.kt:14)

at org.jetbrains.kotlin.native.interop.gen.jvm.MainKt.buildNativeLibrary(main.kt:507)

at org.jetbrains.kotlin.native.interop.gen.jvm.MainKt.processCLib(main.kt:265)

at org.jetbrains.kotlin.native.interop.gen.jvm.MainKt.interop(main.kt:73)

at org.jetbrains.kotlin.cli.utilities.InteropCompilerKt.invokeInterop(InteropCompiler.kt:45)

at org.jetbrains.kotlin.cli.utilities.MainKt.mainImpl(main.kt:19)

at org.jetbrains.kotlin.cli.utilities.MainKt.main(main.kt:41)

Execution failed for task ':kotlin-library:cinteropNearbyMessagesIosArm64'.

> Process 'command '/Applications/Android <http://Studio.app/Contents/jre/jdk/Contents/Home/bin/java|Studio.app/Contents/jre/jdk/Contents/Home/bin/java>'' finished with non-zero exit value 1

I was able to install the cocoapod using a podfile and

pod install

. With no KMM involved. I've tried all sorts of random stuff besides but these are the steps that seem like they should work.

Is it possible to create an infix function scoped to a specific class? Something like:

// Foo is a library class and out of my control
class Foo

infix fun Foo.togetherWith(first: Any, second: Any) = ...

inline fun fooBuilder(builder: Foo.() -> Unit) {
  Foo().apply(builder)
}

fooBuilder {
  1 togetherWith 2
}

I know this specifically doesn't work, but is there any way to achieve this behavior?

still dont understand what Ktor is even after reading a few articles

Is there a setting to disable continuation indents here, I found no options in Intellij Code style.

Hi, is there a way to disable automatic destructures that the compiler autogenerate for data classes?

No #generics channel?

I’m looking if it is possible to use reified for class instantiation. I tried code like:

class BaseFragment<T: BaseViewModel> {
  val viewModel: T = createViewModel()
}

private fun <reified T: BaseViewModel> createViewModel() = T::java.class.newInstance()

This compiles but I have just one function with BaseViewModel class as argument. Is it possible to get many such methods for every class that extends it with more specific view model?

Any suggestions for following problem, let's say I have a simple type which is used in two different projects A and B (modules). Now I need to make this same type behave different in module B. Code example:

How can i avoid long transformation functions when trying to map elements of flow?

override suspend fun observeWatchedShows(): Flow<List<Show>> {
    return watchListDao.observeShows()
        //Map flow of list of Watched Shows to flow of list of Show
        .map { listOfShows ->
            entityMapper.toDomainList(
                //Map list of WatchShows to list of ShowEntity
                listOfShows.map { watchedShow -> watchedShow.show }
            )
        }

    // Mapping Flow<List<WatchedShow>> -> Flow<List<ShowEntity>> -> Flow<List<Show>>
}

This is not getting anywhere, tried changing Xmx in gradle.properites file 😞

What's the current suggestion for an ORM library? I lean towards something Kotlin-idiomatic, and I also kind of prefer light ORM's, OTOH I appreciate popularity and future-proofness (I know, I know, nothing is really future-proof, but still). Within these kind of loose constraints, all suggestions welcomed! (and thanks in advance, of course)

Hey there. I have following code

private suspend fun upsertAssets(code: String, assets: List<CreateAssetCommand>): List<UpsertAssetResponse> {
        return assets.chunked(100)
            .map { akeneoClient.upsertAssets(code, it) }
            .fold(mutableListOf()) { acc, next -> acc + next }
    }

that produces the compile time error

Type mismatch: inferred type is List<UpsertAssetResponse> but MutableList<UpsertAssetResponse> was expected

(the fold line). What am I missing?

Hello, world.KT! I'm looking for some Kotlin orientated game engine for building 2D games. Is there any resource? I would be exporting games to web or android

Heyho, I stumbled across visibility issues of

private val

variables.

class Client(private val delegate: InternalClient)

- The compiler tells me , that i’m not allowed to use

InternalClient

as

val

because of it’s being exposed public. But… the private should limit the visibility to other classes so no getter and no setter should be present, and it shouldn’t make any difference from compiler perspective, since no user is ever allowed to invoke

delegate

directly via

client

. Or am i missing something here?

I had a question regarding performance. I hadn't previously noticed that a field access in kotlin seems to be always via an accessor method. For example a public field Bob.t referenced as b.t in some file will invokevirtual Bob.getT which returns getfield Bob.t - in the case where t is got a lot this can affect performance quite a bit. Turning a data class from kotlin to a simple java object with final immutable fields changes this to getfield and so saves the indirection. Is there a way to prefer field access?

I have 2 lists holding the same data type that has unique “id” property. One is a bigger list that serves as a single source of truth and the other is a sublist. After the big list gets updated, how can I go through the smaller list and update values present there from the bigger list when “id” matches?

#coroutines?

Is it possible to return early from an exhaustive

when

?

This message was deleted.

For a Spring Boot app we want to add some extra meta data to particular fields in the JSON response. Since this is a "cross cutting" concern in our project we want to make this as simple/concise as possible. We made a proof of concept with annotations. So we created 2 annotations and used reflection to generate the metadata based on the annotated fields. An example to use this is:

data class Response(
    val id: Int,
    @MyFirstMetadata
    val label: LabelResponse
)

The idea that for the field

label

we generate some metadata and add this as extra fields in

LabelResponse

. I wonder if there's a way to reach our goal without annotations and reflection. I read about making DSL's in Kotlin, but I couldn't directly find something for our situation. I'm happy to hear your thoughts.

Why this (stream) is not possible in Kotlin , also why do we have different syntax for

for-loop

https://pastebin.com/K1uQx2mL

sophia.likedPeople.stream().forEach(x->println(x.name))

Is there a suggested approach for “an equals method for an interface”? I.e. not checking two actual objects for equality based on their implementing classes but only checking those fields/functions for equality that are declared in interface?

Is there any case where this could be valid? (having

val

, not

var

with nullable type and no custom getter). Do you think we need IDE warning here?

private val requestId: String? = null

registry.addConverter(
            object : Converter<String, IaaSProvider> {
                override fun convert(source: String): IaaSProvider = IaaSProvider.fromString(source)
            }
        )

Converter is a SAM interface, So technically it would be possible to do something like this:

registry.addConverter { source -> IaaSProvider.fromString(source) }

But how would I define generics in this lambda?

So uh I have some old code that I’m trying to update to Kotlin 1.4 and it stopped working. Here is a reproducer https://pl.kotl.in/GGe3tNnwm (try changing the Kotlin version from <1.4 to 1.4+ to see different results) I fear it was actually using a bug that was fixed. Any idea of how I should transform this code to achieve the same behavior as before?

Can one write a when statement and check if a list contains a value? Like the following (pseudocode):

when {
    array.contains(value) -> {

    }
}

hey all, does kotlin have any good networking libraries?

looking to mess around with p2p networking

Is there a neater way to do this?