Macros for efficient development

Examples

convert type

rust use doe::*; let s = as_to!(5., i64); assert_eq!(5, s);

if type is i8 return true

rust use doe::*; assert_eq!(macros::is_i8(&5_i8),true);

if type is i16 return true

rust use doe::*; assert_eq!(macros::is_i16(&5_i16),true);

if type is i32 return true

rust use doe::*; assert_eq!(macros::is_i32(&5_i32),true);

if type is i64 return true

rust use doe::*; assert_eq!(macros::is_i64(&5_i64),true);

if type is i128 return true

rust use doe::*; assert_eq!(macros::is_i128(&5_i128),true);

if type is f32 return true

rust use doe::*; assert_eq!(macros::is_f32(&5.0_f32),true);

if type is f64 return true

rust use doe::*; assert_eq!(macros::is_f64(&5.0_f64),true);

returns a raised to the b power

rust use doe::*; let p = powf!(2.,2.); assert_eq!(p,4.0);

get argument and collect into Vec\

rust use doe::*; //cargo run -- -n 100 let arg = args!(); assert_eq!(arg,vec![format!("-n"),format!("100")]);

get user input from terminal,return String

rust use doe::*; let s = input!(); println!("{:?}",s);

Spliy &str by spliter and collect into Vec\

rust use doe::*; let s = split_to_vec!("aa.bb","."); assert_eq!(s,vec![format!("aa"),format!("bb")]);

read .csv file and Collect into Vec\

rust use doe::*; let s = read_csv!("./data.csv"); assert_eq!(s,vec![vec![format!("a"), format!("b"), format!("c")],vec![format!("1"), format!("2"), format!("3")],vec![format!("10"), format!("20"), format!("30")]]);

sorted new Vec

rust use doe::*; let s1 = sorted!(vec![1.2, 2.6, 0.2]); let s2 = sorted!(vec![8, 1_i128, 5_i128]); assert_eq!(s1,vec![0.2,1.2,2.6]); assert_eq!(s2,vec![1,5,8]);

sorted and deduped Vec

rust use doe::*; let s1 = deduped_sorted!(vec![1.2, 1.2,2.6, 0.2]); let s2 = deduped_sorted!(vec![8, 1_i128,8,5_i128]); assert_eq!(s1,vec![0.2,1.2,2.6]); assert_eq!(s2,vec![1,5,8]);

parse Vec element to type, parse Vec\<&str> Collect to Vec\

rust use doe::*; let v1: Vec<f64> = vec_element_parse!(vec!["15.", "2.9"], f64); let v2: Vec<i128> = vec_element_parse!(vec!["15", "2"], i128); let v3: Vec<f32> = vec_element_parse!(vec![".15", ".2"], f32); assert_eq!(vec![15.0, 2.9], v1); assert_eq!(vec![15, 2], v2); assert_eq!(vec![0.15, 0.2], v3);

convert vec item to String,return Vec\

rust use doe::*; let v1 = vec_element_to_string!(vec!["15.", "2.9"]); let v2 = vec_element_to_string!(vec![15, 2]); let v3 = vec_element_to_string!(vec![0.15, 0.2]); assert_eq!(vec!["15.", "2.9"], v1); assert_eq!(vec!["15", "2"], v2); assert_eq!(vec!["0.15", "0.2"], v3);

return the array elements arranged from outermost elements to the middle element, traveling clockwise (n x n)

rust use doe::*; let v1 = snail_sort!(vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]]); let v2 = snail_sort!(vec![vec![1.1, 2.1, 3.1],vec![4.1, 5.1, 6.1],vec![7.1, 8.1, 9.1]]); assert_eq!(vec![1, 2, 3, 6, 9, 8, 7, 4, 5], v1); assert_eq!(vec![1.1, 2.1, 3.1, 6.1, 9.1, 8.1, 7.1, 4.1, 5.1], v2);

mutiply two matrix

rust use doe::*; let m1: Vec<Vec<f64>> = vec![vec![1.0, 2.0], vec![1.0, 2.0]]; let m2: Vec<Vec<f64>> = vec![vec![0.0, 0.0], vec![0.0, 0.5]]; let mul_result1 = multiply_matrix!(&m2, &m1); let m11: Vec<Vec<i32>> = vec![vec![1, 2], vec![1, 2]]; let m22: Vec<Vec<i32>> = vec![vec![0, 0], vec![0, 0]]; let mul_result2 = multiply_matrix!(&m22, &m11); let m111: Vec<Vec<i64>> = vec![vec![1, 2], vec![1, 2]]; let m222: Vec<Vec<i64>> = vec![vec![0, 0], vec![0, 0]]; let mul_result3 = multiply_matrix!(&m222, &m111); assert_eq!(mul_result1, vec![[0.0, 0.0], [0.5, 1.0]]); assert_eq!(mul_result2, vec![[0, 0], [0, 0]]); assert_eq!(mul_result3, vec![[0, 0], [0, 0]]);

find the fist element and remove

rust use doe::*; let v1 = vec_element_remove!(vec!["15.", "2.9"], "2.9"); let v2 = vec_element_remove!(vec![15, 2, 3, 2], 2); let v3 = vec_element_remove!(vec![0.15, 0.2, 0.2], 0.2); assert_eq!(vec!["15."], v1); assert_eq!(vec![15, 3, 2], v2); assert_eq!(vec![0.15, 0.2], v3);

find element position and collect into Vec

rust use doe::*; let v1 = vec_element_position_all!(vec![1, 2, 5, 3, 6, 2, 2], 2); assert_eq!(v1, vec![1, 5, 6]); let v2 = vec_element_position_all!(vec!["0".to_string(),"4".to_string(),"7".to_string(),"7".to_string(),], "7".to_string()); assert_eq!(v2, vec![2,3]);

slice vec by range

rust use doe::*; let v1 = vec_slice!(vec![1.2, 1.5, 9.0], [..2]); let v2 = vec_slice!(vec![1, 1, 9, 90, 87, 0, 2], [4..6]); let v3 = vec_slice!(vec![1.2, 1.5, 9.0], [..]); let v4 = vec_slice!(vec![1.2, 1.5, 9.0], [1..]); let v5 = vec_slice!(vec!["1", "2", "3", "4", "5"], [2..5]); let v6 = vec_slice!(vec!["1".to_string(),"2".to_string(),"3".to_string()], [1..]); assert_eq!(v1, vec![1.2, 1.5]); assert_eq!(v2, vec![87, 0]); assert_eq!(v3, vec![1.2, 1.5, 9.0]); assert_eq!(v4, vec![1.5, 9.0]); assert_eq!(v5, vec!["3", "4", "5"]); assert_eq!(v6,vec!["2".to_string(),"3".to_string()]);

clone element by index

rust use doe::*; let v1 = vec_element_clone!(vec!["15.", "2.9"], 1); let v2 = vec_element_clone!(vec![15, 2, 3, 2], 2); let v3 = vec_element_clone!(vec![0.15, 0.2, 0.2], 0); let v4 = vec_element_clone!(vec![format!("1"),format!("2"),format!("3"),format!("4"),format!("5")],4); assert_eq!("2.9", v1); assert_eq!(3, v2); assert_eq!(0.15, v3); assert_eq!(format!("5"), v4);

remove file or folder

rust remove_file_or_folder!("./demo.txt"); remove_file_or_folder!("./target");

get vec type ,return string type value

rust use doe::*; assert_eq!(vec_type!(vec![0.2_f64]), format!("Vec<f64>")); assert_eq!(vec_type!(vec![0.2_f32]), format!("Vec<f32>")); assert_eq!(vec_type!(vec![2_i32]), format!("Vec<i32>")); assert_eq!(vec_type!(vec![2_i128]), format!("Vec<i128>")); assert_eq!(vec_type!(vec![2_isize]), format!("Vec<isize>")); assert_eq!(vec_type!(vec![2_usize]), format!("Vec<usize>")); ## convert vec elements type rust use doe::*; let v1: Vec<f64> = vec_element_convert!(vec![1, 2], f64); let v2: Vec<i32> = vec_element_convert!(vec![1.0, 2.0], i32); let v3: Vec<i128> = vec_element_convert!(vec![1.0, 2.0], i128); let v4: Vec<i32> = vec_element_convert!(vec![1_usize, 2_usize], i32); let v5: Vec<i64> = vec_element_convert!(vec![0.15, 2.0], i64); assert_eq!(v1, vec![1.0, 2.0]); assert_eq!(v2, vec![1, 2]); assert_eq!(v3, vec![1, 2]); assert_eq!(v4, vec![1, 2]); assert_eq!(v5, vec![0, 2]);

expr return max value

rust use doe::*; let re_max = max!(1, 20); assert_eq!(re_max,20);

expr return min value

rust use doe::*; let re_min = min!(10, 2, 2, 5, 4, 6); assert_eq!(re_min,2);

convert binary string to decimal

rust use doe::*; let d1 = binary_to_decimal!("01101",i128); assert_eq!(d1,13_i128); let d2 = binary_to_decimal!("00000000000010100110001",i64); assert_eq!(d2,1329_i64); let d3 = binary_to_decimal!("000011",i32); assert_eq!(d3,3_i32); let d4 = binary_to_decimal!("000101",i16); assert_eq!(d4,5_i16); let d5 = binary_to_decimal!("001001",i8); assert_eq!(d5,9_i8);

expr return memory address

rust use doe::*; let d1 = binary_to_decimal!("01101",i128); println!("{:?}",memory_address!(d1));//0x7ffcac734f08

Merge two Vec return merged Vec

rust use doe::*; let v1 = vec_merge!(vec![0, 1, 2], vec![5, 6, 7]); assert_eq!(vec![0, 1, 2, 5, 6, 7],v1); let v2 = vec_merge!(vec![0., 1., 2.], vec![5., 6., 7.]); assert_eq!(vec![0., 1., 2., 5., 6., 7.],v2);

take size of elements and return a new vec

rust use doe::*; let v1 = vec_element_take!(vec![0, 1, 2],2); assert_eq!(vec![0,1],v1);

zip two vec elements in tuple

rust use doe::*; let v1 = vec_zip!(vec![0, 1, 2],vec![0, 1, 2]); assert_eq!(vec![(0,0),(1,1),(2,2)],v1);

enumerate all indexs and elements collect tuple of vec

rust use doe::*; let v1 = vec_enumerate!(vec![12, 11, 20]); assert_eq!(vec![(0,12),(1,11),(2,20)],v1);

sort vec and return sorted vec

rust use doe::*; let v1 = vec_sort!(vec![10, 2, 3]); assert_eq!(vec![2,3,10],v1); let v2 = vec_sort!(vec![1.8, 2.5, 0.3]); assert_eq!(vec![0.3,1.8,2.5],v2);

has stable rust nightly return bool

rust use doe::*; let v1 = has_nightly_compiler!(); assert_eq!(v1, true);

has stable rust compiler return bool

rust use doe::*; let v1 = has_stable_compiler!(); assert_eq!(v1, false);

run command

rust use doe::*; command!("ls -la"); command!("dust"); command!("lsd");

run a function once after a particularized delay(millis)

rust use doe::*; set_timeout!(||{ println!("ok"); },3000);

run a function after a particularized delay(millis) each run delay(millis)

rust use doe::*; duration_set_timeout!(||{ println!("ok"); },3000,1000); //from now delay 3000ms,each 1000ms run func()

run a function repeatedly, beginning after some millis, then repeating continuously at the given interval.

rust use doe::*; set_interval!(||{ println!("ok"); },3000);