Rust Operations

fn f(arg1:A1, arg2:A2) -> R {
  /* do something with args to implement r:R */
  r
}

fn carginals<const N: usize>() -> [usize; N] { 
  let mut array = [0; N];
  for i in 0..N {
    array[i] = i;
  }
  array
}

|arg1:A1, arg2:A2, ...| -> R { 
  /* 
    build r ε R using args and may use values      
    from local context 
  */   
  r          
};

let n = 5;

let cardinals_closure = || {
  (0..n).collect::<Vec<usize>>()               
};

let arr = cardinals_closure();

use std::default::Default;
use std::fmt::Debug;

#[derive(Debug, Default, Clone)]
pub struct S<T: Debug + Default + Clone> {         
  item: T,
}
impl<T: Debug + Default + Clone> S<T> {
  pub fn new() -> Self {
    Self {
      item: Default::default(),
    }
  }
  pub fn get_item(&mut self) -> &mut T {
    &mut self.item
  }
}

fn main() {
  let mut s = S::::new();
  println!("{:?}", s);
  let item = s.get_item();
  *item = 3.1415927;
  println!("item = {:?}", item);                   
  println!("{:?}", s);
}

> cargo run
Compiling structs v0.1.0 (C:\github\JimFawcett\PostDemos\RustOperations\structs)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.41s            
Running `target\debug\structs.exe`
S { item: 0.0 }
item = 3.1415927
S { item: 3.1415927 }
C:\github\JimFawcett\PostDemos\RustOperations\structs
>

use std::sync::atomic::{ AtomicI32, Ordering };

#[derive(Debug)]
pub struct Counter {
  value: AtomicI32,
}
impl Counter {
  pub fn new() -> Counter {
    Counter {
      value:0.into(),
    }
  }
  pub fn incr(&mut self) {
    self.value.fetch_add(1, Ordering::SeqCst);
  }
  pub fn decr(&mut self) {
    self.value.fetch_sub(1, Ordering::SeqCst);
  }
  pub fn count(&self) -> i32 {
    self.value.load(Ordering::SeqCst)
  }
}

pub struct FO {
  name: String
}
impl FO {
  pub fn get_function_object(&self) -> impl Fn()
  {
    let rname = &self.name;
    move || {
      /* do something with rname */
    }
  }
}

pub struct DemoFO {
  name : String,
}
impl DemoFO {
  pub fn new() -> Self {
    Self {
      name:"no_name".to_string(),
    }
  }
  pub fn change_name(&mut self, s:&str) {
    self.name = s.to_string();
  }
  pub fn get_function_object<'a>(&'a self)      
    -> impl Fn() + 'a
  {
    let name = &self.name;
    move || { 
      println!("{:?}", name) 
    }
  }
}


                

pub fn demo_function_object() {
  println!();
  show_label("demo function objects");
  let mut demo = DemoFO::new();

  /* immutable borrow of DemoFO here */   
  let fo = demo.get_function_object();
  fo();
  drop(fo);
  /* 
    mutable borrow of DemoFO below,
    O.K. because fo dropped
  */
  demo.change_name("Arnold");
  let fo = demo.get_function_object();
  fo();
}
  

 demo function objects
-----------------------                   
"no_name"
"Arnold"  

/* demonstration function */
fn this_function_has_a_very_long_name() {
  println!("action of function with long name");
}

pub fn demo_function_pointer() {
  println!();
  show_label("demo function pointer");
  let tfh = this_function_has_a_very_long_name;
  tfh();
}

 demo function pointer
------------------------
action of function with long name         







  

/* demonstration function */
pub fn u(s:&str) {
  println!("{:?}", s);
}
/* function accepts function pointer */         
pub fn v(fp:impl Fn(&str) -> ()) {
  fp("using function pointer");
}
pub fn demo_function_pointer() {
  println!();
  show_label("demo function pointer");
  v(u);
}

 demo function pointer
------------------------                  
"using function pointer"