A modern programming language that makes developers happier.

kotlinlang

From K/N CInterop guide on kotlin webpage:
```We use the staticCFunction{..} helper function from Kotlin/Native to wrap a Kotlin lambda function into a C function pointer. It only allows having unbound and non-capturing lambda functions.```
Could someone elaborate on what it means by `unbound and non-capturing lambda functions`. Does it mean that for instance if you want to register callbacks from c they cannot be in a kotlin class, but rather only top-level function?

i'm not clear on unbound, but non-capturing means that it does not contain references to the context in which it is used

So does that mean there's no way to wrap GTK3 C callbacks in classes for reusability? Even something as a pair of click count buttons managed by Wrapper class?

<@U5969P4HZ> found this snippet in your libui
```/** Function to be run when the user makes a change to the TextField.
     *  Only one function can be registered at a time. */
    fun action(block: TextField.() -&gt; Unit) {
        action = block
        uiEntryOnChanged(ptr, staticCFunction { _, ref -&gt;
            with(<http://ref.to|ref.to>&lt;TextField&gt;()) {
                action?.invoke(this)
            }
        }, ref.asCPointer())
    }

    internal var action: (TextField.() -&gt; Unit)? = null```
Can you explain why the compiler does not complain that action is outside the function?

they can exist within a class but can't capture any reference to the class

Also how can I obtain the referenced value from `COpaquePointer`  as:
```<http://ref.to|ref.to>&lt;TextField&gt;()```

Nvm, figured it out:
```ref.asStableRef&lt;TextField&gt;().get()```