// これを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をつけていないのでここもただの&
}