Rust Programming
This release contains numerous bug fixes and minor improvements. Thanks to Kalcifer for reporting many of these. - LaTeX formatting is now supported to handle mathematics (thanks Silver-Sorbet) - The editor now has a live preview of rendered markdown - Better layout for edit history - Fixed user links in edit history - Edits are now correctly sorted by date - Removed maximum width for page - Render markdown titles smaller than page title - Disable markdown plugins for url shortening and smartquotes - Resize article edit input based on length [More details and download](https://github.com/Nutomic/ibis/releases/0.1.2)
(I'm just starting off with rust, so please be patient) Is there an idiomatic way of writing the following as a one-liner, somehow informing rustc that it should keep the `PathBuf` around? ```rust // nevermind the fully-qualified names // they are there to clarify the code // (that's what I hope at least) let dir: std::path::PathBuf = std::env::current_dir().unwrap(); let dir: &std::path::Path = dir.as_path(); // this won't do: // let dir = std::env::current_dir().unwrap().as_path(); ``` I do understand why rust complains that "temporary value dropped while borrowed" (I mean, the message says it all), but, since I don't really need the `PathBuf` for anything else, I was wondering if there's an idiomatic to tell rust that it should extend its life until the end of the code block.
Rust ownership is a fundamental part of the language. I’ve summarized the basic concepts here as a learning exercise for myself. I’m sharing this to gather feedback, corrections, and suggestions. Feel free to offer improvements wherever needed!
We also have documentation to setup the dev environment: https://join-lemmy.org/docs/contributors/02-local-development.html If you have questions, feel free to ask here, in the relevant issue or in [matrix](https://matrix.to/#/#lemmydev:matrix.org).
Which of these code styles do you find preferable? First option using mut with constructor in the beginning: ```rust let mut post_form = PostInsertForm::new( data.name.trim().to_string(), local_user_view.person.id, data.community_id, ); post_form.url = url.map(Into::into); post_form.body = body; post_form.alt_text = data.alt_text.clone(); post_form.nsfw = data.nsfw; post_form.language_id = language_id; ``` Second option without mut and constructor at the end: ```rust let post_form = PostInsertForm { url: url.map(Into::into), body, alt_text: data.alt_text.clone(), nsfw: data.nsfw, language_id, ..PostInsertForm::new( data.name.trim().to_string(), local_user_view.person.id, data.community_id, ) }; ``` You can see the full PR here: https://github.com/LemmyNet/lemmy/pull/5037/files
link to crate : [https://crates.io/crates/st7567_rs](https://crates.io/crates/st7567_rs)
Rust Project goals for 2024 https://blog.rust-lang.org/2024/08/12/Project-goals.html cc: @rust@lemmy.ml
[\#rust](https://emacs.ch/tags/rust) folks it's supposed to throw this error without `lazy_static` crate , but it doesn't? [https://git.sr.ht/\~carnotweat/morning-rust/tree/main/item/sum.rs#L14](https://git.sr.ht/~carnotweat/morning-rust/tree/main/item/sum.rs#L14) cc [@rust](https://lemmy.ml/c/rust) [@learningrustandlemmy](https://lemmy.ml/c/learningrustandlemmy)
cross-posted from: https://lemmy.world/post/18129059 > This feels like it should already be a feature in a terminal. But I didn't find anything that let me do this efficiently. > > I had a rust library for converting list like `1-4,8-10` into vectors, but thought I'd expand it into a command line command as well, as it is really useful when I want to run batch commands in parallel using templates. > > I wanted to share it since it might be a useful simple command for many people.
Hi all, mpv communities seem to be tiny in lemmy, so I'm sharing it here. This is a program I made for music control from local network. You can run it in a computer with some local media files, or youtube links or any other links yt-dlp supports. And then with the server, you can control the media player and the playlist from any devices in your local network. So that you can just show a QR code or something to house guests for parties, or have it bookmarked within family to control the music. I wanted to make something similar to how youtube app let's you play in TV and such, but my skills were not enough to do that. So I tried a simple alternative that works with computers. In an ideal world, I could make "Play with local mpv server" option come while on other android apps, but I have zero experience in android app development and it looks complicated. I know some other programs also give option to control media, but I wanted to give it a go with a simple implementation. Making the web-server was a tricky part. Only tutorial from the rust book was useful here as every other web server developement in rust seems to be async ones using libraries so I would have to make a complicated system to communicate with the mpv. Using the simple Tcp connection let me make a thread with mpv instance in the scope. I do need to support https and file uploads and other things, but I haven't had any luck finding a solution that works with simple Tcp connection like in the tutorial. Let me know if you know anything. Github: https://github.com/Atreyagaurav/local-mpv
For context, I am using the libraries bevy and print_typewriter. I noticed that before the program even starts, I am able to type in characters. This is bad, since when I ask for the user's input, the previous characters are included inside of it. How do I make sure that only the user's input after the program starts, and after I print a question gets in?
In which BurntSushi does date/time handling. [Reddit discussion](https://www.reddit.com/r/rust/comments/1e929gb/jiff_is_a_new_datetime_library_for_rust_that/), [HN discussion](https://news.ycombinator.com/item?id=41031037). > Before someone asks: > > - [Comparison with other Rust datetime crates](https://docs.rs/jiff/latest/jiff/_documentation/comparison/index.html) > - [Why build another datetime library?](https://docs.rs/jiff/latest/jiff/_documentation/design/index.html#why-build-another-datetime-library) > - [Why not contribute to an existing library instead of building a new one?](https://docs.rs/jiff/latest/jiff/_documentation/design/index.html#why-not-contribute-to-an-existing-library-instead-of-building-a-new-one)
This would entail: - Pulling in the [ClearUrls rules](https://github.com/ClearURLs/Rules) as a git submodule. - Reading / transforming the json there into Rust structs. - Creating a Rust crate that runs a `.clean(input_url) -> String` Lemmy issue: https://github.com/LemmyNet/lemmy/issues/4905
> - Added type `diesel_async::pooled_connection::mobc::PooledConnection` > - MySQL/MariaDB now use `CLIENT_FOUND_ROWS` capability to allow consistent behaviour with PostgreSQL regarding return value of `UPDATe` commands. > - The minimal supported rust version is now 1.78.0 > - Add a `SyncConnectionWrapper` type that turns a sync connection into an async one. This enables SQLite support for diesel-async > - Add support for `diesel::connection::Instrumentation` to support logging and other instrumentation for any of the provided connection impls. > - Bump minimal supported `mysql_async` version to 0.34 > > A special thanks goes to [@momobel](https://github.com/momobel) and [Wattsense](https://www.wattsense.com/) for contributing the `SyncConnectionWrapper` implementation. > > To support future development efforts, please consider [sponsoring me on GitHub](https://github.com/sponsors/weiznich/). > > Full Changelog: [`v0.4.0...v0.5.0`](https://github.com/weiznich/diesel_async/compare/v0.4.0...v0.5.0)
It's less than two weeks until our next Rust and NixOS meetup in Mannheim, Germany. We're meeting on the 16th of July at the Mafinex technology center close to the main station. If you want to join us, please sign up for the event on Mobilizon (no account required) or Meetup.com. https://rheinneckar.events/events/9d740b89-7713-4e19-a112-45aff1670f0f https://www.meetup.com/hackschool-rhein-neckar/events/301504325/ As first talk, we will hear Andre Dossinger on "Using NixOS for Pragmatical Self-hosting", where he will show us how NixOS can be used in a problem oriented manner to preserve privacy and make complex setups manageable. Questions and discussions are highly encouraged! Then, we will hear Benjamin Sparks on "Reading from Streams and Writing to Sinks" using Rust and Tokio, with a focus on low runtime overhead, safe buffer management, and robust error handling. He will show us the types and traits Tokio leverages to efficiently decode bytes and encode structured data in a type-safe manner is presented, and give us a practical demonstration of codecs for two different protocols. Finally, Stefan Machmeier of the EMCL at Heidelberg University will give us an introduction to Nix Flakes, the experimental dependency management system built into Nix since version 2.4 that can be used for reusable Nix libraries as well as your own Nix packages and NixOS configurations. The talks will be recorded and uploaded after the meetup.
cross-posted from: https://programming.dev/post/16349359 > July 2, 2024 > > [Sylvain Kerkour](https://kerkour.com/) writes: > > > Rust adoption is stagnating not because it's missing some feature pushed by programming language theory enthusiasts, but because of a lack of focus on solving the practical problems that developers are facing every day. > > > > ... no company outside of AWS is making SDKs for Rust ... it has no official HTTP library. > > > > As a result of Rust's lack of official packages, even its core infrastructure components need to import hundreds of third-party crates. > > > > - cargo imports over 400 crates. > > > > - crates.io has over 500 transitive dependencies. > > > > ...the offical libsignal (from the Signal messaging app) uses 500 third-party packages. > > > > ... what is really inside these packages. It has been found last month that among the 999 most popular packages on crates.io, the content of around 20% of these doesn't even match the content of their Git repository. > > > > ...how I would do it (there may be better ways): > > > > A stdx (for std eXtended) under the rust-lang organization containing the most-needed packages. ... to make it secure: all packages in stdx can only import packages from std or stdx. No third-party imports. No supply-chain risks. > > [stdx packages to include, among others]: > > > gzip, hex, http, json, net, rand > > Read [Rust has a HUGE supply chain security problem](https://kerkour.com/rust-supply-chain-security-standard-library) > > --- > ### Submitter's note: > > I find the author's writing style immature, sensationalist, and tiresome, but they raise a number of what appear to be solid points, some of which are highlighted above.
gamedev.rs
The June edition of "This Month in Rust GameDev" has [just landed!](https://gamedev.rs/news/052). With it, we have also added the option to subscribe to the newsletter by email. You can find the subscription form by scrolling down on https://gamedev.rs/. This is also your call for submissions! Got a game you're tinkering on? A crate for fellow game devs? Do you want to share a tutorial you've made? Are you excited about a new feature in your favorite engine? Share it with us! You can add your news [to this month's WIP newsletter](https://github.com/rust-gamedev/rust-gamedev.github.io/edit/source/content/news/053/index.md) and mention [the current tracking issue in your PR](https://github.com/rust-gamedev/rust-gamedev.github.io/issues/1547) to get them included. We will then send out the newsletter at the start of next month. Happy coding 🌟
Have been struggling to find some nice Rust wallpapers, so I decided to make one for myself. On the left is Ferris on a canvas. On the right is Corro the unsafe Rusturchin. (The contrast between safe (art-like) and unsafe Rust is supposed to be the joke here.) Edit: The original image is 1080p. I got the drawings of Ferris and Corro from [rustacean.net](https://rustacean.net/)
cross-posted from: https://lemmy.ml/post/17090149 > Hi! I've created a CLI tool for downloading Rust web books (like The Rust Programming Language) as EPUB, so that you can easily read them on your e-book reader. The tool is heavily based on [this gist](https://gist.github.com/peterbartha/54708ae739478a45b52612311d49717c) and a lot of proompting. > > Check it out here: https://github.com/mawkler/rust-book-to-epub
cross-posted from: https://programming.dev/post/15696807 > That was a hard long adventure, massive refactoring with bug-fixing 🥵
So, apparently the chrome/geckodriver processes will terminate on their own if the user sends ctrl+c to the console. It will *not* terminate on its own if the program finishes running naturally. If you're interested in terminating it on your own, like I also was, here is how I went about it. ``` use std::process::{Child, Command}; fn main() { let mut s = Server::default(); s.start(); s.shutdown(); } struct Server { child: Option<Child> } impl Default for Server { fn default() -> Self { Self { child: None } } } impl Server { fn start(&mut self) { self.child = Some(Command::new("./chromedriver") .spawn() .expect("ls command failed to start")); } fn shutdown(&mut self) { input(None); // wait for input so you can observe the process self.child.as_mut().unwrap().kill(); self.child.as_mut().unwrap().wait(); println!("shutdown"); } } pub fn input(prompt: Option<String>) { let mut input = String::new(); match prompt { Some(prompt) => println!("{}", prompt), None => () } io::stdin().read_line(&mut input).expect("Failed to read input"); } ```
The May edition of "This Month in Rust GameDev" has [just landed!](https://gamedev.rs/news/051). With it, we also released a [statistical analysis](https://gamedev.rs/blog/survey-02/) of the survey we ran last month. Thank you very much to the 52 readers who gave us their feedback on how to improve the newsletter! You rock! This is also your call for submissions. Got a game you're tinkering on? A crate for fellow game devs? Do you want to share a tutorial you've made? Are you excited about a new feature in your favorite engine? Share it with us! You can add your news [to this month's WIP newsletter](https://github.com/rust-gamedev/rust-gamedev.github.io/edit/source/content/news/052/index.md) and mention [the current tracking issue in your PR](https://github.com/rust-gamedev/rust-gamedev.github.io/issues/1523) to get them included. We will then send out the newsletter at the start of next month. Happy coding ✨
I’m wondering if anyone knows knows of something like [stylelint](https://stylelint.io) written in rust? I’ve done some searching but can’t find it, but I feel like it must exist in some form. I’m switching over to [Biome](https://github.com/biomejs/biome) from eslint due to the massive speed improvements and I want to do the same with stylelint.
The autocompletion works (mostly) but for example Vec::new() doesn't highlight anything at all. I do get errors when not putting a semicolon, but things like passing too many arguments into the println macro doesn't throw an error. Or how shown in this example, it did not autocomplete the clone method, while also just accepting .clo; at the end of a String (it also didn't autocomplete "String"). In the video I show how it also gives me a recommendation for setting vec![] as a type, which doesn't make any sense. It only seems to a very limited selection of methods and some words I already used in the script. Is this how it's supposed to be, or do I have some very old version perhaps? EDIT: Look in description for the fix
cross-posted from: https://slrpnk.net/post/9960845 > Hello Lemmy! Yesterday I released the first version of an alternative frontend for Threads: Shoelace. It allows for fetching posts and profiles from Threads without the need of any browser-side JavaScript. It's written in Rust, and powered by the spools library, which was co-developed between me and my girlfriend. Here's a quick preview: > >  > >  >  > > The official public instance (at least for now) is located at https://shoelace.mint.lgbt/, if y'all wanna try it out. There's also instructions to deploy it inside the docs you can find in the README. Hope y'all enjoy it!
rustc will use rust-lld by default on x86_64-unknown-linux-gnu on nightly to significantly reduce linking times.
I’m working on a big project in #Rust, there is toolset and API for #Playdate. All going great, moving to stabilization step by step, but I’m tired of looking at the dull 90⭐️. Seriously, could you please throw me into the trends of the github, please! ❤️🔥 [Project repository](https://a.koz.world/playdate), [mastodon](https://gamedev.social/@playdaters).
The April edition of "This Month in Rust GameDev" has [just landed!](https://gamedev.rs/news/050/). You may have noticed that this marks the first release since quite a while. To revive the newsletter, we made some [organisational changes](https://gamedev.rs/blog/newsletter-changes/). We want to continue improving the project, so we've put together a [survey](https://forms.gle/oeSb46twWsxRKYJe7) for you to tell us how the newsletter should evolve. We'd be happy if you filled it out and / or shared it with your fellow game devs 🙂 This is also your call for submissions for [May's edition!](https://github.com/rust-gamedev/rust-gamedev.github.io/issues/1505) Happy coding ✨
I just released v0.1.0 of hinoki, my static site generator :)\ The `README.md` should explain usage, and you can also see how I ported my blog to it [here](https://github.com/jplatte/blog.turbo.fish/commit/c11e40699a59b178a84b829efe9e6556175d3ade). This project started because I'm not entirely happy with Zola, which does not support customizing page paths much (e.g. `/year/month/day/title/index.html` style paths) and made some other design decisions that I wanted to explore alternatives to. You can download the binary from GitHub releases, or `cargo install` it from git. Any feedback is appreciated, here or in the GitHub issues!
The Rust gamedev working group's newsletter ["This Month in Rust GameDev"](https://gamedev.rs/) has been rebooted, starting this April 🎉 This is your call for submissions. Got a game you're tinkering on? A crate for fellow game devs? Do you want to share a tutorial you've made? Are you excited about a new feature in your favorite engine? Share it with us! You can add your news [to this month's WIP newsletter](https://github.com/rust-gamedev/rust-gamedev.github.io/edit/source/content/news/050/index.md) and mention [the current tracking issue in your PR](https://github.com/rust-gamedev/rust-gamedev.github.io/issues/1474) to get them included. We will then send out the newsletter at the start of next month. Happy coding!
https://doc.rust-lang.org/book/ links to a site that's charging an absurd $40 for ebook format. Where can we download it for free?
So I want to update the sprite so my character looks in a different direction each time the player presses left/right, how could I do this? I can't do it in the setup fn, since it's a startup system, appreciate any help EDIT: changed formating here is my code: ``` use bevy::prelude::*; `fn main() { App::new() .add_plugins(DefaultPlugins.set(ImagePlugin::default_nearest())) // prevents blurry sprites .add_systems(Startup, setup) .add_systems(Update, animate_sprite) .add_systems(Update, player_movement_system) .run(); } const BOUNDS: Vec2 = Vec2::new(1200.0, 640.0); static mut FLIP_BOOLEAN: bool = false; fn set_flip_boolean(boolean: bool) { unsafe { FLIP_BOOLEAN = boolean; } } fn get_flip_boolean() -> bool{ unsafe { FLIP_BOOLEAN } } #[derive(Component)] struct Player { movement_speed: f32, } #[derive(Component)] struct AnimationIndices { first: usize, last: usize, } #[derive(Component, Deref, DerefMut)] struct AnimationTimer(Timer); fn animate_sprite( time: Res<Time>, mut query: Query<(&AnimationIndices, &mut AnimationTimer, &mut TextureAtlas)>, ) { for (indices, mut timer, mut atlas) in &mut query { timer.tick(time.delta()); if timer.just_finished() { atlas.index = if atlas.index == indices.last { indices.first } else { atlas.index + 1 }; } } } fn setup( mut commands: Commands, asset_server: Res<AssetServer>, mut texture_atlas_layouts: ResMut<Assets<TextureAtlasLayout>>, ) { let texture = asset_server.load("sprites/Idle01.png"); let layout = TextureAtlasLayout::from_grid(Vec2::new(64.0, 40.0), 5, 1, None, None); let texture_atlas_layout = texture_atlas_layouts.add(layout); let animation_indices = AnimationIndices { first: 0, last: 4 }; let boolean = get_flip_boolean(); commands.spawn(Camera2dBundle::default()); commands.spawn(( SpriteSheetBundle { texture, atlas: TextureAtlas { layout: texture_atlas_layout, index: animation_indices.first, }, ..default() }, Player { movement_speed: 500.0, }, animation_indices, AnimationTimer(Timer::from_seconds(0.1, TimerMode::Repeating)), )); } fn player_movement_system( time: Res<Time>, keyboard_input: Res<ButtonInput<KeyCode>>, mut query: Query<(&Player, &mut Transform)>, ) { let (guy, mut transform) = query.single_mut(); let mut movement_factor = 0.0; let mut movement_direction = Vec3::X; if keyboard_input.pressed(KeyCode::ArrowLeft) { movement_factor -= 1.0; movement_direction = Vec3::X; set_flip_boolean(true); } if keyboard_input.pressed(KeyCode::ArrowRight) { movement_factor += 1.0; movement_direction = Vec3::X; set_flip_boolean(false); } if keyboard_input.pressed(KeyCode::ArrowUp) { movement_factor += 1.0; movement_direction = Vec3::Y; } if keyboard_input.pressed(KeyCode::ArrowDown) { movement_factor -= 1.0; movement_direction = Vec3::Y; } let movement_distance = movement_factor * guy.movement_speed * time.delta_seconds(); let translation_delta = movement_direction * movement_distance; transform.translation += translation_delta; let extents = Vec3::from((BOUNDS / 2.0, 0.0)); transform.translation = transform.translation.min(extents).max(-extents); } ```
Been working on this a few months. It's inspired by previous generations of parser generators, and by my own previous work generating ast lexers from grammar files. This integrates seamlessly with the type system, allowing you to declare your syntax, extract only the data you want as variables, and evaluate them easily. And just from a simple description of your syntax, you'll get beautiful errors which visually point out structures in the input. With this I have been able to implement a (mostly complete) JSON parser in just 12 lines of parsing logic, and a pmdas-respecting expression parser in just 6 (with one helper function to apply individual operators). Examples available on the github repo, also now available on crates.io!