Support

# Scalar types ## Example Execute the following command to run [`./solutions/examples/scalar.rs`](https://github.com/Cyfrin/rust-crash-course/blob/main/topics/scalar/solutions/examples/scalar.rs) ```shell cargo run --example scalar --release ``` ## Exercises Exercises are in [`./exercises/src/lib.rs`](https://github.com/Cyfrin/rust-crash-course/blob/main/topics/scalar/exercises/src/lib.rs) ### Exercise 1 ```rust pub fn eq() { todo!(); } ``` Fix the function `eq` inside [`./exercises/src/lib.rs`](https://github.com/Cyfrin/rust-crash-course/blob/main/topics/scalar/exercises/src/lib.rs) Compare 2 inputs of the type `char` for equality and return a `bool` ### Exercise 2 ```rust pub fn add() { todo!(); } ``` Fix the function `add` inside [`./exercises/src/lib.rs`](https://github.com/Cyfrin/rust-crash-course/blob/main/topics/scalar/exercises/src/lib.rs) Add 3 inputs of the type `f32` and return the sum ### Exercise 3 ```rust pub fn cast(x: u8, y: i8, z: f32) -> f32 { x + y + z } ``` Fix the function `cast` inside [`./exercises/src/lib.rs`](https://github.com/Cyfrin/rust-crash-course/blob/main/topics/scalar/exercises/src/lib.rs) Add the 3 inputs, casting all of them into `f32` ## Test ```shell cargo test ```

Scalar types

Example

Execute the following command to run ./solutions/examples/scalar.rs

cargo run --example scalar --release

Exercises

Exercises are in ./exercises/src/lib.rs

Exercise 1

pub fn eq() {

todo!();

}

Fix the function eq inside ./exercises/src/lib.rs

Compare 2 inputs of the type char for equality and return a bool

Exercise 2

pub fn add() {

todo!();

}

Fix the function add inside ./exercises/src/lib.rs

Add 3 inputs of the type f32 and return the sum

Exercise 3

pub fn cast(x: u8, y: i8, z: f32) -> f32 {

x + y + z

}

Fix the function cast inside ./exercises/src/lib.rs

Add the 3 inputs, casting all of them into f32

Test

cargo test

Scalar Type Exercises

An essential look at Scalar types - Discover Rust's core data components: integers, floats, booleans, and characters, the foundational units of information. Apply your knowledge through hands-on exercises in comparing `char`s, summing `f32` values, and performing numeric type casting.

Course Overview

About the course

What you'll learn

Introduction to the Rust programming language

Rust variables and functions

Scalar types, arrays, strings, enum, structs, vectors, and hash maps in Rust

Rust control flows: If / else, if let and let else, loop, match

Rust ownership, including borrow and references

Rust error handling

Rust Modules

Rust Traits

Course Description

Who is this course for?

Smart Contract Developers
Blockchain Engineers
Web3 Developers
Smart Contract Security Researchers
Solutions Architects

Meet your instructors

Tasuku Nakamura

Founder at smartcontract.engineer

Smart contract engineer and educator.

Last updated on July 11, 2025

Thanks for checking us out

Start learning for free

Start for free

Rust Developer

Rust Programming Basics

Section 1: Course Intro

Duration: 6min

Section 2: Rust Intro

Duration: 18min

Section 3: Data Types

Duration: 47min

1. Scalar Type

A clear primer on Understanding Rust's Scalar Data Types - Explore Rust's fundamental scalar types: integers (signed/unsigned, arch-dependent), floating-point numbers, booleans, and Unicode characters. Understand explicit type conversion with `as` and how to query `MIN`/`MAX` constants for value boundaries. Duration: 4min

2. Scalar Type Exercises

3. Overflow

A detailed guide to Handling Integer Overflows in Rust - Uncover Rust's default integer overflow handling: panicking in debug for safety and wrapping in release for performance. Explore explicit methods such as `checked_add` and `wrapping_add` for robust, mode-independent arithmetic. Duration: 4min

4. Tuple

A detailed exploration to Understanding Tuples in Rust - Uncover creating, accessing, and destructuring Rust's fixed-size, mixed-type collections, including the unit type and nested tuples. Learn how functions use tuples to return multiple values and how destructuring provides convenient access to their elements. Duration: 6min

5. Tuple Exercises

An elemental exploration of Rust Tuples - Discover Rust's way of grouping multiple values of potentially different types into one compound type. You'll get hands-on experience accessing specific elements and swapping their order within a tuple. Reading Time: 0min

6. Array

An essential comparison of Rust Arrays vs. Slices - Discover why arrays have fixed, compile-time lengths while slices offer flexible, runtime views into data. Explore array definition, initialization, and element manipulation, plus techniques for creating powerful slices. Duration: 3min

7. Array Exercises

An elemental guide to Array - Delve into Rust's fixed-size arrays, understanding their creation and how to access specific portions. Practice initializing an array with zeros and master techniques for slicing out the first or last few elements. Reading Time: 0min

8. String And Str

An essential guide to Mastering Strings in Rust: `String` vs. `&str` - Understand Rust's core string types: the owned, heap-allocated `String` for mutable text, and `&str`, an immutable reference to string data. Learn to create, manipulate (slice, append, format), convert between them, and apply best practices for choosing the right type. Duration: 7min

9. String And Str Exercises

An essential primer on `String` and `&str` - Explore Rust's core text types, understanding the distinction between owned `String`s and borrowed `&str` slices. You'll practice these concepts by creating, concatenating, and appending strings in hands-on exercises. Reading Time: 0min

10. Enum

A hands-on journey into Rust Enums - Discover how to craft custom data types using enum variants (basic, tuple, struct) and leverage `derive` for easy printing and comparison. Unpack the standard library's `Option<T>` for managing absence and `Result<T, E>` for clear success/error handling. Duration: 6min

11. Enum Exercises

A practical introduction to Rust Enums - Define your own custom types by creating a `Color` enum with variants such as `Red`, `Green`, and `Blue`. Learn to include variants that hold data, like `Rgba(u8, u8, u8, f32)`, and make your enums public for broader use. Reading Time: 0min

12. Struct

A foundational guide to Understanding Structs in Rust - Define custom data types using named-field, tuple, unit-like, and nested structs, essential building blocks in Rust. Master instance creation, modification, `Debug` printing, and concise shorthands for initialization and updates. Duration: 7min

13. Struct Exercises

A foundational introduction to Structs - Learn to define custom data types in Rust by creating an `Account` `struct` with public `address` (`String`) and `balance` (`u32`) fields. You'll also implement an associated `new` function to initialize `Account` instances with a given address and a default balance of zero. Reading Time: 0min

14. Vector

A dynamic introduction to Rust Vectors - Learn to create, populate, and manage dynamically-sized collections using `Vec::new()`, `vec!`, and `push()`. Explore safe element access with `get()` versus indexing, updating, removing with `pop()`, and creating vector slices. Duration: 6min

15. Vector Exercises

A foundational introduction to Rust Vectors - Learn the basics of Rust's dynamic array type, the `Vec<T>`, and how to create instances. You'll practice by implementing a function to initialize a vector with given elements. Reading Time: 0min

16. Hash Map

A versatile introduction to Rust's `HashMap` - Learn to create and manage key-value pairs, from initialization and data insertion to value retrieval. Discover efficient update techniques, including the `entry().or_insert()` method for adding or modifying map entries. Duration: 4min

17. Hash Map Exercises

A hands-on guide to initializing Rust HashMaps - Discover how to create and populate a `HashMap`, a fundamental Rust collection for key-value storage. You'll practice by implementing a function to initialize a new `HashMap` and insert a specific address-amount pair. Reading Time: 0min

Section 4: Control Flow

Duration: 15min

Section 5: Ownership

Duration: 19min

Section 6: Error Handling

Duration: 8min

Section 7: Module

Duration: 12min

Section 8: Generic Types And Traits

Duration: 46min

Section 9: Async Await

Duration: 14min