This version (1.0.5) of the Compose Compiler requires Kotlin version 1.5.31 but you appear to be using Kotlin version 1.6.0

build.gradle

ext.kotlin_version = '1.5.31'

SharedFlow

sealed class LoginResult {
    object Success : LoginResult()
    object WrongCredentials : LoginResult()
    data class InvalidData(val error: ErrorType) : LoginResult()
}

sealed class ErrorType {
    object EmptyEmail : ErrorType()
    object InvalidEmailFormat : ErrorType()
    object EmptyPassword : ErrorType()
}

InvalidData

EmptyEmail

freeCompilerArgs += listOf()

freeCompilerArgs = freeCompilerArgs + listOf()

@Module
@InstallIn(SingletonComponent::class)
object DependencyModule {

    @Singleton
    @Provides
    fun provideMoshi(): Moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build()

    @Singleton
    @Provides
    fun provideRetrofit(moshi: Moshi): BackendApi = Retrofit.Builder()
        .addConverterFactory(MoshiConverterFactory.create(moshi))
        .baseUrl(Constants.BASE_URL)
        .build()
        .create(BackendApi::class.java)
}

@Composable

val caption : String? = null 
val caption : String? = ""
should I use option 1 or 2 to initialize a variable?

val docRef = db.collection("cities").document("SF")
docRef.addSnapshotListener { snapshot, e ->
    if (e != null) {
        Log.w(TAG, "Listen failed.", e)
        return@addSnapshotListener
    }

    if (snapshot != null && snapshot.exists()) {
        Log.d(TAG, "Current data: ${snapshot.data}")
    } else {
        Log.d(TAG, "Current data: null")
    }
}

fun main(args: Array<String>) {
    val list = mutableListOf(
        DemandLabel(
            id = "1",
            inputType = Constants.DemandLabelInputType.RADIO,
            type = Constants.DemandLabelType.DEFAULT,
            uniqueCode = "duration",
            name = "duration",
            items = listOf(
                DemandLabelItem(
                    id = "1ab", name = "5 min"
                ), DemandLabelItem(
                    id = "123abc", name = "10 min"
                )
            )
        ),
        DemandLabel(
            id = "2",
            inputType = Constants.DemandLabelInputType.RADIO,
            type = Constants.DemandLabelType.DEFAULT,
            uniqueCode = "level",
            name = "level",
            items = listOf(
                DemandLabelItem(
                    id = "2ab", name = "Beginner"
                ), DemandLabelItem(
                    id = "2bc", name = "All"
                )
            )
        ),
        DemandLabel(
            id = "3",
            inputType = Constants.DemandLabelInputType.RADIO,
            type = Constants.DemandLabelType.DEFAULT,
            uniqueCode = "Label 1",
            name = "Label 1",
            items = listOf(
                DemandLabelItem(
                    id = "3abc", name = "Adductors"
                ), DemandLabelItem(
                    id = "3abcdeft", name = "Calves"
                )
            )
        ),
        DemandLabel(
            id = "4",
            inputType = Constants.DemandLabelInputType.CHECKBOX,
            type = Constants.DemandLabelType.CUSTOM,
            uniqueCode = "Label 2",
            name = "Label 2",
            items = listOf(
                DemandLabelItem(
                    id = "4abc", name = "Abdominals2"
                ), DemandLabelItem(
                    id = "4abcdef", name = "Arms2"
                )
            )
        ),
    )
    val mapOfList = list.associateBy({ it.name }, { it.items })
    println(mapOfList)

    val changed = list.groupBy (
        { it.name },
        {it.items.forEach { it.id }} )
    println(changed)
}

fun someFunction(): Flow<Pair<Int, SomeStateType>>

StateFlows

fun <T> Result<T>.toDataState(): DataState<T> {
    onFailure {
        return DataState.failure()
    }.onSuccess {
        return DataState.success(it)
    }
}

class AuthorizationInterceptor : Interceptor {
 
     override fun intercept(chain: Interceptor.Chain): Response {
         // more code
         return AuthorizationHeader(chain, accessToken)
     }
 
 
     private fun AuthorizationHeader(chain: Interceptor.Chain, accessToken: String): Response = synchronized(this) {
         val api = refreshApiCall() // this api call is not working
         return initialResponse
     }
 }

private fun getMonthValue(subscription: VariantDetail, context: Context): String {
    return when (subscription.valueInInt) {
        0 -> ""
        1 -> {
            when ((UnitOfMeasurement.fromType(subscription.unitOfMeasurement))) {
                MONTH -> context.getString(R.string.singular_month)
                DAY -> context.getString(R.string.singular_day)
                WEEK -> context.getString(R.string.singular_week)
                QUARTERLY,
                DOSE,
                NONE -> ""
            }
        }
        else -> {
            when ((UnitOfMeasurement.fromType(subscription.unitOfMeasurement))) {
                MONTH -> {
                    context.getString(
                        R.string.month_text,
                        subscription.value,
                        context.getString(R.string.plural_month)
                    )
                }
                DAY -> {
                    context.getString(
                        R.string.month_text,
                        subscription.value,
                        context.getString(R.string.plural_day)
                    )
                }
                WEEK -> {
                    context.getString(
                        R.string.month_text,
                        subscription.value,
                        context.getString(R.string.plural_week)
                    )
                }
                QUARTERLY,
                DOSE,
                NONE -> ""
            }
        }
    }
}

qualified this

Observer { loginFormState ->
                if (loginFormState == null) {
                    return@Observer
                }
                loginButton.isEnabled = loginFormState.isDataValid
                loginFormState.usernameError?.let {
                    usernameEditText.error = getString(it)
                }
                loginFormState.passwordError?.let {
                    passwordEditText.error = getString(it)
                }
            })

if (loginFormState == null) {
     return@Observer
  }

return@Observer

Function References of @Composable functions are not currently supported

private val onLiveFxRateResult: LiveData<Result<List<FundingAccountWithCcyPair>>> =
    Transformations.switchMap(onLiveFxRateRequested) {
        it.forEach {
            getFundingAccountsWithCcyPairsUseCase.execute(it.accountCountryCode)
        }
    }

MutableSharedFlow

interface I

@JvmInline
value class A(val instance: I) : I by instance // Error: Value class cannot implement an interface by delegation if expression is not a parameter

val index = liveFxRates.indexOfFirst { result.data.isCurrencyPairEqual(fxLiveRateGainLoss =  it) }
if(index > -1) {
    liveFxRates.removeAt(index)
    liveFxRates.add(index, liveFxRates[index].copy(buyValue = "-", sellValue = "-"))
}

flatmap()

viewModelScope.launch {
  val api = NetworkService().api
  val ordersResponse = api.fetchOrdersCoroutine()
  val deliveryItems = mutableListOf<DeliveryItem>()
  ordersResponse.orders.forEach { orderId ->
    val orderResponse = api.fetchOrderByIdCoroutine(orderId)
    deliveryItems.addAll(orderResponse.items)
  }
}