Integers

Right, arrays. Let’s talk about the workhorse, the trusty (if sometimes rigid) container that you’ll use more often than you’ll check your email. An array is the simplest way to say, “I need exactly N things of exactly the same type, and I want them right next to each other in memory.” It’s a fixed-length, homogeneous collection. Let’s unpack that jargon. Fixed-length means you declare its size upfront and that’s it. No take-backsies. The array’s length is part of its type signature. A [i32; 5] is a completely different and distinct type from a [i32; 6]. This is Rust being its usual brutally honest self with the compiler: it needs to know exactly how much stack space to allocate for your array, and it can’t do that if the size might change.

Right, so you’ve met arrays, which are all about order and homogeneity. A tuple is its delightfully messy cousin: a fixed-size collection where each position can have its own, specific type. It’s the data structure you reach for when you need a quick, lightweight grouping of disparate items without the ceremony of defining a full-blown struct or class. Think of it as a minimalist, type-safe bag for your values. The Anatomy of a Tuple You create a tuple by simply wrapping a comma-separated list of values in parentheses. The magic, and the entire point, is in its type signature. Let’s look at a classic example: a function returning an HTTP status code and a message.

Now, let’s talk about char. You might be coming from a language where a char is a single, lonely byte representing an ASCII character. Rust politely asks you to forget all that. In Rust, a char is not a byte; it’s a Unicode Scalar Value. This is a fancy way of saying it represents a single Unicode code point, and it takes up a full 4 bytes in memory. “Why on earth would you do that, Rust?” I hear you cry. It’s not for fun, I promise. It’s for correctness. By making a char 32 bits wide, Rust can guarantee that every char is a valid, self-contained Unicode value. This completely sidesteps the nightmare of trying to figure out if a byte is part of a UTF-8 sequence or not when you’re just trying to iterate over characters. It’s a bit like using a sledgehammer to crack a nut, but the nut is the entire history of broken text encoding, and the sledgehammer is beautifully designed.

Right, let’s talk about bool. It seems laughably simple, doesn’t it? true or false. One bit. On or off. What could possibly go wrong? Well, my friend, welcome to the wonderfully absurd world of software, where we’ve managed to build entire careers on top of this single, solitary binary decision. At its heart, a boolean is the most fundamental unit of logic in your program. It’s the answer to every yes/no question you will ever ask your code: Is the user logged in? Should this element be visible? Did that horribly complex operation just succeed? It’s the bedrock of every if, while, and for statement you’ll ever write. Getting it right is non-negotiable.

Right, let’s talk about numbers that lie to you. Not maliciously, mind you, but out of sheer, fundamental, mathematical necessity. We’re entering the world of floating-point numbers, and if you think 0.1 + 0.2 == 0.3, prepare to have your entire reality gently, but firmly, corrected. We use them to represent a huge range of values, from the mass of a proton to the national debt, by allowing the decimal point to “float.” Rust gives you two main flavors: f32 (single-precision) and f64 (double-precision). Unless you’re working on a deeply embedded system where every byte counts, just use f64. It’s the default for a reason: it’s double the precision (about 15-16 decimal digits instead of 6-7 for f32) and on modern hardware, the performance difference is often negligible. The extra headache you save yourself from weird precision errors is worth it.

Right, let’s talk about what happens when your integer math goes sideways. You’re probably thinking, “It’s just a number, how bad could it be?” Oh, my sweet summer child. In most languages, this is a silent, catastrophic failure. In Rust, it’s a conversation, and you get to choose how that conversation goes. The core design choice here is brilliant: in development, you want to know immediately when your assumptions are violated. In production, you might need a predictable, if technically wrong, outcome to keep the whole thing from crashing.

Right, let’s talk about how you tell a computer, “Here, have a number.” It seems simple, but like most things in computing, we’ve devised a few different ways to do it, each with its own historical baggage and modern use case. I’m going to show you the whole cast of characters: decimal (our everyday numbers), hex, octal, binary, and the slightly oddball byte literal. Pay attention; this is where a lot of subtle, head-scratching bugs are born.

Alright, let’s talk about the building blocks of numbers in Rust. This isn’t your high school algebra class; we’re dealing with the raw, unforgiving metal of the machine. Rust forces you to be explicit about your numbers because it values correctness over convenience, a trade-off you’ll learn to love (or at least respect). The first thing to know is the great divide: signed and unsigned integers. A signed integer (i8, i16, i32, i64, i128) can be negative, zero, or positive. An unsigned integer (u8, u16, u32, u64, u128) can only be zero or positive. Think of it like a i for “I can be negative” and a u for “uh, only positive, please.” The number (8, 16, 32, etc.) is the size in bits. More bits means you can count higher (or lower, in the case of i types) at the cost of using more memory. This isn’t just pedantry; getting it wrong can lead to catastrophic bugs.

Alright, let’s talk about everyone’s favorite binary decision-makers: Booleans. You’d think a type that can only be true or false would be the simplest thing in the world, a serene island of logic in a chaotic sea of data. And you’d be mostly right, which is why we’re going to spend our time on the weird, murky waters that surround that island—the places where language designers decided to get “creative.”

Right, let’s talk about type conversions. This is where we stop politely asking the compiler to guess what we mean and start telling it exactly what to do. It’s the difference between mumbling an order at a coffee shop and pointing directly at the exact bean, roast, and cup size you want. The latter is less prone to catastrophic, caffeinated error. You’ll want to do this for two main reasons: 1) You need to feed data into a function that demands a specific type, or 2) You’re doing math or concatenation with mixed types and you need to be explicit to avoid the language’s sometimes… creative interpretation of your intentions.

Right, let’s talk about strings. You’ve already seen them: bits of text wrapped in single or double quotes. They’re how we talk to the user and the user talks to us. But sometimes, what you write in your code isn’t exactly what you want in your string. This is where the whole interpreted vs. raw string business comes in, and it’s one of those things that seems trivial until you’re staring at a file path that won’t work or a regex that’s exploded.

Right, let’s talk about strings. You’d think a simple sequence of characters would be the least dramatic part of a programming language, but no. Rust’s strings are a masterclass in forcing you to think correctly about text upfront, saving you from a world of pain later. They are also, and I say this with affection, a bit weird at first glance. The first thing you need to get your head around is that a String in Rust is not an array of characters. It’s not. Stop thinking that. It’s a growable, mutable, owned, UTF-8 encoded byte vector. The &str (pronounced “string slice”) is its immutable, borrowed view into that UTF-8 data. This distinction—String for owning and modifying, &str for borrowing and viewing—is central to everything, and it’s brilliant once it clicks.

Right, let’s talk about byte and rune. These two are the aliases in the room. They don’t introduce new behavior, but they give a massive hint about intent. Using them is like saying, “I’m not just storing a number; I’m storing a meaning.” The Humble byte (a.k.a. uint8) type byte = uint8 — that’s its entire definition. It’s just a friendly, semantic alias for an unsigned 8-bit integer. So why does it exist? Because we constantly deal with 8-bit data. Think about it: raw memory, network packets, and—most importantly—every single element of a slice that makes up a string. Using byte instead of uint8 is you telling everyone (and your future self), “This isn’t just any number from 0 to 255; this is a piece of data.”

Right, complex numbers. You probably remember these from that one math class you took and swore you’d never use again. Well, surprise. They’re not just academic ghosts; they’re the absolute backbone of entire fields like electrical engineering, signal processing, quantum physics, and computer graphics. And Go, being a practical language for building real systems, has them baked right in as first-class citizens. No need to import some clunky external library; they’re just there, waiting for you.

Right, let’s talk about numbers that can’t make up their mind: floating-point numbers. You need them for almost anything interesting—graphics, simulations, science, even just dividing 10 by 3. They’re called “floating-point” because the decimal point can float; the number of digits before and after it isn’t fixed. Go gives you two main flavors: float32 (single-precision) and float64 (double-precision). Unless you’re in a memory-constrained environment (like embedded systems) or working with a specific API that demands them, you should almost always use float64. It’s the default for most literals and it’s what the math package expects. The extra precision and range are worth the trivial memory cost on modern hardware.

Right, let’s talk about integers. You’d think counting would be simple, right? You had it figured out by age three. But here we are, in a language designed by Google engineers, and we have to choose from a whole menu of them. This isn’t over-engineering; it’s a necessary concession to reality. Sometimes you need to save memory, sometimes you need to count to a number so large it would make the national debt blush, and sometimes you need to talk directly to the metal of the machine. Go gives you the tools for all of it.