// これをimplementしているときは表示できる
trait TraitMyDisp{
  fn disp(&self);
}

// これをimplementしているときは値を二乗する
trait TraitMyPow{
  fn get_pow2(&self)->f32;
}

//////////////////////////////////////////
//////////////////////////////////////////
struct IntValue{ value: i32 }

impl TraitMyDisp for IntValue{
  fn disp(&self){
    println!("{}",self.value);
  }
}
impl TraitMyPow for IntValue{
  fn get_pow2(&self)->f32{
    ( self.value*self.value ) as f32
  }
}
//////////////////////////////////////////
//////////////////////////////////////////
struct FloatValue{ value:f32 }

impl TraitMyPow for FloatValue{
  fn get_pow2(&self)->f32{
    ( self.value*self.value ) as f32
  }
}

// C++だと T に get_pos2があればビルドが通るが
// Rustでは valueに対して何をできるのかを指定しなければならない
fn call<T>(value:T){
  println!("call {}",value.get_pow2()); // NG   T にget_pow2が必要なんて聞いてない 
}

fn main(){

  // TraitMyDisp , TraitMyPow の両方が実装済み
  let i_val = IntValue{value:2};

  // TraitMyPow のみが実装済み
  let f_val = FloatValue{value:2.0};

  call(i_val); 
}

// T は TraitMyPow を実装していなければならない
fn call< T : TraitMyPow >(value:T){
  println!("call {}",value.get_pow2());
}

// <T:トレイト + トレイト> のように+で複数指定できる 
fn call_both<T:TraitMyPow + TraitMyDisp>(value:&T){

  // TraitMyDisp::dispは使っていないが、トレイト境界を指定しているので
  // Tがdispに対応していないならコンパイルできない（たとえ使っていなくても）
  println!("call {}",value.get_pow2());
}


fn main(){

  // TraitMyDisp , TraitMyPow の両方が実装済み
  let i_val = IntValue{value:2};

  // TraitMyPow のみが実装済み
  let f_val = FloatValue{value:2.0};

  call_both(&i_val); // OK
  // call_both(&f_val); // NG FloatValueのためのTraitMyDispはimplしていない

}

// Addモジュールを使う
use std::ops::Add;

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////

// add関数の定義
// Tの必須の振る舞いとしてAddを指定。これで operator + が使える
fn add< T : Add<Output=T> >( v1:T , v2:T ) -> T
{
  
v1 + v2

}

fn main(){

  let val:i32 = add( 3,4);

}

// 振る舞い
trait Flying{
  fn fly(&self);
}

// 構造体 鷹
struct Hawk{
  weight:f32,
  speed:f32,
}

// トレイトのR実装
impl Flying for Hawk{

  // メソッド 
  fn fly(&self){
    println!("鷹が飛ぶ {} km/h \n",self.speed );
  }

}

// 構造体 ハチドリ
struct Hummingbird{
  weight:f32,
  speed:f32,
}

// トレイトのR実装
impl Flying for Hummingbird{
  // メソッド 
  fn fly(&self){
    println!("ハチドリが飛ぶ {} km/h\n", self.speed);
  }
}

fn main() {
  
  // スタック上に確保する固定長配列は [T;N]の形をしている
  // T ... Type , N ... 個数
  let ary:[ Box<dyn Flying> ; 2 ] =
  [
    // Boxはヒープにメモリを確保する。
    Box::new(Hawk{weight:1100.0,speed:190.0}), // アカオノスリ
    Box::new(Hummingbird{weight:20.0,speed:98.0}) // ハチドリ
  ];

  ary[0].fly();
  ary[1].fly();

}

fn main() {

  ////////////////////////////////////////////
  // 固定長配列（スタック）

  let mut ary1:[i32;5]=[1,2,3,4,5];

  for a1 in ary1{
    print!("{} ",a1);
  }
  println!("");

  // 初期化しないバージョン
  let mut ary2:[i32;5]  = unsafe { std::mem::MaybeUninit::uninit().assume_init() };
  for a2 in ary2{
    println!("* {} ",a2);
  }
  println!("\n");

  ////////////////////////////////////////////
  // 可変長配列

  let mut vec1:Vec<&str> = vec!["a", "b", "c"];
  vec1.push("d");
  for v1 in vec1{
    print!("{} ",v1);
  }
  println!("");

  // 初期化しないバージョン
  let mut vec2:Vec<&str> = vec![];
  vec2.push("d");
  for v2 in vec2{
    print!("* {} ",v2);
  }
  println!("\n");

  ////////////////////////////////////////////
  // 固定長配列（ヒープ）

  let mut box1:Box<[f32;5]> = Box::new([10.5 , 11.5 , 12.5 , 13.5 , 14.5]);
  for b1 in box1.iter(){
    print!("{} ",b1);
  }
  println!("");

  // 初期化しないバージョン
  let mut box2:Box<[f32;5]> = Box::new(unsafe { std::mem::MaybeUninit::uninit().assume_init() } );
  for b2 in box2.iter(){
    println!("* {} ",b2);
  }

}

// #[derive(Debug)] をつけるとprintln!でそのまま表示できるようになる
#[derive(Debug)]
// 構造体の定義。
struct Rectangle{
  width:i32,
  height:i32,
}

fn main() {
  
  // 初期化なしでは定義できない
  //let mut rr = Rectangle{};  
  let mut rr = Rectangle{width:0,height:0};

  // mut をつけているので代入できる
  rr.width = 20;
  rr.height = 20;

  // #[derive(Debug)] をつけているので {:?} で表示できる
  println!("{:?}",rr);

}

// 構造体の定義
struct Rectangle{
  width:i32,
  height:i32,
}

// implの中でメソッドや関連関数を定義
impl Rectangle{

  // Rectangleのメソッドを定義 メソッドはselfをとる。 selfがないなら関連関数
  fn area(&self)->i32{
    return self.width * self.height;
  }

}

fn main() {
  
  // インスタンス生成
  let mut rr = Rectangle{width:0,height:0};

  rr.width = 20;
  rr.height = 20;

  // メソッド呼び出し 
  println!("{}",rr.area() );

}

// 構造体の定義
struct Rectangle{
  width:i32,
  height:i32,
}

impl Rectangle{

  // 関連関数。 &selfをとらない。
  // Rectangle::new で呼び出す。
  // 新規インスタンス生成関連関数は「new」にする習慣がある
  fn new()->Rectangle{

    return Rectangle{width:20,height:30};

  }

  // メソッド
  fn area(&self)->i32{return self.width * self.height;}

}

fn main() {
  
  // 関連関数でインスタンス生成
  let mut rr = Rectangle::new();

  println!("{}",rr.area() );

}

// 振舞いの定義
trait behavior_calc_area{
  fn area(&self)->f32;
}

// 構造体の定義
struct Rectangle{
  width:i32,
  height:i32,
}

// トレイトのR実装
impl behavior_calc_area for Rectangle{

  // メソッド 
  fn area(&self)->f32{
    return (self.width * self.height) as f32;
  }

}

struct Triangle{
  width:i32,
  height:i32,
}

// トレイトのR実装
impl behavior_calc_area for Triangle{
  // メソッド 
  fn area(&self)->f32{
    return (self.width * self.height) as f32 / 2.0 ;
  }
}

fn main() {
  
  // インスタンス生成
  let t:Triangle = Triangle{width:10,height:5};
  let r:Rectangle = Rectangle{width:10,height:5};

  println!("{}\n",t.area() );
  println!("{}\n",r.area() );

}

// 関数定義
// 値渡し
fn add(a:f32,b:f32)->f32{
  return a+b;
}

fn main()  {

  // 関数呼び出し
  // 引数に整数を入れてもaddのf32に暗黙変換できないらしいので
  // as f32 で実数に型変換する
  let k = add(3 as f32,5 as f32);

  println!("k= {}",k);

}

// デフォルトで不変参照。C++でいうところのconst。kの内容を変更できない
fn add2(k: &i32)->f64{

  // &mutでないときは *k としなくていいらしい
  return (k + 2) as f64;
}

fn main() {

  let a:i32=3;  // mutがついていないので変更不可

  println!(" {}", add2(&a) ); // aの定義時にmutをつけていないのでここもただの&
}

// &mut で可変参照
fn swap(i:&mut i32,j:&mut i32){
  let k:i32;

  // &mutの時は頭に*をつけて *i とする
  k = *i;
  *i = *j;
  *j = k;
}

fn main() {
  let mut a:i32=3;
  let mut b:i32=8;
  swap(&mut a,&mut b);
  println!("{} {}",a,b);
}

use std::ops::Mul;
fn square<T: Mul<Output = T> + Copy >(val:T)->T{

  return val*val;

}

use std::fmt::Display;
fn console_log<T: Display> (x: T) {  

  println!("{}", x);

}

fn main() {
  
  println!("{}",  square(3) );

  console_log( 3 );

}

fn main() {
  for x in 1..=9{
    for y in 1..=9{
        print!("{} ",x*y);
    }
    println!("");
  }
}

fn main() {
  let mut k = 0;// 変数はデフォルトで変更不可なのでmutをつける
  while k < 10{
    println!("k=={}",k);
    k+=1; // Rustには++がない
  }

}

fn main()  {

  let k = 3;

  if k == 1{
    println!("k==1");
  }
  else if k==2{
    println!("k==2");
  }
  else{
    println!("other k");
  }

}

fn main()  {

  let k = 2;

  let msg = if k%2!=0 {"odd"}else{"even"};
 
  println!("{}",msg);
 
}

fn main()  {

  let i = 2;

  // switchに近い。
  // ただし、matchの中で、「取りうるすべての可能性について」処理する必要がある
  match i{

    // Cと違いbreakしなくてもいい。ほかの式が実行されることはない
    3 => println!("three"),

    // 複数の指揮を実行するときは{}で括る
    4 => {
      println!("four");
      println!("FOUR")
    },

    // 取りうるすべての可能性を記述しなければいけないため
    // ワイルドカード _ を使ってCのdefaultと同じことをする。
    _ => println!("others"),
  };
 
}

fn main()  {

  let i = 3;

  let msg:&str =   match i{

    3 => "three",

    4 => "four",

    _ => "others",
  };

  println!("{}",msg);

}

// 入出力を使う
use std::io;

fn main() {

  // 変数 buffer を定義
  let mut buffer = String::new();

  // bufferへ文字列入力
  io::stdin().read_line(&mut buffer);

  // bufferを表示
  println!("{}",buffer);

}

// 入出力を使う
use std::io;

fn main() {

  // 変数 buffer を定義
  let mut buffer = String::new();

  io::stdin().read_line(&mut buffer); //標準入力から入力

  // 型指定 :i32 が必要
  // read_lineから読み込んだ文字列に対してはtrim()が必要
  let val:i32 = buffer.trim().parse().unwrap();

  // bufferを表示
  println!("{}",val);

}

// ファイル入力を使う
use std::{fs::File, io::Read};

fn main() {

  let filename = "test.txt";
 
  // ファイル入力を使う
  let mut file = File::open(filename).expect("file not found");

  // 変数 buffer を定義
  let mut buffer = String::new();

  // ファイルから入力
  file.read_to_string(&mut buffer).expect("something went wrong reading the file");

  // ファイルを閉じる方法
  // 方法1 スコープを抜けるとdropが呼ばれる（C++のデストラクタのようなもの）
  // 方法2 明示的にdropを呼び出す
  drop(file); // 明示的にdropを呼び出す

  // bufferを表示
  println!("{}",buffer);

}

use std::fs::File;

// write!やwrite_allを使うのに必要
use std::io::Write;

// 戻り値は std::io::Result<()> 型
// 最後に OK(()) を返す。
// これを入れないとwrite_allなどが使えない
fn main()-> std::io::Result<()> {

  let filename = "test.txt";
 
  // ファイル入力を使う
  let mut file = File::create(filename)?;
  // 末尾の ? は例外処理のようなもの関連
  // ただしRustには例外がないのであくまでそれっぽく振る舞うだけ。

  // 変数 buffer を定義
  let _buffer = "hello".to_string();

  // ファイルへ書き出し
  file.write_all(_buffer.as_bytes())?;

  // こっちも使える
  // write!(file,"hello2")?;

  // ファイルを閉じる
  drop(file);

  // std::io::Result<()> 型の場合
  Ok(())

}