I'm increasingly using nested delegates to partition code.
```d
void foo(Thing thing)
{
void sendThing(const string where, int i)
{
send(thing, where, i);
}
sendThing("bar", 42);
}
```
...where the nested `sendThing` sometimes returns something,
sometimes doesn't. `Thing` may be a class or a value type,
`thing` may be a parameter to the parent function, may be a
variable previously declared in the parent function, may be
mutable or immutable, may be modified inside `sendThing`; any
combination of things. If `sendThing` doesn't need to access the
scope of `foo` I mark it `static` to enforce that, but mostly it
does.
From the spec:
### `19.19.2` Delegates & Closures
3. Those referenced stack variables that make up the closure
are allocated on the GC heap, unless:
* The closure is passed to a scope parameter.
* The closure is an initializer for a scope variable.
* The closure is assigned to a scope variable.
I'm generally not storing the delegates or passing them around as
values, so I don't think the thing about scope variables and
parameters *directly* applies.
Am I safe as long as I don't do something like, pass `&sendThing`
as an argument to `std.concurrency.receive`?
