Hi everyone, I have been playing around with Orbit-MVI lately and I really like its simplicity. However, after using Mobius for a long time I'm not too sure what the best practices are. So here's my problem. I usually represent my network calls as suspend function returning and Either from the Arrow library. In Mobius, when consuming an Either I would just call

fold()

and dispatch and effect on the left case (error), and a new state on the right case (success), within the same

fold()

Using Orbit-MVI I either have to fold the

apiResponse

twice in the reduce block and the suspend block from the

intent

(option1), or do the

fold()

outside the reduce block but then the fold is happening in the impure world which isn't good practice in my opinion. Which option do you think is best, and is there any alternative to achieve this?

I am rendering a simple Image in Jetpack Compose.

Image(
    painter = rememberImagePainter(imageUrl),
    contentDescription = "Header Image",
    modifier = Modifier.height(200.dp)
)

I am getting the below error --- Failed to create image decoder with message 'unimplemented'

I just upgrade from Giraffe to Hedgehog, and now I got an error during the gradle project sync

coreLibraryDesugaring configuration contains no dependencies. ... please add dependencies to coreLibraryDesugaring configuration

Any hints are really appreciated.

Lazy properties with an option to recompute, reset - ResettableLazy Use-case - we used to have a nullable variable and nullify user session specific values like user data, API client, etc.. When ResettableLazy is introduced, we can reduce few lines of code and avoid overhead of synchronization Please see the below code and share suggestions

class Example {
    val loggedInUser: ResettableLazy<User> = resettableLazy {
        getUserFromDB()
    }

    fun logout() {
        loggedInUser.reset()
    }

    fun showUserInfo() {
        userNameText.text = loggedInUser.value.name
    }
}

object UninitializedValue

fun <T> resettableLazy(initializer: () -> T): ResettableLazy<T> = ResettableLazyImpl(initializer)
fun <T> resettableLazy(lock: Any? = null, initializer: () -> T): ResettableLazy<T> = ResettableLazyImpl(initializer)

fun <T> resettableLazyUnSynchronized(initializer: () -> T): ResettableLazy<T> = ResettableLazyUnSynchronizedImpl(initializer)

interface ResettableLazy<T> {
    val value: T

    fun isInitialized(): Boolean
    fun reset()
}

private class ResettableLazyImpl<T>(private val initializer: () -> T, lock: Any? = null) :
    ResettableLazy<T> {
    /**
     * This is an extended version of Kotlin Lazy property [kotlin.SynchronizedLazyImpl]
     * calling reset() will set UninitializedValue
     * if the values are used after reset() call, the value will be initialised again
     */
    @Volatile private var _value: Any? = UninitializedValue
    // final field is required to enable safe publication of constructed instance
    private val lock = lock ?: this

    override val value: T
        get() {
            var tempValue = _value
            if (tempValue !== UninitializedValue) {
                @Suppress("UNCHECKED_CAST")
                return tempValue as T
            }

            return synchronized(lock) {
                tempValue = _value
                if (tempValue !== UninitializedValue) {
                    @Suppress("UNCHECKED_CAST") (tempValue as T)
                } else {
                    val typedValue = initializer!!()
                    _value = typedValue
                    typedValue
                }
            }
        }

    override fun reset() {
        synchronized(lock) {
            _value = UninitializedValue
        }
    }

    override fun isInitialized(): Boolean = _value !== UninitializedValue

    override fun toString(): String = if (isInitialized()) value.toString() else "Lazy value not initialized yet."
}

private class ResettableLazyUnSynchronizedImpl<T>(private val initializer: () -> T) :
    ResettableLazy<T> {
    /**
     * This is a downgraded version of Kotlin Lazy property [ResettableLazyImpl], use it if everything happens in main thread
     */
    private var _value: Any? = UninitializedValue

    override val value: T
        get() {
            if (_value === UninitializedValue) {
                _value = initializer()
            }
            @Suppress("UNCHECKED_CAST")
            return _value as T
        }

    override fun reset() {
        _value = UninitializedValue
    }

    override fun isInitialized(): Boolean = _value !== UninitializedValue

    override fun toString(): String = if (isInitialized()) value.toString() else "Lazy value not initialized yet."
}

Will

String.format

be available in native?

In Jetpack Compose, it's common to pass lambda functions as parameters in both stateful and stateless composables. I'm considering using interfaces for this purpose instead and would like to understand the implications of this approach.

Why does a

Row

including

TextButton

have a height of 48 dp, although the button itself has height of 40 dp? I'm not adding any padding to the `Row`:

What's the difference between

beforeTest

,

beforeEach

and

beforeAny

? I've read the documentation but I'm still confused.

I tried bumping Gradle to 8.0 but I’m running into this error:

> ‘compileDebugJavaWithJavac’ task (current target is 11) and ‘kaptGenerateStubsDebugKotlin’ task (current target is 17) jvm target compatibility should be set to the same Java version.

I’m running Gradle on JVM version 17, and I have set the `sourceCompatibility`/`targetCompatibility`/`jvmTarget` options in the my

build.gradle

files to

JavaVersion.VERSION_11

. The error disappears if I align the Gradle JVM and target versions to be either 11 or 17, but I didn’t think these versions needed to be aligned. Does anyone have any input on what versions we should be using?

What am I doing wrong with observeAsState() method. See details in the thread.