Yield on signal implementation?
So what's your strategy for doing this?  To be honest I looked at this a while ago, and didn't understand nim's async and godot-nim well enough at the time to move forward.  

Here are my thoughts on this so far. I can see how we'd used `asynchdispatch`'s `poll` in the `method process` to process Futures. We'd explicitly have to add something like:
```nim
import asynchdispatch
gdobj ...
  method process() =
    if hasPendingOperations():
      poll(0)
    ...
```
So Futures will complete.

Then we'd tag a function with `{.async.}`, and since that function returns a Future when invoked. Inside that function we would then use `await` on some function, call it `onSignal`, that returns a Future used in a callback for `connect`.

```nim
  method ready() =
    # created self.timer
    asyncCheck self.onTimer()

  proc onTimer() {.async.} = 
    await onSignal(self.timer, "timeout") #onSignal returns a Future[void], await on it to block
    print "timer timeout"
```

What I'm trying to figure out is how to create/reference the callback to be passed to `connect` when it only accepts a string for the callback? I don't think we can automatically generate the callback inside of `onSignal` without passing the signal parameter types since a signal api is not part of gdnative. Take for example, Area2D has a `area_shape_entered ( int area_id, Area2D area, int area_shape, int self_shape )` signal, we'd need to pass the signal parameters explicitly, or modify the gdnative api to include signals.

```nim
  proc somefunc() {.async.} =
    await onSignal(self.area2D, "area_shape_entered", proc(area_id:int, area:Area2D, area_shape:int, self_shape:int))
    print &"{area_shape=} entered"
    ...
```

So assuming we have all the info we need to generate a callback what are the options for passing it to `connect`?  Currently callbacks are class member procs that need `{.gdExport.}`, which uses `nativeScriptRegisterMethod` to register it with godot.  But we can't use `{.gdExport.}` on a callback inside of a proc. So `onSignal` needs a new macro to process it, call it `genSignalCallback`, that will `genSym` a name for the callback, register it with godot, then pass the callback name to `connect`.  But the problem with that is `genSignalCallback` needs to write to the AST generated by `godotmacros gdobj`.  I don't know if that's even possible "out-of-band", so we'd have to parse procs when `gdobj` is generating the AST to add the generated callback as another method to be registered. Since only `{.async.}` functions can contain `await onSignal` we'd only have to parse those functions.

Hmm so this seems doable. Thoughts?

_Originally posted by @geekrelief in https://github.com/pragmagic/godot-nim/issues/74#issuecomment-748647765_