Download to read offline
![String string = "Hello";
int[] arr = {1, 2, 3};
List<Integer> list = Arrays.asList(1, 2, 3);
let i: i32 = 123;
let l: i64 = 456;
let f: f32 = 0.5;
let d: f64 = 0.5f64;
let string: &str = "Hello";
let arr: [i32; 3] = [1, 2, 3];
let list: Vec<i32> = vec![1, 2, 3];
InRust,numericliteralscanoptionallyhaveatypesuffix,forexample1000u32 or0.5f64.
Mutability
Variablesneedtobeexplicitlydeclaredmutable(let versus let mut),likeinJavaScript
(const and let)orKotlin(val and var).
ThemutabilitymodelinRustisnotlikeJavaScript,butabitmorelikeconstinC++,asRust
willnotletyoucallmodifyingmethodsonavariablewhichisnotdeclaredasmutable.
let arr1: string[] = [];
arr1.push("123"); // OK
arr1 = ["a", "b"]; // OK
const arr2: string[] = [];
arr2.push("123"); // OK, even though arr2 is const
arr2 = []; // error, arr2 is const
let mut arr1 = vec![];
arr1.push("123"); // OK
arr1 = vec!["a", "b"]; // OK
let arr2 = vec![];
arr2.push("123"); // error, arr2 is not mutable
arr2 = vec![]; // error, arr2 is not mutable
InTypeScript,declaringavariableasconst onlypreventsreassignment,notmodification.InRust,only
variablesdeclaredasmut canbemodified
Destructuring
Rust
TypeScript
Rust
↑](https://image.slidesharecdn.com/rustforprofessionals-230103014500-bf7c6cd4/85/Rust-for-professionals-pdf-3-320.jpg)
![fn add(a: i32, b: i32) -> i32 {
a + b
}
NotethatthereisnosemicolonintheRustfunction,otherwiseitwouldreturnvoid
Rustcurrentlyhasnonamedargumentsordefaultarguments(likePythonandTypeScript)
anddoesnotallowmethodoverloading(likeC++,JavaorTypeScript).
Innerfunctions
Rustalsosupportsinnerfunctions.
const RE = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/;
function isValidRange(start, end) {
function isValid(date) {
return date && date.match(RE);
}
return isValid(start) && isValid(end);
}
use regex::Regex;
const RE: &str = r"^[0-9]{4}-[0-9]{2}-[0-9]{2}$";
fn is_valid_range(start: &str, end: &str) -> bool {
fn is_valid(date: &str) -> bool {
!date.is_empty()
&& Regex::new(RE)
.unwrap()
.is_match(date)
}
is_valid(start) && is_valid(end)
}
NotethatRegex isanexternalcrateandnotpartofRust’sstandardlibrary
Extensionmethods
Rust(likeKotlin)alsosupportsextensionmethods,sothepreviousexamplecouldbe
rewrittenusingextensions.
typealias Range = Pair<String, String>
fun Range.isValid(): Boolean {
val (start, end) = this
Rust
JavaScript
Rust
Kotlin
↑](https://image.slidesharecdn.com/rustforprofessionals-230103014500-bf7c6cd4/85/Rust-for-professionals-pdf-5-320.jpg)
![};
println!("using log level {}", level);
level
}
TheRustcodeusesmatch,whichislikeswitch inJavaorJavaScriptexceptthatit’sanexpressionand
providesmoreflexibility.Unlessmanyotherlanguages,Rustallowsvariableshadowingforlocalvariables
(level inthisexample)
Structs(classes)
RustdoesnothavefullsupportforclasseslikeJavaorTypeScript,butinsteadoffersstructs
(similartostructsinC).Thesearelikedatacontainerswithmethods,buttheydon’tsupport
alloftheobjectorientedconcepts,likeinheritance.
public class HttpClient {
private final ClientImpl clientImpl;
public HttpClient() {
clientImpl = new ClientImpl();
}
public String get(String url) {
return clientImpl.newRequest()
.get(url).asString();
}
}
public static void main(String[] args) {
HttpClient httpClient = new HttpClient();
System.out.println(httpClient
.get("https://example.com/"));
}
pub struct HttpClient {
client_impl: ClientImpl,
}
impl HttpClient {
pub fn new() -> HttpClient {
HttpClient {
client_impl: ClientImpl {},
}
}
pub fn get(&self, url: &str) -> String {
self.client_impl.new_request()
Java
Rust
↑](https://image.slidesharecdn.com/rustforprofessionals-230103014500-bf7c6cd4/85/Rust-for-professionals-pdf-8-320.jpg)
![impl Named for User {
fn name(&self) -> &String {
return &self.name;
}
}
Rustismostlyastaticlanguage,sosomethingsthatotherlanguagewilldoduringruntime,
Rustwilldoduringcompiletime,whenpossible.Interfacesareusuallyusedfordynamic
dispatchandifyouwanttousetraitsinasimilarway,seethischapteraboutstaticand
dynamicdispatchandthisblogpost.
Defaultmethods
Traitsalsosupportdefaultmethods,likeinterfacesinJavaorKotlin.
Associatedfunctions
InRust,traitscanalsohaveassociatedfunctions,forexample from_str in
std::str::FromStr (sectionstringparsingintheRustCookbook)
interface FromList<T> {
fun fromList(list: List<Int>): T?
}
data class MyPoint(val x: Int, val y: Int) {
companion object : FromList<MyPoint> {
override fun fromList(list: List<Int>):
MyPoint? {
return when (list.size) {
2 -> MyPoint(list[0], list[1])
else -> null
}
}
}
}
object Main {
@JvmStatic
fun main(args: Array<String>) {
val point = MyPoint.fromList(listOf(100, 200))
println(point)
}
}
trait FromList<T> {
fn from_list(list: &Vec<i32>) -> Option<T>;
}
struct MyPoint {
Kotlin
Rust
↑](https://image.slidesharecdn.com/rustforprofessionals-230103014500-bf7c6cd4/85/Rust-for-professionals-pdf-10-320.jpg)
![x: i32,
y: i32,
}
impl FromList<Self> for MyPoint {
fn from_list(list: &Vec<i32>) -> Option<Self> {
match list.len() {
2 => Some(MyPoint {
x: list[0],
y: list[1],
}),
_ => None,
}
}
}
fn main() {
let point =
MyPoint::from_list(&vec![100, 200]).unwrap();
println!("({}, {})", point.x, point.y);
}
FormoreinformationabouttheOption type,seetheNullvaluessectionbelow.ThekeywordSelf (upper
case)canbeusedtoreferencethecurrenttype
Enums
Rustsupportsenums,likeJavaorKotlin,butwithmoreflexibility.TheRustenumsoffermore
thaninC++orTypeScript,astheyarenotmerelyalistofconstants,butmorelikeunions.
enum UserRole {
RO("read-only"), USER("user"),
ADMIN("administrator");
private final String name;
UserRole(String name) {
this.name = name;
}
String getName() {
return name;
}
boolean isAccessAllowed(String httpMethod) {
switch (httpMethod) {
case "HEAD":
case "GET":
return true;
Java
↑](https://image.slidesharecdn.com/rustforprofessionals-230103014500-bf7c6cd4/85/Rust-for-professionals-pdf-11-320.jpg)
![case "POST":
case "PUT":
return this == USER || this == ADMIN;
case "DELETE":
return this == ADMIN;
default:
return false;
}
}
}
class Main {
public static void main(String[] args) {
UserRole role = UserRole.RO;
if (role.isAccessAllowed("POST")) {
System.out.println("OK: "
+ role.getName());
} else {
System.out.println("Access denied: "
+ role.getName());
}
}
}
#[derive(PartialEq)]
enum UserRole {
RO,
USER,
ADMIN,
}
impl UserRole {
fn name(&self) -> &str {
match *self {
UserRole::RO => "read-only",
UserRole::USER => "user",
UserRole::ADMIN => "administrator",
}
}
fn is_access_allowed(
&self,
http_method: &str,
) -> bool {
match http_method {
"HEAD" | "GET" => true,
"POST" | "PUT" => {
*self == UserRole::USER
Rust
↑](https://image.slidesharecdn.com/rustforprofessionals-230103014500-bf7c6cd4/85/Rust-for-professionals-pdf-12-320.jpg)
![|| *self == UserRole::ADMIN
}
"DELETE" => *self == UserRole::ADMIN,
_ => false,
}
}
}
fn main() {
let role = UserRole::RO;
if role.is_access_allowed("POST") {
println!("OK: {}", role.name());
} else {
println!("Access denied: {}", role.name());
}
}
Rustdoesnotsupportconstantsinenums,soweneedtouseamatchinthename method.Theenum
matchesarecheckedatcompiletime,sowhenallenumvariantsareused,thereisnoneedtohavea
defaultbranch.
Formoreinformationaboutthe#[derive(PartialEq)] line,seethesectionaboutAttributes
Associatedvalues
Rustenumsalsosupportassociatedvalues,whichmeanstheyarenotconstant,butinstead
allowthecreationofenumvariantinstanceswithspecificvalues.
sealed class GitCommand {
abstract fun execute()
}
object Status : GitCommand() {
override fun execute() =
executeCommand(listOf("status"))
}
class Checkout(
private val branch: String
) : GitCommand() {
override fun execute() =
executeCommand(listOf("checkout", branch))
}
class Add(
private val files: List<String>
) : GitCommand() {
override fun execute() =
executeCommand(listOf("add") + files)
}
Kotlin
↑](https://image.slidesharecdn.com/rustforprofessionals-230103014500-bf7c6cd4/85/Rust-for-professionals-pdf-13-320.jpg)
![class Log(
private val decorate: Boolean,
private val patch: Boolean
) : GitCommand() {
override fun execute() {
val args = mutableListOf("log")
if (decorate) {
args.add("--decorate")
}
if (patch) {
args.add("--patch")
}
executeCommand(args)
}
}
fun executeCommand(args: List<String>) {
val redirect = ProcessBuilder.Redirect.INHERIT
ProcessBuilder(listOf("git") + args)
.redirectInput(redirect)
.redirectOutput(redirect)
.redirectError(redirect)
.start()
.waitFor()
}
object Main {
@JvmStatic
fun main(args: Array<String>) {
val command =
Log(decorate = false, patch = true)
command.execute()
}
}
use std::process::Command;
pub enum GitCommand<'g> {
STATUS,
CHECKOUT(&'g str),
ADD(Vec<&'g str>),
LOG { decorate: bool, patch: bool },
}
impl<'g> GitCommand<'g> {
fn execute(self) {
let args: Vec<&str> = match self {
GitCommand::STATUS => vec!["status"],
GitCommand::CHECKOUT(branch) => {
vec!["checkout", branch]
Rust
↑](https://image.slidesharecdn.com/rustforprofessionals-230103014500-bf7c6cd4/85/Rust-for-professionals-pdf-14-320.jpg)
![}
GitCommand::ADD(files) => {
[vec!["add"], files].concat()
},
GitCommand::LOG {
decorate,
patch,
} => {
let mut args = vec!["log"];
if decorate {
args.push("--decorate")
}
if patch {
args.push("--patch")
}
args
}
};
execute_command("git", &args);
}
}
fn execute_command(command: &str, args: &[&str]) {
Command::new(command)
.args(args)
.spawn()
.expect("spawn failed!")
.wait()
.expect("command failed!");
}
fn main() {
let command = GitCommand::LOG {
decorate: false,
patch: true,
};
command.execute();
}
SealedClassesinKotlinaresimilartoRust’senums,astheyallowthemodellingofaclosedtypehierarchy
Seethissectionaboutenumsformoreexamples.
Concepts
Ownership
OnethingthatisveryspecialaboutRustisthewayithandlesmemoryallocations:Itdoesn’t
haveagarbagecollector(likeJavaScript,JavaorGo),butthedeveloperdoesnotneedto ↑](https://image.slidesharecdn.com/rustforprofessionals-230103014500-bf7c6cd4/85/Rust-for-professionals-pdf-15-320.jpg)
![freememoryexplicitly,either(likeinC).Instead,Rustautomaticallyfreesmemorywhenitis
nolongerinuse.Forthismechanismtowork,thedeveloperneedstoexplicitlythinkabout
ownershipofthevaluestheprogramisusing.
class User {
private String name;
public User(String name) {
this.name = name;
}
}
public static void main(String[] args) {
String name = "User";
User user1 = new User(name);
User user2 = new User(name);
}
struct User {
name: String,
}
fn main() {
let name = String::from("User");
let user1 = User { name };
let user2 = User { name }; // compile error
}
InJava,thegarbagecollectorwillregularlychecktheobjectreferencesandwhennothingreferencesthe
Userinstancesanymore,theywillbedeleted.Oncebothinstanceshavebeendetectedasunused,the
"User" stringcanalsobedeleted.
InRust,valuescanonlybeownedbyoneobjectatatime:theassignmenttouser1 isOK,becausethe
valuewillbemovedfromthename variabletouser1.Thecreationofuser2,however,willgiveacompile
error,becausethestring"User" isnowownedbyuser1,notbyname.
InC,thedeveloperhastomakesurethatallocatedmemoryisfreedwhenitisnolonger
needed.Thiscanleadtobugs(memoryleaks)andwasoneofthemotivationforRust’s
differentapproachtomanagingmemory.WhileRustoffersprotectionsagainstit,it’snot
impossibletohavememoryleaks.
#include <string>
std::string* get_string() {
std::string* string = new std::string("hello");
delete string;
Java
Rust
C++
↑](https://image.slidesharecdn.com/rustforprofessionals-230103014500-bf7c6cd4/85/Rust-for-professionals-pdf-16-320.jpg)
![return string;
}
fn get_string() -> String {
let string = String::from("hello");
drop(string);
return string; // compile error!
}
Inthisexample,theC++codehasauseafterfreeerror.Notethatthisisonlyanexample,dropisrarely
usedinRustcode(valueswillbedroppedautomaticallywhentheygooutofscope)
Rust’sownershipmodelalsohelpswhendealingwithmulti-threadedcode.Thecompiler
keepstrackofthevaluestheprogramisusingandmakessurethatthesamevalueisnot
accessedfrommultiplethreadswithoutproperlockinglogicaroundit.
#include <vector>
#include <thread>
int main() {
std::vector<std::string> list;
auto f = [&list]() {
for (int i = 0; i < 10000; i++) {
list.push_back("item 123");
}
};
std::thread t1(f);
std::thread t2(f);
t1.join();
t2.join();
}
use std::thread;
fn main() {
let mut list = vec![];
let f = move || {
for _ in 0..10000 {
list.push("item 123");
}
};
Rust
C++
Rust
↑](https://image.slidesharecdn.com/rustforprofessionals-230103014500-bf7c6cd4/85/Rust-for-professionals-pdf-17-320.jpg)
![let t1 = thread::spawn(f);
let t2 = thread::spawn(f); // compile error!
t1.join().unwrap();
t2.join().unwrap();
}
Thestd::vector classisnotthread-safeandtheC++programwillcompilewithouterrors,butwhen
running,itwillprobablycrashwithanerrorlikepointer being freed was not allocated orsimilar.In
Rust,theclosuref takesownershipoflist (indicatedbythemovekeyword),that’swhythecompilergives
anerrorwhenf isusedmorethanonce.
Strings
Rusthasmultiplestringtypes,themostimportantonesarestr(usuallyintheformof &str)
andString.
The &str typeonlyreferencesborrowedcontent,sothisisthetypethatisusedforstatic
stringsandwhenreferencingstringslices.Likeotherimmutablereferences, &str values
cannotbemodified.Use String ifyouneedamodifiablestring.
const FILE_DATE = "2020-01-01";
function printCopyright() {
const year = FILE_DATE.substr(0, 4);
const copyright = `(C) ${year}`;
console.log(copyright);
}
const FILE_DATE: &str = "2020-01-01";
fn print_copyright() {
let year: &str = &FILE_DATE[..4];
let copyright: String = format!("(C) {}", year);
println!("{}", copyright);
}
Seethissectionaboutstringsformoreexamples
The String typeisusedfordynamicallycreatedstrings,whichcanbemodifiedandwhere
thelengthisnotfixedatcompiletime.
Usually, &str willbeusedforfunctionparametersand String willbeusedasreturnvalue.
public static String repeat(String s, int count) {
StringBuilder result = new StringBuilder();
for (int i = 0; i < count; i++) {
result.append(s);
}
JavaScript
Rust
Java
↑](https://image.slidesharecdn.com/rustforprofessionals-230103014500-bf7c6cd4/85/Rust-for-professionals-pdf-18-320.jpg)
![return result.toString();
}
fn repeat(s: &str, count: u32) -> String {
let mut result = String::new();
for _ in 0..count {
result += s;
}
result
}
Thisisjustanexample,RustalreadyhasString.repeat
Forstructfields,usually String shouldbeused,asthevaluewillprobablybeownedbythat
struct,especiallywhendealingwithlongerlivingobjects.
Forstringconstants, &'static str canbeusedforfieldsinstead.
data class User(
private val source: String,
private val name: String,
private val address: String
) {
companion object {
fun fromString(string: String): User {
val lines = string.lines()
return User("kotlin-v1.0", lines[0],
lines[1])
}
}
}
pub struct User {
source: &'static str,
name: String,
address: String,
}
impl User {
pub fn new(s: &str) -> User {
let mut lines = s.lines();
User {
source: "rust-v1.0",
name: lines.next().unwrap().to_owned(),
address: lines.next().unwrap().to_owned(),
}
}
}
Rust
Kotlin
Rust
↑](https://image.slidesharecdn.com/rustforprofessionals-230103014500-bf7c6cd4/85/Rust-for-professionals-pdf-19-320.jpg)
![Notethatdefaultfieldaccessisprivate inRust
Toconvertavariable s1 oftype String to &str,use &s1.
Toconvertavariable s2 oftype &str to String,use s2.to_owned() (thisallocatesnew
memoryandcreatesacopyofthestring).Sometimesthisconversionisalsonecessaryfor
literals,like "string literal".to_owned().
Nullvalues
Rustdoesnothaveaspecial null value(alsocalled None or nil insomelanguages).
Instead,thereistheOptionenum,whichisverysimilartotheOptionaltypeinJava.
public static Integer getYear(String date) {
if (date.length() >= 4) {
String s = date.substring(0, 4);
try {
return Integer.valueOf(s);
} catch (NumberFormatException e) {
return null;
}
} else {
return null;
}
}
public static void main(String[] args) {
Integer year = getYear("2020-01-01");
if (year != null) {
System.out.println(year);
}
}
fn get_year(date: &str) -> Option<u32> {
if date.len() >= 4 {
let s = date[..4];
match s.parse() {
Ok(year) => Some(year),
Err(_) => None
}
} else {
None
}
}
fn main() {
if let Some(year) = get_year("2020-01-01") {
println!("{}", year);
Java
Rust
↑](https://image.slidesharecdn.com/rustforprofessionals-230103014500-bf7c6cd4/85/Rust-for-professionals-pdf-20-320.jpg)
![};
}
NotethattheJavaScriptcodereturnsaPromise,soit’sasynchronous,whiletheRustexamplecodeis
synchronous
Attributes(annotations)
Rustalsosupportsattributes(alsocalledannotationsinotherlanguages).Theyare
interpretedduringcompiletimeandarecomparabletopreprocessormacrosinCorC++.
#include <cstdint>
[[nodiscard]] int32_t add(int32_t a, int32_t b) {
return a + b;
}
int main() {
add(1, 2); // warning: unused return value
}
#[must_use]
fn add(a: i32, b: i32) -> i32 {
a + b
}
fn main() {
add(1, 2); // warning: unused return value
}
Averycommonattributeisderive,whichcanbeusedtoquicklyimplementtraits.Itisoften
usedlike #[derive(Debug, PartialEq)],toimplementtheDebugandPartialEqtraits.
Miscellaneous
Packagemanagement
RustusuallyusestheCargopackagemanager,whichislikenpmoryarnforJavaScriptor
MavenforJava.
Thepackageregistryisavailableatcrates.io.
Projectsetup
IfyouhaveusedESLintbeforeforJavaScriptorTypeScript,rust-clippyisasimilartoolfor
Rust,whichdetectscommonmistakesandbugs.
C++
Rust
↑](https://image.slidesharecdn.com/rustforprofessionals-230103014500-bf7c6cd4/85/Rust-for-professionals-pdf-24-320.jpg)
More Related Content
Similar to Rust for professionals.pdf
Rust for professionals.pdf
- 1.
- 2. ThisisashortintroductiontoRust,intendedfordevelopersthatalreadyknowanother language.Intheexamples,RustiscomparedwithTypeScript,JavaScriptorJava,sometimes withC++orKotlin. ForadeepdiveintothesyntaxandRust’sconcepts,havealookatTheRustProgramming Language,butforaquickoverview,readon. Naming Regardingnames,Rustpreferssnakecaseforvariablesandfunctions,soamethodwould becalled read_str insteadofreadStr.Forstructs,traitsandenums,camelcase(orPascal case)isused,forexample HttpClient. Syntax Rust’ssyntaxisamixofexistinglanguages(curlybraces,functionsandreferenceslikeinC, typeafteridentifierlikeinGoorKotlin,genericsandtypeparameterslikeinC++orJava) withsomeRust-specificelements(lifetimenames,patterns,macros,attributes).Foraquick overviewofthesyntax,seetheRustLanguageCheatSheetoranoverviewofRust’s keywords. Variables RustvariabledeclarationsareverysimilartoTypeScriptorKotlin,butlookabitdifferentfrom JavaorC. const s: string = ""; let n: number = 0.9; let i = 123; // Type inferred let s: &str = ""; let mut n: f64 = 0.9; let mut i = 123; // Type inferred Mostofthetime,thetypecanbeommittedinRustandthecompilerwillinferthecorrecttype Types InRust,therearemorespecificprimitivedatatypes. Thevoidtypeiscalledunitandisindicatedby (),seefunctionsforanexample. int i = 123; long l = 456L; float f = 0.5f; double d = 0.5; TypeScript Rust Java ↑
- 3. String string ="Hello"; int[] arr = {1, 2, 3}; List<Integer> list = Arrays.asList(1, 2, 3); let i: i32 = 123; let l: i64 = 456; let f: f32 = 0.5; let d: f64 = 0.5f64; let string: &str = "Hello"; let arr: [i32; 3] = [1, 2, 3]; let list: Vec<i32> = vec![1, 2, 3]; InRust,numericliteralscanoptionallyhaveatypesuffix,forexample1000u32 or0.5f64. Mutability Variablesneedtobeexplicitlydeclaredmutable(let versus let mut),likeinJavaScript (const and let)orKotlin(val and var). ThemutabilitymodelinRustisnotlikeJavaScript,butabitmorelikeconstinC++,asRust willnotletyoucallmodifyingmethodsonavariablewhichisnotdeclaredasmutable. let arr1: string[] = []; arr1.push("123"); // OK arr1 = ["a", "b"]; // OK const arr2: string[] = []; arr2.push("123"); // OK, even though arr2 is const arr2 = []; // error, arr2 is const let mut arr1 = vec![]; arr1.push("123"); // OK arr1 = vec!["a", "b"]; // OK let arr2 = vec![]; arr2.push("123"); // error, arr2 is not mutable arr2 = vec![]; // error, arr2 is not mutable InTypeScript,declaringavariableasconst onlypreventsreassignment,notmodification.InRust,only variablesdeclaredasmut canbemodified Destructuring Rust TypeScript Rust ↑
- 4. Rustsupportsdestructuring,likeJavaScriptorKotlin. function distance(a, b){ const { x: x1, y: y1 } = a; const { x: x2, y: y2 } = b; return Math.sqrt( Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2) ); } fn distance(a: &Point, b: &Point) -> f32 { let Point { x: x1, y: y1 } = a; let Point { x: x2, y: y2 } = b; ((x2 - x1).powf(2.0) + (y2 - y1).powf(2.0)).sqrt() } struct Point { x: f32, y: f32, } MoreexamplescanbefoundinthissectionfromtheRustforC++programmersguide Functions FunctionsarebasicallythesameasinC,Java,GoorTypeScript:Theyhaveaname,zeroor moreparametersandareturntype. void log(char* message) { printf("INFO %sn", message); } fn log(message: &str) -> () { println!("INFO {}", message); } Theunittype() (voidinsomelanguages)isthedefaultreturntypewhennotypeisgivenforafunction.It couldbeomittedinthisexample,likefn log(message: &str) { ... } InRust,functionsareexpressions,whichmeansthelaststatementisalsothereturnvalue (likeinRuby).Thisisabitlikeimplicitreturn,butnotexactly.Theofficialstyleistoonlyuse return forearlyreturns. public static int add(int a, int b) { return a + b; } JavaScript Rust C Rust Java ↑
- 5. fn add(a: i32,b: i32) -> i32 { a + b } NotethatthereisnosemicolonintheRustfunction,otherwiseitwouldreturnvoid Rustcurrentlyhasnonamedargumentsordefaultarguments(likePythonandTypeScript) anddoesnotallowmethodoverloading(likeC++,JavaorTypeScript). Innerfunctions Rustalsosupportsinnerfunctions. const RE = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/; function isValidRange(start, end) { function isValid(date) { return date && date.match(RE); } return isValid(start) && isValid(end); } use regex::Regex; const RE: &str = r"^[0-9]{4}-[0-9]{2}-[0-9]{2}$"; fn is_valid_range(start: &str, end: &str) -> bool { fn is_valid(date: &str) -> bool { !date.is_empty() && Regex::new(RE) .unwrap() .is_match(date) } is_valid(start) && is_valid(end) } NotethatRegex isanexternalcrateandnotpartofRust’sstandardlibrary Extensionmethods Rust(likeKotlin)alsosupportsextensionmethods,sothepreviousexamplecouldbe rewrittenusingextensions. typealias Range = Pair<String, String> fun Range.isValid(): Boolean { val (start, end) = this Rust JavaScript Rust Kotlin ↑
- 6. return start.isNotEmpty() &&end.isNotEmpty() } object Main { @JvmStatic fun main(args: Array<String>) { val range = Range("2020-01-01", "2020-12-31") if (range.isValid()) { println("Range is valid!") } } } type Range<'r> = (&'r str, &'r str); trait IsValid { fn is_valid(&self) -> bool; } impl<'r> IsValid for Range<'r> { fn is_valid(&self) -> bool { let (start, end) = &self; !start.is_empty() && !end.is_empty() } } fn main() { let range = ("2020-01-01", "2020-12-31"); if range.is_valid() { println!("Range is valid!"); } } InRust,extensionmethodsareaddedbyimplementingatrait.Whenthereisonlyonemethod,it’scommon tonamethetraitlikethemethod(IsValid).The'r denotesalifetime,formoreinformation,seethis sectionfromtheRustbook Closures(lambdas) Rustsupportsclosures(alsocalledLambdas,arrowfunctionsoranonymousfunctionsin otherlanguages). Whenaccessingvariablesfromoutsidetheclosure,RustismorestrictthanJavaScriptor Java,seecapturingformoredetails. function findEmails(list) { return list.filter( s => s && s.includes("@") Rust JavaScript ↑
- 7. ); } fn find_emails(list: Vec<String>)-> Vec<String> { list.into_iter() .filter(|s| s.contains("@")) .collect() } Formorefilterexamples,seethissectionfromthedocumentation Expressions InRust,almosteverythingisanexpression,likeinKotlinanddifferentfromJavaScriptor Java.Youcandirectlyassigntheresultofan if statementtoavariable,forexample. function getLogLevel() { let level = process.env.TRACE ? "trace" : process.env.DEBUG ? "debug" : "info"; level = level === "trace" ? 0 : level === "debug" ? 1 : 2; console.log("using log level", level); return level; } fn get_log_level() -> u32 { let level = if std::env::var("TRACE").is_ok() { "trace" } else if std::env::var("DEBUG").is_ok() { "debug" } else { "info" }; let level = match level { "trace" => 0, "debug" => 1, _ => 2, Rust JavaScript Rust ↑
- 8. }; println!("using log level{}", level); level } TheRustcodeusesmatch,whichislikeswitch inJavaorJavaScriptexceptthatit’sanexpressionand providesmoreflexibility.Unlessmanyotherlanguages,Rustallowsvariableshadowingforlocalvariables (level inthisexample) Structs(classes) RustdoesnothavefullsupportforclasseslikeJavaorTypeScript,butinsteadoffersstructs (similartostructsinC).Thesearelikedatacontainerswithmethods,buttheydon’tsupport alloftheobjectorientedconcepts,likeinheritance. public class HttpClient { private final ClientImpl clientImpl; public HttpClient() { clientImpl = new ClientImpl(); } public String get(String url) { return clientImpl.newRequest() .get(url).asString(); } } public static void main(String[] args) { HttpClient httpClient = new HttpClient(); System.out.println(httpClient .get("https://example.com/")); } pub struct HttpClient { client_impl: ClientImpl, } impl HttpClient { pub fn new() -> HttpClient { HttpClient { client_impl: ClientImpl {}, } } pub fn get(&self, url: &str) -> String { self.client_impl.new_request() Java Rust ↑
- 9. .get(url) .as_string() } } fn main() { lethttp_client = HttpClient::new(); println!("{}", http_client.get("https://example.com/")); } InJava,mutabilityisgivenonafieldlevel,hereclientImpl isimmutable.InRust,themutabilitymodifieris setontheinstancevariableandnotperfield,soyoucannothavemutableandimmutablefieldsinthe samestruct(seetheInteriorMutabilityPattern) Methodsdonothaveimplicitaccesstothis,asinJavaorJavaScript,soyouneedtopassan explicitargumentnamed self,likeinPython.Methodswithoutthisparameterarecalled associatedfunctions(theyarecalledstaticmethodsinsomelanguages). InRust,thereisnoconstructor,structsarecreatedsimilarlytoobjectsinJavaScript.For caseswhereconstructorlogicisrequired,thereisaconventiontocreateanassociated function(staticmethod)named new,whichwillreturntheconstructedobjectinstance. Traits(interfaces) ThemostsimilarthingtointerfacesinRustaretraits. interface Named { fun name(): String } data class User( val id: Int, val name: String ) : Named { override fun name(): String { return this.name } } pub trait Named { fn name(&self) -> &String; } pub struct User { pub id: i32, pub name: String, } Kotlin Rust ↑
- 10. impl Named forUser { fn name(&self) -> &String { return &self.name; } } Rustismostlyastaticlanguage,sosomethingsthatotherlanguagewilldoduringruntime, Rustwilldoduringcompiletime,whenpossible.Interfacesareusuallyusedfordynamic dispatchandifyouwanttousetraitsinasimilarway,seethischapteraboutstaticand dynamicdispatchandthisblogpost. Defaultmethods Traitsalsosupportdefaultmethods,likeinterfacesinJavaorKotlin. Associatedfunctions InRust,traitscanalsohaveassociatedfunctions,forexample from_str in std::str::FromStr (sectionstringparsingintheRustCookbook) interface FromList<T> { fun fromList(list: List<Int>): T? } data class MyPoint(val x: Int, val y: Int) { companion object : FromList<MyPoint> { override fun fromList(list: List<Int>): MyPoint? { return when (list.size) { 2 -> MyPoint(list[0], list[1]) else -> null } } } } object Main { @JvmStatic fun main(args: Array<String>) { val point = MyPoint.fromList(listOf(100, 200)) println(point) } } trait FromList<T> { fn from_list(list: &Vec<i32>) -> Option<T>; } struct MyPoint { Kotlin Rust ↑
- 11. x: i32, y: i32, } implFromList<Self> for MyPoint { fn from_list(list: &Vec<i32>) -> Option<Self> { match list.len() { 2 => Some(MyPoint { x: list[0], y: list[1], }), _ => None, } } } fn main() { let point = MyPoint::from_list(&vec![100, 200]).unwrap(); println!("({}, {})", point.x, point.y); } FormoreinformationabouttheOption type,seetheNullvaluessectionbelow.ThekeywordSelf (upper case)canbeusedtoreferencethecurrenttype Enums Rustsupportsenums,likeJavaorKotlin,butwithmoreflexibility.TheRustenumsoffermore thaninC++orTypeScript,astheyarenotmerelyalistofconstants,butmorelikeunions. enum UserRole { RO("read-only"), USER("user"), ADMIN("administrator"); private final String name; UserRole(String name) { this.name = name; } String getName() { return name; } boolean isAccessAllowed(String httpMethod) { switch (httpMethod) { case "HEAD": case "GET": return true; Java ↑
- 12. case "POST": case "PUT": returnthis == USER || this == ADMIN; case "DELETE": return this == ADMIN; default: return false; } } } class Main { public static void main(String[] args) { UserRole role = UserRole.RO; if (role.isAccessAllowed("POST")) { System.out.println("OK: " + role.getName()); } else { System.out.println("Access denied: " + role.getName()); } } } #[derive(PartialEq)] enum UserRole { RO, USER, ADMIN, } impl UserRole { fn name(&self) -> &str { match *self { UserRole::RO => "read-only", UserRole::USER => "user", UserRole::ADMIN => "administrator", } } fn is_access_allowed( &self, http_method: &str, ) -> bool { match http_method { "HEAD" | "GET" => true, "POST" | "PUT" => { *self == UserRole::USER Rust ↑
- 13. || *self ==UserRole::ADMIN } "DELETE" => *self == UserRole::ADMIN, _ => false, } } } fn main() { let role = UserRole::RO; if role.is_access_allowed("POST") { println!("OK: {}", role.name()); } else { println!("Access denied: {}", role.name()); } } Rustdoesnotsupportconstantsinenums,soweneedtouseamatchinthename method.Theenum matchesarecheckedatcompiletime,sowhenallenumvariantsareused,thereisnoneedtohavea defaultbranch. Formoreinformationaboutthe#[derive(PartialEq)] line,seethesectionaboutAttributes Associatedvalues Rustenumsalsosupportassociatedvalues,whichmeanstheyarenotconstant,butinstead allowthecreationofenumvariantinstanceswithspecificvalues. sealed class GitCommand { abstract fun execute() } object Status : GitCommand() { override fun execute() = executeCommand(listOf("status")) } class Checkout( private val branch: String ) : GitCommand() { override fun execute() = executeCommand(listOf("checkout", branch)) } class Add( private val files: List<String> ) : GitCommand() { override fun execute() = executeCommand(listOf("add") + files) } Kotlin ↑
- 14. class Log( private valdecorate: Boolean, private val patch: Boolean ) : GitCommand() { override fun execute() { val args = mutableListOf("log") if (decorate) { args.add("--decorate") } if (patch) { args.add("--patch") } executeCommand(args) } } fun executeCommand(args: List<String>) { val redirect = ProcessBuilder.Redirect.INHERIT ProcessBuilder(listOf("git") + args) .redirectInput(redirect) .redirectOutput(redirect) .redirectError(redirect) .start() .waitFor() } object Main { @JvmStatic fun main(args: Array<String>) { val command = Log(decorate = false, patch = true) command.execute() } } use std::process::Command; pub enum GitCommand<'g> { STATUS, CHECKOUT(&'g str), ADD(Vec<&'g str>), LOG { decorate: bool, patch: bool }, } impl<'g> GitCommand<'g> { fn execute(self) { let args: Vec<&str> = match self { GitCommand::STATUS => vec!["status"], GitCommand::CHECKOUT(branch) => { vec!["checkout", branch] Rust ↑
- 15. } GitCommand::ADD(files) => { [vec!["add"],files].concat() }, GitCommand::LOG { decorate, patch, } => { let mut args = vec!["log"]; if decorate { args.push("--decorate") } if patch { args.push("--patch") } args } }; execute_command("git", &args); } } fn execute_command(command: &str, args: &[&str]) { Command::new(command) .args(args) .spawn() .expect("spawn failed!") .wait() .expect("command failed!"); } fn main() { let command = GitCommand::LOG { decorate: false, patch: true, }; command.execute(); } SealedClassesinKotlinaresimilartoRust’senums,astheyallowthemodellingofaclosedtypehierarchy Seethissectionaboutenumsformoreexamples. Concepts Ownership OnethingthatisveryspecialaboutRustisthewayithandlesmemoryallocations:Itdoesn’t haveagarbagecollector(likeJavaScript,JavaorGo),butthedeveloperdoesnotneedto ↑
- 16. freememoryexplicitly,either(likeinC).Instead,Rustautomaticallyfreesmemorywhenitis nolongerinuse.Forthismechanismtowork,thedeveloperneedstoexplicitlythinkabout ownershipofthevaluestheprogramisusing. class User { privateString name; public User(String name) { this.name = name; } } public static void main(String[] args) { String name = "User"; User user1 = new User(name); User user2 = new User(name); } struct User { name: String, } fn main() { let name = String::from("User"); let user1 = User { name }; let user2 = User { name }; // compile error } InJava,thegarbagecollectorwillregularlychecktheobjectreferencesandwhennothingreferencesthe Userinstancesanymore,theywillbedeleted.Oncebothinstanceshavebeendetectedasunused,the "User" stringcanalsobedeleted. InRust,valuescanonlybeownedbyoneobjectatatime:theassignmenttouser1 isOK,becausethe valuewillbemovedfromthename variabletouser1.Thecreationofuser2,however,willgiveacompile error,becausethestring"User" isnowownedbyuser1,notbyname. InC,thedeveloperhastomakesurethatallocatedmemoryisfreedwhenitisnolonger needed.Thiscanleadtobugs(memoryleaks)andwasoneofthemotivationforRust’s differentapproachtomanagingmemory.WhileRustoffersprotectionsagainstit,it’snot impossibletohavememoryleaks. #include <string> std::string* get_string() { std::string* string = new std::string("hello"); delete string; Java Rust C++ ↑
- 17. return string; } fn get_string()-> String { let string = String::from("hello"); drop(string); return string; // compile error! } Inthisexample,theC++codehasauseafterfreeerror.Notethatthisisonlyanexample,dropisrarely usedinRustcode(valueswillbedroppedautomaticallywhentheygooutofscope) Rust’sownershipmodelalsohelpswhendealingwithmulti-threadedcode.Thecompiler keepstrackofthevaluestheprogramisusingandmakessurethatthesamevalueisnot accessedfrommultiplethreadswithoutproperlockinglogicaroundit. #include <vector> #include <thread> int main() { std::vector<std::string> list; auto f = [&list]() { for (int i = 0; i < 10000; i++) { list.push_back("item 123"); } }; std::thread t1(f); std::thread t2(f); t1.join(); t2.join(); } use std::thread; fn main() { let mut list = vec![]; let f = move || { for _ in 0..10000 { list.push("item 123"); } }; Rust C++ Rust ↑
- 18. let t1 =thread::spawn(f); let t2 = thread::spawn(f); // compile error! t1.join().unwrap(); t2.join().unwrap(); } Thestd::vector classisnotthread-safeandtheC++programwillcompilewithouterrors,butwhen running,itwillprobablycrashwithanerrorlikepointer being freed was not allocated orsimilar.In Rust,theclosuref takesownershipoflist (indicatedbythemovekeyword),that’swhythecompilergives anerrorwhenf isusedmorethanonce. Strings Rusthasmultiplestringtypes,themostimportantonesarestr(usuallyintheformof &str) andString. The &str typeonlyreferencesborrowedcontent,sothisisthetypethatisusedforstatic stringsandwhenreferencingstringslices.Likeotherimmutablereferences, &str values cannotbemodified.Use String ifyouneedamodifiablestring. const FILE_DATE = "2020-01-01"; function printCopyright() { const year = FILE_DATE.substr(0, 4); const copyright = `(C) ${year}`; console.log(copyright); } const FILE_DATE: &str = "2020-01-01"; fn print_copyright() { let year: &str = &FILE_DATE[..4]; let copyright: String = format!("(C) {}", year); println!("{}", copyright); } Seethissectionaboutstringsformoreexamples The String typeisusedfordynamicallycreatedstrings,whichcanbemodifiedandwhere thelengthisnotfixedatcompiletime. Usually, &str willbeusedforfunctionparametersand String willbeusedasreturnvalue. public static String repeat(String s, int count) { StringBuilder result = new StringBuilder(); for (int i = 0; i < count; i++) { result.append(s); } JavaScript Rust Java ↑
- 19. return result.toString(); } fn repeat(s:&str, count: u32) -> String { let mut result = String::new(); for _ in 0..count { result += s; } result } Thisisjustanexample,RustalreadyhasString.repeat Forstructfields,usually String shouldbeused,asthevaluewillprobablybeownedbythat struct,especiallywhendealingwithlongerlivingobjects. Forstringconstants, &'static str canbeusedforfieldsinstead. data class User( private val source: String, private val name: String, private val address: String ) { companion object { fun fromString(string: String): User { val lines = string.lines() return User("kotlin-v1.0", lines[0], lines[1]) } } } pub struct User { source: &'static str, name: String, address: String, } impl User { pub fn new(s: &str) -> User { let mut lines = s.lines(); User { source: "rust-v1.0", name: lines.next().unwrap().to_owned(), address: lines.next().unwrap().to_owned(), } } } Rust Kotlin Rust ↑
- 20. Notethatdefaultfieldaccessisprivate inRust Toconvertavariable s1oftype String to &str,use &s1. Toconvertavariable s2 oftype &str to String,use s2.to_owned() (thisallocatesnew memoryandcreatesacopyofthestring).Sometimesthisconversionisalsonecessaryfor literals,like "string literal".to_owned(). Nullvalues Rustdoesnothaveaspecial null value(alsocalled None or nil insomelanguages). Instead,thereistheOptionenum,whichisverysimilartotheOptionaltypeinJava. public static Integer getYear(String date) { if (date.length() >= 4) { String s = date.substring(0, 4); try { return Integer.valueOf(s); } catch (NumberFormatException e) { return null; } } else { return null; } } public static void main(String[] args) { Integer year = getYear("2020-01-01"); if (year != null) { System.out.println(year); } } fn get_year(date: &str) -> Option<u32> { if date.len() >= 4 { let s = date[..4]; match s.parse() { Ok(year) => Some(year), Err(_) => None } } else { None } } fn main() { if let Some(year) = get_year("2020-01-01") { println!("{}", year); Java Rust ↑
- 21. } } TheOption typeisjustaregularenumfromRust’sstandardlibrary,withthetwoentriesNone andSome. WhenreturningOption,empty(null)valuescanbereturnedasNoneandnon-emptyvaluesneedtobe wrapped,likeSome(year) Tosimplycheckifavalueis null,withoutneedingtogettheactualvalue, is_none() can beused. Integer year = getYear(""); if (year == null) { System.err.println("Invalid date given!"); } let year: Option<u32> = get_year(""); if year.is_none() { println!("Invalid date given!"); } Sometimesit’susefultorunsomecodeonlyifavalueis null,toensureavariablehasa non-null value.TherearemanywaystodoitinRust,butusing match offersthemost concisesyntax. String url = "https://github.com"; String content = cache.get(url); if (content == null) { content = loadUrl(url); } let url = "https://github.com"; let content = match cache.get(url) { Some(content) => content, None => load_url(url), }; NotethatintheRustcode,content isimmutable(toachievethesameinJava,wewouldneedtointroduce anotherlocalvariableoranewmethod) Errorhandling RustdoesnotofferexceptionslikeC++,JavaorJavaScript.Instead,errorconditionsare indicatedviathemethod’sregularreturnvalue,likeinCorGo. Java Rust Java Rust ↑
- 22. package main import ( "fmt" "log" "strconv" ) funcParsePort(port string) (uint16, error) { p, err := strconv.ParseUint(port, 10, 16) if err != nil { return 0, err } if p == 0 { return 0, fmt.Errorf("invalid: %d", p) } return uint16(p), nil } func main() { port, err := ParsePort("123") if err != nil { log.Fatalf("failed to parse port: %v", err) } log.Printf("port: %d", port) } use std::error::Error; fn parse_port(s: &str) -> Result<u16, Box<Error>> { let port: u16 = s.parse()?; if port == 0 { Err(Box::from(format!("invalid: {}", port))) } else { Ok(port) } } fn main() { match parse_port("123") { Ok(port) => println!("port: {}", port), Err(err) => panic!("{}", err), } } InRustit’scommontohavestatementswhichcoverallpossiblecases,eitherusingif/else ormatch,so youarelesslikelytoencounteranearlyreturn inRustthaninGo Go Rust ↑
- 23. Inthepreviousexample,weneededtouse Box<Error>,becausethereturnederrortype cannotbedeterminedduringcompiletime:Itwilleithercontainaninstanceof std::num::ParseIntError (fromtheparsemethod,whenparsingfails),orastring(when theportiszero). The? intheline let port: u16 = s.parse()? isthe?operator:when parse returnedan error, parse_port willreturnthaterror,otherwisetheunwrappedresultof parse willbe assignedto port. Input Rustisoftenusedforterminalapplications,soitalsosupportsreadinginput.Therelevant codeisinthestd::iomodule. const { stdin } = require("process"); function readStr() { return new Promise((resolve, reject) => { let result = ""; stdin.setEncoding("utf8"); stdin.on("readable", () => { let chunk; while ((chunk = stdin.read())) { result += chunk; } }); stdin.once("error", err => reject(err)); stdin.once("end", () => resolve(result)); }); } use std::io::{stdin, Read}; fn read_str() -> Option<String> { let mut buffer = String::new(); match stdin().read_to_string(&mut buffer) { Ok(_) => Some(buffer), Err(err) => { eprintln!( "Error while reading input: {}", err ); None } JavaScript Rust ↑
- 24. }; } NotethattheJavaScriptcodereturnsaPromise,soit’sasynchronous,whiletheRustexamplecodeis synchronous Attributes(annotations) Rustalsosupportsattributes(alsocalledannotationsinotherlanguages).Theyare interpretedduringcompiletimeandarecomparabletopreprocessormacrosinCorC++. #include <cstdint> [[nodiscard]] int32_tadd(int32_t a, int32_t b) { return a + b; } int main() { add(1, 2); // warning: unused return value } #[must_use] fn add(a: i32, b: i32) -> i32 { a + b } fn main() { add(1, 2); // warning: unused return value } Averycommonattributeisderive,whichcanbeusedtoquicklyimplementtraits.Itisoften usedlike #[derive(Debug, PartialEq)],toimplementtheDebugandPartialEqtraits. Miscellaneous Packagemanagement RustusuallyusestheCargopackagemanager,whichislikenpmoryarnforJavaScriptor MavenforJava. Thepackageregistryisavailableatcrates.io. Projectsetup IfyouhaveusedESLintbeforeforJavaScriptorTypeScript,rust-clippyisasimilartoolfor Rust,whichdetectscommonmistakesandbugs. C++ Rust ↑
- 25.