use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert("name", "hoge");
    // このHashMapはヒープ上にデータを確保している
}

fn main() {
    let array: [u8; 10_000_000] = [0; 10_000_000];
}

/*
thread 'main' has overflowed its stack
fatal runtime error: stack overflow
*/

fn main() {
    let vec = vec![0; 10000000];
    // ヒープ上に確保している
}

fn main() {
    // i32型のデータをヒープに確保
    let heap_data = Box::new(42);

    // Derefトレイトを実装しているため、直接中身にアクセスできる
    println!("Heap data: {}", *heap_data);

    // 関数に渡す
    hoge(heap_data);  // この時点でheap_dataの所有権はhoge関数に移動

    // この時点でheap_dataはdropされているので、以下の行はエラーとなる
    // println!("Heap data: {}", *heap_data);
    //
    // error[E0382]: borrow of moved value: `heap_data`
}

fn hoge(data: Box<i32>) {
    println!("hoge: {}", *data);
    // 関数が終了するとdataもdropされ、ヒープ上のデータも解放される
}

// lib\rustlib\src\rust\library\core\src\ops\deref.rs

#[lang = "deref"]
#[doc(alias = "*")]
#[doc(alias = "&*")]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_diagnostic_item = "Deref"]
pub trait Deref {
    /// The resulting type after dereferencing.
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_diagnostic_item = "deref_target"]
    #[lang = "deref_target"]
    type Target: ?Sized;

    /// Dereferences the value.
    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_diagnostic_item = "deref_method"]
    fn deref(&self) -> &Self::Target;
}

use std::ops::Deref;

struct Hoge<T>(T);

impl<T> Hoge<T> {
    fn new(x: T) -> Hoge<T> {
        Hoge(x)
    }
}

impl<T> Deref for Hoge<T> {
    // Derefトレイト内に定義されている関連型`Target`に`T`型を設定
    type Target = T;

    fn deref(&self) -> &T {
        &self.0
    }
}

fn main() {
    let x = 5;
    let y = Hoge::new(x);

    assert_eq!(5, x);
    assert_eq!(5, *y); // ここでderefメソッドが呼び出される
}

// lib\rustlib\src\rust\library\alloc\src\boxed.rs

#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_box", issue = "92521")]
impl<T: ?Sized, A: Allocator> const Deref for Box<T, A> {
    type Target = T;

    fn deref(&self) -> &T {
        &**self
    }
}