Front Page / Metafunctions / Miscellaneous / inherit_linearly

# inherit_linearly

### Synopsis

    template<
          typename Types
        , typename Node
        , typename Root = empty_base
        >
    struct inherit_linearly
        : fold<Types,Root,Node>
    {
    };

### Description

A convenience wrapper for `fold` to use in the context of sequence-driven class composition. Returns the result the successive application of binary `Node` to the result of the previous `Node` invocation (`Root` if it's the first call) and every type in the Forward Sequence `Types` in order.

### Header

    #include <boost/mpl/inherit_linearly.hpp>

### Model of

Metafunction

### Parameters

Parameter | Requirement | Description
--- | --- | ---
`Types` | Forward Sequence | Types to inherit from.
`Node` | Binary Lambda Expression | A derivation metafunction.
`Root` | A class type | A type to be placed at the root of the class hierarchy.

### Expression semantics

For any Forward Sequence `types`, binary Lambda Expression `node`, and arbitrary class type `root`:

    typedef inherit_linearly<types,node,root>::type r;

Return type: | A class type.
Semantics: | Equivalent to
    typedef fold<types,root,node>::type r;

### Complexity

Linear. Exactly `size<types>::value` applications of `node`.

### Example

    template< typename T > struct tuple_field
    {
        T field;
    };

    template< typename T >
    inline
    T& field(tuple_field<T>& t)
    {
        return t.field;
    }

    typedef inherit_linearly<
          vector<int,char const*,bool>
        , inherit< _1, tuple_field<_2> >
        >::type tuple;

    int main()
    {
        tuple t;

        field<int>(t) = -1;
        field<char const*>(t) = "text";
        field<bool>(t) = false;

        std::cout
            << field<int>(t) << 'n'
            << field<char const*>(t) << 'n'
            << field<bool>(t) << 'n'
            ;
    }

### See also

Metafunctions, Algorithms, inherit, empty_base, fold, reverse_fold