Just freeing my imagination. Is there any language that features in its design something like function inheritance or function composition. I have a couple of Composable functions that I repeatedly call in other Composables. Eg: A 'BackPressHandler' to handle back press in each screen. Other common TopBars and such. Instead of copy and paste the same functions call block in every screen, is there any way to tell the compiler to inline other function calls automatically in the order we pass. Let's say Fun1() { ... } :

uses/inline/copy

::Fun2, ::Fun3 This kind of design. The result something like:

Fun1(){
  Fun2()
  Fun3()
  ...
}

Perhaps a feature in the Compose plugin 🤔

Could you clarify more what syntax you're sort of thinking of and what the expected behaviour would be like?

I would say something that looks like:

Fun1 call ::Fun2, ::Fun3 () { fun1-body-here }

call

could be combined with

inline

I mean, if you really want to, one can do:

fun call(vararg blocks: () -> Unit) { for(block in blocks) block() }

//elsewhere
Fun1() {
  call(::Fun2, ::Fun3)
  ...
}

Yeah I've realized that similar stuff can be achieved with existing language features. Like what you mentioned or creating helper Composable functions that encapsulates the reusable code and slot Composable to fill in.

Fun1WithReusableStuff(@Composable Slot...) {
  Fun2()
  Slot()
  Fun3()
}

Then use it like:

Fun1WithReusableStuff {
  ... // Composable stuff
}