Rust勉強中の細かなメモ

let image_bytes: Vec<u8> = res.body_bytes().await?;
let image = image::load_from_memory(&image_bytes)?;

fn sample(&Vec<AAA>) {}

fn sample(&[AAA]){}

let bytes: &[u8] = "aaa".as_bytes();
let bytes: Vec<u8> = bytes.to_vec();

use itertools::Itertools;

fn vec_to_double_vec<T>(vec: Vec<T>, size: usize) -> Vec<Vec<T>> {
    vec.into_iter()
        .chunks(size)
        .into_iter()
        .map(|chunk| chunk.collect_vec())
        .collect_vec()
}

fn output() {
        let vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
        let vec_vec = vec_to_double_vec(vec, 3);
        println!("{:?}", vec_vec);
}

// [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11]]

use rand::seq::SliceRandom;

fn shuffle() {
	let ids = "a,b,c,d,e,f,g";
	let mut v: Vec<&str> = ids.split(',').collect();
	let mut rng = rand::thread_rng();
	v.shuffle(&mut rng);
	println!("{:?}", v);
}

// ["b", "g", "f", "a", "e", "d", "c"]

fn sample_into(
    value: impl Into<String>,
)  {
    let value = value.into();
    // なんらかの処理 
}

async fn plus_one_async(num: i32) -> i32 {
	num + 1
}
fn plus_three(num: i32) -> i32 {
	num + 3
}

async fn sample() {
	let results = future::join_all((0..5).map(|i| plus_one_async(i)))
		.await
		.into_iter()
		.map(|i| plus_three(i))
		.collect_vec();
	println!("Got {:?}", results);
}

fn run() {
	async_std::task::block_on(sample());
}

// [4, 5, 6, 7, 8]

async fn sample2() {
        let results = future::join_all((0..5).map(|i| plus_one_async(i))).await;
        let results = results.into_iter().map(|i| plus_three(i)).collect_vec();
        println!("Got {:?}", results);
}

let vec = ids
            .into_iter()
            .map(|id| id_to_image_url(id))
            .map(|url| get_image_from_url(url))
	    .collect_vec();

let vec = ids
            .into_iter()
            .map(id_to_image_url)
            .map(get_image_from_url)
	    .collect_vec();

fn sample() -> Result<(ImageBuffer<image::Rgb<u8>, std::vec::Vec<u8>>, u32, u32), ParameterError> {}

type ImageBufferRgb8 = ImageBuffer<Rgb<u8>, Vec<u8>>;

fn sample() -> Result<(ImageBufferRgb8, u32, u32), ParameterError> {}

let file_bytes : &[u8] = include_bytes!("../読み込みたいファイル") as &[u8];

let file_path = "../読み込みたいファイル";
let file_bytes : &[u8] = include_bytes!(file_path) as &[u8];

lib.rs
sample_mod
  sample_code.rs
sample_mod.rs

// sample_mod.rs
pub mod sample_code;

mod sample_mod;
use sample_mod::sample_code;

error[E0599]: no method named `write_all` found for mutable reference `&mut std::io::BufWriter<std::fs::File>` in the current scope
  --> src/usecase/day_list_images_maker.rs:58:10
   |
58 |     fout.write_all(b).unwrap();
   |          ^^^^^^^^^ method not found in `&mut std::io::BufWriter<std::fs::File>`
   |
   = help: items from traits can only be used if the trait is in scope
   = note: the following trait is implemented but not in scope; perhaps add a `use` for it:
           `use std::io::Write;`

let image = DynamicImage::ImageRgb8(image)
let memory_writer = &mut BufWriter::new(Vec::new());
image.write_to(memory_writer, ImageFormat::Jpeg).unwrap();

    let image = DynamicImage::ImageRgb8(image);
    let memory_writer = &mut BufWriter::new(Vec::new());
    image.write_to(memory_writer, ImageFormat::Jpeg).unwrap();
    memory_writer.flush()?;
    let bytes = memory_writer.get_ref(); // :&[u8]

    let file_path = PathBuf::from("./画像.jpeg");
    let fout = &mut BufWriter::new(File::create(file_path)?);
    fout.write_all(bytes)?;
    fout.flush()?;

image.save(file_path);

use async_trait::async_trait;

#[async_trait]
pub trait Port {
    async fn sample(st: String) -> String;
}

pub struct Adaptor;

#[async_trait]
impl Port for Adaptor {
    async fn sample(st: String) -> String {
        // ここに何らかの非同期処理があるとする
        st
    }
}

// これはできない
pub fn execute_ng() {
    let adaptor = Adaptor {};
    let port: Port = adaptor;
    let value = port.sample("aaaaaa");
}

// これはできる
pub fn execute_ok() {
    let adaptor = Adaptor {};
    let value = execute(&adaptor);
}

pub fn execute<T: Port>(port: &T) {
    let value = port.sample("aaaaa");
}

pub trait Port {
    fn sample(value: &str) -> String;
}

pub struct Adaptor {};

impl Port for Adaptor{
    fn sample(value: &str) -> String {
        // Stringを返すなんらかのコード
    }
}

fn plus(value1: u32, value2:u32) -> u32 {
    value1 + value2
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    // 「Run test」ボタンがここに表示される（VSCode）
    fn check_plus() {
        assert_eq!(plus(2, 2), 4);
    }
}

async fn plus_async(value1: u32, value2:u32) -> u32 {
    value1 + value2
}

#[cfg(test)]
mod tests {
    use super::*;

    #[async_std::test]
    // 「Run test」ボタンがここに表示されてほしいけどでない（VSCode）
    async fn check_plus_async() {
        assert_eq!(plus_async(2, 2).await, 4);
    }
}

use std::thread::sleep;
use std::time::Duration;

fn sample_sleep() {
    sleep(Duration::from_millis(20000));
}

// たくさん使うならインポートしてもいいけど、
// 少ない箇所でちょっと試すだけなら上から直接書くほうがよさそう
// use std::time::{Duration, Instant};
// use std::thread::sleep;

fn main() {
    let start = std::time::Instant::now();
  
    std::thread::sleep(std::time::Duration::from_millis(5000));
  
    let end = start.elapsed();
  
    println!("{:?}", end); 
}
// -> 5.000139505s

use anyhow::Result;

fn sample() -> Result<()> { // Result<(), anyhow::Error>と書いてあるのと同じ
   sample_error1()?;
   sample_error2()?;
   Ok(())
}

use anyhow::{Context, Result};

fn sample(file_path: PathBuf) -> Result<()> { // Result<(), anyhow::Error>と書いてあるのと同じ
   sample_error1().context("エラーについての説明文")?;
   sample_error2(file_path).with_context(|| format!("エラーについての説明文。たとえばファイルパスを出力に入れたり→ {}", file_path))?;
   Ok(())
}

use anyhow::{anyhow, Result};

fn sample(value: i32) -> Result<i32> {
    match value {
        1 => Ok(100),
        _ => Err(anyhow!("error massage, value = {}", value)),
    }
}

#[test]
fn check_invalid() {
    let error_value = "error_value";
    let error = Err(anyhow!("error message sample, error_value = {}", error_value));
    assert_eq!(
        format!("{}", error.unwrap_err()),
        format!("error message sample, error_value = {}", error_value)
    );
}

use tide::prelude::*;
use tide::{Request, Response, StatusCode};

#[async_std::main]
async fn main() -> tide::Result<()> {
    execute().await
}

pub async fn execute() -> tide::Result<()> {
    tide::log::start();
    let mut app = tide::new();
    let app = router_setting_sample(app);
    app.listen("127.0.0.1:8080").await?;
    Ok(())
}

pub fn router_setting_sample(mut app: tide::Server<()>) -> tide::Server<()>{
    let mut root_path = app.at("/root_path");
    root_path.at("/sample1").post(sample_handler1);
    root_path.at("/sample2").post(sample_handler2);
    app
}

// handlerの関数については後述

#[derive(Debug, Deserialize)]
struct Target {
    sample_value: String,
}

pub async fn sample_handler1(mut req: Request<()>) -> tide::Result {
    let Target { sample_value } = req.body_json().await?;
    // このあたりで実際はコントローラ呼んだり、いろいろする
    let mut res = Response::new(StatusCode::Ok);
    res.set_body(format!("sample_handler1_body, sample_value = {}", sample_value));
    res.append_header("key: impl Into<HeaderName>", "value: impl ToHeaderValues");
    res.set_content_type("text/plain");
    Ok(res)
}

pub async fn sample_handler2(mut req: Request<()>) -> tide::Result {
    let Target { sample_value } = req.body_json().await?;
    // このあたりで実際はコントローラ呼んだり、いろいろする
    let res = Response::builder(StatusCode::Ok)
        .body(format!("sample_handler2_body, sample_value = {}", sample_value))
        .header("key: impl Into<HeaderName>", "value: impl ToHeaderValues")
        .content_type("text/plain")
        .build();
    Ok(res)
}

        // /aaa/bbb/ccc.rs に存在する場合
        let mod_path = module_path!();
        println!("module_path = {}", mod_path);

       // aaa::bbb::ccc

use std::env;

// matchを使ったり
fn sample1() {
    let port = match env::var("PORT") {
        Ok(p) =>  p,
        Err(_e) => "8080".to_string()
    };
    // なんらかの処理
}

// もしくはunwrap_orを使ったり
fn sample2() {
    let listener = env::var("PORT")
        .map(|port| "0.0.0.0:".to_string() + &port)
        .unwrap_or("127.0.0.1:8080".to_string());
    // なんらかの処理
}

    let a: &str = "aaa";
    let b: &str = "bbb";

    // let ab: &str = a + b; // これはコンパイルエラー

    let ab: String = a.to_string() + b;
    let ab: &str = &ab; // どうしても結果を&strにしたいなら、Stringに&をつけて変換

    // let ab: String = a + b.to_string(); // これはコンパイルエラー

    // &strからStringを作る方法も2種類ある
    let a: String = String::from(a);
    let b: String = b.to_string();

    // let ab: String = a + b; // これはコンパイルエラー
    let ab: String = a + &b;

    let c: &str = "ccc";
    let d: &str = "ddd";
    let cd: &str = format!("{}{}", c, d);

    let c: String = String::from(c);
    let d: String = d.to_string();
    let cd: String = format!("{}{}", c, d);
    // let cd: &str = format!("{}{}", c, d); // これはVSCodeのエディタ上ではエラーにならないけどコンパイルの際にエラーになった

use sysinfo::SystemExt;

fn memory_check() {
    let mut system = sysinfo::System::new_all();
    system.refresh_all();
    println!("total memory: {} KB", system.get_total_memory());
    println!("used memory : {} KB", system.get_used_memory());
    println!("total swap  : {} KB", system.get_total_swap());
    println!("used swap   : {} KB", system.get_used_swap());
}

$ RUST_BACKTRACE=1 cargo run

use thiserror::Error;

#[derive(Error, Debug)]
pub enum SampleMyError {
    #[error("Unimplemented Error.")]
    Unimplemented,
    #[error("Sample error. {msg})")]
    Sample1 {
        value: String,
        msg: String,
    },
    #[error(transparent)]
    Sample2(#[from] std::io::Error),
    #[error("unknow error")]
    Unknown,
}

pub(crate) fn sample_router(mut app: tide::Server<()>) -> tide::Server<()> {
    let mut sample = app.at("/sample");
    // ミドルウェアの呼び出しはgetやpostなどのメソッドを指定するより前でないといけない様子
    sample.with(After(error_distributor));
    sample
        .at("/hc")
        .get(|_| async move { Ok("health check ok.\n") });
    sample
        .at("/sample_error")
        .get(sample_handler); // この中で独自実装のエラーが出て、Resultで返されるとする
   // 他の処理
}

// ステータスコードは例として意味を考えずばらばらに設定ししている
async fn error_distributor(mut res: Response) -> tide::Result {
    if let Some(err) = res.downcast_error::< SampleMyError >() {
        match err {
            SampleMyError::Unimplemented => {
                res.set_body("Unimplemented error!!");
                res.set_status(StatusCode::BadRequest);
            }
            SampleMyError::Sample1 {
                value: _,
                msg: _,
            } => {
                // ここをres.set_body(msg.to_string());のように１行で書くと警告が出るけどよくわかってない
                let msg = msg.to_string();
                res.set_body(msg);
                res.set_status(StatusCode::TooEarly);
            }
            // 何もしない場合の例。実際、エラーが来て何もしないことはあまりなさそうだけれど
            SampleMyError::Sample2(_) => {}
            SampleMyError::Unknown => {
                res.set_body("Unknown error!!");
                res.set_status(StatusCode::InternalServerError);
            }
        }
    }
    Ok(res)
}

[dependencies]
async-std = { version = "1.8.0", features = ["attributes"] }
serde = { version = "1.0", features = ["derive"] }

#[cfg(feature="derive")]
// ここで関数定義や使用など

[features]
default = ["h1-server", "cookies", "logger", "sessions"]

[dependencies.｛クレート名｝]
version = "0.15.1"
default-features = false
features = ["h1-server", "cookies", "sessions"]

｛クレート名｝.version = "0.15.1"
｛クレート名｝.default-features = false
｛クレート名｝.features = ["h1-server", "cookies", "sessions"]

｛クレート名｝ = { version = "0.16.0", default-features = false, features = ["h1-server", "cookies", "sessions"] }

let default_hook = panic::take_hook();
panic::set_hook(Box::new(move |panic_info| {
	default_hook(panic_info);
	error!(
		type_ = "Panic",
		message = format!("{:?}", panic_info).as_str()
	);
}));

tracing = "0.1.23"
tracing-subscriber = "0.2.15"
tracing-futures = "0.2.5"

tracing_subscriber::fmt()
        .json()
        .with_current_span(false)
        .flatten_event(true)
        .with_span_list(true)
        .init();
let app = tide::new();

use tracing::{error, info, warn};

info!("メッセージ");
warn!("メッセージ");
error!("メッセージ");

let message_value = get_message(); 
error!(method = "POST", message = message_value.as_str());

-> {"timestamp":"Feb 24 15:39:13.685","level":"ERROR","method":"POST","message":"メッセージ"

// 省略、いくつかの値をリクエストから取得していたり
let request_id = Uuid::new_v4().to_simple().to_string();
Ok(async {
        // 省略、リクエストから処理を実行しレスポンスやステータスコードを取得したりしているとする
        let response = other1::run(request);
        let status = //
	if status.is_server_error() {
		error!(
			type_ = "Response",
			method = method.as_str(),
			status = status as u16,
			time = time.as_str(),
		);
	} else if status.is_client_error() {
            // 省略、warnで出したり
	} else {
		info!(
			type_ = "Response",
			method = method.as_str(),
			status = status as u16,
			time = time.as_str(),
		);
	}
	response
}
.instrument(info_span!("trace", request_id = request_id.as_str()))
.await)

// 別のモジュール
fn run(request: Request) -> Response {
    let response = other2::sample(request);
    info!("run"); // span_info!内なので、このログにも上記のrequest_idが追記で出力される
    response
}

// さらに別のモジュール
fn sample(request: Request) -> Response {
    let response = // 省略
    info!("sample"); // span_info!内なので、このログにも上記のrequest_idが追記で出力される
    response
}

let uuid = Uuid::new_v4().to_simple().to_string();

// コンパイルエラーの例
let joined = values.iter().join(", ");

// 正しい例
let joined = values.iter().collect::<Vec<_>>().join(", ")

println!("{{ {} }}", "aa");
// -> { aa }

println!("\"{}\"", "aa");
// -> "aa"

let aa = "aaaaa";
println!("{{ \"aa\" : \"{}\" }}", aa);
// -> { "aa" : "aaaaa" }

#[derive(Debug)]
struct Target {
    date: String,
}

impl fmt::Display for Target {
    // This trait requires `fmt` with this exact signature.
    // このトレイトは`fmt`が想定通りのシグネチャであることを要求します。
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "sample target => date : {}", self.date)
    }
}

// 以下はdateに20210127が入っている場合の出力例

println!("target={}", target);
// -> sample target => date : 20210127

println!("target={:?}", target);
// -> target=Target { date: "20210127" }

use std::sync::Mutex;

pub struct State {
    pub value: Mutex<String>,
}

impl State {
    pub fn set_value(&self, v: String) {
        let mut value = self.value.lock().unwrap();
        *value = v;
    }
}

fn set_value_outer(state: &State, v : String) {
    state.set_value(v);
}


fn main() {
    let s = State {value : Mutex::new("aaa".to_string())};
    println!("{}", s.value.lock().unwrap());
    s.set_value("bbb".to_string());
    println!("{}", s.value.lock().unwrap());
    let s2 :&State = &s;
    set_value_outer(s2, "ccc".to_string());
    println!("{}", s2.value.lock().unwrap()); 
}

use chrono::{DateTime, Local};
use std::sync::{Arc, Mutex};

#[derive(Clone)]
pub struct State {
    value: Arc<Mutex<String>>,
}

impl State {
    pub fn new() -> Self {
        let value = Arc::new(Mutex::new("first".to_string()));
        State { value: value }
    }
    pub fn set_value(&self, v: String) {
        let mut value = self.value.lock().unwrap();
        *value = v;
    }

    pub fn get_value(&self) -> String {
        (*self.value.lock().unwrap()).clone()
    }
}

fn sample(req: Request<State>) {
        let s = &req.state();
        let local_datetime: DateTime<Local> = Local::now();
        let time = format!("{}", local_datetime);
        println!("state.value = {}, time = {}", s.get_value(), time);
        let state_ = req.state();
        state_.set_value(time);
}


// 時間をあけて2回リクエストしたとする、前のリクエスト時にセットされたものが保持されているのがわかる
// -> state.value = first, time = 2021-03-18 12:04:01.726265 +09:00
// -> state.value = 2021-03-18 12:04:01.726265 +09:00, time = 2021-03-18 12:05:22.875833 +09:00

fn main() {
    let values : Vec<i32> = vec![1, 2, 3, 4, 5, 6];
    let value : Option<i32> = 
        values
            .iter()
            .map(|v| print(*v))
            .find(|v| *v == 4);
    println!("{:?}", value);        
}
// -> 1, 2, 3, 4, Some(4)

fn print(num : i32) -> i32 {
    print!("{}, ", num);
    num
}

fn main() {
    let value = "aaaabbbbcccc";
    let value = &value[5..];
    println!("{}", value);
    
    let value = "aaaabbbbcccc";
    let value = &value[2..7];
    println!("{}", value);

    let aa = "aaaa";
    let value = "aaaabbbbcccc";
    let value = &value[aa.len()..];
    println!("{}", value);

}

// -> bbbcccc
// -> aabbb
// -> bbbbcccc

let num: i64 = "1615967167".parse().unwrap();

use chrono::{DateTime, TimeZone, Utc};

let exp: i64 = "1615967167".parse().unwrap();
let dt = Utc.timestamp(exp, 0);
println!("{}", dt);
// -> 2021-03-17 07:46:07 UTC

let unixtime : i64 = Utc::now().timestamp();

// もう少しわけると以下な型の流れの感じ
let now : DateTime<Utc> = Utc::now();
let now : i64 = now.timestamp();

fn time_disp() {
        let utc_date_time = Utc::now();
        let local_date_time = chrono::Local::now();
        println!(
            "utc_date_time = {}, local_date_time = {}, utc_timestamp = {}, local_timestamp = {}",
            utc_date_time,
            local_date_time,
            utc_date_time.timestamp(),
            local_date_time.timestamp()
        );
}
// -> utc_date_time = 2021-04-07 07:34:53.516659 UTC, local_date_time = 2021-04-07 16:34:53.516670 +09:00, utc_timestamp = 1617780893, local_timestamp = 1617780893

let value = match result {
	Ok(value) => value,
	Err(err) => return ｛エラーメッセージとかなにか返したいものを用意｝,
}

// returnしない方は、なにもしたくないとき
let value = match result {
	Err(err) => return ｛エラーメッセージとかなにか返したいものを用意｝,
	_ => (),
}

fn main() {
    let value: String = "bbb".to_string();
    let value = match value.as_str() {
        "aaa" => 3,
        "bbb" => 4,
        _ => 5,
    };
    println!("{}", value);
}
// -> 4

#[derive(Clone, Debug, PartialEq, Eq)]
enum Sample1 {
    Name,
    Body,
    Image,
}

// 構造体のようにメソッドを作れる
impl Sample1 {
    fn new() -> Self {
        let sample = Sample1::Name; // なんらかの判定処理があって決まったとする
        sample
    }

    fn is_body(&self) -> bool {
        *self == Sample1::Body
    } 
}

fn print_sample1() {
    println!("{}", Sample1::new().is_body());
    println!("{}", Sample1::Body.is_body());
}
// -> false
// -> true

// 値を持たせたりもできる
#[derive(Debug)]
enum Sample2 {
    Value,
    Age(i32),
    Name { first: String, last: String },
}

fn print_sample2_name() {
    let sample2 = Sample2::Name{ first : "aaaa".to_string(), last : "bbb".to_string() }; 
    println!("{:?}", sample2);
}
// -> Name { first: "aaaa", last: "bbb" }

use anyhow::{anyhow, Result};
use std::env;

#[derive(Clone, Debug, PartialEq, Eq)]
enum Env {
    Local,
    Dev,
    Prod,
}

impl Env {
    fn new() -> Result<Self> {
        let env = env::var("ENV").unwrap_or_default();
        let env = match env.as_str() {
            "local" => Env::Local,
            "dev" => Env::Dev,
            "prod" => Env::Prod,
            _ => {
                return Err(anyhow!(
                    "ENV invalid error, ENV = {}, ENV is local or dev or prod",
                    env
                ))
            }
        };
        Ok(env)
    }
}

#[cfg(test)]
mod env_tests {
    use super::*;

    #[test]
    fn check_env_local() -> Result<()> {
        env::set_var("ENV", "local");
        assert_eq!(Env::new()?, Env::Local);
        Ok(())
    }
}

us anyhow::Result;

fn sample() -> Result<String> {
    let value : sample::Result<String> = // なんらかの処理
    value
}

us anyhow::Result;

fn sample() -> Result<String> {
    let value : sample::Result<String> = // なんらかの処理、もしくはここで?を使っても良い
    Ok(value?)
}

#[allow(dead_code)]
fn sample() -> i32 {
    3
}

#[derive(Debug)]
struct Sample {
    name: String,
    value: i32
}

fn sample1() {
    let sample = Sample { name : "aaa".to_string(), value: 4 };
    let sample = Sample {
        name: "bbb".to_string(),
       ..sample
    };
    println!("{:?}", sample);
}
// -> Sample { name: "bbb", value: 4 }

fn sample2() {
    let mut sample = Sample { name : "aaa".to_string(), value: 4 };
    sample.name = "bbb".to_string();
    println!("{:?}", sample);
}
// -> Sample { name: "bbb", value: 4 }

#[test]
#[should_panic]
fn check_invalid() {
    sample_with_panic();
}

// 以下のHashの部分をつける
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Sample {
    value1: String
    value2: NaiveDate,
}

use std::hash::{Hash, Hasher};

impl Hash for Sample {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.value1.hash(state);
    }
}

use once_cell::sync::OnceCell;

#[derive(Clone, Debug, PartialEq, Eq)]
struct DBContainer {
	data: SampleData,
}

pub trait DBPort {
    fn save(&self, data: SampleData) -> Result<()>;
}

static DB_CONTAINER: OnceCell<DBContainer> = OnceCell::new();
struct DBTestAdaptor {}
impl DBPort for DBTestAdaptor {
	fn save(&self, data: SampleData) -> Result<()> {
		let db_container = DBContainer { data };
		let _ = DB_CONTAINER.set(db_container);
		Ok(())
	}
}

#[test]
fn check() -> Result<()> {
	let data = SampleData{ value: "aaaa".to_string() };
	let db_port = DBTestAdaptor {};
	db_port.save(data.clone());
	assert_eq!(data, DB_CONTAINER.get().unwrap());
	Ok(())
}

use anyhow::Result;
use chrono::NaiveDate;
use std::str::FromStr;

#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct YearMonthDay {
    value: NaiveDate,
}

impl YearMonthDay {

    // 単純に同じような作成する動作を用意するだけならここにfrom_strを書けばいいけれど、それよりの下のようにした方がいい。

    pub fn yyyy_mm_dd(&self) -> String {
        self.value.format("%Y%m%d").to_string()
    }
}

impl FromStr for YearMonthDay {
    // ここのエラーはそのときに必要なものに変えることができる
    type Err = anyhow::Error;
    fn from_str(yyyy_mm_dd: &str) -> Result<Self, Self::Err> {
        let value = NaiveDate::parse_from_str(yyyy_mm_dd, "%Y%m%d")?;
        Ok(Self { value })
    }
}

let str = "aaa";
let bytes: &[u8] = s.as_bytes();

serde = { version = "1.0.126", features = ["derive"] }
serde_derive = "1.0"
serde_json = "1.0"

use serde_json::json;
use serde_json::Value;
use itertools::Itertools;

fn book_to_json(
    book: Book,
) -> Value {
    json!({
        "id" : book.id,
        "book_name" : book.book_name,
        "author_name" : book.author_name,
        "publisher_name" : book.publisher_name,
    })
}

fn books_to_json(
    books: Vec<Book>,
   user_id: String,
) -> Value {
    let books: Vec<Value> = books
        .books
        .into_iter()
        .map(|book| book_write_json(book))
        .collect_vec();
    // 別のところで作ったValueやVec<Value>を埋め込むこともできる
    json!({
        "books": books,
        "user_id": user_id
    })
}

let content_base64 = fs::read_to_string("/パス/base64のファイル名")?;
println!("{}", content_base64);
let bytes = base64::decode(content_base64).unwrap();
let content = String::from_utf8(bytes.to_vec()).unwrap();
println!("{}", content);

// sample1モジュール（sample1.rsファイル）にいるとする

pub struct Book {
    pub id: Id,
    pub book_name: BookName,
}

#[cfg(test)]
pub mod tests {
    use super::*;

    pub fn book_for_test(
        id: &str,
        book_name: &str,
    ) -> AmazonBook {
        AmazonBook {
            asin_id: AsinId::new(asin_id),
            book_name: BookName::new(book_name),
        }
    }
}


// 以下はsample2モジュール（sample2.rsファイル）にいるとする

use crate::sample1::{ Book, Id, BookName };

// これはコンパイルエラー
// use crate::smaple1::test::book_for_test;

// 本番用コードでは以下のようにちゃんと書く、
// この例ではあまり意義は感じられないけど、こうすることでより型安全になる
fn sample() {
    let book = Book{
      id : Id("sample_id".to_string()),
      book_name : BookName("book_name".to_string()),
    };
    println!("{}", book);
}

// でもテストでこれをいっぱい書くのはめんどくさい
#[cfg(test)]
pub mod tests {
    use super::*;
    use crate::smaple1::test::book_for_test;

    fn sample() {
        // let book = Book{
        //     id : Id("sample_id".to_string()),
        //     book_name : BookName("book_name".to_string()),
        // }
        // 上記の代わりに以下のように書ける
        let book = book_for_test("sample_id", "sample_book");
        println!("{}", book);
    }
}