inout and templates don't mix...

[cy via Digitalmars-d-learn]

halp

There's a module that tries to define complex operations on both 
const and non-const structs, since it's the same operation for 
both. So every function that invokes those operations is 
copy-pasted twice, just with "const" added. Switching to inout to 
eliminate that huge amount of code duplication causes an error, I 
can't figure out how to fix.

struct Someop(Type) {
  Type thing;
  void foo() {
        thing.bar();
  }
}

struct Foo {
  void bar() {
        import std.stdio: writeln;
        writeln("bar");
  }
}

struct Bar {
  void thingy(inout(Foo) foo) inout {
        auto op = Someop(foo);
        op.foo();
  }
}

void main() {
  Foo foo;
  Bar bar;
  bar.thingy(foo);
}

=>

Error: struct derp.Someop cannot deduce function from argument 
types !()(inout(Foo))

if I put in Someop!(typeof(foo))(foo) it gives the error:

Error: variable derp.Someop!(inout(Foo)).Someop.thing only 
parameters or stack based variables can be inout

...even though Someop is a struct allocated on the stack.

What I'm dealing with is like:

struct Bar {
  void thingy(Foo foo) {
        auto op = Someop(foo);
        //...lotsastuff...
        op.foo();
  }
  void thingy(const(Foo) foo) const {
        auto op = Someop(foo);
        //...lotsastuff...
        op.foo();
  }
  // repeat ad-nauseum...
}