Accessing mutable data that isn't

[Spott]

I've been screwing around with templates lately, and I'm
attempting to figure out why the following won't compile:

struct value
{
      int a;

      const auto
          opBinary(string op, T)(in T rhs) const pure {
              static if (op == "+")
                  return intermediateValue!(value.plus,this,rhs)();
          }

      ref value opAssign(T)( in T t ) {
          a = t.a;
          return this;
      }

      static
      int plus(T1, T2)(in T1 x, in T2 y) pure {
          return x.a + y.a;
      }

}

struct intermediateValue(alias Op, alias A, alias B)
{

      auto opBinary(string op, T)(in T rhs) const pure {
          static if (op == "+")
              return intermediateValue!(value.plus,this,rhs)();
      }

      @property auto a() const pure {
          return Op(A, B);
      }

}

void main()
{
      value a = value(2);
      value b = value(3);
      value c;
      c = a + b;
}

The error is:
d_playground.d(34): Error: pure nested function 'a' cannot access
mutable data 'this'
d_playground.d(34): Error: pure nested function 'a' cannot access
mutable data 'this'
d_playground.d(10): Error: template instance
d_playground.value.opBinary!("+",
value).opBinary.intermediateValue!(plus, this, rhs) error
instantiating
d_playground.d(44):        instantiated from here: opBinary!("+",
value)
d_playground.d(44): Error: template instance
d_playground.value.opBinary!("+", value) error instantiating

What is going on?  Why is 'a' not allowed to "access" mutable
data (even though it isn't modifying it)? How do I tell the
compiler to pass "this" in a const fashion?