Enum Example - Rust Typing CST Test

Mode:

Duration:

enum Message {
	Quit,
	Move { x: i32, y: i32 },
	Write(String),
}

fn process(msg: Message) {
	match msg {
		Message::Quit => println!("Quit message"),
		Message::Move { x, y } => println!("Move to ({}, {})", x, y),
		Message::Write(text) => println!("Text: {}", text),
	}
}

fn main() {
	process(Message::Move { x: 10, y: 20 });
	process(Message::Write(String::from("Hello")));
}Coding works best on desktop or with an external keyboard.

Enum Example — Rust Code

Demonstrates enums with associated data and pattern matching.

enum Message {
	Quit,
	Move { x: i32, y: i32 },
	Write(String),
}

fn process(msg: Message) {
	match msg {
		Message::Quit => println!("Quit message"),
		Message::Move { x, y } => println!("Move to ({}, {})", x, y),
		Message::Write(text) => println!("Text: {}", text),
	}
}

fn main() {
	process(Message::Move { x: 10, y: 20 });
	process(Message::Write(String::from("Hello")));
}

Rust Language Guide

A modern, memory-safe, high-performance systems programming language focused on safety, concurrency, and zero-cost abstractions, designed to replace C/C++ in critical software.

Primary Use Cases

▸Systems programming
▸WebAssembly applications
▸Cloud-native backends
▸Blockchain and cryptographic systems
▸Embedded systems
▸Game engines
▸High-performance CLI tools

Notable Features

▸Memory safety without garbage collection
▸Ownership and borrowing system
▸Zero-cost abstractions
▸Powerful package manager (Cargo)
▸Pattern matching and algebraic data types
▸Fearless concurrency

Origin & Creator

Created by Graydon Hoare at Mozilla Research, first public release in 2010, and stable 1.0 released in 2015. Originated as a personal project, later backed by Mozilla. Evolved through Rust 2015, 2018, and 2021 editions, adding async/await, improved ergonomics, better tooling, Cargo, and a richer standard library.

Industrial Note

Highly adopted in cloud infrastructure, operating system components, cryptography, blockchain systems, safety-critical systems, and WebAssembly. Used by Microsoft, Amazon, Google, Cloudflare, and Meta for secure and high-performance services.

Quick Explain

▸Rust is a compiled, multi-paradigm language emphasizing memory safety without garbage collection.
▸It uses ownership, borrowing, and lifetimes to provide deterministic safety at compile time.
▸Designed for system programming, WebAssembly, cloud services, and performance-critical applications.

Core Features

▸Ownership, borrowing, lifetimes
▸Traits and generics
▸Pattern matching
▸Async/await
▸Smart pointers and interior mutability

Learning Path

▸Learn ownership and borrowing
▸Understand enums and pattern matching
▸Master traits and generics
▸Learn async Rust
▸Build real applications

Practical Examples

▸Build a CLI tool using clap
▸Create a REST API with Axum/Actix
▸Write a WebAssembly module
▸Develop a multithreaded task scheduler

Comparisons

▸Safer than C/C++
▸Faster than Go in many workloads
▸More predictable than Java
▸Lower-level than Python

Strengths

▸Eliminates common memory bugs
▸Performance comparable to C++
▸Excellent developer experience with Cargo
▸Strong compile-time guarantees
▸Growing community and enterprise adoption

Limitations

▸Steep learning curve due to ownership model
▸Long compile times
▸More complex generics and lifetimes
▸Smaller ecosystem than C++/Python

When NOT to Use

▸When rapid prototyping is needed
▸For simple scripts or automation
▸When large VM-based ecosystems are required
▸When compile times are a bottleneck

Cheat Sheet

▸Ownership rules
▸Common lifetimes
▸Trait implementations
▸Cargo command patterns

FAQ

▸Why is Rust so safe?
▸Rust prevents memory bugs at compile time using ownership, borrowing, and lifetimes, eliminating entire classes of errors without garbage collection.
▸Is Rust good for beginners?
▸Rust is challenging but rewarding; excellent for those wanting to learn safe, modern systems programming.
▸How do I avoid borrow checker errors?
▸Follow ownership guidelines, avoid unnecessary mutable references, and break logic into smaller functions.
▸How is Rust different from C++?
▸Rust guarantees safety and concurrency without garbage collection, whereas C++ relies on manual discipline and conventions.

30-Day Skill Plan

▸Week 1: Ownership, lifetimes, basic syntax
▸Week 2: Collections, traits, generics
▸Week 3: Async Rust, threading
▸Week 4: Build a full backend or CLI project

Final Summary

▸Rust provides memory safety and high performance.
▸Ideal for systems programming, WASM, and secure backends.
▸Cargo and the ecosystem make development smooth.
▸Mastering Rust prepares you for modern software engineering.

Project Structure

▸src/ for main code
▸Cargo.toml for manifest
▸target/ for compiled binaries
▸tests/ for integration tests
▸examples/ for demo programs

Monetization

▸Build secure cloud tools
▸Develop blockchain protocols
▸Sell CLI utilities and libraries

Productivity Tips

▸Use cargo-watch
▸Master pattern matching
▸Use Result everywhere for safety
▸Leverage crates.io effectively

Basic Concepts

▸Ownership and borrowing
▸Variables and shadowing
▸Functions and closures
▸Structs and enums
▸Traits and generics
▸Error handling with Result/Option

Official Docs

▸The Rust Programming Language book
▸Rust Reference
▸Rustonomicon

More Rust Typing Exercises

Rust Ownership Example Rust Borrowing Example Rust Trait Example Rust Result and Error Handling Rust Iterator Example Rust Struct with Methods Rust String Manipulation Rust Generic Function Rust Closures Example

Practice Other Languages

C React Python C++TypeScript Kotlin PHP Java C#Ruby Mql Cql N1ql Cypher Gremlin

enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
}

fn process(msg: Message) {
match msg {
Message::Quit => println!("Quit message"),
Message::Move { x, y } => println!("Move to ({}, {})", x, y),
Message::Write(text) => println!("Text: {}", text),
}
}

fn main() {
process(Message::Move { x: 10, y: 20 });
process(Message::Write(String::from("Hello")));
}

Coding works best on desktop or with an external keyboard.

Enum Example — Rust Code

Demonstrates enums with associated data and pattern matching.

enum Message { Quit, Move { x: i32, y: i32 }, Write(String), } fn process(msg: Message) { match msg { Message::Quit => println!("Quit message"), Message::Move { x, y } => println!("Move to ({}, {})", x, y), Message::Write(text) => println!("Text: {}", text), } } fn main() { process(Message::Move { x: 10, y: 20 }); process(Message::Write(String::from("Hello"))); }

Rust Language Guide

A modern, memory-safe, high-performance systems programming language focused on safety, concurrency, and zero-cost abstractions, designed to replace C/C++ in critical software.

Primary Use Cases

▸Systems programming
▸WebAssembly applications
▸Cloud-native backends
▸Blockchain and cryptographic systems
▸Embedded systems
▸Game engines
▸High-performance CLI tools

Notable Features

▸Memory safety without garbage collection
▸Ownership and borrowing system
▸Zero-cost abstractions
▸Powerful package manager (Cargo)
▸Pattern matching and algebraic data types
▸Fearless concurrency

Origin & Creator

Industrial Note