// Compute the extents and strides for the specified slice in the dim dimension.
// Note that dim is an integral_constant specifying the dimension in which the
// slice is computed.
template<std::size_t N>
  template<std::size_t D, std::size_t M>
  inline std::size_t
  matrix_slice<N>::do_slice_dim(const matrix_slice<M>& desc, slice s)
  {
    // If the starting point is past the extent, we're requesting the
    // entire slice.
    if (s.start >= desc.extents[D])
      s.start = 0;
 
    // If the lenght is large or the slice requests more elements than are
    // available, make it stop at the right extent.
    if (s.length > desc.extents[D] || s.start + s.length > desc.extents[D])
      s.length = desc.extents[D] - s.start;
 
    // If the stride over-runs the edge of the matrix, re-compute the length
    // so that we stop after the right number of increments. This is:
    //
    //    l = ceil(d/s)
    //
    // where d is the distance from the start to the extent, and s is the
    // stride. 
    if (s.start + s.length * s.stride > desc.extents[D])
      s.length = ((desc.extents[D] - s.start) + s.stride - 1) / s.stride;
 
    // Compute the extents and stride in this dimension.
    extents[D] = s.length;
    strides[D] = desc.strides[D] * s.stride;
    return s.start * desc.strides[D];
  }
 
// Slicing a single column is the same as a 1-count slice at the current
// dimension. Here, dim is an integral_constant specifying the dimension
// being sliced.
template<std::size_t N>
  template<std::size_t D, std::size_t M>
    inline std::size_t
    matrix_slice<N>::do_slice_dim(const matrix_slice<M>& desc, std::size_t n)
    {
      return do_slice_dim<D>(desc, slice(n, 1, 1));
    }
 
 
// Translate the slice arguments is {s, args...} into the output slice, and
// return the offset of the first element of the matrix. Note that the returned
// element is effectively computed as the dot product of the starting offsets of
// each slice argument with the strides of this slice.
//
// All of the heavy lifting is done in do_slice_dim.
//
// TODO: It is possible to reduce the dimensionality of the resulting slice when
// we encounter slice::none arguments or plain index. An index requests only a
// single element, so we can effectively compute drop the corresponding
// dimension.
 
template<std::size_t N>
  template<std::size_t M, typename T, typename... Args>
    inline std::size_t
    matrix_slice<N>::do_slice(const matrix_slice<M>& desc, 
                              const T& s, 
                              const Args&... args)
    {
      constexpr std::size_t D = N - sizeof...(Args) - 1;
      std::size_t m = do_slice_dim<D>(desc, s);
      std::size_t n = do_slice(desc, args...);
      return m + n;
    }
 
template<std::size_t N>
  template<std::size_t M>
    inline std::size_t
    matrix_slice<N>::do_slice(const matrix_slice<M>& desc)
    {
      return 0; 
    }