04:21 <Noah[m]> diondokter the bigest problem with using rust errors here is that you cannot select the correct span because you cannot conjure it from thin air and then it just becomes annoying :/ otherwise I would love actual rust errors for something like this :)

08:25 <Ralph[m]> are https://doc.rust-lang.org/stable/embedded-book/ and https://docs.rust-embedded.org/book/ the same version & updated at the same time? which is the canonical URL to which one should link?

08:25 <Ralph[m]> (btw: does this tie in with the discussion whether the embedded WG should stay under the rust foundation? if it isn't associated with the foundation, would the book still be hosted on rust-lang.org?)

08:40 <JamesMunns[m]> fwiw, language wise:... (full message at <https://catircservices.org/_irc/v1/media/download/AbXDZrayUi8oWVTb49pzs-_A9o2zrT_C4lVWWhrV2tlQceybYXujqYbAB_tritmZcK5BSivltynTgZpi3Dv2qmS_8AAAAAAAAGNhdGlyY3NlcnZpY2VzLm9yZy9WeUZyWXNvdlBtYUlXY0xFWUdWc2lybHA>)

08:56 <JamesMunns[m]> or, maybe t-lang docs, which also hosts some other formal/informal books

08:57 <JamesMunns[m]> To answer the "when are they updated" question, iirc r-e org updates on every PR merge, doc r-l org updates whenever we submit a PR to update the submodule (it might be automatic on release now? not sure)

08:58 <JamesMunns[m]> I'd probably treat the r-e org one as canonical, inclusion in the bookshelf is so people can get them with rustup doc (everyone who has rust installed has the embedded book already!)

08:58 <JamesMunns[m]> if you type `rustup doc` in your console, it'll open the bookshelf on your PC, which includes the embedded book already locally :)

08:59 <Ralph[m]> JamesMunns[m]: TIL!

09:00 <Ralph[m]> thanks for your comprehensive answer!

10:49 <dngrs[m]> <diondokter[m]> "Yeah, there's no Rust input" <- maybe report the error in the KDL? Not very helpful to rustc I suppose but file:line could still be beneficial for the user

10:49 <dngrs[m]> * suppose but `file:line, * file:line` could

10:57 <diondokter[m]> <dngrs[m]> "maybe report the error in the..." <- Yes, I think that's the plan now. Just print the errors and warnings to stdout or stderr so they appear next to the compiler errors/warnings

11:25 <DominicFischer[m> <JamesMunns[m]> "that's useful if you have say..." <- Can this be done without the boxing? I'm now considering this option for control transfers 😄. I'm hoping a `DynPinList<dyn MyTrait>` is feasible without alloc.

11:26 <JamesMunns[m]> <JamesMunns[m]> "that's useful if you have say..." <- Well, you can get something LIKE that, using unsafe vtable methods, which is generally fine if you are only using that interface inside of library code (e.g. not user funcs)

11:27 <JamesMunns[m]> <JamesMunns[m]> "that's useful if you have say..." <- you might be able to put an `&mut dyn Trait` in the node? Not sure offhand, would have to try

11:31 <dngrs[m]> (chanting) dyn! dyn! dyn!

11:31 <dngrs[m]> (context: https://bsky.app/profile/dngrs.bsky.social/post/3lrkwjpn2c222 )

11:48 <DominicFischer[m> <JamesMunns[m]> "you might be able to put an `&..." <- I think this would force me to declare a lifetime on the T in PinList

11:48 <JamesMunns[m]> <JamesMunns[m]> "you might be able to put an `&..." <- Ah yes, it would, which wouldn't work

11:49 <JamesMunns[m]> <JamesMunns[m]> "you might be able to put an `&..." <- (unless that lifetime was 'static, e.g. you use a staticcell)

11:50 <JamesMunns[m]> <JamesMunns[m]> "you might be able to put an `&..." <- As @dngrs linked, I think you could make a "proxy" struct that impls the trait (or just a struct has safe wrapper methods of the unsafe vtable fns), but I dunno exactly what you need/want, API wise

11:54 <JamesMunns[m]> But yeah, this is more like what ergot/cfg-noodle do, using the other half of the type erasure, to give you something morally equivalent to `Mutex<Vec<dyn Trait>>`, but currently I don't have a pleasant wrapper for the second half of that.

11:55 <JamesMunns[m]> It's very possible to get something that BEHAVES that way, even if it's not as directly pleasant to use. Very open to suggestions on how to make an actual library API for that, instead of a squishy unsafe pattern

11:56 <DominicFischer[m> Ah thanks, that helps, I think I have an idea of how to do this. Or at least what I want the API to look like

11:57 <JamesMunns[m]> You probably can't use PinList for type erasure, because you need to iterate over `NonNull<NodeHeader>` types, so you can do the type-punning in a way that is sound wrt provenance. cordyceps can do it, but pinlist can't

11:59 <JamesMunns[m]> (PinList gives you *references*, which are only valid for the T they reference, whereas `NonNull<T>` can be casted to `NonNull<StartsWithTButHasMore>` as long as it was *created* from a `StartsWithTButHasMore` ptr

12:00 <DominicFischer[m> let list: DynPinList<dyn MyTrait> = DynPinList::new();

12:00 <DominicFischer[m> let node = Node::new_for(&list, MyObject { .... }, |my_obj: &mut MyObject| -> &mut dyn MyTrait { my_obj });

12:00 <DominicFischer[m> node.attach();

12:01 <JamesMunns[m]> yeah, maybe, you might get yourself in trouble with using references, because you want all the nodes (regardless of their actual type) to START with a common header you can use for iteration (and erasing generics/lifetimes), but once you make a REFERENCE of the header, you've truncated the provenance to only the header and not the entire object

12:01 <JamesMunns[m]> definitely poke around how cfg-noodle and ergot do it. I do it in a VERY specific way for VERY specific soundness reasons.

12:02 <JamesMunns[m]> (there's probably other ways, but this is one way I'm fairly certain is sound)

12:16 <DominicFischer[m> https://github.com/jamesmunns/ergot/blob/dabf9a283307ca0053e7c9dd08c5e95e7ef9f256/crates/ergot/src/socket/owned.rs#L212-L214 is what I imagine doing before calling that lambda. I don't know enough about provenance but I'll shoot you a PR and see what you think

12:18 <JamesMunns[m]> Yes, but be aware, if you have something like:... (full message at <https://catircservices.org/_irc/v1/media/download/AViYtjqRGeme4ihp3aYolOPMZC50_zFGKP7yDiBwVk1_lo5_R4srNGKT8T1qmwNz9nI5PEfXe9FALjI-bF3AsNi_8AAAAAAAAGNhdGlyY3NlcnZpY2VzLm9yZy9GRnd6c0FxU2JqTmFCaEhwcFJTVUxiVE4>)

12:19 <JamesMunns[m]> s/`//

12:20 <JamesMunns[m]> you also CAN'T just turn the &mut into the NonNull, because the &mut MyHeader ONLY has provenance for that range, so turning it into a ptr and then going out of range is still unsound

12:20 <JamesMunns[m]> @Dominic Fischer ^

12:21 <JamesMunns[m]> since PinList ALWAYS creates references, you'd need to change pinlist a lot, to always use RawIter from cordyceps instead of Iter/IterMut/IterPinMut

12:21 <JamesMunns[m]> but yeah, maybe as a totally separate PinListDyn or so.

12:22 <DominicFischer[m> Oh yeah, I 100% meant having a separate type from PinList.

12:22 <JamesMunns[m]> Yes, but be aware, if you have something like:... (full message at <https://catircservices.org/_irc/v1/media/download/AR6CIORyTUZWr_KgHgtbn7X3gj9GtIYxkwWLXf9MnOucatuMSqggA1jYoSxkjt52tvOoaYjskhAbKxjRIyWpkQC_8AAAAAAAAGNhdGlyY3NlcnZpY2VzLm9yZy9WR01nZGtYSWFxVWRlSmNIRFhJV2V2SWY>)

17:45 <RockBoynton[m]> what is the recommended way to link data to specific RAM regions, now that static mut is heavily discouraged?

17:53 <JamesMunns[m]> whatcha wanna do with that region of RAM?

17:54 <JamesMunns[m]> In general, an issue with putting stuff outside of RAM is that the default init won't initialize it.

17:54 <JamesMunns[m]> So: you can either explicitly make it uninit, and init it before you use it (the `grounded` crate can help with this), use pre-init (probably with some asm) to init it, or do your own init (outside of cmrt)

17:55 <RockBoynton[m]> Stick some large static data structure in it

17:56 <RockBoynton[m]> Right, before I would use static mut with MaybeUninit and init in my application init code

17:56 <JamesMunns[m]> https://docs.rs/grounded/latest/grounded/uninit/struct.GroundedCell.html is basically `UnsafeCell<MaybeUninit<T>>`

17:57 <JamesMunns[m]> you could do the same with that, get the ptr, do an unsafe init once, then turn it into a &'static mut T

17:58 <JamesMunns[m]> (or you could roll your own wrapper that does the same)

17:58 <JamesMunns[m]> the issue is that UnsafeCell doesn't impl Sync, so you need to have a wrapper that does impl sync

17:58 <JamesMunns[m]> (tho I need to relax mine a bit: https://github.com/jamesmunns/grounded/issues/7)

22:27 <DominicFischer[m> <JamesMunns[m]> "but yeah, maybe as a totally..." <- https://gist.github.com/Dominaezzz/129520288d494fb43352b08c4f8ab69e

22:27 <DominicFischer[m> Putting aside the use nightly (which could be skipped by doing the lambda thing), I love the way the API turned out.

22:27 <DominicFischer[m> Now tell me why it's unsound 😂

22:28 <DominicFischer[m> (Check out the tests at the bottom first)

22:32 <JamesMunns[m]> looks neat!

22:33 <JamesMunns[m]> I'd probably need to poke it a bit to form a better opinion, but looks promising!

22:33 <JamesMunns[m]> you can try running your tests with miri to see if it immediately objects to something :)

22:37 <DominicFischer[m> Ah, I've never used miri, I'll give it a shot

22:47 <DominicFischer[m> <JamesMunns[m]> "you can try running your tests..." <- `cargo miri test` looks clean. Are there any recommended flags I should pass or is the default the strictest?

22:47 <JamesMunns[m]> default is reasonable imo

22:48 <JamesMunns[m]> it's a sanitizer, so it can only call out ub it sees at runtime

22:49 <JamesMunns[m]> but if your basic tests pass, that's a good sign!

23:49 <therealprof[m]> <JamesMunns[m]> "yeah, that tracks" <- The most annoying thing above sigrok is (maybe was) the build process. Now that I mentioned that I'll probably start having nightmares again...