I don’t have anything to add, except that typst is awesome. And that ‘accessibler’ should be a word.

I did fill out the survey. Turns out I don’t have a usecase for any of this, and therefore I’m in the “don’t care” realm really, since I’m also not really appreciative of corresponding features in other languages I know. I’d generally be critical of the cost vs. gain balance here though…

And it really only concerns a certain subset - 32bit applications compiled with the gnu toolchain. I’m glad they keep the workload in check this way.

Huh? I might be misunderstanding something (maybe a joke, even!), but this is my lemmy account, that’s kinda older indeed. How would that be connected to my mastodon account?

Huh haven’t heard of this for quite some time, nice it’s still going strong :)

I hope this is the first of many contributions we’ll have between the two projects and that we can continue to collaborate with and help each other.

Great to hear!

I wasn’t on X, but now I’ve created a mastodon account :)

Man, I’d love that, if only the pay was better… but than again, if the pay was better I’d be even less qualified. But typst is awesome, all the best wishes for the team including the new hire :)

Oh yeah, the docs even mention Unblock<Stdin> explicitely. Thanks a lot!

Yeah that looks fine, thanks! It would introduce a new dependency (async_io) though, so I might go with Unblock mentioned above. Let’s see what happens when I try to make the switch :)

(e) Ah I don’t think this really works, I’d need to wrap it in an Async, but the docs explicitely mention not to use that with Stdin: https://docs.rs/smol/latest/smol/struct.Async.html#supported-types. Unblock it is then :)

unsafe does not disable the borrow checker. It does however give you abilities to circumvent it, namely by letting you dereference pointers, which are not subject to the borrow checker.

Sure, but isn’t this in a dependency? Can’t be reached when only importing your crate anyways? And if you’re building a binary, I don’t think this could really considered exported, is what I mean :)

Actually, dead code eliminination should do the trick, if you’re compiling a binary at least (same for a library I think, but there could be re-exports there). Did you compile in release mode?

Huh, I did not know that you can speed up builds by stripping debug info, need to try that out :)

Yeah I was very happy to find that out. I was calling latex externally before, and there was a lot of pain interacting with the filesystem and temporary files. Now it all happens in-memory :)

One thing that prevents me from letting users build their own templates is the scripting capabilities. A joker creating an endless loop could block the whole server.

I know little about servers, but can’t you run the generation in a thread with a timeout or so? Or maybe compile to wasm and let the generation run on the users machines? I also know little about wasm, but I’d have guessed it has facilities to keep runtime and load under control.

What would be nice is a “safe” mode in which no access to the file system (include and sorts) and limited runtime makes it safe to let users build their own templates.

Ah, are you by chance shelling out to the typst binary? You can actually use typst as a library, and then you’ve got full control over the files involved, so it’s “safe” in that respect.

That might indeed be the case, I did not look very closely, but mlua has gotten quite some coverage (and I do like lua quite a bit), so I wanted it mentioned :)

Seems to be missing mlua at least: https://github.com/mlua-rs/mlua

transitive performance benefits

I would have assumed the benchmark suite accounts for that, otherwise the results aren’t quite as meaningfull really. Which ties back you your 2nd senctence: I certainly trust the rust team more than myself on these things :)

only affect very select use cases

I did not read the whole conversation, but sorting seems a very common usecase (not mine, but seems to me a lot of people sort data), so this seems quite a broad improvement to me.

that is already perceived as a pain point

Note though, as is mentioned in the issue, that the survey showed people still prioritize runtime performance over compilation performance in general, so this tradeoff seems warranted.

the total regression is still minor

It’s not unheard of that regressions can be unmade later on, so here’s hoping :)

The post mentioned that the introduction of these new algorithms brings compile-time improvements too, so how should I see this?

I assume you mean the first post of the PR? I’d assume it’s simply outdated (or might not have been true to begin with). See https://github.com/rust-lang/rust/pull/124032#issuecomment-2181789935 for the perf run with this PR, it’s showing quite a bit of regression.