Re: [boost] Re: loki::type_list == boost::mpl::list_node

From: Hamish Mackenzie (hamish_at_[hidden])
Date: 2002-04-14 21:57:57

On Sun, 2002-04-14 at 19:43, Andrei Alexandrescu wrote:
> "Hamish Mackenzie" <hamish_at_[hidden]> wrote in message
> news:1018803083.2507.1250.camel_at_lightening.firestream.co.uk...
> > I think a lot of confusion has resulted from people, including
> myself,
> > thinking that mpl::type_list and loki::type_list are (or should be)
> the
> > same thing.  Both have advantages and disadvantages.
> > If mpl and loki are to be integrated it is loki::type_list and
> > mpl::list_node that need to be merged.
> 
> 
> Thanks Hamish for a refreshingly constructive and useful motion.
> 
> > loki::type_list could be renamed to type_list_node.
> >
> > Then mpl list_node could be split into type_list_node and
> value_list_node
> > (reducing the number of template args from 4 to 2).
> >
> > This would leave us with
> >   mpl::type_list == loki::TYPE_LIST_NN
> >   mpl::type_list_node == loki::type_list_node
> 
> I believe this is a nice approach that could make everybody happy.
> Then, Loki's dependency of mpl would be precisely one little header.
> 

Something else that occurs to me is that I can see no reason not have
both implementations of the algorithms in the same namespace.  The loki
style implementation being specialisation for type_list_node and
type_list_nil.  This may be desirable as I expect sometimes recursive
approach may use fewer compiler resources.

That would make count_if (code borrowed from Aleksey's and Andrei's
posts)

// ____ IMPLEMENTATION 1 ____

template<
  typename Sequence
, typename Predicate
>
struct count_if
{
  typedef typename fold<
    Sequence
  , integral_c<unsigned long, 0>
  , select_if< apply<Predicate,_2>, next<_1>, _1 >
  >::type type;

  typedef typename type::value_type value_type;
  BOOST_STATIC_CONSTANT(value_type, value = type::value)
};

// ____IMPLEMENTATION 2____
// for type lists only

#ifdef HAS_PARTIAL_SPEC // Sorry don't know what the name is
#ifdef USE_RECURSIVE_ALGORITHMS

template <class Predicate>
struct count_if<type_list_nil, Predicate>
{
  typedef unsigned long value_type;

  BOOST_STATIC_CONSTANT( value_type, value = 0);

  typedef integer_c< value_type, value > type;
};

template <class H, class T, class Predicate>
struct count_if<type_list_node<H, T>, Predicate>
{
  typedef unsigned long value_type;

  BOOST_STATIC_CONSTANT(
    value_type,
    value = (Predicate::apply<H>::value ? 1 : 0) +
      count_if<T, Predicate>::value);

  typedef integer_c< value_type, value > type;
};

#endif // USE_RECURSIVE_ALGORITHMS
#endif // HAS_PARTIAL_SPEC

I have made them a bit longer in order to make them compatible.

It would be nice if both lived in the same file so if I don't understand
one I can look at the other.  Also a well written test library could
check the results are the same using both algorithms.

Hamish