| Home | Libraries | People | FAQ | More

### cons

##### Description

`cons` is a simple Forward Sequence. It is a lisp style recursive list structure where `car` is the head and `cdr` is the tail: usually another cons structure or `nil`: the empty list. Fusion's `list` is built on top of this more primitive data structure. It is more efficient than `vector` when the target sequence is constructed piecemeal (a data at a time). The runtime cost of access to each element is peculiarly constant (see Recursive Inlined Functions).

##### Header

    #include <boost/fusion/container/list/cons.hpp>
    #include <boost/fusion/include/cons.hpp>

##### Synopsis

    template <typename Car, typename Cdr = nil>
    struct cons;

##### Template parameters

Parameter | Description | Default
--- | --- | ---
`Car` | Head type |
`Cdr` | Tail type | `nil`

##### Model of

- Forward Sequence

Notation

`nil`

  An empty `cons`

`C`

  A `cons` type

`l`, `l2`

  Instances of `cons`

`car`

  An arbitrary data

`cdr`

  Another `cons` list

`s`

  A Forward Sequence

`N`

  An MPL Integral Constant

##### Expression Semantics

Semantics of an expression is defined only where it differs from, or is not defined in Forward Sequence.

Expression | Semantics
--- | ---
`nil()` | Creates an empty list.
`C()` | Creates a cons with default constructed elements.
`C(car)` | Creates a cons with `car` head and default constructed tail.
`C(car, cdr)` | Creates a cons with `car` head and `cdr` tail.
`C(s)` | Copy constructs a cons from a Forward Sequence, `s`.
`l = s` | Assigns to a cons, `l`, from a Forward Sequence, `s`.
``at`<N>(l)` | The Nth element from the beginning of the sequence; see `at`.

| Note
``at`<N>(l)` is provided for convenience and compatibility with the original Boost.Tuple library, despite `cons` being a Forward Sequence only (`at` is supposed to be a Random Access Sequence requirement). The runtime complexity of `at` is constant (see Recursive Inlined Functions).

##### Example

    cons<int, cons<float> > l(12, cons<float>(5.5f));
    std::cout << at_c<0>(l) << std::endl;
    std::cout << at_c<1>(l) << std::endl;