Rust

cargo doc --open

cargo clippy

cargo build --release

cargo install cargo-audit
cargo audit

[profile.release]
lto = "fat"
opt-level = "s"
strip = "symbols"

• GPUI: https://www.gpui.rs/
• Bevy: https://bevy.org/
• clap: commandline arguments CLI
• chrono: datetime
• icalendar: ical

println!("{:?}", value);

• To use arguments from struct Arg, add this to Cargo.toml file:

  [dependencies]
  clap = {version = "4.6.1", features = ["derive"]}
  

• Then you can use like this:

  use clap::Parser;
  
  #[derive(Parser, Debug)]
  #[command(version, about, about_long = None)]
  struct Arg{
      #[arg(short, long)]
      filename: String,
  }
  
  let arg = Arg::parse();
  let path = Path::new(&arg.filename);
  
  

struct Entry {
    date: String,
    weight: f32,
    fat: Option<f32>,
    muscle: Option<f32>,
}

struct TimeoutSeconds(u64);

let s = "42";
let f: f32 = s.parse().unwrap();

match v.len() {
    0 => pass(),
    1 => pass(),
    _ => calculate(),
}

match result {
    None => {},
    Some(value) => println!("{:?}", value),
}

use std::cmp::Ordering;

number1.cmp(&number2);
Ordering::Less;
Ordering::Greater;
Ordering::Equal;

use regex::Regex;

let re = Regex::new(r"(.*) some pattern ([0-9\.]+) is another pattern ([0-9\.]+).").unwrap();
for line in read_to_string(path).unwrap().lines() {
    match re.captures(line) {
        None => {}, 
        Some(capture) => {
            println!("{:?}", capture);
            println!("{}", capture.get(0).unwrap().as_str());
            println!("{}", capture.get(1).unwrap().as_str());
            println!("{}", capture.get(2).unwrap().as_str());
            println!("{}", capture.get(3).unwrap().as_str());
        }   
    }
}

let v1 = vec![1, 2, 3];

let mut v2 = Vec::new();
for number in 1..5 {
    v2.push(number);
}

use std::process::Command;
let command = Command::new("/usr/bin/acpi")
        .output()
        .expect("Could not run acpi");
    
let output = String::from_utf8(acpi_command.stdout).unwrap();

use std::fs::read_to_string;
use std::path::Path;

let path = Path::new("/some/path");
for line in read_to_string(path).unwrap().lines() {
    println!("{}", line);
}

use rand::Rng;
let number: i32 = rand::rng().random_range(1..=100);

let parts = "10,20,30".split(",").collect();
let i: i32 = parts[0].parse().unwrap();

for part in &parts {
    println!("{part}");
}

• Common Combination

  use chrono::{Utc, Datelike, Timelike};
  let dt = Utc::now();
  
  println!("{}-{} {}", dt.year(), dt.month(), dt.hour());
  

• TimeZone

  use chrono::TimeZone;
  Utc::now()
  Utc.with_ymd_and_hms(y, m, d, h, min, s)
  Local.with_ymd_and_hms(...)
  

• Datelike

  use chrono::Datelike;
  
  dt.year()
  dt.month()        // 1–12
  dt.month0()       // 0–11
  dt.day()          // 1–31
  dt.day0()         // 0–30
  dt.ordinal()      // day of year (1–366)
  dt.weekday()
  

• Timelike

  use chrono::Timelike;
  
  dt.hour()         // 0–23
  dt.minute()       // 0–59
  dt.second()       // 0–59
  dt.nanosecond()
  
  dt.with_hour(10) // returns Option
  dt.with_minute(30) // returns Option
  dt.with_second(0) // returns Option
  

• Duration

  use chrono::Duration;
  
  dt + Duration::hours(2)
  dt - Duration::days(1)