let () = my.very(long).expression(blah, bleh, bloh);

Workaday Wizard fucked around with this message at 21:02 on Jan 3, 2017

DONT THREAD ON ME fucked around with this message at 19:01 on Jan 7, 2017

 // Extern definitions
extern {
    static mut __etext: usize;
    static mut __data_start__: usize;
    static mut __data_end__: usize;
    static mut __bss_start__: usize;
    static mut __bss_end__: usize;
}
...
// Inside the init function
let data_size = & __data_end__ as *const usize as usize - & __data_start__ as *const usize as usize; 
ptr::copy_nonoverlapping(& __etext as *const usize, &mut __data_start__ as *mut usize, data_size);

let bss_size = & __bss_end__ as *const usize as usize - & __bss_start__ as *const usize as usize; 
ptr::write_bytes(&mut __bss_start__ as *mut usize, 0, bss_size);

gonadic io fucked around with this message at 22:30 on Jan 28, 2017

warning: found Rust tuple type in foreign module; consider using a struct instead, #[warn(improper_ctypes)] on by default

gonadic io fucked around with this message at 10:58 on Jan 29, 2017

gonadic io fucked around with this message at 23:14 on Jan 31, 2017

General_Failure fucked around with this message at 13:24 on Feb 1, 2017

• "if let" owns. If your match block would have one "useful" match and one "_"/throwaway match, you can save a level of indentation by using "if let" instead. I've got a couple examples in the "exec_stack" function when I use the operators. This is really nice for Options because None is really the same as _ there.
  
• If you need to unpack multiple things at the same time, you can match on a tuple of them. I did that when pulling two values out of the stack for the binary ops. (Note that this won't work for values that depend on each other, like if you need to unpack the first to get the second.)
  
• When I wrote the return value, I screwed around a little and used an Option combinator to turn it into one line. .ok_or() is a way to turn an Option into a Result by giving an Err value it can use for Nones.
  
• Also, that .into_iter() in your parse() function wasn't doing anything.
  

 let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_)  => continue
        };

mrbass21 fucked around with this message at 10:42 on Feb 27, 2017

use std::collections::HashMap;
struct foo {
    pub vars: HashMap<String, String>,
}

impl foo {
    fn bar(&mut self, name: &str, val: &str) -> &str {
        if self.vars.contains_key(name) {
            return self.vars.get(name).unwrap();
        }
        self.vars.entry(name.to_string()).or_insert(val.to_string())
    }
}

fn main() {
    let mut f = foo{vars: HashMap::new()};
    f.bar("hello", "world");
}

QuietMisdreavus fucked around with this message at 19:23 on Mar 2, 2017

gonadic io fucked around with this message at 12:45 on Mar 10, 2017

QuietMisdreavus fucked around with this message at 03:23 on Mar 11, 2017

pub trait EightSegment {
    unsafe fn new() -> Self;
    fn display(&mut self, count: u32);
}

macro_rules! create_eight_segment (
    ($struct_name: ident,
     ...
    ) => {{
        pub struct $struct_name;
        impl EightSegment for $struct_name {
            ...
        }
        $struct_name::new()
    }}
);

fn main() {
  let mut digit = unsafe {
    create_eight_segment!(EightSegment2, D7, D6, D3, D4, D5, D8, D9, D2)
  };
  loop {
    let s = ...
    digit.display(s);
  }
}

gonadic io fucked around with this message at 16:30 on Mar 22, 2017