namespace boost::numeric::ublas {

enum class storage_traits {
  READ_ONLY,
  READ_WRITE,
};

struct storage_tag{};

namespace sparse {

template <class T, storage_traits S> struct sparse_policy;

template <class T> struct sparse_policy<T, storage_traits::READ_ONLY> : storage_tag {
  static constexpr storage_traits access = storage_traits::READ_ONLY;
  virtual T at(int) = 0;
  virtual T at(int) const = 0;
};

template <class T> struct sparse_policy<T, storage_traits::READ_WRITE> : storage_tag{
  static constexpr storage_traits access = storage_traits::READ_WRITE;
  virtual T &at(int) = 0;
  virtual T at(int) const = 0;
};

template<typename T>
struct map_storage : sparse_policy<T, storage_traits::READ_ONLY>{

  virtual T at(int k) override final {
    return 1;
  };
  virtual T at(int k) const override final {
    return b;
  };

  // int a = 10;
  int b = 11;
};

} // namespace sparse
template<typename T>
struct access_data {
private:
  static constexpr auto lm = [](){
    if constexpr(std::is_base_of<storage_tag,T>::value){
      return T::access;
    }else{
      return storage_traits::READ_WRITE;
    }
  };
public:
  static constexpr storage_traits value = lm();
};
} // namespace boost::numeric::ublas

namespace boost::numeric::ublas {

template <typename T, typename E = shape<dynamic_rank>,
          typename F = first_order, typename A = std::vector<T>>
struct tensor {
  using base_type = A;
  using extent_type = E;
  using stride_type = stride_t<E, F>;
  tensor() {
    // data_ = base_type(extents_.size());
  }

  tensor(size_t size, T val):data_(size,val){}

  auto at(int k) -> std::conditional_t<access_data<A>::value == storage_traits::READ_ONLY, T, T& >{
    return data_.at(0);
  }

  auto at(int k) const{
    data_.at(0);
  }
  /* .... */
  // private:
  base_type data_;
  extent_type extents_;
  stride_type strides_;
};
} // namespace boost::numeric::ublas


int main(int argc, char const *argv[]) {
    tensor<int,shape<-1>,first_order,sparse::map_storage<int>> t1;
    cout<<t1.at(0)<<'\n'; // 1 type int

    tensor<int> t2(2,10);
    t2.at(0) = 11;
    cout<<t2.at(0)<<'\n';// 11 type int&
    return 0;
}