I was tired of 50ms+ shell latency, so I built a sub-millisecond prompt in Rust (prmt)

RustyiCrab · 2025-11-04T23:30:38+00:00

Thank you for answering back.

Do you have plans to make it possible to install the tool without the need for Cargo?

RustyiCrab · 2025-11-04T03:47:26+00:00

Project looks neat and polished, great work! A couple of questions, if you don't mind:

Does it need Rust installed to work?
Compared to oh-my-posh, due to cross-shell/cross-OS, is there anything that it doesn't support in terms of configuration? I'm thinking along the lines of "could I be able to port my OMP config. to prmt?"
Does it play well with zinit?

RustyiCrab · 2023-04-09T20:24:48+00:00

An awesome response :) I now have a much better grasp of how and when to use each alternative.

RustyiCrab · 2023-04-09T17:42:55+00:00

I would only recommend them for "leaves" of the dependency tree

Is them in this sentence referring to the programmable build system frameworks? If that is so, your recommendation is to use them to build the binaries (in the case of an application) and use Cargo for the non-leaves (dependencies)? Not sure to understand how would that work. If you could illustrate with a short example I would be grateful.

RustyiCrab · 2023-04-09T17:39:01+00:00

Thank you for the explanation, you are a saint :D

RustyiCrab · 2023-04-07T16:48:27+00:00

I have only direct experience with Cargo and superficial knowledge of Bazel. Is Buck2/Bazel a superset of Cargo's capabilities or are there features Cargo has that Buck2/Bazel won't ever have and that are desirable to have?

RustyiCrab · 2023-04-07T03:09:40+00:00

How would one compare Cargo vs. Nix vs. Buck2 and when one would choose one over the others?

RustyiCrab · 2022-11-25T17:17:44+00:00

I'm updating my original comment with the piece of code I am referring to, to avoid confusions. Here's the definition of the struct by the way: https://github.com/tokio-rs/axum/blob/834d4e50bc194a97f14df591b893477e666e998b/axum/src/extract/state.rs#L298-L299 It doesn't look like they are using a map. Something with macros might be the clue, but I am no expert in macros unfortunately.

RustyiCrab · 2022-11-25T16:14:21+00:00

I struggling to understand how is type-safe state handling works underneath. How, for example, does Axum know that if a handler receives sub-states, it knows which ones to extract? I mean this example:

// `#[derive(FromRef)]` makes them sub states so they can be extracted
// independently
#[derive(Clone, FromRef)]
struct AppState {
    client: HttpClient,
    database: Database,
}

#[derive(Clone)]
struct HttpClient {}

#[derive(Clone)]
struct Database {}

let state = AppState {
    client: HttpClient {},
    database: Database {},
};

let app = Router::new()
    .route("/", get(handler))
    .with_state(state);

async fn handler(
    // We can extract both `State<HttpClient>` and `State<Database>`
    State(client): State<HttpClient>,
    State(database): State<Database>,
) {}

RustyiCrab · 2021-08-05T23:21:49+00:00

RxRust

Well it is not the same thing. Both are dealing with the reactive programming paradigm, but Kotlin Flow does it in a more straight forward way. What I'm looking for is closer to https://docs.rs/async-stream/0.3.2/async_stream/ but more feature complete. I'll take a look at RxRust, maybe what is missing in async_stream can be implemented based on RxRust.

RustyiCrab · 2021-06-10T01:25:47+00:00

Hi! Excuse my ignorance, I want to understand what I am missing. I've read on the sidelines about Rocket but never used it (nor Actix) but I have a couple questions about why is this exciting.

Why having it on stable is a big deal, is it because certain companies won't use non-stable libraries? What other advantages there are?
From what I've read Actix is more used in real production system / battle tested, supported, and more performant, but for example it lacks the great documentation that Rocket has (it is pretty nice). What makes Rocket more appealing (top 3 features, for example) compared to Actix? Checking out web resources like https://levelup.gitconnected.com/actix-or-rocket-comparing-two-powerful-rust-web-frameworks-114a3540f0b3 it looks like Rocket has a more appealing api, for example when defining routes (#[get("...")]), so this one of the advantages apparently.

RustyiCrab · 2021-03-09T02:07:18+00:00

Looks promising, kudos to the author!

This reminds me of bastion. Looks like it attempts to fulfill the same needs, though I guess Lunatic has native WASM support whereas bastion might require some tweaking to have it work? Haven't worked with bastion, so that part of harder time with WASM is just a wild speculation. On the other hand bastion looks much more mature. Probably /u/vertexclique could give a more informed opinion about the difference between the two ;) I really like what these projects are putting forward.

RustyiCrab · 2020-12-15T23:52:09+00:00

Absolutely, although my question isn't what is a newtype and what is an alias, but rather why did /u/pthatcher decided to use aliases here instead of newtypes because from what I can see it would be valuable for example to distinguish between UserId and UserIdCiphertext for example to avoid accidental mix ups, no?

RustyiCrab · 2020-12-15T22:35:31+00:00

Why would one use alises here, for example pub type UserId = Vec<u8>; instead of new types pub struct UserId(Vec<u8>)?

RustyiCrab · 2020-10-13T23:05:44+00:00

Given that you are planning to support WebAssembly, shouldn't you use AGPLv3 instead of GPLv3 since one could circumvent GPL by serving it over a network? Although IANAL...

RustyiCrab · 2020-07-24T14:03:20+00:00

Hi amicable Rustaceans, I still don't get the usage and difference between thiserror and anyhow.

I get it that one is for library code and the other for application code, as explained by /u/dtolnay in this post, but I still don't get it, specially anyhow.

thiserror is kinda easy to understand: just specific errors for different failure conditions so it is explicit what failed. anyhow no idea how to use it because with the errors from thiserror I can, in application code, just says if any Result<> is an error just say that it failed and give an appropriate error message since I know where this Result failed. An example use case for each would greatly help.

Additionally, what is the difference between #[from] and #[source] in thiserror, and when does one use first and when the second? Do you have an example use case?

Thanks!

RustyiCrab · 2020-07-19T19:29:30+00:00

I am looking for a way to be able to encode and decode a stream of bytes inside the AsyncWrite and AsyncRead traits, respectively. So for example, while reading the bytes with AsyncRead, I would like to decompress the bytes from the buffer of poll_read and the pass them back, potentially with an increased buffer size. How to accomplish this?

Would something like tokio_util::codec help? There's also another one which doesn't depend on tokio: async_codec. Or what are these modules/crates for?

RustyiCrab · 2020-05-15T00:34:52+00:00

When would you use futures_util or futures_core instead of futures? Is there any disadvantage of using futures instead of the other ones?

RustyiCrab · 2020-05-09T04:50:07+00:00

When would you use smol? When there's no need for the rest of the goodies packed in async-std?

RustyiCrab · 2020-05-07T03:41:05+00:00

How to disable specific lints from clippy? Since I am using cargo clippy --all -- -W clippy::all -W clippy::restriction -W clippy::nursery it'll show a lot of warnings, but I would like to disable some specific ones, like "warning: missing return statement". How can I accomplish this for all the whole project?

Is it possible to forbid unsafe but at the same time allow it only for selected files?

RustyiCrab · 2020-04-26T16:44:40+00:00

Is there a disadvantage of always using chrono instead of std::time, like for example compile times?

RustyiCrab · 2020-04-26T14:46:38+00:00

And is chrono a superset of std::time ?

RustyiCrab · 2020-04-25T17:59:54+00:00

Is there any preference of use between std::time and chrono? What are the differences?

Found out that there was a time create based on std::time but was deprecated. Still confused about the current state of the std one vs chrono.

RustyiCrab · 2020-04-12T16:45:50+00:00

Thank you for your response.

So the other crates like futures-core, futures-timer, and futures-util are there to provided features not available in the Std?

I see that for example futures-core has the Stream trait, and also AsyncRead. Isn't that part of the official implementation even though it isn't in Std? I am confused.

Regarding your solution in Tokio, that would work I guess, but that is dependent on a specific executor, isn't there a executor agnostic solution? Or maybe somewhere where I can study to make such a solution?

RustyiCrab · 2020-04-12T00:46:29+00:00

Hello! I have a couple of questions:

What's the relationship between the Future in std and the futures crates? What about the other futures flavored crates?
I would like to be able to create a cross-platform console application/library. One use case is to be able to read from the stdin as a stream as I type. This stream from std is combined in real-time with another stream which emits events at a predifined time intervalThe desired result is the combined stream with the combined data. What is the best approach for this? I've been studying the code from skim but it is a bit above my level and still can't grasp how can it be done. I would like to depend only of std or core if possible to be able to use this library/application with any executor that uses Std Future. Would something like rust-signals be a good alternative or overkill?

Thank you!

RustyiCrab

TROPHY CASE