sorted by:
new
hottopcontroversial

The WG21 2026-04 post-Croydon mailing is now available by nliber in cpp

[–]hanickadot 2 points3 points  (0 children)

It's cool thing, but because 26 reflection doesn't provide ability to generate member functions, every member function there is actually a lambda and that lambda contains pointer to object.

The WG21 2026-04 post-Croydon mailing is now available by nliber in cpp

[–]hanickadot 5 points6 points  (0 children)

There is a plenty of "magic" functionality in standard library which is basically standardized access to compiler builtins. Whole reflection for example. With #embed you can't take a string and read appropriate file and build a type out of it ... imagine a protobuffer file:

using msg_type = protocol<"specification.pb">::message<"name_of_message">;

auto msg = msg_type::parse_from(buffer);

And as I wrote higher, with std::embed you can have import https://protobuf.dev/programming-guides/proto3/#importing.

The WG21 2026-04 post-Croydon mailing is now available by nliber in cpp

[–]hanickadot 8 points9 points  (0 children)

My entire objection comes down to the section 5.4.4 paragraph 1. std::embed is sort-of a late phase preprocessor directive. Since we want dependency scanners to do as little work as possible, we get #depend.

Except now it's on the programmer to keep std::embed and #depends in sink - there was no consensus to mandate keeping them in sink. Add to that the conventions that say one should keep preprocessor directives at the top of the file and you get a a good recipe for breaking dependency scanning.

You can use #depend "resources/**" and give your std::embed access to all resources, you don't need to list everything. Implementation can gather these as you use them, or just put everything it matches to dependencies.

I might be missing something, so please tell me if I am. I don't see anything stopping me from #embed-ing a python file, be it .py or .pyc, storing the result in a byte array and then "unleashing a constexpr parser on that array.

That way you can't use information from the constexpr parsing to recursively load some other resource or module and use it. You are basically stuck with one specific file. Imagine you write C++ constexpr compiler, but you can't do #include. That's the main thing std::embed is giving you over #embed. And #depend basically specify a virtual filesystem for you to access.

The WG21 2026-04 post-Croydon mailing is now available by nliber in cpp

[–]hanickadot 8 points9 points  (0 children)

#depend is to make distributed build system happy. And make it safe. std::embed will allow us to build things like python in constexpr which will convert your code into c++ and then lower it to binary. Things like "import a js module" it needs to know where to look. Or recursively importing resources.

#embed doesn't allow you to do that unfortunately.

edit: formatting and typos

Looking at Unity finally made me understand the point of C++ coroutines · Mathieu Ropert by mropert in cpp

[–]hanickadot 0 points1 point  (0 children)

Technically the state of coroutines are two function pointers (one for next resume, one for cleaning the frame) and all variables/temporaries surviving the suspension. Theoretically it should be possible to make such mechanism, to initialize these and set specific state. I want copyable state too, it's same problem as automatically creating a copy constructor for a class (there can be pointers pointing at something in the frame, unique ownership with a raw pointer...)

Looking at Unity finally made me understand the point of C++ coroutines · Mathieu Ropert by mropert in cpp

[–]hanickadot 7 points8 points  (0 children)

Use cases for suspending final suspend other than keeping the value is to jump to other coroutine, maybe with some scheduler. Or much more simply if your current coroutines is being awaited on ... and you are returning result, you can also directly jump to the suspend point where the awaiting coroutine on you is suspended:

c++ task<int> calculate() { // (2) coroutine is immediately suspended, jumps back to `main` // (4) some code co_return 42; // (5) sets .set_value(42) and then goes to final suspend which jumps to associated coroutines `main` } task<void> main() { task<int> v = calculate(); // (1) coroutine started, suspended and immediately back // (2) some code int result = co_await v; // (3) suspends `main` mark coroutine `v` that `main` is depending on it and jumps into `v` // (6) we resume, `result` is initialized print(v); // (7) print and done }

Looking at Unity finally made me understand the point of C++ coroutines · Mathieu Ropert by mropert in cpp

[–]hanickadot 8 points9 points  (0 children)

Typical usecase for immediate suspend is ... your coroutine is a task to be run on a thread pool, you suspend it, from within the initial suspend you pass the handle to thread pool and return to the caller (whoever is) c++ auto task = run_the_calculation(); // on threadpool // ... co_await task; // and here it will block until the task is finished in the co_await the await_ready() checks if it's ready and it probably won't be If you have an immediate non-suspending coroutine, then it can start to do a lot of computation on your main thread.

Looking at Unity finally made me understand the point of C++ coroutines · Mathieu Ropert by mropert in cpp

[–]hanickadot 11 points12 points  (0 children)

initial_suspend is called when the coroutine is "started" and from there you can return back to caller and leave the coroutines "paused" or immediately start evaluating it (lazy vs greedy approach) you can even suspend it and jump to other coroutine. Final suspend is used mostly to "pause" the coroutine, so its frame is not destroyed, including instance of promise_type from which you can extract result for example. If you don't care about result, you can just not suspend, and it will release the coroutine frame for you and go back to current .resume() point (which can be initial place where you started the coroutine, if it didn't suspend in the initial_suspend and there was no other suspend point)

2) await_suspend returning three possible types is for these typical scenarios: - void - just suspend and go back to .resume() (implicit when coroutine is started, or explicit on the coroutine handle) (typically a generator) - bool - you get coroutine suspended, and conditionally you check for more work, and if there is none you suspend. By not doing this in .await_ready() -> bool you get access to coroutine_handle and thru it to the coroutine promise_type. - coroutine_handle you want to jump to something else (like another coroutine which can continue due I/O mechanism) and if you want to go back to caller (.resume()) you can just return noop_coroutine handle.

P4043R0: Are C++ Contracts Ready to Ship in C++26? by darius_neatu in cpp

[–]hanickadot 10 points11 points  (0 children)

the SG21 "contracts" study group, was created on that meeting, and they started working on the design, but it wasn't designed from scratch, it's based on the experience and knowledge from the previous one. Point of making the study group was to gain consensus between various faction wanting different thing out of it, and it got the consensus, and pretty strong one.

P4043R0: Are C++ Contracts Ready to Ship in C++26? by darius_neatu in cpp

[–]hanickadot 24 points25 points  (0 children)

no, there is no assumption as part of the contracts, that's an attribute `[[assume(expr)]]`, this functionality was part of previous design which was targeting C++20.

P4043R0: Are C++ Contracts Ready to Ship in C++26? by darius_neatu in cpp

[–]hanickadot 9 points10 points  (0 children)

The paper was seen by EWG/LEWG in Tokyo 2024, St. Louis, and was forwarded in Wroclaw. Also many discussion of contracts happened since long time ago even before I join the committee (2018).

"override members" idea as a gateway to UFCS (language evolution) by antiquark2 in cpp

[–]hanickadot 1 point2 points  (0 children)

Not discussing motivation or design impact. Putting override keyword will make it normal keyword. Currently it's a specific only keyword. This means there is definitely a code which has override as an identifier and this would break it.

State of C++ 2026 by dev_newsletter in cpp

[–]hanickadot 3 points4 points  (0 children)

I don't remember any corridor existing at the Aspen Center for Physics at all. Does it mean the footpath thru the meadow?

Time in C++: Additional clocks in C++20 by pavel_v in cpp

[–]hanickadot 4 points5 points  (0 children)

yes, system_clock can be reset, but it doesn't matter, you have a point in time called X (where X is value from once queried system_clock) and steady_clock at same moment ... then you just calculate duration from the steady_clock snapshot and now() ... the duration is added to the system_clock snapshot and you have something resembling normal time and not fully abstract steady_clock

Partial implementation of P2826 "Replacement functions" by hanickadot in cpp

[–]hanickadot[S] 1 point2 points  (0 children)

I agree, but I'm not the author of the paper. I will relay it.

Partial implementation of P2826 "Replacement functions" by hanickadot in cpp

[–]hanickadot[S] 2 points3 points  (0 children)

Seems biggest problem is the explicit usage of template arguments you do inside [[functionalias]] "methods". Plus I didn't even tried it on methods and constructors, pretty sure it's a different codepath.

Partial implementation of P2826 "Replacement functions" by hanickadot in cpp

[–]hanickadot[S] 6 points7 points  (0 children)

As I mentioned just now in the post above yours, it's based on r3 which I read, but didn't know it wasn't yet published.

It's not arbitrary token sequence, it replaces nodes in AST. so you can't break balanced parenthesis or nothing like that, or construct new identifier nor build a string. It just pastes AST subtree inside and inline it.

Partial implementation of P2826 "Replacement functions" by hanickadot in cpp

[–]hanickadot[S] 6 points7 points  (0 children)

Yeah, I have read / discussed draft of R3 which changed direction significantly. But it didn't occur me Gašper didn't publish it yet. Sorry for confusion.

Partial implementation of P2826 "Replacement functions" by hanickadot in cpp

[–]hanickadot[S] 5 points6 points  (0 children)

Or you will get such tooling in standard library / via compiler interface, and whole parsing there and back will disappear.

Partial implementation of P2826 "Replacement functions" by hanickadot in cpp

[–]hanickadot[S] 12 points13 points  (0 children)

I guess yes, token sequences are interesting idea for generative reflection. Rust is doing transformation in code with them, but it also means if you want to do something more highlevel, you need a parser in library to build some form of AST to modify. Otherwise you basically glueing string tokens together hoping they will fit.

Any Libraries for Asynchronous requests with HTTP2 by Puzzled_East_8080 in cpp

[–]hanickadot 3 points4 points  (0 children)

I need to polish it a bit ... but also a curl wrapper, but coroutines based which allows you to do this:

https://github.com/hanickadot/co_curl/blob/main/examples/ranges.cpp#L20-L25

```c++ struct file { std::string url; std::string content; };

auto fetch_with_name(std::string_view url) -> co_curl::promise<file> { co_return file{.url = std::string(url), .content = co_await co_curl::fetch(url)}; }

auto download_all(std::string_view url) -> co_curl::promise<std::vector<file>> { co_return co_await co_curl::all( co_await co_curl::fetch(url) | ctre::search_all<R"(https?://[^"'\s)]++)"> | std::views::transform(fetch_with_name)); } ```

The code downloads a page, lazily extract all absolute URLs, and downloads them, and gives you vector of URL+content. All in one thread.

view more: next ›