Rustの概要と基本的な文法および各種適用事例での実装例

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

rustc -V

cargo --version

let x = 10;           // イミュータブル変数
let mut y = 20;       // ミュータブル変数
const Z: i32 = 30;    // 定数

let a: i32 = 42;      // 符号付き32ビット整数
let b: f64 = 3.14;    // 64ビット浮動小数点数
let c: bool = true;   // ブール値
let d: char = 'A';    // 1文字のUnicode文字
let e: &str = "Hello, Rust!";  // 文字列スライス

// 条件分岐
if x > 0 {
    println!("x is positive");
} else if x < 0 { println!("x is negative"); } else { println!("x is zero"); } 
// ループ 
   for i in 0..5 { 
// 0から4までのループ 
    println!("Value: {}", i); } while y > 0 {
    println!("Countdown: {}", y);
    y -= 1;
}

let mut numbers: Vec = Vec::new();
numbers.push(10);
numbers.push(20);
numbers.push(30);
println!("{:?}", numbers);  
// 出力: [10, 20, 30]

fn add(a: i32, b: i32) -> i32 {
    return a + b;
}

let sum = add(5, 3);
println!("Sum: {}", sum);  // 出力: Sum: 8

fn main() {
    let number = 5;

    match number {
        1 => println!("One"),
        2 => println!("Two"),
        3 | 4 => println!("Three or Four"),
        5..=10 => println!("Between Five and Ten"),
        _ => println!("Other"),
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

fn main() {
    let coin = Coin::Quarter;
    let cents = value_in_cents(coin);
    println!("Value in cents: {}", cents); // 出力: Value in cents: 25
}

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 10, y: 20 };

    match p {
        Point { x, y } => println!("x: {}, y: {}", x, y),
    }
}

fn main() {
    let numbers = vec![1, 2, 3];

    match &numbers {
        // 参照のパターンマッチング
        &[] => println!("Empty"),
        &[a] => println!("Single element: {}", a),
        // スライスのパターンマッチング
        &[a, b, c] => println!("Three elements: {}, {}, {}", a, b, c),
        _ => println!("More than three elements"),
    }
}

struct Person {
    name: String,
    age: u32,
    is_student: bool,
}

fn main() {
    let person1 = Person {
        name: String::from("Alice"),
        age: 30,
        is_student: false,
    };

    let person2 = Person {
        name: String::from("Bob"),
        age: 25,
        is_student: true,
    };
}

fn main() {
    let person1 = Person {
        name: String::from("Alice"),
        age: 30,
        is_student: false,
    };

    println!("Name: {}", person1.name);      // 出力: Name: Alice
    println!("Age: {}", person1.age);        // 出力: Age: 30
    println!("Is Student: {}", person1.is_student); // 出力: Is Student: false
}

fn main() {
    let person1 = Person {
        name: String::from("Alice"),
        age: 30,
        is_student: false,
    };

    let person2 = Person {
        name: String::from("Bob"),
        ..person1
    };

    println!("Name: {}", person2.name); // 出力: Name: Bob
    println!("Age: {}", person2.age);   // 出力: Age: 30 (person1からコピーされた)
}

trait Drawable {
    fn draw(&self);
}

struct Circle {
    radius: f64,
}

impl Drawable for Circle {
    fn draw(&self) {
        println!("Drawing a circle with radius {}", self.radius);
    }
}

fn draw_shape(shape: &T) {
    shape.draw();
}

trait Greeting {
    fn greet(&self) {
        println!("Hello!");
    }
}

struct Person {
    name: String,
}

impl Greeting for Person {
    fn greet(&self) {
        println!("Hello, {}!", self.name);
    }
}

fn main() {
    // クロージャの定義
    let add = |x, y| x + y;

    // クロージャの呼び出し
    let result = add(3, 5);
    println!("Result: {}", result);  // 出力: Result: 8
}

fn main() {
    let value = 10;
    let add_value = |x| x + value; // 外部の変数valueをキャプチャ

    let result = add_value(5);
    println!("Result: {}", result); // 出力: Result: 15

    // valueはまだ有効で、再利用できる
    let another_result = add_value(7);
    println!("Another Result: {}", another_result); // 出力: Another Result: 17
}

fn main() {
    // 引数と戻り値に型アノテーションを追加
    let add: fn(i32, i32) -> i32 = |x, y| x + y;

    let result = add(3, 5);
    println!("Result: {}", result);  // 出力: Result: 8
}

cargo new add_numbers
cd add_numbers

use std::io;

fn main() {
    println!("Enter the first number:");
    let mut num1 = String::new();
    io::stdin().read_line(&mut num1).expect("Failed to read input.");
    let num1: i32 = num1.trim().parse().expect("Invalid input. Please enter a valid number.");

    println!("Enter the second number:");
    let mut num2 = String::new();
    io::stdin().read_line(&mut num2).expect("Failed to read input.");
    let num2: i32 = num2.trim().parse().expect("Invalid input. Please enter a valid number.");

    let result = add_numbers(num1, num2);
    println!("The result of adding {} and {} is: {}", num1, num2, result);
}

fn add_numbers(a: i32, b: i32) -> i32 {
    a + b
}

cargo build
cargo run

cargo new rust_web_app
cd rust_web_app

[dependencies]
actix-web = "3.0.0"

use actix_web::{get, web, App, HttpResponse, HttpServer, Responder};

// ルートハンドラー
#[get("/")]
async fn index() -> impl Responder {
    HttpResponse::Ok().body("Hello, Rust Web!")
}

// パスパラメータを受け取るハンドラー
#[get("/greet/{name}")]
async fn greet(info: web::Path<(String,)>) -> impl Responder {
    let name = &info.0;
    HttpResponse::Ok().body(format!("Hello, {}", name))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .service(index)
            .service(greet)
    })
    .bind("127.0.0.1:8000")?
    .run()
    .await
}

cargo run

use std::time::SystemTime;
use std::hash::{Hash, Hasher};
use std::collections::hash_map::DefaultHasher;

// ブロックのデータを表す構造体
struct Block {
    index: u32,         // ブロックの番号
    timestamp: u64,     // ブロックの生成時刻
    data: String,       // ブロックのデータ（例: トランザクション情報）
    previous_hash: u64, // 直前のブロックのハッシュ値
    hash: u64,          // ブロックのハッシュ値
}

// ブロックチェーンを表す構造体
struct Blockchain {
    chain: Vec,
}

impl Blockchain {
    // 新しいブロックを作成するメソッド
    fn new_block(&mut self, data: String) {
        let index = self.chain.len() as u32;
        let timestamp = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs();
        let previous_hash = self.get_previous_hash();
        let hash = self.calculate_hash(index, timestamp, &data, previous_hash);

        let new_block = Block {
            index,
            timestamp,
            data,
            previous_hash,
            hash,
        };

        self.chain.push(new_block);
    }

    // 直前のブロックのハッシュ値を取得するメソッド
    fn get_previous_hash(&self) -> u64 {
        match self.chain.last() {
            Some(block) => block.hash,
            None => 0,
        }
    }

    // ブロックのハッシュ値を計算するメソッド
    fn calculate_hash(&self, index: u32, timestamp: u64, data: &str, previous_hash: u64) -> u64 {
        let mut hasher = DefaultHasher::new();
        index.hash(&mut hasher);
        timestamp.hash(&mut hasher);
        data.hash(&mut hasher);
        previous_hash.hash(&mut hasher);
        hasher.finish()
    }
}

fn main() {
    let mut blockchain = Blockchain {
        chain: vec![],
    };

    blockchain.new_block("Genesis Block".to_string());
    blockchain.new_block("Block 1".to_string());
    blockchain.new_block("Block 2".to_string());

    // ブロックチェーンの内容を表示
    for block in blockchain.chain.iter() {
        println!("Index: {}", block.index);
        println!("Timestamp: {}", block.timestamp);
        println!("Data: {}", block.data);
        println!("Previous Hash: {}", block.previous_hash);
        println!("Hash: {}", block.hash);
        println!("------------------");
    }
}

[package]
name = "embedded_example"
version = "0.1.0"
edition = "2018"

[dependencies]

#![no_std]
#![no_main]

use cortex_m_rt::entry;
use stm32f4xx_hal::{prelude::*, stm32};
use panic_halt as _;

#[entry]
fn main() -> ! {
    // STM32F4のデバイスを取得
    let dp = stm32::Peripherals::take().unwrap();
    let cp = cortex_m::Peripherals::take().unwrap();

    // GPIO設定を取得
    let gpioa = dp.GPIOA.split();
    let mut led = gpioa.pa5.into_push_pull_output();

    // 500msのインターバルでLEDを点滅させる
    loop {
        led.set_high().unwrap();
        delay(500_000);
        led.set_low().unwrap();
        delay(500_000);
    }
}

fn delay(cycles: u32) {
    for _ in 0..cycles {
        cortex_m::asm::nop();
    }
}