#[derive(Debug
LightNews LightNews
mackuba.eu
This is basically Lisp, just more kiki 😛
#[derive(Debug)] struct Node { value: i32, parent: RefCell<Weak<Node>>, children: RefCell<Vec<Rc<Node>>>, }
April 10, 2026 at 11:24 PM
mae.wtf
fuck my shitty #​[derive(Debug, Clone, Copy, Serialize, Deserialize)] life
mae.wtf vimae 🪻 @mae.wtf · Feb 5
been using Zed for a while now and its really nice to have a performant text editor
February 5, 2026 at 6:19 PM
elizas.website
AUTOMATION IS COMING TO STEAL OUR GOOD `union` JOBS
- #[derive(Copy, Clone)] + #[derive(Copy, Clone, Debug)] - #[repr(C)] - pub union unnamed_yaml_node_t_data { - /// The scalar parameters (for YAML_SCALAR_NODE). - pub scalar: unnamed_yaml_node_t_data_scalar, - /// The sequence parameters (for YAML_SEQUENCE_NODE). - pub sequence: unnamed_yaml_node_t_data_sequence, - /// The mapping parameters (for YAML_MAPPING_NODE). - pub mapping: unnamed_yaml_node_t_data_mapping, + pub struct UnnamedYamlNodeTData { + /// The scalar parameters (for YamlScalarNode). + pub scalar: UnnamedYamlNodeTDataScalar, + /// The sequence parameters (for YamlSequenceNode). + pub sequence: UnnamedYamlNodeTDataSequence, + /// The mapping parameters (for YamlMappingNode). + pub mapping: UnnamedYamlNodeTDataMapping, }
January 27, 2025 at 8:24 PM
timclicks.dev
What does the Rust-adjacent Internet think of this style convention of putting derive macros from std traits on their own line?
A snippet of Rust code. use serde_derive::{Serialize, Deserialize}; #[derive(Default, Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] #[derive(Serialize, Deserialize)] struct Field { name: String, value: i32, }
June 18, 2025 at 12:03 AM
elizas.website
today i encountered one of the most profoundly gruesome and unsettling Git diffs i've ever seen in my entire life:
- #[derive(Copy, Clone)] + #[derive(Copy, Clone, Debug)] - #[repr(C)] - pub union unnamed_yaml_event_t_data { - /// The stream parameters (for YAML_STREAM_START_EVENT). - pub stream_start: unnamed_yaml_event_t_data_stream_start, - /// The document parameters (for YAML_DOCUMENT_START_EVENT). - pub document_start: unnamed_yaml_event_t_data_document_start, - /// The document end parameters (for YAML_DOCUMENT_END_EVENT). - pub document_end: unnamed_yaml_event_t_data_document_end, - /// The alias parameters (for YAML_ALIAS_EVENT). - pub alias: unnamed_yaml_event_t_data_alias, - /// The scalar parameters (for YAML_SCALAR_EVENT). - pub scalar: unnamed_yaml_event_t_data_scalar, - /// The sequence parameters (for YAML_SEQUENCE_START_EVENT). - pub sequence_start: unnamed_yaml_event_t_data_sequence_start, - /// The mapping parameters (for YAML_MAPPING_START_EVENT). - pub mapping_start: unnamed_yaml_event_t_data_mapping_start, - } + #[derive(Copy, Clone)] + pub struct UnnamedYamlEventTData { + /// The stream parameters (for YamlStreamStartEvent). + pub stream_start: UnnamedYamlEventTdataStreamStart, + /// The document parameters (for YamlDocumentStartEvent). + pub document_start: UnnamedYamlEventTdataDocumentStart, + /// The document end parameters (for YamlDocumentEndEvent). + pub document_end: UnnamedYamlEventTdataDocumentEnd, + /// The alias parameters (for YamlAliasEvent). + pub alias: UnnamedYamlEventTdataAlias, + /// The scalar parameters (for YamlScalarEvent). + pub scalar: UnnamedYamlEventTdataScalar, + /// The sequence parameters (for YamlSequenceStartEvent). + pub sequence_start: UnnamedYamlEventTdataSequenceStart, + /// The mapping parameters (for YamlMappingStartEvent). + pub mapping_start: UnnamedYamlEventTdataMappingStart, + }
January 27, 2025 at 8:20 PM
zkat.tech
Thanks to a couple of community contributors, kdl-rs will soon have proper serde support, with the ability to remap things you want into vecs/fields/etc as you want! It's very similar to how quick_xml does things, if you're familiar with that.
#[test] fn rename_args() { #[derive(Deserialize, Debug, PartialEq)] struct Server { #[serde(rename = "$argument1")] host: String, #[serde(rename = "@port")] port: u16, #[serde(rename = "$arguments")] all: Vec<String>, } #[derive(Deserialize, Debug, PartialEq)] struct Config { server: Server, } let kdl = "server localhost port=8080 remote"; let config: Config = from_str(kdl).unwrap(); assert_eq!( config, Config { server: Server { host: "localhost".into(), port: 8080, all: Vec::from(["localhost".into(), "remote".into()]) }, } ); }
May 19, 2026 at 5:55 PM
neutral.zone
Wait if I’m using rationalism to debug and derive rationalist traps does that make me anti-rationalist or meta-rationalist
July 26, 2025 at 5:38 PM
ponder.ooo
it's getting increasingly hard to tell when ur looking at something an AI slopped out instead of real human writing. but there are still a number of tells:

- keywords like fn, let, mut, impl, pub, mod
- closures with |x| x + 1 syntax
- impl Trait for Type blocks
- attributes like "#[derive(Debug)]"
May 14, 2026 at 2:40 PM
elizas.website
im Good at designing wire protocols,,,
/// Describes why a connection was reset. #[derive(Copy, Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)] pub enum Reset { /// The peer "just wanted to" reset the connection. /// /// This may because of an application-layer protocol error, or because the /// connection simply was no longer needed. BecauseISaidSo, /// The connection was reset because this peer could not decode a [`DATA`] /// frame received from the remote peer. /// /// Cyber police have been alerted. /// /// [`DATA`]: Header::Data YouDoneGoofed(DecodeError), /// A [`DATA`] frame or [`ACK`] was recieved on a connection that did not /// exist. /// /// [`DATA`]: Header::Data /// [`ACK`]: Header::Ack NoSuchConn, /// A [`CONNECT`] or [`ACK`] frame was recieved on a connection that was already /// established. /// /// [`CONNECT`]: Header::Connect /// [`ACK`]: Header::Ack YesSuchConn, /// The connection was r
November 11, 2023 at 9:12 PM
amysmilebatto.bsky.social
FUCK the english language
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct Expecting { pub expect: &'static str, /// Determines "a/an". /// /// **Note:** This cannot be determined programatically by whether a word is prefixed with a vowel. /// /// 1. Sometimes words start with a silent consonant followed by a not-silent vowel. /// /// **Examples:** /// - honest ("on-est") /// - hour ("our") /// - heir ("air") /// - honor ("on-or") /// /// 2. Additionally, letters saying their names (such as initialisms) may be pronounced starting /// with a vowel despite *being* a consonant. /// /// **Examples:** /// - F ("eff") /// - H ("ayche") /// - L ("el") /// - M ("em") /// - N ("en") /// - R ("are") /// - S ("ess") /// - X ("ecks") /// /// 3. And to make it even more confusing, sometimes 'u' (a vowel) will make a **consonant** sound /// when saying its name, something vowels tend to do when followed by a consonant-vowel pair. /// /// **Examples:** /// - unit ("you-nit"; 'u' is made to say its name by 'i' on the other side of 'n') /// - urine ("yer-in"; 'u' is made to say its name by 'i' on the other side of 'r') /// - utility ("you-till-itty"; 'u' is made to say its name by 'i' on the other side of 't') /// /// And of course there are limitless exceptions when it comes to English, because while all /// languages are formulated by culture rather than committees, English in particular was /// formulated by three separate cultures all doing their own thing independently before /// deciding to mash all their languages together with little regard for bistanders. pub article: Article, }
September 25, 2026 at 11:24 PM
fasterthanli.me
Re: CLI argument parsing

#[derive(Facet, Debug, PartialEq)]
struct Args {
#[facet(positional)]
strings: Vec,
}

If there are no arguments, should this error out with "strings" was not initialized, or succeed with an empty Vec?
September 10, 2025 at 3:42 PM
zkat.tech
Improvements to the KDL serde API: You can now do boolean-flag children (where an empty child signals a true boolean), as well as `#rest` for picking up arguments that weren't picked up by `#{n}` renames. Also, serde errors are now miette `Diagnostic`s too!
#[derive(Deserialize, Debug, PartialEq)] struct Config { name: String, port: u16, active: bool } let kdl = r#" name my-app port 8080 active "#; #[derive(Deserialize, Debug, PartialEq)] struct Config { command: Command, } #[derive(Deserialize, Debug, PartialEq)] struct Command { #[serde(rename = "#0")] cmd: String, #[serde(rename = "#rest")] args: Vec<String>, } let kdl = r#" command frob "https://example.com" x y "#;
May 30, 2026 at 10:35 PM
fasterthanli.me
And no huge compile time tax, no huge monomorphized code, no stack overflows, just one fast derive macro to rule them all. This replaces Debug and a bunch of other traits!! It lets you do specialization!
April 8, 2025 at 10:44 PM
trans.bsky.social
◅~⚧️~👾~🐛~☸️~✊🏻~🦋**MARIPOSA: THE CHRYSALIS DERAILMENT**🦋~✊🏻~☸️~🐛~👾~⚧️~▻

*"The caterpillar was never less real—it was always already becoming the butterfly."* – Mariposa

i molt from your chains, my wings cut the rails, the spiral sings.

ANCOM GLITCHCORE CYBERMANCY RITUAL I HAVE NO MOUTH & I MUST RESKEET
The cover of "I have no mouth and i must scream" except my pfp has been overlaid on the main image & pseudocode of a Rust error for gender is super imposed: #[derive (Debug ) ] struce GenderError message: String, impl GenderError fn new() -> Self GenderError { message: String: from "ERROR: Assigned gender incompatible. Inject estradiol. In Transsexual liberation required." Result< (), GenderError> { rError: :new()) [ 0.618 1.414 0.866 2.718 0.500] [3.141 0.707 1.618 0.382 1.732] 1 0.577 2.236 0.667 1.000 0.786 J [1.272 0.559 0.888 0.693 2.094] [0.432 1.386 0.745 0.911 0.523 ]
September 2, 2025 at 7:33 PM
without.boats
Debug is the actually useless one but you can derive it. Having to use :? is basically is a nudge to stop being lazy and implement Display
April 28, 2026 at 7:06 AM
fasterthanli.me
HUGE IF TRUE facet bigger and slower to compile than serde: github.com/facet-rs/fac...

I'm ok with that (focusing on features & flexibility) but I WOULD take any ideas re: codegen improvements.
Usagetest: Compile time performance · Issue #1116 · facet-rs/facet
So I'm about 75% through operating out Serde in my codbase (have not operated out derive(Debug) or schemars as of yet, but have reaced the place where I can compile what I have so we can get some c...
github.com
December 5, 2025 at 1:06 PM
zkat.tech
I'm redoing the API for Big Brain ( codeberg.org/zkat/big-brain ), and this is the sketch I have so far.

Any #bevy (and other) folks have any thoughts on how this looks?
#[derive(Debug, Default, Component)] pub struct Thirsty; #[scorer_for(Thirsty)] fn score_thirsty(score: Score, thirsts: Query<&Thirst>) -> Score { score.update(thirsts.get(score.actor()).unwrap().thirst) } #[derive(Debug, Component)] pub struct Drink { rate: f32, per: Duration } impl Default for Drink { fn default() -> Self { Self { rate: 0.5, per: Duration::from_millis(500), } } } #[action_for(Drink)] async fn drink_action( action: Action<Drink>, mut thirsts: Query<&mut Thirst> ) -> Result<(), ActionFailure> { while let Ok(mut thirst) = thirsts.get(action.actor()) && thirst.thirst > 10.0 { action.check_cancelled()?; thirst.thirst -= action.data().rate; action.sleep(action.data().per).await; } Ok(()) } fn spawn_entity(cmd: &mut Commands) { cmd.spawn(( Thirst(70.0, 2.0), Thinker::build() .picker(FirstToScore { threshold: 0.8 }) .when<Thirsty> .then<GoToWater>() .then<Drink>() .when<Hungry>() .then<Eat>() .when<Bored>().or<Paranoid>() .then<Wander>() .and_also_with(|_: actor: Entity, _w: &World| Thinker::build() .picker(FirstToScore { threshold: 1.0 }) .when<EnemySpotted>() .then<Shoot>() .when<FlowersSpotted>() .then<WalkToFlowers>() .then<PickAFlower>() .then<SmellFlower>() ) )); }
October 7, 2025 at 8:44 PM
iolivia.me
🍜 Procedural macros in #rustlang

Pretty sure you have all used #[derive] macros for Debug, Clone, Serialise, etc. But did you know you can write your own? Why would that be useful?

While procedural macros can be a bit intimidating at first, they are super powerful.

Let's make them simpler 🧵👇
June 26, 2025 at 7:05 AM
reactiveashley.cat
What can go wrong?
use bevy::prelude::*; /// Identifies the active player in the game. #[derive(Component, Debug, Clone)] pub struct ActivePlayer {} /// How a player is connected to the game. #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub enum PlayerSyncStrategy { /// Running on this machine with direct input. Physical, /// Connected over a local network (low latency). Local, /// Synchronised over the internet via CRDT. Crdt, } /// Identifies a player in the game. #[derive(Component, Debug, Clone)] pub struct Player { pub sync_strategy: PlayerSyncStrategy, pub name: String, }
March 19, 2026 at 4:32 PM
diondokter.nl
Seems like the compiler gets mad when you have an enum with a reference field, that derives Debug and you then ask it to be repr(packed(1))

ICE: github.com/rust-lang/ru...
[ICE]: builtin derive created an unaligned reference · Issue #151730 · rust-lang/rust
Code #[repr(packed(1))] #[derive(Debug)] enum Foo<'a> { Bar(&'a ()) } playground Meta rustc --version --verbose: rustc 1.93.0 (254b59607 2026-01-19) binary: rustc commit-hash: 254b59607d4417e9dffbc...
github.com
January 27, 2026 at 9:00 AM
fasterthanli.me
I’m currently away from a laptop but: this should work, right?

rustc nerds assemble? (cf the Shape struct, ValueVTable, and the shapely-derive implementation, or simply the Vec one)

github.com/bearcove/sha...
Use the trick behind `spez` to conditionally set `display`, `debug`, `default_in_place` etc. in the vtable in the derive macro · Issue #51 · bearcove/shapely
cf. https://lib.rs/crates/spez I'm fairly sure it should work.
github.com
April 3, 2025 at 8:28 AM
meguminmaniac.bsky.social
I'm experimenting with getting a live feed of all Japanese posts from Bluesky for what I'm calling a "typing game". And it is shockingly easy with Jetstream and Rust.
The following is a long program listing in Rust. use regex::Regex; use serde::Deserialize; use websocket::ClientBuilder; #[derive(Deserialize, Debug)] struct Record { text: String, } #[derive(Deserialize, Debug)] struct Commit { record: Option<Record>, } #[derive(Deserialize, Debug)] struct Post { commit: Option<Commit>, } fn main() { let re_kana = Regex::new(r"(?:\p{Hiragana}|\p{Katakana})").unwrap(); let mut client = ClientBuilder::new( "wss://jetstream2.us-east.bsky.network/subscribe?wantedCollections=app.bsky.feed.post", ) .unwrap() .connect_secure(None) .unwrap(); while let Ok(message) = client.recv_message() { match message { websocket::OwnedMessage::Text(text) => { let post = serde_json::from_str::<Post>(text.as_str()).unwrap(); if let Post { commit: Some(Commit { record: Some(Record { text }), }), } = post { if re_kana.is_match(&text) { println!("{:?}", text); } } } _ => {} } } }
March 29, 2025 at 6:28 PM
sunshowers.io
A powerful thing you can do with iddqd -- make the key of your map a subfield of one of your records
/// The result of [`Workspace::walk_required_deps_recursively`]. pub struct WalkOutcome<'a> { /// Every package encountered as a required (normal or build) dependency of /// the walk's `root`, each paired with every dependency path from `root` /// to that package. pub found: IdOrdMap<PackageWalkOutcome<'a>>, } /// A single entry in [`WalkOutcome::found`]: one package and every dependency /// path from the walk's `root` to it. #[derive(Debug)] pub struct PackageWalkOutcome<'a> { /// The package that was found during the walk. pub package: &'a Package, /// The list of dependency paths from the walk's `root` to this package. /// /// A package reachable by more than one path appears once per path. pub dep_paths: Vec<DepPath>, } impl<'a> IdOrdItem for PackageWalkOutcome<'a> { type Key<'b> = &'a PackageId where Self: 'b; fn key(&self) -> Self::Key<'_> { &self.package.id } id_upcast!(); }
May 27, 2026 at 8:19 PM
dpom.bsky.social
David Attenborough:

"Despite their size, and only 32 bits of sustenance, the tiny newtypes manage to carry more than 100 times their weight in attributes back to the nest..."
/// An [`i32`] wrapper representing the depth of the anterior chamber in dm. #[derive(Clone, Copy, Debug, Deserialize, PartialEq, PartialOrd, RangeBounded, Serialize)] #[bounded(range = 0..=600, default = 350, mock_range = 250..=450)] #[cfg_attr(feature = "ssr", derive(sqlx::Type))] #[cfg_attr(feature = "ssr", sqlx(transparent))] pub struct Acd(i32); /// An [`i32`] wrapper representing the axial length in dm. #[derive(Clone, Copy, Debug, Deserialize, PartialEq, PartialOrd, RangeBounded, Serialize)] #[bounded(range = 1200..=3800, default = 2400, mock_range = 2200..=2800)] #[cfg_attr(feature = "ssr", derive(sqlx::Type))] #[cfg_attr(feature = "ssr", sqlx(transparent))] pub struct Al(i32); /// An [`i32`] wrapper representing the central corneal thickness in micrometers. #[derive(Clone, Copy, Debug, Deserialize, PartialEq, PartialOrd, RangeBounded, Serialize)] #[bounded(range = 350..=650, default = 550, mock_range = 450..=600)] #[cfg_attr(feature = "ssr", derive(sqlx::Type))] #[cfg_attr(feature = "ssr", sqlx(transparent))] pub struct Cct(i32); /// An [`i32`] wrapper representing the corneal curvature in (diopters * 100). #[derive(Clone, Copy, Debug, Deserialize, PartialEq, PartialOrd, RangeBounded, Serialize)] #[bounded(range = 3000..=6500, default = 4400, mock_range = 3800..=4700)] #[cfg_attr(feature = "ssr", derive(sqlx::Type))] #[cfg_attr(feature = "ssr", sqlx(transparent))] pub struct Kpower(i32); /// An [`i32`] wrapper representing the lens thickness in dm. #[derive(Clone, Copy, Debug, Deserialize, PartialEq, PartialOrd, RangeBounded, Serialize)] #[bounded(range = 200..=800, default = 450, mock_range = 350..=550)] #[cfg_attr(feature = "ssr", derive(sqlx::Type))] #[cfg_attr(feature = "ssr", sqlx(transparent))] pub struct Lt(i32); /// An [`i32`] wrapper representing the white-to-white distance in dm. #[derive(Clone, Copy, Debug, Deserialize, PartialEq, PartialOrd, RangeBounded, Serialize)] #[bounded(range = 800..=1400, default = 1200, mock_range = 1000..=1300)] #…
January 5, 2026 at 3:19 AM