Boost logo

Boost :

From: Pavel Chikulaev (pavel.chikulaev_at_[hidden])
Date: 2005-03-07 14:21:21

"Jonathan Turkanis" <technews_at_[hidden]> wrote in message
> Now that I look at your sample, I wonder whether it is possible to support
> operators which take instances of different types. This would be essential
> for
> an expression templates library.
class Vector;
old class Matrix
    static lazy::type<Vector> Vector_;
//Actually there is no need to define it
//It is possible to use LAZY_OP(lazy::type<Vector>() * lazy::type<Vector>())
//but defining static object AFAIK is the simpliest way.
    LAZY_OP(Matrix_ * Vector_); // Or Matrix_ * Vector_ I don't remember
    ENABLE_LAZY_OP(Matrix_ = Matrix_ * Vector_);
//You can use all classes. Just wrap their types in lazy::type<> and use
//LAZY_OP or ENABLE_LAZY_OP or ALIAS and so on.

I'm predicting you're next question - Is templates supported? Yes.
template<typename T>
class Matrix
    static lazy::type<Matrix> Matrix_;

    template<typename U>
    struct Matrix__ : lazy::type<Matrix<U> > {};

    template<typename U>
    LAZY_OP(Matrix_ + Matrix__<U>()); //A bit uglier, isn't it?

> Have you considered the approach taken by Boost.Operators?
    Not yet.
    I still don't know whether to make += lazy operator or
    code += operator as usual.

> Also, I believe Fusion (the sucessor to Tuple) would be a valuable tool.
    Is it (same as)(old version of) Tuple?

Pavel Chikulaev 

Boost list run by bdawes at, gregod at, cpdaniel at, john at