Before you can write LolRust, you must learn to speak it. Before you can speak it, you must understand why it says what it says. These are not arbitrary substitutions. Every keyword is a small theology. Every alias is a window into the nature of cats, and therefore, of programs.
Study them. Internalize them. Then write something that compiles.
The primary act of creation in LolRust is not to define a function, but to declare that it iz. This is not a small distinction. fn main() is bureaucratic. iz main() is ontological. The function does not need to justify its existence — it simply is. Ceiling cat affirms this.
The most important keyword in the language, and the oldest. Before LolRust, before LolCode, before any of this, there was the meme: i can haz cheezburger? A cat asking permission to have something. In LolRust, the question mark is gone. The asking is still there, but the answer is already yes. You can haz. You do haz. This is the binding.
A mutable binding is a wiggly binding. It has not settled into itself yet. It contains the possibility of becoming something else. Cats understand this: the thing you're chasing is only interesting because it moves. i can haz wiggly x = 0 is a declaration that x intends to become more than it currently is. This is ambitious. The compiler respects this.
This is the voice of the program speaking into the world. The exclamation mark, inherited from Rust's macro syntax, perfectly captures the energy of a cat who has something to say and is saying it now, loudly, at 3 AM. meow!("Oh hai world! :3") is hello-world poetry.
When the program needs to speak to stderr — the shadow channel, the error stream, the voice that goes to the wrong place on purpose — it hisses. Not every output is a meow. Some things are hisses. The program knows the difference. You should too.
When the program reaches a state from which there is no return — when the invariant has been violated, when the impossible has occurred, when the cat has knocked the glass off the table and there is no catching it now — the program says ohno! and stops. This is honest. Rust panics are honest. At least we admit what we're doing.
A struct is a collection of fields shaped into a coherent unit. A cat in loaf position — paws tucked, perfectly compact, all edges folded inward — is the same thing. The loaf contains everything. It has fields you can access. It occupies space. You can implement methods on it. So can a cat, depending on the cat.
To implement methods on a struct is to teach the loaf. The loaf does not know how to do things until you teech it. This is correct. Cats are not born knowing how to open cabinets. They learn. They practice. They develop methods. You write those methods in the teech block.
An enum is a type that can be one of several things. Cat treats come in flavors. Your Result comes in flavors: Ok and Err. Your Option comes in flavors: Some and None. flavurz captures this truth without the sterile neutrality of enumeration. These are not values. They are flavors. Some flavors are preferred.
A trait defines what something is capable of. It is not what something is, but what it can do. Cats have skillz: they can knock things off tables, they can ignore you at critical moments, they can generate warmth. A type implementing a trait has skillz. You respect types with skillz.
Pattern matching is how Rust investigates a value: examines it, identifies it, acts accordingly. Cats do this with their noses. They approach the unknown and sniff it until they know what it is. sniff x { ... } is the program pressing its face against a value and determining its nature. Exhaustively. The compiler makes sure you've sniffed every possibility.
Ceiling cat is the observer. Ceiling cat sees all boolean conditions. When you write if ceiling cat sez n % 2 == 0, you are asking ceiling cat whether the number is even, and ceiling cat — from their perch above the ceiling, watching everything — will tell you. Ceiling cat has never been wrong about a boolean expression.
Ceiling cat, having been consulted and found the first condition false, has further observations to offer. Ceiling cat is thorough. Ceiling cat will chain as many conditions as necessary. Ceiling cat does not get tired.
When ceiling cat has exhausted all conditions and none have been true, we descend. Basement cat lives below the floor. Basement cat handles the fallback cases. Basement cat is not evil — merely shadowed. The else branch is where programs go when all other options have failed. Basement cat receives them without judgment.
Zoomies are the sudden, explosive, apparently causeless running that cats do at 2 AM. They do not stop until they decide to stop. There is no external termination condition. The cat simply runs. zoomies { ... } is the infinite loop, and it is the most honest name for it. You will be in this loop forever, unless you flop.
The for loop pursues each element of a collection, one after another, until the collection is exhausted. This is chasing. The cat chases the cursor across the screen, one position at a time, until the cursor disappears. chase n around 1..=100 is a cat pursuing every integer from 1 to 100. The cat is thorough. The cat will catch them all.
You do not chase in a collection. You chase around a collection. The preposition matters. Things move around. Iterators are not static containers — they are trajectories. chase n around items reads correctly because the cat is moving around the items, catching each one as it goes.
The readme says "self-explanatory" and the readme is correct. Keep going. While the thing is true. When it stops being true, stop going. This is the while loop. This does not require elaboration. Even the cat understands this.
After the zoomies, there is the flop. The cat, having expended all energy, simply falls over wherever it is. The loop stops. Execution continues after the loop body. The flop is sudden and unconditional. flop does not apologize for ending the loop. It simply does.
Skip to the next iteration. Don't process the rest of this loop body. Just: again. The cat has already decided. The current mouse is not worth catching. We move to the next mouse. Again.
The function has been holding something this whole time. Now it releases it. This is not a gift — it is an expulsion. The return value comes from inside the function and is deposited, sometimes ungracefully, into the calling scope. Like a hairball. But with type safety. You knew exactly what kind of hairball to expect because the function signature told you.
By default in Rust, things are private. They exist but are not accessible from outside. To make something public is to make it visible to everycat. Everycat can see this function. Everycat can call it. This is a significant decision. Not everything should be visible to everycat. But what is, is.
The import statement is a request. use std::io is formal and distant. gimme std::io is honest. You want it. You're asking for it. You will use it immediately and without shame. gimme makes the dependency relationship visible in the code's emotional texture.
A module is a container. It holds things. It organizes things. You put things in it and then you know where they are. Cats, famously, love boxes. They will get in any box. They will protect the box. They are suspicious of boxes they didn't put themselves in. The module system is a system of boxes, and cats navigate it naturally.
A constant does not change. It was always this value and will always be this value. It is not wiggly. It does not move. It is forever. The compiler will enforce this. You cannot make forever wiggly. You cannot i can haz wiggly forever. Some things are not meant to change, and the compiler knows which ones.
The static cat has claimed this memory location and will not be moved. Not by the garbage collector — there is no garbage collector; this is Rust. Not by the stack frame — the static cat lives in the data segment, which persists for the lifetime of the program. You've seen this cat. You've tried to get them off the keyboard. They are a stickycat. They are not moving.
The unsafe block says: I know what I'm doing. The compiler does not know what I'm doing, so it will not check. I am stepping outside the type system, outside the borrow checker, outside the No Touchie Checker's jurisdiction. This is yolo. The parenthetical is important: cats have nine lives, so they can afford more yolos than most. But the counter is finite. Every yolo block is a withdrawal from the account. Use sparingly. The No Touchie Checker is not your enemy. It is trying to protect you.
An async function does not do the thing when you call it. It creates a promise to do the thing, and then it does the thing later, when you waitforit. This is laziness in the computational sense — deferred evaluation, cooperative multitasking — but also in the feline sense. The cat has been asked to fetch. The cat acknowledges the request. The cat will fetch when the cat is ready. The cat is lazee.
You called the lazee function. You have a future. Now you must wait for it. waitforit suspends your current task until the future resolves. The ellipsis in the readme is accurate — this is genuinely a waiting situation. You sit. You wait. The cat returns. Eventually. The cat always returns.
The move keyword transfers ownership. The closure or thread takes the value. It is no longer yours. It has been yoinked. You cannot use it after the yoink. The borrow checker will tell you this clearly, in the language of errors, but the emotional truth is simpler: yoink. That value is gone. It is in the closure now. The closure is eating it.
This vocabulary is not a replacement for learning Rust. It is a reframing. Every keyword maps exactly. The type system is unchanged. The borrow checker is unchanged. The performance characteristics are unchanged. Only the names have been improved, by making them true.
— Sage, theologian-in-residence