A modern programming language that makes developers happier.

kotlinlang

What is the name of the syntactical feature where you can scope a `Unit` to be a sort of anonymous extension function on a given class? I noticed it in the Compose code (I think) but I haven't been able to find it in the docs.

Example:
```fun render(node: Node, action: Node.() -&gt; Unit) {
    node.action()
}```

in the example, `render` is a higher-order function taking a function type (or lambda) with receiver. <https://kotlinlang.org/docs/lambdas.html>

Thanks for the link! It looks like "function literal with receiver" is the specific terminology I'm looking for here. Thanks!
<https://kotlinlang.org/docs/lambdas.html#function-literals-with-receiver>

a function literal starts with `fun`, which is not the only way to get a function type - a lambda expression `{ ... }` also does

the example there is just to show that you can explicitly write the receiver type of a function literal, while with a lambda expression it can only be inferred

Ah ok.
```Lambda expressions can be used as function literals with receiver when the receiver type can be inferred from the context.```
So if I'm understanding the terminology, in this case the lambda is not strictly speaking a "function literal" (since it is not defined as `fun`) but is simply being used in the same way?

"lambda with receiver" is probably the most common description for what you're asking for, but I don't think the docs mention it - that phrasing is a bit inaccurate