//Purpose:
//  Test if the code posted here:
/*
http://article.gmane.org/gmane.comp.lib.boost.devel/251897
 */
//  With headers:
/*
From: Louis Dionne <ldionne.2@gmail.com>
Newsgroups: gmane.comp.lib.boost.devel
Subject: Efficient tuple implementation
Date: Sat, 7 Jun 2014 02:18:47 +0000 (UTC)
Lines: 89
Approved: news@gmane.org
Message-ID: <loom.20140607T041645-909@post.gmane.org>
 */
//  can be extended to have "tagged" tuples.
//Result:
//  gcc4.8.1:fails compile
//  clang3.4:passes compile.
//
 
    enum tag_enum
    { op_or
    , op_and
    };
    
    template<tag_enum Tag>
    struct tag_t
    {
      tag_enum operator()()const
      {
        return Tag;
      }
    };

    auto tuple_tagged 
    = [](auto tag_v, auto ...xs) 
      {
        return [=](auto access) { return access(tag_v, xs...); };
      };
      
    template<typename Tag>
    struct operation_tagged
    ;

    template<>
    struct operation_tagged<tag_t<op_or> >
    {
        bool operation()
        {
            return false;
        }
        template<typename Head, typename... Tails>
        bool operation(Head head, Tails... tails)
        {
            if(head) 
              return head;
            else
              return operation(tails...);
        }
        template<typename... Xs>
        bool operator()(Xs... xs)
        {
            return operation(xs...);
        }
    };

    template<>
    struct operation_tagged<tag_t<op_and> >
    {
        bool operation()
        {
            return true;
        }
        template<typename Head, typename... Tails>
        bool operation(Head head, Tails... tails)
        {
            if(!head) 
              return head;
            else
              return operation(tails...);
        }
        template<typename... Xs>
        bool operator()(Xs... xs)
        {
            return operation(xs...);
        }
    };

    auto operation_apply
    = [](auto xs) 
      {
        return xs
          ( [](auto tag_v, auto... operands) 
            { 
              operation_tagged<decltype(tag_v)> operation_v;
              return operation_v(operands...);
            }
          );
      };

#include <iostream>
int main()
{
    auto or_all_true_input=tuple_tagged(tag_t<op_or>(),true,true,true);
    auto or_all_true_output=operation_apply(or_all_true_input);
    std::cout<<"or_all_true_output="<<or_all_true_output<<"\n";
    
    auto or_one_false_input=tuple_tagged(tag_t<op_or>(),true,false,true);
    auto or_one_false_output=operation_apply(or_one_false_input);
    std::cout<<"or_one_false_output="<<or_one_false_output<<"\n";
    
    auto or_all_false_input=tuple_tagged(tag_t<op_or>(),false,false,false);
    auto or_all_false_output=operation_apply(or_all_false_input);
    std::cout<<"or_all_false_output="<<or_all_false_output<<"\n";
    
    auto and_all_true_input=tuple_tagged(tag_t<op_and>(),true,true,true);
    auto and_all_true_output=operation_apply(and_all_true_input);
    std::cout<<"and_all_true_output="<<and_all_true_output<<"\n";
    return 0;
}