Sorry for late response.

Here is brief syntax:

```#include "tensor/tensor.hpp"
#include "tensor/product.hpp"namespace cc {
template<class E0, class E1, class E2>
void f(int i, int j, int k,
const tensor::expression<E0> &t2_,
const tensor::expression<E1> &VVVO_,
const tensor::expression<E2> &OVOO_,
tensor::tensor<3> &X) {
USING_TENSOR_INDEX((a)(b)(c)(e)); // tensor::index<'a'> a; .. etc
USING_TENSOR_INDEX((l)(m));        const E0 &t2 = t2_();
const E1 &VVVO = VVVO_();
X(a,b,c) += (t2(a,e,i,j)*VVVO(b,c,e,k)); // ok
X(a,b,c) += 3.0*(t2(a,e,i,j)*VVVO(b,c,e,k)); // ok
X(a,c,b) += (t2(a,e,i,j)*VVVO(b,c,e,k)); // ok, transposed
X(a,b,k) += (t2(a,e,i,j)*VVVO(b,c,e,k)); // compile error rank2 + rank3
X(a,b,c) += (t2(a,e,m,j)*VVVO(b,c,m,k)); // compile error, rank3 + rank4
X(a,b,m) += (t2(a,e,i,j)*VVVO(b,c,i,k)); // compile error, index mismatch
}    void f(int i, int j, int k) {
size_t size[4];        tensor::tensor<4> t2, VVVO(size), OVOO(200,200,200,100);
tensor::tensor<3> X(100,100,100);
triples(i, j, k, t2, VVVO, OVOO, X);
}}// No contravariance/covariance per se.```
operators and constructors are generated using boost_pp.
integral index reduces tensor rank by one.
tensor index (which can be range) creates a view of tensor.
The storage is handled by multi_array by default - but can have other backends via traits.
I think it has pretty flexible design, not finished yet but most of pieces are there.
May need innermost loop optimization - something with iterators rather then multi_array[index] i use now.
Can potentially add openmp for outermost loop.

My priority was static checks to verify correct indices/ranks/etc.
I can put the library on google code (about 500-700 lines) if you like further look?

Bye.