you could “dd” your root partition to a partition on that HDD every now and then. and if you don’t have your home on a different partition do that and it’s easy to back this up with a syncing tool if u decided to do that or at least the .config .local and .cache directories because many programs put their configuration files in there.

BE VERY CAREFUL WHEN USING “dd” BECAUSE IT CAN MAKE YOU LOSE DATA FOR A WHOLE PARTITION OR DEVICE

docker keeps some data in ~/.local/share/docker btw

alright then.

I see. expected is such a great library to have regardless of the standard version. damn c++03, I’m not familiar with that standard.

I enabled support for c++11 regardless, it’s kinda cool to do so. and I enabled conditional support to use nl::expected with constexpr for c++20 and higher. nl::unexpected with constexpr requires c++23 tho

ikr, constexpr is pretty cool. sure, no problem. I could make it fully compatible with c++14 without c++17 extensions if u wanna use it with c++14

because “if constexpr(…)” is a c++17 feature which i’m using it to allow usage of nl::unexpected() to return a nl::expected<nl::monostate, E> to nl::expected<T, E> in this copy constructor

template<class U>
expected(const expected<U, E>& other) : _has_value(other.has_value())   // a copy constructor  
{
        if (_has_value)
        {
                if constexpr (std::is_same<U, monostate>::value) // it checks if U == monostate
                {
                        // makes an empty instance of "T"
                }
                else if constexpr (std::is_same<U, T>::value) // it checks if U == T
                {
                        // otherwise copies "other._value" into _value
                }
                else
                {
                        static_assert(
                            not std::is_same<U, T>::value, "no available conversion between the provided value types");
                }
        }
        else
        {
                new (std::addressof(_error)) E(other.error());
        }
}

 template<class E>
 expected<monostate, E> unexpected(const E& e) // then this can covert <monostate, E> to <T, E> fine because of this copy constructor
 {                
         return expected<monostate, E>(e);
 }


// example usage

nl::expected<int, std::string> meow = nl::unexpected("error");

but i could take a different approach and make 2 copy constructor one that explicitly takes

expected(const expected<monostate, E>& other)

and another

expected(const expected& other)

I was also using “std::is_same_v” which is a c++17 feature instead “std::is_same<>::value” but i made a commit and changed it. it now compiles with c++14 but with c++17 extensions

thank you! if someone wants a more modern API that’s kinda similar to tomlplusplus and a little nicer to use with modern error handling then my library might come in handy. my API is inspired a lot by tomlplusplus . i was trying to make a build system that uses TOML as a config file and I needed a json library so i decided to make my own as a learning experience which was great.

I’m not familiar with simdjson, but i know a little about nlohmann and I think the exception free path using ljson::expected is a nicer/safer approach. also there is convenient operator overloads in my library to add objects/array together, but nlohmann also has that i think

// accessing values in ljson
ljson::node node = ljson::parser::parse(raw_json);
std::string val = node.at("key").as_string();

// accessing values in nlohmann
nlohmann::json::json json;
raw_json >> json;
std::string val = json["key"].get<std::string>();