Rust Practice Repository

A collection of Rust programming exercises and examples to learn and practice the Rust programming language.

Overview

This repository contains various Rust programming exercises covering fundamental concepts including:

• Variables and mutability
• Data types (tuples, arrays)
• Functions
• Control flow
• Input/output operations
• Algorithm implementations

Project Structure

rust-practice/
├── Cargo.toml          # Project configuration
├── Cargo.lock         # Dependency lock file
├── src/
│   └── main.rs        # Main source file with exercises
└── README.md          # This file

Features

The main program (src/main.rs) includes several programming exercises:

1. Basic Variable Operations

• Variable declaration and mutability
• Constants
• Type annotations

2. Data Structures

• Tuples: Creation, destructuring, and access
• Arrays: Creation, indexing, and length operations

3. Functions

• Function definitions and return values
• Parameter passing
• Function calls

4. Utility Functions

• Temperature Conversion: Fahrenheit to Celsius converter
• Fibonacci Sequence: Generates Fibonacci numbers based on user input
• 12 Days of Christmas: Prints the complete lyrics using loops and arrays

5. User Interaction

• Input handling using std::io
• Error handling for user input parsing
• Interactive Fibonacci sequence calculator

Getting Started

Prerequisites

• Rust installed on your system (Install Rust)

Running the Program

1. Clone or navigate to this repository

2. Run the program:

   cargo run

3. Follow the prompts to interact with the Fibonacci calculator

Building the Project

cargo build

Running Tests

cargo test

Code Examples

Temperature Conversion

fn convert_farenheight_to_celcius(fahrenheight_temp: f64) -> f64 {
    let conversion_farenheight_to_celcius = (fahrenheight_temp - 32.0) * 5.0 / 9.0;
    conversion_farenheight_to_celcius
}

Fibonacci Sequence

fn generate_fibonacci_sequence(sequence: u32) -> u64 {
    let mut current = 0;
    let mut next = 1;
    let mut result = 0;
    let mut number = sequence - 1;

    while number != 0 {
        number -= 1;
        result = current + next;
        current = next;
        next = result;
    };

    result
}

Learning Objectives

This project demonstrates:

• Rust syntax and basic language features
• Memory safety concepts
• Error handling patterns
• Input/output operations
• Algorithm implementation
• Code organization and structure

Future Enhancements

Potential areas for expansion:

• Add more data structure examples (structs, enums)
• Implement additional algorithms
• Add unit tests
• Include error handling improvements
• Add command-line argument parsing
• Implement file I/O operations

Contributing

This is a personal learning repository, but suggestions and improvements are welcome!

License

This project is for educational purposes and personal learning.