The Rust Programming Language - Understanding Variable Bindings in Rust
In this Rust Programming tutorial, you'll understand Variable Bindings in Rust. Virtually every non-'Hello World’ Rust program uses variable bindings. They bind some value to a name, so it can be used later. let is used to introduce a binding.
Virtually every non-'Hello World’ Rust program uses variable bindings. They bind some value to a name, so it can be used later. let is used to introduce a binding, like this:
fn main() {
let x = 5;
}
Putting fn main() { in each example is a bit tedious, so we’ll leave that out in the future. If you’re following along, make sure to edit your main() function, rather than leaving it off. Otherwise, you’ll get an error.
In many languages, a variable binding would be called a variable, but Rust’s variable bindings have a few tricks up their sleeves. For example the left-hand side of a let statement is a ‘pattern’, not a variable name. This means we can do things like:
# #![allow(unused_variables)]
#fn main() {
let (x, y) = (1, 2);
#}
After this statement is evaluated, x will be one, and y will be two. Patterns are really powerful, and have their own section in the book. We don’t need those features for now, so we’ll keep this in the back of our minds as we go forward.
Rust is a statically typed language, which means that we specify our types up front, and they’re checked at compile time. So why does our first example compile? Well, Rust has this thing called ‘type inference’. If it can figure out what the type of something is, Rust doesn’t require you to explicitly type it out.
We can add the type if we want to, though. Types come after a colon (:):
# #![allow(unused_variables)]
#fn main() {
let x: i32 = 5;
#}
If I asked you to read this out loud to the rest of the class, you’d say “x is a binding with the type i32 and the value 5.”
In this case we chose to represent x as a 32-bit signed integer. Rust has many different primitive integer types. They begin with i for signed integers and u for unsigned integers. The possible integer sizes are 8, 16, 32, and 64 bits.
In future examples, we may annotate the type in a comment. The examples will look like this:
fn main() {
let x = 5; // x: i32
}
Note the similarities between this annotation and the syntax you use with let. Including these kinds of comments is not idiomatic Rust, but we'll occasionally include them to help you understand what the types that Rust infers are.
By default, bindings are immutable. This code will not compile:
let x = 5;
x = 10;
It will give you this error:
error: re-assignment of immutable variable `x`
x = 10;
^~~~~~~
If you want a binding to be mutable, you can use mut:
# #![allow(unused_variables)]
#fn main() {
let mut x = 5; // mut x: i32
x = 10;
#}
There is no single reason that bindings are immutable by default, but we can think about it through one of Rust’s primary focuses: safety. If you forget to say mut, the compiler will catch it, and let you know that you have mutated something you may not have intended to mutate. If bindings were mutable by default, the compiler would not be able to tell you this. If you did intend mutation, then the solution is quite easy: add mut.
There are other good reasons to avoid mutable state when possible, but they’re out of the scope of this guide. In general, you can often avoid explicit mutation, and so it is preferable in Rust. That said, sometimes, mutation is what you need, so it’s not forbidden.
Initializing bindingsRust variable bindings have one more aspect that differs from other languages: bindings are required to be initialized with a value before you're allowed to use them.
Let’s try it out. Change your src/main.rs file to look like this:
fn main() {
let x: i32;
println!("Hello world!");
}
You can use cargo build on the command line to build it. You’ll get a warning, but it will still print "Hello, world!":
Compiling hello_world v0.0.1 (file:///home/you/projects/hello_world)
src/main.rs:2:9: 2:10 warning: unused variable: `x`, #[warn(unused_variables)]
on by default
src/main.rs:2 let x: i32;
^
Rust warns us that we never use the variable binding, but since we never use it, no harm, no foul. Things change if we try to actually use this x, however. Let’s do that. Change your program to look like this:
fn main() {
let x: i32;
println!("The value of x is: {}", x);
}
And try to build it. You’ll get an error:
$ cargo build
Compiling hello_world v0.0.1 (file:///home/you/projects/hello_world)
src/main.rs:4:39: 4:40 error: use of possibly uninitialized variable: `x`
src/main.rs:4 println!("The value of x is: {}", x);
^
note: in expansion of format_args!
<std macros>:2:23: 2:77 note: expansion site
<std macros>:1:1: 3:2 note: in expansion of println!
src/main.rs:4:5: 4:42 note: expansion site
error: aborting due to previous error
Could not compile `hello_world`.
Rust will not let us use a value that has not been initialized.
Let us take a minute to talk about this stuff we've added to println!.
If you include two curly braces ({}, some call them moustaches...) in your string to print, Rust will interpret this as a request to interpolate some sort of value. String interpolation is a computer science term that means "stick in the middle of a string." We add a comma, and then x, to indicate that we want x to be the value we’re interpolating. The comma is used to separate arguments we pass to functions and macros, if you’re passing more than one.
When you use the curly braces, Rust will attempt to display the value in a meaningful way by checking out its type. If you want to specify the format in a more detailed manner, there are a wide number of options available. For now, we'll stick to the default: integers aren't very complicated to print.
Scope and shadowingLet’s get back to bindings. Variable bindings have a scope - they are constrained to live in the block they were defined in. A block is a collection of statements enclosed by { and }. Function definitions are also blocks! In the following example we define two variable bindings, x and y, which live in different blocks. x can be accessed from inside the fn main() {} block, while y can be accessed only from inside the inner block:
fn main() {
let x: i32 = 17;
{
let y: i32 = 3;
println!("The value of x is {} and value of y is {}", x, y);
}
println!("The value of x is {} and value of y is {}", x, y); // This won't work.
}
The first println! would print "The value of x is 17 and the value of y is 3", but this example cannot be compiled successfully, because the second println! cannot access the value of y, since it is not in scope anymore. Instead we get this error:
$ cargo build
Compiling hello v0.1.0 (file:///home/you/projects/hello_world)
main.rs:7:62: 7:63 error: unresolved name `y`. Did you mean `x`? [E0425]
main.rs:7 println!("The value of x is {} and value of y is {}", x, y); // This won't work.
^
note: in expansion of format_args!
<std macros>:2:25: 2:56 note: expansion site
<std macros>:1:1: 2:62 note: in expansion of print!
<std macros>:3:1: 3:54 note: expansion site
<std macros>:1:1: 3:58 note: in expansion of println!
main.rs:7:5: 7:65 note: expansion site
main.rs:7:62: 7:63 help: run `rustc --explain E0425` to see a detailed explanation
error: aborting due to previous error
Could not compile `hello`.
To learn more, run the command again with --verbose.
Additionally, variable bindings can be shadowed. This means that a later variable binding with the same name as another binding that is currently in scope will override the previous binding.
# #![allow(unused_variables)]
#fn main() {
let x: i32 = 8;
{
println!("{}", x); // Prints "8".
let x = 12;
println!("{}", x); // Prints "12".
}
println!("{}", x); // Prints "8".
let x = 42;
println!("{}", x); // Prints "42".
#}
Shadowing and mutable bindings may appear as two sides of the same coin, but they are two distinct concepts that can't always be used interchangeably. For one, shadowing enables us to rebind a name to a value of a different type. It is also possible to change the mutability of a binding. Note that shadowing a name does not alter or destroy the value it was bound to, and the value will continue to exist until it goes out of scope, even if it is no longer accessible by any means.
# #![allow(unused_variables)]
#fn main() {
let mut x: i32 = 1;
x = 7;
let x = x; // `x` is now immutable and is bound to `7`.
let y = 4;
let y = "I can also be bound to text!"; // `y` is now of a different type.
#}
Rust & WebAssembly para JavaScripters
A lo largo de la charla descubriremos las características más destacables de Rust, sus similitudes y diferencias con JavaScript y veremos qué aporta Rust al futuro de la Web gracias a WebAssembly. Rust es un lenguaje tipado, rápido y seguro, que ha sido diseñado por Mozilla como lenguaje de sistemas, aunque en los últimos tiempos ha ganado mucha popularidad en el terreno del desarrollo Web gracias a WebAssembly, su amplio ecosistema y gran comunidad
Rust es un lenguaje tipado, rápido y seguro, que ha sido diseñado por Mozilla como lenguaje de sistemas, aunque en los últimos tiempos ha ganado mucha popularidad en el terreno del desarrollo Web gracias a WebAssembly, su amplio ecosistema y gran comunidad. A lo largo de la charla descubriremos las características más destacables de Rust, sus similitudes y diferencias con JavaScript y veremos qué aporta Rust al futuro de la Web gracias a WebAssembly.
Rust vs. Go: Should I Rust, or Should I Go
Well both Rust and Go provide amazing performance. Should you write you’re next big thing with Rust or with Go? Go is fast and powerful, but it avoids bogging the developer down, focusing instead on simplicity and uniformity. Rust. If on the other hand, wringing out every last ounce of performance is a necessity, then Rust should be your choice. Rust is more of a competitor to C++ than it is with Go.
“Should I stay, or should I go?” Great song by the band The Clash. I’m listening to it, right now, while I’m writing this article. The song debuted back in 1982, a long time ago. Back then, I was just a kid exploring a new hobby — programming my Atari 2600. The first video game I ever wrote was written using 6502 Assembly for that console. The compiler for it cost about $65, if I recall, which at the time equated to mowing ~13 or so lawns.
The game was simple: using the joystick, maneuver your spaceship through a randomly generated scrolling cave. The cave walls were sinusoidal, scrolling vertically on the left and right sides of the screen, and you had to make sure your craft didn’t crash into them. I know, I know: Not that sophisticated. But I was only ten or eleven years old at the time.
Despite the “power” of the processor, computing sine values at run-time was simply too much for it. So, using my handy Texas Instruments calculator, I pre-calculated a bunch of the sine values, carefully writing them down on paper, and then entering them in as constants for the game. This greatly enhanced the performance of the game, and made it usable.
So what’s my point? What’s any of this got to do with Rust or Go?
Today’s languages are far more advanced than 6502 Assembly, which make it easier to write complex programs. It took a lot of my time to write that game, and I could do it much faster today, with less code than I did back then. But which language today provides that magic combination of simplicity and power?
Well both Rust and Go provide amazing performance. They both compile to machine code, the Holy Grail of performance. And with today’s processing power, developers can do amazing things with either of these languages. So the question is: Should you write you’re next big thing with Rust or with Go?
With a quick search, you can easily find several articles that go into detail about the differences between the two languages. But the focus of this article is the bang for the buck, that magic combination of performance per line of code.
To put it another way, where is that sweet spot of simple code and top-end performance? And in this case, is it Rust, or is it Go?
There really isn’t any argument: Rust is faster than Go. In the benchmarks above, Rust was faster, and in some cases, an order of magnitude faster.
But before you run off choosing to write everything in Rust, consider that Go wasn’t that far behind it in many of those benchmarks, and it’s still much faster than the likes of Java, C#, JavaScript, Python and so on. So in other words, it’s almost a wash between Rust and Go on the axis of performance. Now, if what you’re building needs to wring out every last ounce of performance, then by all means, choose Rust. But if what you need is top-of-the-line performance, then you’ll be ahead of the game choosing either of these two languages.
So then we’re down to the complexity of the code. This is where things can be muddy since this can be more subjective than performance benchmarks. Let’s look at a simple exercise: building a small web server that prints out “Hello World” when it receives an HTTP request. To do this in Rust, it looks something like this:
use std::net::{TcpStream, TcpListener};
use std::io::{Read, Write};
use std::thread;
fn handle_read(mut stream: &TcpStream) {
let mut buf = [0u8; 4096];
match stream.read(&mut buf) {
Ok(_) => {
let req_str = String::from_utf8_lossy(&buf);
println!("{}", req_str);
},
Err(e) => println!("Unable to read stream: {}", e),
}
}
fn handle_write(mut stream: TcpStream) {
let response = b"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=UTF-8\r\n\r\n<html><body>Hello world</body></html>\r\n";
match stream.write(response) {
Ok(n) => println!("Response sent: {} bytes", n),
Err(e) => println!("Failed sending response: {}", e),
}
}
fn handle_client(stream: TcpStream) {
handle_read(&stream);
handle_write(stream);
}
fn main() {
let port = "8080";
let listener = TcpListener::bind(format!("127.0.0.1:{}", port)).unwrap();
println!("Listening for connections on port {}", port);
for stream in listener.incoming() {
match stream {
Ok(stream) => {
thread::spawn(|| {
handle_client(stream)
});
}
Err(e) => {
println!("Unable to connect: {}", e);
}
}
}
}
Something pretty similar in Go looks like this:
package main
import (
"fmt"
"io"
"log"
"net/http"
)
type handler struct{}
func (theHandler *handler) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
log.Printf("Received request: %s\n", request.URL)
log.Printf("%v\n", request)
io.WriteString(writer, "Hello world!")
}
const port = "8080"
func main() {
server := http.Server{
Addr: fmt.Sprintf(":%s", port),
Handler: &handler{},
}
server.ListenAndServe()
}
Now, they are not 100% exactly the same, but they are close enough. The difference between them is ~20 lines of code. Rust definitely forces the developer to consider more, and thus write more code than Go.
Another example: Consider one of the more difficult aspects of software development: multi-threading. When tackling something like this, as you undoubtedly would when building an HTTP server, there’s a lot to think about:
- You need to ensure everything you design is thread safe (locks)
- You need to handle communication between threads (channels)
- You have to design with concurrency and parallelism in mind (threads and routines)
Both Rust and Go handle these hurdles really efficiently, but Go requires less effort. With Rust, you have way more options, and thus more power, when spawning threads. Just look at some of the documentation on this. Here’s just one way to spawn a thread in Rust:
use std::thread;
let handler = thread::spawn(|| {
// thread code
});
handler.join().unwrap();
On the other hand, here’s how to create something similar using Go:
go someFunction(args)
Another crucial part of writing code is handling errors. Here I think Rust and Go are quite similar. Rust enables the developer to handle errors cases through the use of the enum return types: Option<T>and Result<T, E>. The Option<T> will return either None or Some(T) whereas Result<T, E> will return either Ok(T) or Err(T). Given that most of Rust’s own libraries, as well as other third-party libraries, return one of these types, the developer will usually have to handle the case where nothing is returned, or where an error is returned.
Here’s a simple example of the Result type being returned by a function in Rust:
fn foo_divide(a: f32, b: f32) -> Result<f32, &'static str> {
if b == 0.0 {
Err("divide by zero error!")
} else {
Ok(a / b)
}
}fn main() {
match foo_divide(5.0, 4.0) {
Err(err) => println!("{}", err),
Ok(result) => println!("5 / 4 = {}", result),
}
}
Notice that the Err case must be handled within the match statement.
Go, on the other hand, leaves this more up to the developer, since errors can be ignored using the _. However, idiomatic Go strongly recommends returning an error, especially since functions in Go can return multiple values. Therefore, it’s easy to have functions return their intended value along with an error, if there is one.
Here is the corresponding example from above done in Go:
func fooDivide(a float32, b float32) (float32, error) {
if b == 0 {
return 0, errors.New("divide by zero error!")
} return a / b, nil
}func main() {
result, err := fooDivide(5, 4)
if err != nil {
log.Printf("an error occurred: %v", err)
} else {
log.Printf("The answer is: 5 / 4 = %f", result)
}
}
Notice that this line:
result, err := fooDivide(5, 4)
could have been written as
result, _ := fooDivide(5, 4)
In the latter case, the error returned would have been ignored.
Honestly, they’re both pretty similar, except for Rust forcing error checking. Otherwise, there’s little difference, and it’s difficult to find an advantage one has over the other. To my eyes, this is a draw.
I could keep going, digging deeper into other language differences. But the bottom line, from threads, to channels, to generics, Rust provides the developer with more options. In this respect, Rust is closer to C++ than Go. Does this make Rust inherently more complex?
I think so, yes.
So here are my recommendations:
- Either. If you’re building a web service that handles high load, that you want to be able to scale both vertically and horizontally, either language will suit you perfectly.
- Go. But if you want to write it faster, perhaps because you have many different services to write, or you have a large team of developers, then Go is your language of choice. Go gives you concurrency as a first-class citizen, and does not tolerate unsafe memory access (neither does Rust), but without forcing you to manage every last detail. Go is fast and powerful, but it avoids bogging the developer down, focusing instead on simplicity and uniformity.
- Rust. If on the other hand, wringing out every last ounce of performance is a necessity, then Rust should be your choice. Rust is more of a competitor to C++ than it is with Go. Having battled with C++, Rust feels just as powerful but with many happy improvements. Rust empowers developers to have control over every last detail of how their threads behave with the rest of the system, how errors should be handled, and even the lifetime of their variables!
- Rust. Rust was designed to interoperate with C. Go can as well, but gives up a lot to achieve this goal, and it’s not really its focus.
- Go. If readability is a requirement, go with Go. It’s far too easy to make your code hard for others to grok with Rust.
I hope you enjoyed reading this!
The Rust Programming Language - Understanding If in Rust
The Rust Programming Language - Understanding If in Rust. Rust’s take on if is not particularly complex, but it’s much more like the if you’ll find in a dynamically typed language than in a more traditional systems language. if is a specific form of a more general concept, the ‘branch’, whose name comes from a branch in a tree: a decision point, where depending on a choice, multiple paths can be taken.
Rust’s take on if is not particularly complex, but it’s much more like the if you’ll find in a dynamically typed language than in a more traditional systems language. So let’s talk about it, to make sure you grasp the nuances.
if is a specific form of a more general concept, the ‘branch’, whose name comes from a branch in a tree: a decision point, where depending on a choice, multiple paths can be taken.
In the case of if, there is one choice that leads down two paths:
# #![allow(unused_variables)]
#fn main() {
let x = 5;
if x == 5 {
println!("x is five!");
}
#}
If we changed the value of x to something else, this line would not print. More specifically, if the expression after the if evaluates to true, then the block is executed. If it’s false, then it is not.
If you want something to happen in the false case, use an else:
# #![allow(unused_variables)]
#fn main() {
let x = 5;
if x == 5 {
println!("x is five!");
} else {
println!("x is not five :(");
}
#}
If there is more than one case, use an else if:
# #![allow(unused_variables)]
#fn main() {
let x = 5;
if x == 5 {
println!("x is five!");
} else if x == 6 {
println!("x is six!");
} else {
println!("x is not five or six :(");
}
#}
This is all pretty standard. However, you can also do this:
# #![allow(unused_variables)]
#fn main() {
let x = 5;
let y = if x == 5 {
10
} else {
15
}; // y: i32
#}
Which we can (and probably should) write like this:
# #![allow(unused_variables)]
#fn main() {
let x = 5;
let y = if x == 5 { 10 } else { 15 }; // y: i32
#}
This works because if is an expression. The value of the expression is the value of the last expression in whichever branch was chosen. An if without an else always results in () as the value.