Le 24/06/15 18:39, Louis Dionne a écrit :
John Bytheway <jbytheway+boost <at> gmail.com> writes:
[...] - What is your evaluation of the library's: * Design
The design seems reasonable, and I like the adherence to mathematical concepts. The most difficult thing is getting the names right, and I know there's been plenty of debate on that. The name that most concerns me is Range, given that that term is already commonly used in Boost as a concept with a completely different meaning (in the Boost.Range sense). Interval might be reasonable too?
* Implementation
Did not look.
* Documentation
Mostly very good, but of course there is always room for improvement. One particular thing I wanted to raise here is that I struggled to find enough information about Hana-convertibility (i.e. using the 'to' function). For example, I wondered if I could create a Tuple from a Range, and it seems I can. Then I wondered whether I could create a std::Array from a homogeneous Tuple, but it seems I cannot. A Tuple is a Sequence, and a Sequence can be created from any Foldable. Since a Range is Foldable, it works. However, a std::array is _not_ a Sequence.
Couldn't std::array<T,0> be considered the empty Array and so Array could be considered a homogeneous sequence?
How should I know these things? The Foldable -> Sequence conversion is documented in the reference of Foldable, here: http://ldionne.com/hana/structboost_1_1hana_1_1Foldable.html However, I agree that it could/should appear closer to the description of the `to` function. One problem is that a lot of types provide the `to` function, but I can't really describe all of them in the reference for `to`.
Where should these conversions be documented to make it easier for users to find them?
I would put the To function on the Source class it it s a concrete type. Otherwise on the Target class. It could be added on a see also section for the other class or concept.
(This latter case of converting to an array is something I feel ought to be supported for easing the boundary between runtime and compile-time sequences) std::array is not "general" enough to allow construction from an arbitrary Hana Sequence. As you point out, it would only work for Sequences containing objects of a single type. However, this breaks the naturality of the `to` function. Of course, nothing prevents me from adding a conversion to std::arrays, but it wouldn't actually fit in Hana's mathematical framework.
I know the above must seem quite fuzzy, so let me try to explain my point by considering the implementation of a `to<std::array>` conversion:
namespace boost { namespace hana { template <typename S> struct to_impl<ext::std::Array, S, when<models<Sequence, S>()>> { template <typename Xs> static /*constexpr*/ auto apply(Xs&& xs) { using T = std::remove_reference_t<decltype(hana::head(xs))>; auto len = hana::length(xs); return hana::unpack(std::forward<Xs>(xs), [=](auto&& ...x) { return std::array<T, len>{{std::forward<decltype(x)>(x)...}}; }); } }; }}
See how we make an arbitrary choice to use the type of the first element of the sequence for `T`? This, and the fact that it will only work when the Sequence happens to contain elements of a single type, are what breaks naturality. Why not request that the sequence is homogeneous?
Vicente