On 13/02/2024 19.46, Yexuan Xiao via Std-Proposals wrote:
> That’s why my proposal does not include a parsing API, it leaves it entirely to the user (or future proposals). It focuses on how to precisely represent JSON, and how to manipulate it.

Frankly, representation classes without an actual parser are
close to useless in practice.

I think some of the questions listed below can have rather
simple answer, but it feels the character type needs to
be configurable.

And yes, a survey of the state of the art and why your approach
is better (or not) is definitely needed for any meaningful
proposal.

Jens


------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
> *From:* Tiago Freire <tmiguelf_at_hotmail.com>
> *Sent:* Wednesday, February 14, 2024 2:41
> *To:* std-proposals_at_[hidden] <std-proposals_at_lists.isocpp.org>
> *Cc:* Yexuan Xiao <bizwen_at_[hidden]rg>
> *Subject:* RE: A Minimal JSON Support Library for C++
>
>
> I think that parsers are an immediate no go for standardization.
>
> They are better kept for an independent library project.
>
> They just have too many behavior details that are simply unrealistic to force upon developers as default.
>
>
>
> What’s the underlying character type? char? char8_t? char16_t? char32_t?
>
> How does it handle the polymorphic types?
>
> Can I stream it from memory? Can I stream it from a file? Can I stream it with my own custom streamer?
>
> What type of encodings does it support? And how do I choose it?
>
> What is the view model? Is it a copy of the block into memory? Is it a mapping of the stream block into a reference?
>
> How do you handle errors?
>
> Can I diagnose errors as it is being parsed?
>
> How do I handle meta-data?
>
>
>
> You may think that there is a “standard way” of doing it, but there’s no such thing.
>
> I can give you many different design choices, one is not necessarily better than the other, it is only better depending on what you do with it.
>
>
>
> These are my 2cents
>
>
>
>
>
> *From:*Std-Proposals <std-proposals-bounces_at_lists.isocpp.org> *On Behalf Of *Yexuan Xiao via Std-Proposals
> *Sent:* Tuesday, February 13, 2024 6:47 PM
> *To:* std-proposals_at_lists.isocpp.org
> *Cc:* Yexuan Xiao <bizwen_at_nykz.org>
> *Subject:* [std-proposals] A Minimal JSON Support Library for C++
>
>
>
> Hello everyone, I recently designed a JSON library that is suitable to the C++ standard, but I don’t have much experience with using allocators, so I need an allocator expert to help me improve it. Any suggestions are welcome and I hope you like it.
>
>
>
> https://storage.nykz.org/proposals/minimal-json/ <https://storage.nykz.org/proposals/minimal-json/>
>
>
>
> Here are some use cases:
>
>
> #include "basic_json.hpp"
>
> #include <string_view>
>
> int main()
>
> {
>
> /*
>
> Note: This code is for demonstration purposes only and can be compiled only, not be run.
>
>       */
>
>       // json
>
>       using json = bizwen::json;
>
> using namespace std::literals;
>
> json j01{};
>
> json j02{ j01 };
>
> // j j03{ nullptr }; deleted
>
> json j04{ 1. };
>
> json j05{ true };
>
>       json j06{ 1.f };
>
>       json j07{ 1u };
>
>       json j08{ 1l };
>
> json j09{ 1ll };
>
>       json j10{ 1ull };
>
>       json j11{ "aaa" };
>
>       auto str = "bbb";
>
> json j12{ str, str + 3 };
>
>       json j13{ str, 3 };
>
>       json j14{ str };
>
>       json j15{ "bbb"sv };
>
>       // since initializer_list returns a reference to a const object, this method is inefficient
>
> // json j16{ json::array_type{ json{0}, json{1} } };
>
>       // json j17{ json::object_type{ { "key0"s, json{ 0 } }, { "key1"s, json{ 1 } } } };
>
>    json j16{ json::array{ 0, 1 } };
>
>       json j17{ json::object{"key0"s, 0, "key1"s, 1} };
>
> json j18{ bizwen::basic_json_node<>{} };
>
> swap(j17, j18); // adl hidden friend
>
> j17.swap(j18);
>
>       j17 = j18;
>
>       std::swap(j17, j18);
>
>       json::node_type n{ std::move(j18) };
>
>  
>
>       // const_slice
>
>       using const_slice = bizwen::const_json_slice;
>
>       const_slice c1;
>
>       c1.empty();
>
> c1.array();
>
> c1.string();
>
> c1.null();
>
>       c1.boolean();
>
>       c1.number();
>
>       c1.object();
>
>       c1.array();
>
>       c1.object();
>
>       c1.integer();
>
>       c1.uinteger();
>
>       c1["key"];
>
>       c1["key"s];
>
> // requires transparent comparable
>
>       // c1["key"sv];
>
>       c1[1];
>
>       const_slice c2{ j17 };
>
>       c2.swap(c1);
>
>       std::swap(c1, c2);
>
>       const_slice c3{ std::move(j17) };
>
>       const_slice c4 = c3;
>
> const_slice c5 = std::move(c4);
>
> c4 = c5;
>
>       c5 = std::move(c4);
>
>       bool b{ c5 };
>
>       bizwen::nulljson_t nj{ c5 };
>
> json::string_type const& s{ c5 };
>
> json::array_type const& a{ c5 };
>
> for (auto const& i : a)
>
> {
>
> const_slice item{ i };
>
> }
>
> json::object_type const& o{ c5 };
>
> for (auto const& [k, v] : o)
>
> {
>
> const_slice item{ v };
>
> }
>
> long long ll{ c5 };
>
> unsigned long long ull{ c5 };
>
>
>
> // slice
>
> using slice = bizwen::json_slice;
>
>       slice s1{};
>
>       slice s2{ j17 };
>
>       const_slice c6 = s2;
>
> std::string str1;
>
>       s2 = str1;
>
>       s2 = std::string{};
>
>       s2 = "aaa";
>
> s2 = std::string_view{};
>
>       s2 = bizwen::nulljson;
>
>       s2 = true;
>
>       s2 = 1.;
>
>       s2 = 1;
>
>       s2 = 1u;
>
>       s2 = 1ll;
>
>       s2 = 1ull;
>
>       s2 = n;
>
> s2["key"] = 1;
>
> }
>
>
>
>