A modern programming language that makes developers happier.

kotlinlang

Hi, i saw a code snippet who is written by a googler like below:
```@Composable
fun PolygonComposable(polygon: RoundedPolygon, modifier: Modifier = Modifier) =
    PolygonComposableImpl(polygon, modifier)

@Composable
private fun MorphComposable(
    sizedMorph: Morph,
    progress: Float,
    modifier: Modifier = Modifier,
    isDebug: Boolean = false
) = MorphComposableImpl(sizedMorph, modifier, isDebug, progress)```
Why did they seperate the composable to implementation and caller ? What is the benefit of this ?

Without knowing more about the code and context, I can’t see any reason to do this. 

Ahh ok. Here are the implementations:
```@Composable
private fun MorphComposableImpl(
    sizedMorph: Morph,
    modifier: Modifier = Modifier,
    isDebug: Boolean = false,
    progress: Float
) {
    Box(
        modifier
            .fillMaxSize()
            .drawWithContent {
                drawContent()
                val scale = min(size.width, size.height)
                val path = sizedMorph.toComposePath(progress, scale = scale)
                if (isDebug) {
                    drawPath(path, Color.Green, style = Stroke(2f))
                    sizedMorph.forEachCubic(progress) { cubic -&gt;
                        cubic.transform { x, y -&gt; TransformResult(x * scale, y * scale) }
                        debugDraw(cubic)
                    }
                } else {
                    drawPath(path, Color.White)
                }
            })
}

@Composable
internal fun PolygonComposableImpl(
    polygon: RoundedPolygon,
    modifier: Modifier = Modifier,
    debug: Boolean = false
) {
    val sizedShapes = remember(polygon) { mutableMapOf&lt;Size, List&lt;Cubic&gt;&gt;() }
    Box(
        modifier
            .fillMaxSize()
            .drawWithContent {
                drawContent()
                val scale = min(size.width, size.height)
                val shape = sizedShapes.getOrPut(size) { polygon.cubics.scaled(scale) }
                if (debug) {
                    shape.forEach { cubic -&gt; debugDraw(cubic) }
                } else {
                    drawPath(shape.toPath(), Color.White)
                }
            })
}```
and the repo: <https://github.com/chethaase/ShapesDemo>

yea i have no idea why he split up those functions

Ah ok. Appreciated for your answers. Have a nice day.

just to be clear, i would advise against doing this, as i would always advice against adding complexity for no reason :sweat_smile:  i’m sure he had a reason at the time but maybe this was left in by accident after some changes :shrug::skin-tone-2:

Yea agree with that but i also saw similar practice in compose source code

So when i see a googler apply this, then i wanted to learn the reason why

This is useful for testing mocks of these composables, but i can’t think of any other reason.

How would you mock these composables? You can’t change the function that `PolygonComposable` is calling without more bytecode manipulation than most mocking libraries do by default.