サクサク読めて、アプリ限定の機能も多数!
トップへ戻る
Pixel 9
blog.yoshuawuyts.com
Extending Rust's Effect System — 2024-02-09 introduction rust without generics why effect generics? stage i: effect-generic trait definitions stage ii: effect-generic bounds, impls, and types what are effects? stage iii: more effects outro This is the transcript of my RustConf 2023 talk: "Extending Rust's Effect System", presented on September 13th 2023 in Albuquerque, New Mexico and streamed onli
What is WASI? — 2023-06-02 introduction what is webassembly? bytecode, webassembly, and the jvm what are webassembly components? what is wasi? categorizing webassembly iterating on wasi the future of wasi conclusion appendix a: terminology cheat sheet Introduction Now that the final touches are being put on the second version of WASI (WASI Preview 2), I figured now might be a good time to write a
Pattern Extensions — 2023-05-26 shapes of types pattern initializers pattern matching pattern types the "is" keyword on product patterns on string patterns conclusion Microsoft Build is happening this week, and with it come new announcements for the C# language and dotnet runtime. I was watching the video: "What's new in C#12 and beyond", and the C# team talked about pattern matching and pattern c
Rust should own its debugger experience — 2023-01-12 introduction integration done right debuggers today towards a coherent experience conclusion Introduction 40% of Rust Developers believe Rust's debugging experience could use improvement. And that's not surprising: when we write code we make assumptions, and sometimes we assume wrong. This leads to bugs, which we then track down and fix. This is
Why Async Rust — 2022-09-26 language hierarchy async under the hood rust's async features ad-hoc cancellation ad-hoc concurrency combining cancellation and concurrency performance: workloads performance: optimizations ecosystem conclusion A lot of system design is about thinking of the nature of the domains we encounter. And only later, once we understand them, encoding this understanding in a way
State Machines II: an enum-based design — 2022-08-23 the case for state machines representing state machines in rust in the future ergonomics: overview ergonomics: merging self-types ergonomics: merging return types tying it together conclusion In the past I've written about state machines in Rust. And more recently I've also written about anonymous enums 1 in Rust. I've been wondering what would
optimizing hashmaps even more — 2021-05-08 hashmaps and hashing algorithms enums as keys static strings as keys hybrid static + dynamic keys looking ahead conclusion In our last post we took a look at possible ways we could improve the ergonomics of Rust's refcounting APIs. In this post we'll be looking at Hashmap: how it's currently implemented, how we could optimize it further, and finally direc
State Machines: Introduction — 2020-03-30 what are state machines? state machines in rust today future directions conclusion Every now and then I like to think about topics that don't directly relate to my daily work. One of those topics has been parsers: back in January I wrote about byte-ordered stream parsing and how I think we can improve streaming parsing in Rust with a small set of API addit
Error Handling Survey — 2019-11-13 introduction libraries error-chain failure context-attribute err-derive auto_enums snafu fehler anyhow thiserror std::error::error features returning result from main error-based assertions causes backtraces creating errors from strings early returns with string errors context on result custom errors other / miscellaneous try blocks verbose io errors error pointe
There's quite a bit to unpack here. Let's dig in! duplex duplex is always implemented using AsyncRead + AsyncWrite. This is not unlike other languages. A key difference, however, is that using Rust's trait system we can evade multiple inheritance problems that plague some other languages. Examples of duplex streams include sockets and files. through through streams are implemented using either Asy
Runtime — 2019-04-16 our north star runtime today attributes runtimes bindings conclusion Asynchronous programming in Rust continues to make exciting strides, including the upcoming stabilization of the futures API. But, while these core APIs make it possible to write async Rust code today, it's not easy: it's a far cry from the smoothness of synchronous code. The vision of the Async Ecosystem WG
このページを最初にブックマークしてみませんか?
『Yoshua Wuyts — Blog』の新着エントリーを見る
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く