public typelist<_Data_...>

{

template<typename... __Data_>

friend class DataBind;

template<typename _Head, typename... _Body_>

struct HeadBody {

using Head = _Head;

using Body = DataBind<_Body_...>;

};

using Head = typename HeadBody<_Data_...>::Head;

using Body = typename HeadBody<_Data_...>::Body;

Head head;

Body body;

// QUESTION: If there is a friend relation, why is the private call recursion not allowed?

template<typename Call, typename _Head, typename... _Body_>

void recursed(Call&& call) {

body([call, this] (_Body_&... _body_) {

// NOTE: Must call public method since no friend relationship exists

call(head, _body_...);

});

}

template<bool t_condition, typename t_type>

struct define_if {};

template<typename t_type>

struct define_if<true, t_type> {

using type = t_type;

};

public:

//! Default Constructor

//!

//! This constructor assumes as all _Data_ types have default constructors

DataBind() = default;

//! Copy construction

//!

//! Construction assumes all argument __Data_ types can be cast to _Data types

//! Requires that sizeof...(_Data) == sizeof...(__Data)

template<typename... __Data_>

DataBind(const DataBind<__Data_...>& source):

head(source.head),

body(source.body)

{}

//! Move contruction

//!

//! Construction assumes all argument __Data types can be converted to _Data types

//! Requires that sizeof...(_Data) == sizeof...(__Data)

template<typename... __Data_>

DataBind(DataBind<__Data_...>&& src):

head(static_cast<Head&&>(src.head)),

body(static_cast<Body&&>(src.body))

{}

// TODO: Variadic concatenation constructors

//! Copy assignment

//!

//! Assignment assumes all argument __Data types can be cast to _Data types

//! Base case enforces requirement that sizeof...(_Data) == sizeof...(__Data)

template<typename... __Data>

DataBind& operator = (const DataBind<__Data...>& rhs) {

head = rhs.head;

body = rhs.body;

return *this;

}

//! Move assignment

//!

//! Assignment assumes all argument __Data types can be moved to _Data types

//! Requires that sizeof...(_Data) == sizeof...(__Data)

template<typename... __Data>

DataBind& operator = (DataBind<__Data...>&& rhs) {

head = static_cast<Head&&>(rhs.head);

body = static_cast<Body&&>(rhs.body);

return *this;

}

// QUESTION: Is specialization inference from a variadic constructor possible?

// NOTE: As of C++17 the template specialization can be inferred

// from constructor arguments, so a template template can also

// be used here via auto as return type.

// NOTE: This would require using _Data_ in the constructor, which could conflict

// with the default constructor.

// QUESTION: Is it possible to handle mixed copy & move arguments?

// QUESTION: If partial arguments are provided,

// will the remaining arguments be defaulted?

// QUESTION: If too many arguments are provided, what happens?

//! Copy constructor using constituent copy construtors

//!

//! Copy constructor accepts arguments only of the types specified as _Data_ variadic.

//! Consequently, class template deduction is possible from constructor.

//!

//! Head separation prevents conflict with default constructor.

//! The argument count must be `<= sizeof...(_Data_)`

//! A partial list of P arguments will initialize only the first P members, with the remaining

//! being default initialized.

template<typename... _Body_>

DataBind(const Head& _head, const _Body_&... _body):

head(_head),

body(_body...)

{}

//! Move constructor using constituent move construtors

//!

//! Move constructor accepts arguments only of the types specified as Data variadic.

//! Consequently, class template deduction is possible from constructor.

//!

//! Head separation prevents conflict with default constructor.

//! The argument count must be `<= sizeof...(_Data_)`

//! A partial list of P arguments will initialize only the first P members, with the remaining

//! being default initialized.

template<typename... _Rest>

DataBind(Head&& _head, _Rest&&... _body):

head(static_cast<Head&&>(_head)),

body(static_cast<_Rest&&>(_body)...)

{}

//! Rebinds the DataBind elements as arguments of call

//!

//! It is expected that the argument is an in-line (r-value) lambda.

//! This makes it possible to handle arbitrary return types through

//! external binding.

template<typename Call>

void operator () (Call&& call) {

recursed<Call, _Data_...>(static_cast<Call&&>(call));

}

// QUESTION: Is it necesary to redefine typelist<_Data_...> if it is inherited?

//! Returns the element of DataBind identified by index

//!

//! It is expected that the return type is assigned to auto& value,

//! since the return type is determined by the index template argument.

template<sizetype index>

typename define_if<

0 != index,

Body

>::type::template part<index - 1>&

data() {

// NOTE: part<index> must be outside of declare_if arguments, otherwise

// recursion will not terminate when index == 0

return body.template data<index - 1>();

}

template<sizetype index>

typename define_if<

0 == index,

Head

>::type&

data() {

return head;

}

template<sizetype index>

const typename define_if<

0 != index,

Body

>::type::template part<index - 1>&

data() const {

return body.template data<index - 1>();

}

template<sizetype index>

const typename define_if<

0 == index,

Head

>::type&

data() const {

return head;

}