libCat VS EA Standard Template Library

That's awesome! I'm working on something that sounds similar. https://github.com/cons-cat/libcat

I'd love to see your work if you're willing to share it here!

It's worse in the standard library than it has to be. When I refactored my traits to minimize template instantiations and lean on concepts as much as possible, I measured over 30% improvement to clean build compile times. It's not possible for the standard to do this, because it would subtly change the API. For instance, you can't instantiate or take the address of a concept, but you can for a type-trait class. No reason you'd want to do that, but you can, so they can't "break" the standard library by optimizing this.

This doesn't have to be true. Over the past year I've made progress towards demonstrating how even non-freestanding C++ can be written without any C or C++ standard library headers or DLLs (with large benefits). There are a few names which the compilers require to be in the std:: namespace, though, but they're very special features like source_location and construct_at with semantics that can't be expressed otherwise.

It isn't that hard to put a predicate into a type. We have lambdas in an unevaluated context, CTAD, and templated type aliases. https://github.com/Cons-Cat/libCat/blob/main/src/libraries/scaredy/cat/scaredy https://github.com/Cons-Cat/libCat/blob/main/src/global_includes.hpp#L70 https://github.com/Cons-Cat/libCat/blob/main/src/libraries/linux/cat/linux#L289 You do it like this.

I use clang-tidy. These are my current linting rules.

I'm working on this! https://github.com/Cons-Cat/LibCat

Can I introduce you to EASTL

C++, but generally treat it as C. STL is pretty slow while debugging so we avoid it and write our own replacements. If you don't want to drive that deep use something like EASTL: https://github.com/electronicarts/EASTL

In my opinion, you should also benchmark it against something like boost::container::flat_set or eastl::vector_set and you should expect the same performance as with your ordered functionality. Another interesting idea for organization of such flat and sorted container can be found here.

check it out: https://github.com/electronicarts/EASTL

EASTL might also be worth a look, the code is relatively readable and well-documented.

I just took a look at their atomic.h and wow, "well-documented" is an understatement !

I recently read this benchmark series about hashing and hashmaps, which includes EA STL. It performs fairly decently overall in that regard. EA STL also has benchmarks in its source repo. But I would also expect that some of its perfomance improvements are almost self evident, such as containers like tuple_vector, intrusive containers, and fixed-size containers that don't have an analogous feature in the STL, all of which are integrated into its own polymorphic allocators and arenas (different from and more flexible than std::pmr) along with its other algorithms. It would be interesting to see them benchmarked against Boost, which has similar features but written in the STL style.

I'm currently trying to add EASTL to my project, but when I try to build it using CMake (either as a subdirectory, or directly in the EASTL subdirectory), I get the error message EASTL\include\EASTL\internal\atomic\atomic_integral.h(330,2): error C2338: static_assert failed: 'eastl::atomic atomic macro not implemented!'. Does anyone have any clue why this could be happening?

I haven't, but that's a great idea! I did test it against the EASTL and that worked well and is still fast enough it appears instant.

EA did it. Problem with "reliable containers" that go with your runtime is that you can't control if they cater to your specific use cases.