tuples

The boost::mpl algorithms seem not to be able to work on std::tuple types out of the box, e.g., the following does not compile (boost-1.46.0, g++ snapshot 2011-02-19): #include <tuple> #include <boost/mpl/vector.hpp> #include <boost/mpl/contains.hpp> namespace mpl=boost::mpl; typedef mpl::vector<int,float,bool> types; static_assert(mpl::contains<types, float>::value, "vector contains bool"); typedef std::tuple<int,float,bool> types2; // the following does not compile: // error: no class template named ‘apply’ in ‘struct boost::mpl::contains_impl<boost::mpl::non_sequence_tag>’ static_assert(mpl

I am trying to create a list based on another list, with the same values repeated 3 times consecutively. At the moment, I am using: >>> my_list = [ 1, 2 ] >>> three_times = [] >>> for i in range( len( my_list ) ): ... for j in range( 3 ): ... three_times.append( my_list[ i ] ) ... >>> print three_times [1, 1, 1, 2, 2, 2] But I would like to do it using a more Pythonic way, such as: >>> my_list = [ 1, 2 ] >>> three_times = [] >>> three_times = [ (value,) * 3 for value in my_list ] >>> print three_times [(1, 1, 1), (2, 2, 2)] However, I cannot find a way to unpack the tuples. Something like

In Elixir, if I try to pattern match the following two tuples: {a} = {1, 2} I get a match error. But if I do the same for two maps: %{x: a} = %{x: 1, y: 2} It works fine, and a binds to 1. I can see why matching the two tuples gave an error, but why did matching the maps not give an error? In the first example you are attempting to match a single element tuple against a two-element tuple. In the second example you are matching on the :x key in both the left and right maps. EDIT: I should clarify the rules around data structures and pattern matching in Elixir. When matching on tuples, you need

I have a tuple type. I want to add a element type in it to get a new tuple type. I can do it like decltype tuple_cat(MyTuple, std::tuple<MyType>()) However, I don't find tuple_cat in boost::tuple , how to do it in boost? I assume you want all this in compile time. Here is the general explanation: concatening tuples is similar to concatening lists or arrays, is that the algorithm is the same. Here, given tuples a and b , I choosed to move the last element of a to the beginning of b , and repeat until a is empty. First: base structures. The following structure keeps a parameter pack. It can be

Currently I have two functions : template<typename Type> bool f(Type* x); template<typename... List> bool f(std::tuple<List...>* x); Is there any way to merge these two functions with an extra template parameter that indicates whether the passed type is a tuple ? template<typename Type, bool IsTuple = /* SOMETHING */> bool f(Type* x); Xeo Sure, using is_specialization_of (link taken and fixed from here ): template<typename Type, bool IsTuple = is_specialization_of<Type, std::tuple>::value> bool f(Type* x); The question is, however, do you really want that? Normally, if you need to know if a