pub fn example() {
 // Trying to get the size of a str (or any other DST)
 // via `std::mem::size_of` will result in a compile-time error.
 //
 // TODO: Comment out the following line and move on to the next exercise.
 std::mem::size_of::<str>();
}

pub fn example() {
 // std::mem::size_of::<str>();
 // std::mem::size_of::<[usize]>();

 // 次はコンパイルが通る
 std::mem::size_of::<&str>();
 std::mem::size_of::<&[usize]>();
 std::mem::size_of::<[usize; 3]>();
}

// TODO: Implement the `From` trait for the `WrappingU32` type to make `example` compile.

pub struct WrappingU32 {
 value: u32,
}

fn example() {
 let wrapping: WrappingU32 = 42.into();
 let wrapping = WrappingU32::from(42);
}

impl From<u32> for WrappingU32 {
 fn from(value: u32) -> Self {
 Self { value }
 }
}

trait MyFrom<T> {
 fn my_from(value: T) -> Self;
}

trait MyInto<U> {
 fn my_into(self) -> U;
}

// Dual Traitたらしめている部分
impl<T, U> MyInto<U> for T
where
 U: MyFrom<T>
{
 fn my_into(self) -> U {
 U::my_from(self)
 }
}

// 意味としては、「型Tに対して、MyFrom<T>を実装しているUについてMyInto<U>を実装する」

// TODO: Define a new trait, `Power`, that has a method `power` that raises `self`
// to the power of `n`.
// The trait definition and its implementations should be enough to get
// the tests to compile and pass.
//
// Recommendation: you may be tempted to write a generic implementation to handle
// all cases at once. However, this is fairly complicated and requires the use of
// additional crates (i.e. `num-traits`).
// Even then, it might be preferable to use a simple macro instead to avoid
// the complexity of a highly generic implementation. Check out the
// "Little book of Rust macros" (https://veykril.github.io/tlborm/) if you're
// interested in learning more about it.
// You don't have to though: it's perfectly okay to write three separate
// implementations manually. Venture further only if you're curious.

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

 #[test]
 fn test_power_u16() {
 let x: u32 = 2_u32.power(3u16);
 assert_eq!(x, 8);
 }

 #[test]
 fn test_power_u32() {
 let x: u32 = 2_u32.power(3u32);
 assert_eq!(x, 8);
 }

 #[test]
 fn test_power_ref_u32() {
 let x: u32 = 2_u32.power(&3u32);
 assert_eq!(x, 8);
 }
}

use num::Num;
use std::collections::HashMap;
use std::hash::Hash;

fn power_inner<N>(n: N, e: u32) -> N
where
 N: Num + Hash + Eq + Clone + Copy + std::fmt::Debug,
{
 if e == 0 {
 return N::one();
 }

 if e == 1 {
 return n;
 }

 let vv = power_inner(n, e / 2);

 let v = vv * vv * if e % 2 == 0 { N::one() } else { n };

 v
}

trait Power<RHS = Self>: Num + Hash + Eq + Clone + Copy {
 fn power(self, rhs: RHS) -> Self;
}

macro_rules! power_impl {
 ( $(($t:ty, $r:ty))* ) => {$(
 impl Power<$r> for $t {
 fn power(self, rhs: $r) -> Self {
 power_inner(self, rhs.clone().into())
 }
 }
 )*}
}

power_impl!((u32, u32)(u32, u16)(u32, &u32)(u128, u32));