月: 2024年4月

use std::ops::Deref;

struct MyBox<T>(T);

impl MyBox<T> {      // original smart pointer
    fn new(x: T) -> MyBox {
        MyBox(x)
    }
}

impl Deref for MyBox {    // deref coercion
    type Target = T;    // to define return value type T for the Deref "Target"
                        // in the DeRef trait : fn deref(&self) -> &Self::Target;

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

fn hello(name: &str) {          // "&" is needed to get a known size of the argument at compile-time
    println!("Hello, {}!", name);
}

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

    assert_eq!(5, x);
    assert_eq!(5, *y);  // to success compile, Deref definition should be defined

    println!("x = {}, y = {}", x, *y);

    let m = MyBox::new(String::from("Rust"));
    hello(&m);
}

fn main(){
    println!("{}", hoge()());
}

fn hoge() -> Box<dyn Fn() -> String> {
    Box::new(|| -> String {
        String::from("ほげー！")
    })
}

    let abc = hoge();
    println!("{}", abc());

    let fn_plain = create_fn(); // return a closure
    
    fn_plain();

と

    create_fn()();

は等価です

    fn any<F>(&mut self, f: F) -> bool
    where
        Self: Sized,
        F: FnMut(Self::Item) -> bool,


    fn find<P>(&mut self, predicate: P) -> Option<self::item> 
    where 
        Self: Sized, 
        P: FnMut(&Self::Item) -> bool,  // &Self::Item means closure variables are used as reference  

fn main() {
    let vec1 = vec![1, 2, 3];
    let vec2 = vec![4, 5, 6];

    // `iter()` for vecs yields `&i32`.
    let mut iter = vec1.iter();
    // `into_iter()` for vecs yields `i32`.
    let mut into_iter = vec2.into_iter();

    // `iter()` for vecs yields `&i32`, and we want to reference one of its
    // items, so we have to destructure `&&i32` to `i32`
    println!("Find 2 in vec1: {:?}", iter     .find(|&&x| x == 2));
    // `into_iter()` for vecs yields `i32`, and we want to reference one of
    // its items, so we have to destructure `&i32` to `i32`
    println!("Find 2 in vec2: {:?}", into_iter.find(| &x| x == 2));

    let array1 = [1, 2, 3];
    let array2 = [4, 5, 6];

    // `iter()` for arrays yields `&i32`
    println!("Find 2 in array1: {:?}", array1.iter()     .find(|&&x| x == 2));
    // `into_iter()` for arrays yields `i32`
    println!("Find 2 in array2: {:?}", array2.into_iter().find(|&x| x == 2));
}

// return a closure
fn create_fn() -> impl Fn() {
    let text = "Fn".to_owned();
    move || println!("This is a: {}", text)
}

fn main() {
    // return a closure
    let data = vec![1, 2, 3];

    // you don't need 'move' in this case becuase data is still available after this line
    let closure = move || println!("captured {data:?} by value");   
    closure();

    // call function and receive closure
    let fn_plain = create_fn(); // return a closure
    
    fn_plain();

fn apply_clo<F: Fn(i32)>(i: i32, f: F) {
    f(i);
}

fn main() {
    // ARG for the closure
    let sqr = |y: i32| println!("{}", y*y);

    // equivalent function
    fn sqr_f(y: i32){
        println!("{}", y*y);
    }

    apply_clo(23, sqr);
    apply_clo(32, sqr_f);
}

// A function which takes a closure as an argument and calls it.
// <f> denotes that F is a "Generic type parameter"
fn apply<f>(f: F) where
    // The closure takes no input and returns nothing.
    F: FnOnce() {
    // ^ TODO: Try changing this to `Fn` or `FnMut`.

    f();
}

// A function which takes a closure and returns an `i32`.
fn apply_to_3<f>(f: F) -> i32 where
    // The closure takes an `i32` and returns an `i32`.
    F: Fn(i32) -> i32 {

    f(3)
}

fn main() {
    use std::mem;

    let greeting = "hello";
    // A non-copy type.
    // `to_owned` creates owned data from borrowed one
    let mut farewell = "goodbye".to_owned();

    // Capture 2 variables: `greeting` by reference and
    // `farewell` by value.
    let diary = || {
        // `greeting` is by reference: requires `Fn`.
        println!("I said {}.", greeting);

        // Mutation forces `farewell` to be captured by
        // mutable reference. Now requires `FnMut`.
        farewell.push_str("!!!");
        println!("Then I screamed {}.", farewell);
        println!("Now I can sleep. zzzzz");

        // Manually calling drop forces `farewell` to
        // be captured by value. Now requires `FnOnce`.
        mem::drop(farewell);
    };

    // Call the function which applies the closure.
    apply(diary);

    // `double` satisfies `apply_to_3`'s trait bound
    let double = |x| 2 * x;

    println!("3 doubled: {}", apply_to_3(double));
}

pub trait FnOnce
where
    Args: Tuple,
{
    type Output;

    // Required method
    extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
}

pub trait FnMut: FnOnce
where
    Args: Tuple,
{
    // Required method
    extern "rust-call" fn call_mut(
        &mut self,
        args: Args
    ) -> Self::Output;
}

pub trait Fn: FnMut
where
    Args: Tuple,
{
    // Required method
    extern "rust-call" fn call(&self, args: Args) -> Self::Output;
}