ALT rust code: ``` fn main() { let x = len([1, 2, 3]); } ```

ALT rust compiler output: ``` error[E0425]: cannot find function `len` in this scope --> /home/gh-compiler-errors/test.rs:3:13 | 3 | let x = len([1, 2, 3]); | ^^^ not found in this scope | help: use the `.` operator to call the method `len` on `&[{integer}]` | 3 - let x = len([1, 2, 3]); 3 + let x = [1, 2, 3].len(); | ```

ALT an anatomical picture of a crab, with a large arrow circling back in itself: the crab cycle -- there is only one step, and it is crab.

ALT Rust code: ``` trait Foo { async fn foo() -> i32; } impl Foo for () { async fn foo() -> i32 { 0 } } fn main() { let _ = <() as Foo>::foo(); } ```

ALT Rust code: ``` trait Trait { fn hello<'a: 'a>(&'a self); } impl Trait for () { fn hello<'b: 'b>(&'b self) { println!("Hello, world"); } } trait Foo { fn bar<'c: 'c>(&'c self) -> impl Trait; } impl Foo for () { fn bar<'d: 'd>(&'d self) -> impl Trait { () } } fn call_generically<T: Foo>(t: T) { t.bar().hello(); } fn main() { call_generically(()); } ```

ALT Terminal output: ``` $ ./test Hello, world ```

ALT Rust code: ``` fn foo<'a>(s: &'a str) -> usize { s.len() } fn main() { let s = "hello, world".to_string(); let x: return#foo(_) = foo(&s); println!("length of {s:?} = {x}"); } ```

ALT Rust code: ``` trait Trait {} struct Foo<T: Trait> { t: T, } fn main() { let _ = Foo { t: () }; } ```

ALT Before: Terminal output ``` $ rustc +nightly ~/test.rs error[E0277]: the trait bound `(): Trait` is not satisfied --> /home/gh-compiler-errors/test.rs:8:13 | 8 | let _ = Foo { t: () }; | ^^^ the trait `Trait` is not implemented for `()` | ```

ALT After: Terminal output ``` $ rustc +dev ~/test.rs error[E0277]: the trait bound `(): Trait` is not satisfied --> /home/gh-compiler-errors/test.rs:8:19 | 8 | let _ = Foo { t: () }; | ^^^^^ the trait `Trait` is not implemented for `()` | ```

ALT Rust error output: ``` error[E0277]: `()` is not an iterator --> /home/gh-compiler-errors/test.rs:2:20 | 2 | Iterator::next(&mut ()); | -------------- ^^^^^^^ `()` is not an iterator | | | required by a bound introduced by this call | = help: the trait `Iterator` is not implemented for `()` error[E0277]: `()` is not an iterator --> /home/gh-compiler-errors/test.rs:2:5 | 2 | Iterator::next(&mut ()); | ^^^^^^^^^^^^^^^^^^^^^^^ `()` is not an iterator | = help: the trait `Iterator` is not implemented for `()` error[E0277]: `()` is not an iterator --> /home/gh-compiler-errors/test.rs:2:5 | 2 | Iterator::next(&mut ()); | ^^^^^^^^^^^^^^ `()` is not an iterator | = help: the trait `Iterator` is not implemented for `()` ```

ALT A rust team sticker that says (with typo) "compilier team". There is an extra "i" in the word compiler. The sticker has a picture of a person dumping raw materials into a machine, and coming out of on a conveyor belt are a line of gears.

ALT picture of myself with orange hair

ALT Terminal output: ``` error[E0529]: expected an array or slice, found `Vec<{integer}>` --> /home/gh-compiler-errors/test.rs:2:9 | 2 | let [..] = vec![1, 2, 3]; | ^^^^ pattern cannot match with input type `Vec<{integer}>` | help: consider slicing here --> /home/gh-compiler-errors/rust2/library/alloc/src/macros.rs:50:36 | 50~ $crate::__rust_force_expr!(<[_]>::into_vec( 51+ #[rustc_box] 52+ $crate::boxed::Box::new([$($x),+]) 53~ )[..]) ```

ALT a picture of me taken in a bathroom mirror, wearing a dangling red crab earring

ALT Rust code: ``` fn a(a: i32, b: (), c: i32) {} fn main() { a(1, 2); } ```

ALT Rust error output: ``` error[E0061]: this function takes 3 arguments but 2 arguments were supplied --> src/lib.rs:6:5 | 6 | a(1, 2); | ^ | note: function defined here --> src/lib.rs:1:4 | 1 | fn a(a: i32, b: (), c: i32) { | ^ ------ ----- ------ help: wrap these arguments in parentheses to construct a tuple | 6 | a(1), (2); | + + ``` Suggesting turning `a(1, 2);` into `a(1), (2);`

ALT a bottle of Arctic Fox branch "sunset orange" hair dye

ALT Rust compiler error message: ``` error[E0283]: type annotations needed | note: multiple `impl`s satisfying `Self: Pack<'a>` found --> /home/gh-compiler-errors/test.rs:1:1 | 1 | pub trait Pack<'a> { | ^^^^^^^^^^^^^^^^^^ ... 4 | Self: for<'x> Pack<'x>; | ^^^^^^^^^^^^^^^^ error: aborting due to previous error ```

ALT A comment that reads: We use a DUMMY_SP here as a way to signal trait bounds that come from the trait itself that *shouldn't* be shown as the source of an obligation and instead be skipped. Otherwise we'd use `tcx.def_span(def_id);` Then a line of rust code that says: `let span = rustc_span::DUMMY_SP;`

ALT Rust code that adds the given note to an error: A constant containing interior mutable data behind a reference can allow you to modify that data. This would make multiple uses of a constant to be able to see different values and allow circumventing the `Send` and `Sync` requirements for shared mutable data, which is unsound.

ALT Rust compiler output: ``` error[E0061]: this function takes 3 arguments but 4 arguments were supplied --> /home/michael/test.rs:6:5 | 6 | foo("hi", 1, 2, "hi"); | ^^^ | help: wrap these arguments in a tuple | 6 | foo("hi", (1, 2), "hi"); | + + error[E0061]: this function takes 3 arguments but 3 arguments were supplied --> /home/michael/test.rs:7:5 | 7 | bar("hi", "hi", "hi"); | ^^^ | help: wrap this argument in a tuple | 7 | bar("hi", ("hi",), "hi"); | + ++ error: aborting due to 2 previous errors ```

ALT Rust source code: ``` fn foo(s: &str, a: (i32, i32), s2: &str) {} fn bar(s: &str, a: (&str,), s2: &str) {} fn main() { foo("hi", 1, 2, "hi"); bar("hi", "hi", "hi"); } ```

ALT A lenovo monitor. On the base is a small red slot, into which an iphone fits almost perfectly when inserted in landscape mode, propping the phone up

ALT A github comment reading "Just getting an idea of the implications of this PR. It LGBT" and it is cut off after that.

ALT a dog looking clueless in a fake chemistry lab setting, with the title "i have no idea what i'm doing"

ALT the word "Documentation", but each character in the word is placed below the previous one (instead of to the right of the previous one, as expected in a Left-to-Right script), except for the characters "ti" which are grouped together as if they were one character.

ALT screenshot of a browser page, a local copy of the rust documentation (similar to https://doc.rust-lang.org/nightly/index.html), but the page is rendered incorrectly: all of the sentences are descending from the top like icicles or rain, instead of left-to-right as expected, and everything is off-center to the right of the page.

ALT Rust code: import std::{io::{self, Write}, rc::Rc}; fn main() { let x = Rc::new(1); let _ = write!(io::stdout(), "{:?}", x); }

ALT a very gnarly end of a coaxial cable, with the backshell crushed slightly and shielding wires frayed

ALT A router speed test showing 1058.55 megabits per second download speed, and 144.54 megabits per second upload. a cellular signal reads 4 out of 5 bars of ultra-wide band 5G connection.

ALT A two-part image: On the first half, a man with a piece of FlexTape is in front of a leak of water from a large tub. The man is labeled "Me" and the leak is labeled "rustc ICEs". On the second frame, there is a close-up of the man is slapping the tape onto the leak, and the tape is labeled "extra normalization calls".

ALT A Rust compiler error message. It is a borrow checker error signalling that a variable named "this" cannot be borrowed mutably more than once. The error message reads literally: ``` error[E0499]: cannot borrow `*this` as mutable more than once at a time --> compiler/rustc_borrowck/src/lib.rs:1119:41 ```

ALT Rust code sample that reads: ```rust #![feature(unsize)] #![feature(ptr_metadata)] use core::fmt::Debug; use core::marker::Unsize; use core::ptr::{self, DynMetadata, Pointee}; fn gimme_the_vtable<T, U: ?Sized>() -> DynMetadata<U> where T: Unsize<U>, U: Pointee<Metadata = DynMetadata<U>>, { (ptr::null::<T>() as *const U).to_raw_parts().1 } fn main() { let t = gimme_the_vtable::<(), dyn Debug>(); println!("{t:?}"); } ```

ALT three crows sitting on top of an apartment building, with the evening sky in the background

ALT san francisco golden gate bridge barely peeking above the fog, reminiscent of an emoji of the same bridge

ALT Code for add and multiply functions in Rust. The code in Rust is: ``` pub fn add(a: usize, b: usize) -> usize { (0..a).chain(0..b).count() } pub fn mul(a: usize, b: usize) -> usize { (0..a).flat_map(|_| (0..b)).count() } ```

ALT Command-line invocation "cargo new --bin quartz", with successful output "Created binary (application) `quartz` package"

ALT Michael (me) has a bright orange sweater on, and has purple hair and headphones on his head

ALT Web page that reads “The Ubuntu Brand Guidelines exist so that we can all communicate Ubuntu with the same precision that we use to make it”, and features colored dots in shades of orange and purple