import std;
auto pointertoindex(T)(T[] arr,T* p){
	assert(&arr[0]<=p && &arr[$-1]>=p);
	return p-&arr[0];
}
unittest{
	auto foo=[1,2,3,4,5];
	auto bar=&foo[0];
	//pointertoindex(foo,bar).writeln;
}
auto opSlice(T)(T[] arr,T* i,T* j){
	auto i_=pointertoindex(arr,i);
	auto j_=pointertoindex(arr,j);
	assert(j_>=i_);
	return arr[i_..j_];
}
unittest{
	auto somefunc(string s){
		static int i=-2;
		i+=5;
		return &s[i];
	}
	auto foo="helloworld";
	auto start=somefunc(foo);
	auto end=somefunc(foo);
	foo[start..end].writeln;
}

Remove the restrictions on op overloads needing to be defined in the type. Both for a) you wrap basic types allot for one api difference b) when you go to use a verbose op overload call call like T.opSlice you need to track down every basic type and reimpliment it or some other hack

mynullable(T){
  T me;
  bool isnull;
  int opCmp(typeof(this) a,typeof(this) b){
    if( ! a.isnull && ! b.isnull){
      return a.opCmp(b);
    }
    ...