pathologically simple hotloading

[monkyyy]

can anyone imagine any simplifications?

```d app.d
import std;
import core.stdc.stdlib;
import core.sys.posix.dlfcn;

struct enity{
	int i;
	ubyte[100] j;
	//int x;
	//int y;
}
string exe(string input){
	//auto config=0;//Config.stderrPassThrough|Config.retainStdout;
	//input.writeln;
	return input.executeShell(/*null,config*/).output[0..min($,$-1)];
}
void runcompiler(){
	"opend -shared -of=hotload.so hotload.d".exe.writeln;
}
void* handle;
void*[] store;
string[] api;
enum PATH=__FILE_FULL_PATH__[0..$-__FILE__.length];
void loadso(){
	handle=dlopen((PATH~"/hotload.so").toStringz,RTLD_LAZY);
	assert(handle!=null,dlerror.to!string);
	store=[];
	foreach(s;api){
		store~=dlsym(handle,s.toStringz);
	}
}
void hotload(string s,T...)(ref enity e,T args){
	alias F=extern(C) void function(enity*,T);
	auto I=api.countUntil(s);
	if(I==-1){return;}
	if(store[I]==null){return;}
	F call=cast(F)(store[I]);
	call(&e,args);
}
void main(){
	api~="foo";
	api~="bar";
	runcompiler;
	loadso;
	//---
	enity[10] enitys;
	foreach(ref e;enitys){
		hotload!"foo"(e);
	}
	foreach(e;enitys){
		e.i.writeln;
	}
	foreach(ref e;enitys){
		hotload!"bar"(e,true);
	}
}
```

```d hotload.d
import std;
extern(C):
struct thingy{
	int x;
	int y;
}
void foo(thingy* t){
	t.x=uniform(0,10);
	t.y=uniform(20,50);
	(*t).writeln;
}
void bar(thingy* t,bool b){
	(*t).writeln;
}
```

As written I believe ill need to improve my compiler bugs ulities 
to make a ct appendable string[]
i'll need to detect enity-like data types and ensure that

trade off between a uda based like my old version: 
https://codeberg.org/monkyyy/raylib2026/src/commit/e5a7e93cc379981ca44bab70f92f3dfd68653944/hotloadlib.d#L35

I think a void* version is more flexible and should have less 
compile time (as hotload.d isnt even processed) its changing the 
"direction" of the type inference so by not reading `hotload` 
maybe I avoid spooky order of complation issues in exchange for 
less safety?

idk, I feel like this is all under explored, how to best use 
dlsym with template based apis?