I have been searching for a simple way to copy loads of text from remote servers for a while. This includes files, but is sometimes also only multiple lines from stdout of a program. Oftentimes this is kinda hard to do in terminal emulators, so I wrote a very small program to copy text via Operating System Commands....
Regarding Cargo.lock, the recommendation always was to include it in version control for application/binary crates, but not library ones. But tendencies changed over time to include it even for libraries. If a rust-toolchain file is tracked by version control, and is pinned to a specific stable release, then Cargo.lock should definitely be tracked too [1][2].
It’s strictly more information tracked, so there is no logical reason not to include it. There was this concern about people not being aware of –locked not being the default behaviour of cargo install, giving a false sense of security/reliability/reproducibility. But “false sense” is never a good technical argument in my book.
Anyway, your crate is an application/binary one. And if you were to not change the “*” dependency version requirement, then it is almost guaranteed that building your crate will break in the future without tracking Cargo.lock ;)
Here is an originally random list (using cargo tree --prefix=depth) with some very loose logical grouping. Wide-scoped and well-known crates removed (some remaining are probably still known by most).
Use Option::ok_or_else() and Result::map_err() instead of let … else.
let … else didn’t always exist. And you might find that some old timers are slightly triggered by it.
Functional style is generally preferred, as long as it doesn’t effectively become a code obfuscater, like over-using Options as iterators (yes Options are iterators).
(Borken sanitization will probably butcher this code, good thing the problem will be gone in Lemmy 0.19)
Three tips here:
You don’t need to annotate the type here because it can be inferred since headers will be returned as a struct field, the type of which is already known.
In this pattern, you should know that you can provide the collected type as a generic param to collect() itself. That may prove useful in other scenarios.
You should know that you can collect to a if the iterator items are Results/Options. So that .unwrap() is not an ergonomic necessity 😉
Minor point
Use .into() or .to_owned() for &str => String conversions.
Again, some pre-specialization old timers may get slightly triggered by it.
make good use of the crate echo system
It’s important to make good use of the crate echo system, and talking to people is important in doing that correctly and efficiently.
This post is a good start.
More specifically, the http crate is the compatibility layer used HTTP rust implementations. Check it out and maybe incorporate it into your experimental/educational code.
Your executor of choice should be doing tokio compat for you, one way or another, so you don’t have to worry about it (e.g. async-global-executor with the tokio feature).
Next Day Edit: Sorry. Forgot to use my Canadian Aboriginal syllabics again. Because apparently it’s too hard to admit HTML-sanitizing source markdown was wrong!
One thing that irks me in these articles is gauging the opinion of the “Rust community” through Reddit/HN/Lemmy😉/blogs… etc. I don’t think I’d be way off the mark when I say that these platforms mostly collectively reflect the thoughts of junior Rustaceans, or non-Rustaceans experimenting with Rust, with the latter being the loudest, especially if they are struggling with it!
And I disagree with the argument that poor standard library support is the major issue, although I myself had that thought before. It’s definitely current lack of language features that do introduce some annoyances. I do agree however that implicit coloring is not the answer (or an answer I want to ever see).
Take this simple code I was writing today. Ideally, I would have liked to write it in functional style:
And done. A productive Rustacean is hardly wasting time on this.
Okay, bool::then() is not the best example. I’m just show-casing that it’s current language limitations, not stdlib ones, that are behind the odd async annoyance encountered. And the solution, I would argue, does not have to come in the form of implicit coloring.
I too love making unaware “Tests Considered Harmful” arguments based on some blind analysis.
Funnily enough, one could easily do some actually potentially useful shallow analysis, instead of a completely blind one, simply by noticing the libc crate dependency, then running:
Ignoring the usage in test modules, use of raw libc appears to be more than you would think from the title. One can also argue that some of that usage would be better served by using rustix instead of raw libc.
Of course authors can counter with arguments why using rustix* is not feasible or would complicate things, and would argue that the use of unsafe+libc is required for this kind of project, and it’s still reasonably limited and contained.
And a little bit more informed back-and-forth discussion can go from there.
Searching for rustix in the sudo-rs repo returned this. So this predictably has been brought up before.
I do, however, hold to the fact that any sudo implementation will be more complicated than doas. Sudo, as a project, has more options and usecases than doas so it also has more posibilities for bugs or misconfiguration for the user.
Fair.
I’m unable to tell what codebase your are refering to with you’re grep arguments, sorry.
I would bad mouth Axum and Actix just because of the overhype. But then, the latter is powering this very platform, and the former is used in the federation crate examples 😉
So let me just say that I tried poem and it got the job done for me. Rusty API. Decent documentation. And everything is in one crate. No books, extension crates, and towers of abstractions needed.
I try to avoid tokio stuff in general for the same reason, although a compatible executor is unfortunately often required.
I have a written a bit of rust by now, but one problem I always seem to encounter it that the features a create supports never seem to be documented. Neither what features are available, what they each do or which are default. Is that really the case, or am I missing something?...
I constantly seem to include something from the docs, only to be told by the compiler that it does not exist, and then I have to open the source for the create to figure out if it’s hidden behind a feature flag.
As others mentioned, the situation is not perfect. And you may need to check Cargo.toml. Maybe even the source.
But as for the quoted part above, the docs should definitely indicate if a part of the API is behind a feature. Let’s take rustix as an example.
Now, it’s true that one could be navigating to method docs in the middle of a long doc page, where those indicators at the top may be missed. But that’s a UI issue. And it could be argued that repeating those indicators over and over would introduce too much clutter.
are there any hurdles or other good reasons to not just adding this to every create?
I’m no expert. But my guess would be that many crate authors may simply not be aware of this feature. It wasn’t always there, and it’s still unstable. You would have to reach the “Unstable features” page of the rustdoc book to know about it.
Or maybe some know about it, but don’t want to use an unstable feature, or are just waiting for it to possibly automatically work without any modifications.
Of course, I would assume none of this applies to the embassy devs. That Cargo.toml file has a flavors field, which is something I’ve never seen before 😉 So, I’m assuming they are way more knowledgable (and up-to-date) about the Rust ecosystem than me.
–all-features doesn’t work with that particular crate because two of the features conflict with each other. The features list in my command is the one used for docs.rs from the crate’s Cargo.toml.
Note: the ᐸᐳ characters used below are Canadian Aboriginal syllabics because Lemmy devs haven’t fixed broken input sanitization yet.
A vec and a string are basically the same thing (a series of bytes)
Everything is a series of bytes! I thought you were going to mention that both are fat pointers. But that “series of bytes” description is quite weird.
This makes handling it much easier because you can still iterate over it
This is not a valid consideration/objection, as Options are iterable and you can flatten them:
<span style="color:#323232;">fn main() {
</span><span style="color:#323232;"> let v = vec![1,2,3];
</span><span style="color:#323232;"> for n in Some(&v).into_iter().flatten() {
</span><span style="color:#323232;"> eprintln!("{n}");
</span><span style="color:#323232;"> }
</span><span style="color:#323232;"> for n in None::ᐸ&Vecᐸi32ᐳᐳ.into_iter().flatten() {
</span><span style="color:#323232;"> eprintln!("{n}");
</span><span style="color:#323232;"> }
</span><span style="color:#323232;">}
</span>
This might involve the compiler making an allocation of an empty array but most of them (gcc, ghc) will now what you are doing and optimize the null check on the empty array to a bool check
This paragraph appears to be out of place in the context of a Rust discussion.
Note: the ᐸᐳ characters used below are Canadian Aboriginal syllabics because Lemmy devs haven’t fixed broken input sanitization yet.
Well, getters are not an official concept in Rust. You can do whatever works best in your case.
Just worth pointing out that a method with a return value of OptionᐸVecᐸStringᐳᐳ wouldn’t be really a getter, as you must be constructing values, or moving ownership, or cloning. None of these actions conceptually belong to a getter.
Also, you should be clear on the what the Option abstraction means. Does it mean the vector is empty? Does it mean the vector does not exist or some sort of null (FFI ore serialization contexts)? And make sure the code does what you expect it to do.
Good choice. Follow it with this Little Book of Rust Macros. And don’t verge into the unsafe stuff early, and don’t verge into it later unless it’s really necessary.
I created rcp, an OSC52 copy tool for your remote server (codeberg.org)
I have been searching for a simple way to copy loads of text from remote servers for a while. This includes files, but is sometimes also only multiple lines from stdout of a program. Oftentimes this is kinda hard to do in terminal emulators, so I wrote a very small program to copy text via Operating System Commands....
What are some useful crates?
I love browsing crates.io and blessed.rs for interesting and useful crates to experiment with. What are your favorite?...
Getting into rust and could use some pointers
Greetings to all....
Hyper v1.0.0 released (crates.io)
Low-level HTTP 1 and 2 processing library “hyper” gets released....
Markdown code blocks are broken
What a hell is going on? I expect to see everything inside backticks exactly as I typed, but something happens to ‘’>" and “...
[help] impl block for generic type overriden by specific type
I want to do basically this:...
Why you might actually want async in your project (notgull.net)
The First Stable Release of a Memory Safe sudo Implementation (www.memorysafety.org)
If you feel that you need a Rust replacement for 'ls', that apparently exists (github.com)
I didn’t know I needed it, but what I know is that I will download it.
Best Rust Web Frameworks to Use in 2023 (www.shuttle.rs)
How can I create a mutable vector singleton?
I’ve been trying to use OneCell, but I keep having errors trying to set it up to handle a mutable vector that I can push to....
What are your favorite Rust-based tools and utilities for the CLI?
Here are mine so far:...
are features never documented
I have a written a bit of rust by now, but one problem I always seem to encounter it that the features a create supports never seem to be documented. Neither what features are available, what they each do or which are default. Is that really the case, or am I missing something?...
What should the getter for a Vec|String| return, &[&str]? What about Option|Vec|String||?
When returning an immutable reference to a private struct field. (On mobile and used vertical bars instead of a bunch of HTML codes)
From C to Rust
Any book out there that can ease me into Rust from C?
Dedicated lemmy instance for rustaceans
Hopefully, I'm not breaking any rules by posting this here!...