A modern programming language that makes developers happier.

kotlinlang

Do we have short syntx for remember in Compose?
```var imageBitmap by remember { mutableStateOf&lt;ImageBitmap?&gt;(null) }```
SwiftUI syntx read so much better
@State var someValue = ""

There used to be a `state` function/delegate. It's deprecated now

You can look into its source and Ctrl+c Ctrl+v into your project

we found that
```var someValue by state { "" }```
led to a lot of confusion for developers in terms of how and where observable state holders and property delegates can be created, so we encourage the longer version as the preferred approach. Decomposing it into the distinct mechanisms of `remember` to create persistence in composition and `mutableStateOf` to create an observable state holder led to better understanding of how things work and what's possible.

If you find yourself doing
```var someValue by remember { mutableStateOf("") }```
often and repeated enough to where it gets onerous or noisy to read, it's often a sign that you want to create a class to hold several observable properties as part of one concept, e.g.
```class MyState(
  foo: Foo,
  bar: Bar
) {
  var foo by mutableStateOf(foo)
  var bar by mutableStateOf(bar)
    private set
}```
and use it with a single `remember`, potentially as part of a default argument expression to allow the state to be hoisted to the caller:
```@Composable fun MyComposable(
  state: MyState = remember { MyState(defaultFoo, defaultBar) }
) {```


this all feeds into intended design patterns for compose code: `@Composable` functions emit UI based on state provided to them via parameters; the more private state you can hoist to be controllable by the caller/testable in isolation, outside of composition, the nicer your API becomes to work with. The pattern of `remember` expressions as default arguments above help balance caller convenience with flexibility when they want/need it, as opposed to creating a lot of private state.

You could also just define your own shortcut:
```@Composable
fun &lt;T&gt;rememberState(block: () -&gt; T) = remember { mutableStateOf(block()) }```

Yep, though if you do I'd recommend marking it `inline`